Seaography

https://docs.rs/seaography/1.1.4
Admin
Seaography is a GraphQL framework and code generator for SeaORM that automatically generates...
Tokens:196,529
Snippets:1,199
Trust Score:9.7
Update:10 months ago
Show doc for...
Tokens:
Raw
### Seaography CLI Installation and Usage

Source: https://docs.rs/seaography/1.1.4/index

Instructions on how to install and use the Seaography CLI for generating SeaORM entities and setting up GraphQL servers.

```APIDOC
## Installation

Install the necessary CLI tools:

```bash
# Used to generate entities
cargo install sea-orm-cli@^1.0.0

cargo install seaography-cli@^1.0.0
```

## Usage Examples

### MySQL

1.  Setup the sakila sample database.
2.  Generate entities and the GraphQL server:
    ```bash
    cd examples/mysql
    sea-orm-cli generate entity -o src/entities -u mysql://user:pw@127.0.0.1/sakila --seaography
    seaography-cli ./ src/entities mysql://user:pw@127.0.0.1/sakila seaography-mysql-example
    cargo run
    ```

### PostgreSQL

1.  Setup the sakila sample database.
2.  Generate entities and the GraphQL server:
    ```bash
    cd examples/postgres
    sea-orm-cli generate entity -o src/entities -u postgres://user:pw@localhost/sakila --seaography
    seaography-cli ./ src/entities postgres://user:pw@localhost/sakila seaography-postgres-example
    cargo run
    ```

### SQLite

1.  Setup the sakila sample database.
2.  Generate entities and the GraphQL server:
    ```bash
    cd examples/sqlite
    sea-orm-cli generate entity -o src/entities -u sqlite://sakila.db --seaography
    seaography-cli ./ src/entities sqlite://sakila.db seaography-sqlite-example
    cargo run
    ```
```

--------------------------------

### Install SeaORM CLI and Seaography CLI

Source: https://docs.rs/seaography/1.1.4/seaography/index

Installs the necessary command-line tools for generating SeaORM entities and Seaography GraphQL servers. Ensure you have Cargo installed.

```bash
cargo install sea-orm-cli@^1.0.0
cargo install seaography-cli@^1.0.0
```

--------------------------------

### Install Seaography CLI and SeaORM CLI

Source: https://docs.rs/seaography/1.1.4/seaography

Installs the necessary command-line tools for Seaography and SeaORM. `sea-orm-cli` is used for entity generation, and `seaography-cli` is used for generating the GraphQL server.

```bash
cargo install sea-orm-cli@^1.0.0 # used to generate entities

```

```bash
cargo install seaography-cli@^1.0.0

```

--------------------------------

### Database Setup (SQLite)

Source: https://docs.rs/seaography/1.1.4/src/seaography/lib.rs

Instructions for setting up the Seaography API with a SQLite database.

```APIDOC
## SQLite Setup

### Description
Steps to set up the Seaography API with a SQLite database.

### Setup Steps
1. **Generate Entities:**
   Navigate to the `examples/sqlite` directory and run the following command to generate Rust entities:
   ```sh
   cd examples/sqlite
   sea-orm-cli generate entity -o src/entities -u sqlite://sakila.db --seaography
   ```

2. **Generate Seaography Schema:**
   Run the Seaography CLI to generate the GraphQL schema:
   ```sh
   seaography-cli ./ src/entities sqlite://sakila.db seaography-sqlite-example
   ```

3. **Run the Application:**
   Execute the application to start the API server:
   ```sh
   cargo run
   ```
```

--------------------------------

### Database Setup (PostgreSQL)

Source: https://docs.rs/seaography/1.1.4/src/seaography/lib.rs

Instructions for setting up the Seaography API with a PostgreSQL database using the Sakila sample database.

```APIDOC
## PostgreSQL Setup

### Description
Steps to set up the Seaography API with a PostgreSQL database using the Sakila sample database.

### Setup Steps
1. **Download Sakila Database:**
   Obtain the [sakila](https://github.com/SeaQL/seaography/blob/main/examples/postgres/sakila-schema.sql) sample database schema.

2. **Generate Entities:**
   Navigate to the `examples/postgres` directory and run the following command to generate Rust entities:
   ```sh
   cd examples/postgres
   sea-orm-cli generate entity -o src/entities -u postgres://user:pw@localhost/sakila --seaography
   ```

3. **Generate Seaography Schema:**
   Run the Seaography CLI to generate the GraphQL schema:
   ```sh
   seaography-cli ./ src/entities postgres://user:pw@localhost/sakila seaography-postgres-example
   ```

4. **Run the Application:**
   Execute the application to start the API server:
   ```sh
   cargo run
   ```
```

--------------------------------

### Install Seaography CLI and SeaORM CLI

Source: https://docs.rs/seaography/1.1.4/index

Installs the necessary command-line tools for Seaography and SeaORM using Cargo. The SeaORM CLI is used for generating entities, and the Seaography CLI is used for generating the GraphQL server.

```bash
cargo install sea-orm-cli@^1.0.0 # used to generate entities
cargo install seaography-cli@^1.0.0
```

--------------------------------

### Seaography GraphQL Queries

Source: https://docs.rs/seaography/1.1.4/index

Examples of how to query data using Seaography with various filters, pagination, and relation traversal.

```APIDOC
## GraphQL Query Examples

### Fetch films and their actors
```graphql
{
  film(pagination: { page: { limit: 10, page: 0 } }, orderBy: { title: ASC }) {
    nodes {
      title
      description
      releaseYear
      actor {
        nodes {
          firstName
          lastName
        }
      }
    }
  }
}
```

### Fetch store and its employee
```graphql
{
  store(filters: { storeId: { eq: 1 } }) {
    nodes {
      storeId
      address {
        address
        address2
      }
      staff {
        firstName
        lastName
      }
    }
  }
}
```

### Fetch inactive customers with pagination (Page-based)
```graphql
{
  customer(
    filters: { active: { eq: 0 } }
    pagination: { page: { page: 2, limit: 3 } }
  ) {
    nodes {
      customerId
      lastName
      email
    }
    paginationInfo {
      pages
      current
    }
  }
}
```

### Fetch inactive customers with pagination (Cursor-based)
```graphql
{
  customer(
    filters: { active: { eq: 0 } }
    pagination: { cursor: { limit: 3, cursor: "Int[3]:271" } }
  ) {
    nodes {
      customerId
      lastName
      email
    }
    pageInfo {
      hasPreviousPage
      hasNextPage
      endCursor
    }
  }
}
```

### Complex query with filters on relations
Find all inactive customers, include their address, and their payments with amount greater than 7 ordered by amount the second result
```graphql
{
  customer(
    filters: { active: { eq: 0 } }
    pagination: { cursor: { limit: 3, cursor: "Int[3]:271" } }
  ) {
    nodes {
      customerId
      lastName
      email
      address {
        address
      }
      payment(
        filters: { amount: { gt: "7" } }
        orderBy: { amount: ASC }
        pagination: { page: { limit: 1, page: 1 } }
      ) {
        nodes {
          paymentId
          amount
        }
        paginationInfo {
          pages
          current
        }
        pageInfo {
          hasPreviousPage
          hasNextPage
        }
      }
    }
    pageInfo {
      hasPreviousPage
      hasNextPage
      endCursor
    }
  }
}
```

### Filter using enumeration
```graphql
{
  film(
    filters: { rating: { eq: NC17 } }
    pagination: { page: { page: 1, limit: 5 } }
  ) {
    nodes {
      filmId
      rating
    }
  }
}
```
```

--------------------------------

### Convert Box to Raw Pointer with Allocator (Rust)

Source: https://docs.rs/seaography/1.1.4/seaography/builder_context/types_map/type.FnOutputTypeConversion

This Rust example demonstrates converting a `Box` into a raw pointer and the associated allocator using `Box::into_raw_with_allocator`. It also shows how to convert it back into a `Box` for automatic cleanup, and also provides a manual cleanup example, including running the destructor and deallocating memory. Safety considerations and associated features are detailed.

```Rust
#![feature(allocator_api)]

use std::alloc::System;

let x = Box::new_in(String::from("Hello"), System);
let (ptr, alloc) = Box::into_raw_with_allocator(x);
let x = unsafe { Box::from_raw_in(ptr, alloc) };
```

```Rust
#![feature(allocator_api)]

use std::alloc::{Allocator, Layout, System};
use std::ptr::{self, NonNull};

let x = Box::new_in(String::from("Hello"), System);
let (ptr, alloc) = Box::into_raw_with_allocator(x);
unsafe {
    ptr::drop_in_place(ptr);
    let non_null = NonNull::new_unchecked(ptr);
    alloc.deallocate(non_null.cast(), Layout::new::<String>());
}
```

--------------------------------

### Rust Box<T> Initialization Examples

Source: https://docs.rs/seaography/1.1.4/seaography/builder_context/types_map/type.FnOutputTypeConversion

Demonstrates various methods for initializing a `Box<T>` in Rust. Includes creating a Box with a value, with uninitialized memory, zeroed memory, and pinning.

```Rust
let five = Box::new(5);

```

```Rust
let mut five = Box::<u32>::new_uninit();
// Deferred initialization:
five.write(5);
let five = unsafe { five.assume_init() };

assert_eq!(*five, 5)

```

```Rust
#![feature(new_zeroed_alloc)]

let zero = Box::<u32>::new_zeroed();
let zero = unsafe { zero.assume_init() };

assert_eq!(*zero, 0)

```

```Rust
let pinned_box = Box::pin(x);

```

--------------------------------

### Fetch Films and Actors (MySQL Example)

Source: https://docs.rs/seaography/1.1.4/index

A GraphQL query to fetch films with pagination and ordering by title, including their associated actors. This demonstrates relational querying and pagination capabilities within Seaography.

```graphql
{
  film(pagination: { page: { limit: 10, page: 0 } }, orderBy: { title: ASC }) {
    nodes {
      title
      description
      releaseYear
      actor {
        nodes {
          firstName
          lastName
        }
      }
    }
  }
}
```

--------------------------------

### Fetch Store and its Employee (MySQL Example)

Source: https://docs.rs/seaography/1.1.4/index

A GraphQL query to fetch store information, filtered by store ID, and including details about its employees and addresses. This showcases filtering and nested relation fetching.

```graphql
{
  store(filters: { storeId: { eq: 1 } }) {
    nodes {
      storeId
      address {
        address
        address2
      }
      staff {
        firstName
        lastName
      }
    }
  }
}
```

--------------------------------

### Get Current Stream Position (Rust)

Source: https://docs.rs/seaography/1.1.4/seaography/builder_context/types_map/type.FnOutputTypeConversion

Returns the current position within the boxed stream, measured in bytes from the start.

```rust
fn stream_position(&mut self) -> Result<u64, Error>
```

--------------------------------

### Filter Using Enumeration (MySQL Example)

Source: https://docs.rs/seaography/1.1.4/index

A GraphQL query demonstrating filtering by an enumeration value. This example filters films by their 'rating' field, specifically selecting films with the NC17 rating and applying pagination.

```graphql
{
  film(
    filters: { rating: { eq: NC17 } }
    pagination: { page: { page: 1, limit: 5 } }
  ) {
    nodes {
      filmId
      rating
    }
  }
}
```

--------------------------------

### Generate SeaORM Entities and Seaography Server for MySQL

Source: https://docs.rs/seaography/1.1.4/seaography/index

Generates SeaORM entities and a Seaography GraphQL server from a MySQL database. This command requires the `sea-orm-cli` and `seaography-cli` to be installed. It outputs generated entities to `src/entities` and creates a new project directory for the server.

```bash
cd examples/mysql
sea-orm-cli generate entity -o src/entities -u mysql://user:pw@127.0.0.1/sakila --seaography
seaography-cli ./ src/entities mysql://user:pw@127.0.0.1/sakila seaography-mysql-example
cd seaography-mysql-example
cargo run
```

--------------------------------

### Generate SeaORM Entities and Seaography Server for Postgres

Source: https://docs.rs/seaography/1.1.4/seaography/index

Generates SeaORM entities and a Seaography GraphQL server from a PostgreSQL database. Similar to the MySQL example, this requires the CLI tools and outputs generated entities and server code.

```bash
cd examples/postgres
sea-orm-cli generate entity -o src/entities -u postgres://user:pw@localhost/sakila --seaography
seaography-cli ./ src/entities postgres://user:pw@localhost/sakila seaography-postgres-example
cd seaography-postgres-example
cargo run
```

--------------------------------

### Generic Implementations for CursorInputBuilder (Rust)

Source: https://docs.rs/seaography/1.1.4/seaography/inputs/cursor_input/struct.CursorInputBuilder

Details various blanket implementations for CursorInputBuilder, including traits like Send, Sync, Freeze, and generic conversions like Any, Borrow, From, Into, TryFrom, and TryInto.

```rust
impl Freeze for CursorInputBuilder
impl !RefUnwindSafe for CursorInputBuilder
impl Send for CursorInputBuilder
impl Sync for CursorInputBuilder
impl Unpin for CursorInputBuilder
impl !UnwindSafe for CursorInputBuilder
```

```rust
impl<T> Any for T
where T: 'static + ?Sized,
fn type_id(&self) -> TypeId
```

```rust
impl<T> Borrow<T> for T
where T: ?Sized,
fn borrow(&self) -> &T
```

```rust
impl<T> BorrowMut<T> for T
where T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
```

```rust
impl<T> From<T> for T
fn from(t: T) -> T
```

```rust
impl<T> Instrument for T
fn instrument(self, span: Span) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
```

```rust
impl<T, U> Into<U> for T
where U: From<T>,
fn into(self) -> U
```

```rust
impl<T> IntoEither for T
fn into_either(self, into_left: bool) -> Either<Self, Self>
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool
```

```rust
impl<T, U> TryFrom<U> for T
where U: Into<T>,
type Error = Infallible
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
```

```rust
impl<T, U> TryInto<U> for T
where U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

```rust
impl<T> WithSubscriber for T
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>
fn with_current_subscriber(self) -> WithDispatch<Self>
```

```rust
impl<T> ErasedDestructor for T
where T: 'static
```

--------------------------------

### Get Stream Length (Nightly Rust)

Source: https://docs.rs/seaography/1.1.4/seaography/builder_context/types_map/type.FnOutputTypeConversion

Returns the total length of the boxed stream in bytes. This is a nightly-only experimental API.

```rust
fn stream_len(&mut self) -> Result<u64, Error>
```

--------------------------------

### Generate MySQL Entities and Seaography Server

Source: https://docs.rs/seaography/1.1.4/index

Generates SeaORM entities and a Seaography GraphQL server from a MySQL database. This process involves using the sea-orm-cli to create entities and then seaography-cli to generate the server code, followed by running the generated server.

```bash
cd examples/mysql
sea-orm-cli generate entity -o src/entities -u mysql://user:pw@127.0.0.1/sakila --seaography
seaography-cli ./ src/entities mysql://user:pw@127.0.0.1/sakila seaography-mysql-example
cargo run
```

--------------------------------

### Iterator Consumption Methods

Source: https://docs.rs/seaography/1.1.4/seaography/builder_context/types_map/type.FnInputTypeConversion

Methods that consume the iterator to produce a single result, such as getting the last element or counting the total number of elements.

```APIDOC
## fn last(self) -> Option<<I as Iterator>::Item>

### Description
Consumes the iterator, returning the last element.

### Method
`last`

### Parameters
None

### Response
#### Success Response (200)
- **Option<Item>** - The last item in the iterator, or None if the iterator is empty.

## fn count(self) -> usize

### Description
Consumes the iterator, counting the number of iterations and returning it.

### Method
`count`

### Parameters
None

### Response
#### Success Response (200)
- **usize** - The total number of elements in the iterator.
```

--------------------------------

### Rust Builder: New Instance Creation

Source: https://docs.rs/seaography/1.1.4/seaography/builder/struct.Builder

Demonstrates the creation of a new 'Builder' instance in Rust. This function requires a static 'BuilderContext' and a 'DatabaseConnection' to initialize the schema builder.

```rust
pub fn new( context: &'static BuilderContext, connection: DatabaseConnection, ) -> Self
```

--------------------------------

### Seek Operations

Source: https://docs.rs/seaography/1.1.4/seaography/builder_context/types_map/type.FnOutputTypeConversion

Provides methods for seeking within a stream, including seeking to specific positions, rewinding, and getting stream length/position.

```APIDOC
## POST /seek

### Description
Performs seek operations on a stream.

### Method
POST

### Endpoint
/seek

### Parameters
#### Request Body
- **seekOperation** (string) - Required - The type of seek operation (e.g., 'seek', 'rewind', 'stream_len').
- **position** (SeekFrom) - Optional - The position to seek to.
- **offset** (i64) - Optional - The relative offset for seeking.

### Response
#### Success Response (200)
- **newPosition** (u64) - The new position after seeking.
- **streamLength** (u64) - The length of the stream.

#### Response Example
```json
{
  "newPosition": 512,
  "streamLength": 4096
}
```
```

--------------------------------

### Get GraphQL Enumeration Configuration in Rust

Source: https://docs.rs/seaography/1.1.4/seaography/enumerations/order_by_enum/struct.OrderByEnumBuilder

A method on the OrderByEnumBuilder that retrieves the GraphQL enumeration configuration. This is useful for understanding the structure and available options for sorting.

```rust
pub fn enumeration(&self) -> Enum
```

--------------------------------

### Create Box from Raw Pointer and Allocator (Rust)

Source: https://docs.rs/seaography/1.1.4/seaography/builder_context/types_map/type.FnOutputTypeConversion

This Rust code demonstrates how to recreate a `Box` from a raw pointer and allocator, and how to create a `Box` from scratch using a system allocator. This involves unsafe operations to manage memory manually, ensuring proper allocation and deallocation to avoid memory leaks or double frees. The examples use `Box::from_raw_in` and manual allocation with `System` allocator.

```Rust
#![feature(allocator_api)]

use std::alloc::System;

let x = Box::new_in(5, System);
let (ptr, alloc) = Box::into_raw_with_allocator(x);
let x = unsafe { Box::from_raw_in(ptr, alloc) };
```

```Rust
#![feature(allocator_api, slice_ptr_get)]

use std::alloc::{Allocator, Layout, System};

unsafe {
    let ptr = System.allocate(Layout::new::<i32>())?.as_mut_ptr() as *mut i32;
    // In general .write is required to avoid attempting to destruct
    // the (uninitialized) previous contents of `ptr`, though for this
    // simple example `*ptr = 5` would have worked as well.
    ptr.write(5);
    let x = Box::from_raw_in(ptr, System);
}
```

--------------------------------

### Prepare and Insert Active Model in Seaography (Rust)

Source: https://docs.rs/seaography/1.1.4/src/seaography/mutation/entity_create_one_mutation.rs

This snippet demonstrates preparing an active model for insertion into a database using `sea-orm` and `async_graphql`. It handles potential errors during the process and returns the inserted data or an error. Dependencies include `async_graphql` and `sea_orm`.

```Rust
Ok(Some(FieldValue::owned_any(result)))
                })
            },
        )
        .argument(InputValue::new(
            &context.entity_create_one_mutation.data_field,
            TypeRef::named_nn(entity_input_builder.insert_type_name::<T>()),
        ))
    }
}
```

--------------------------------

### Iterator Core Methods

Source: https://docs.rs/seaography/1.1.4/seaography/builder_context/types_map/type.FnInputTypeConversion

Core methods for advancing and inspecting iterator elements, including getting the next item, size hints, and finding specific elements.

```APIDOC
## type Item = <I as Iterator>::Item

### Description
The type of the elements being iterated over.

## fn next(&mut self) -> Option<<I as Iterator>::Item>

### Description
Advances the iterator and returns the next value.

### Method
`next`

### Parameters
None

### Response
#### Success Response (200)
- **Option<Item>** - The next item in the iterator, or None if the iterator is exhausted.

## fn size_hint(&self) -> (usize, Option<usize>)

### Description
Returns the bounds on the remaining length of the iterator.

### Method
`size_hint`

### Parameters
None

### Response
#### Success Response (200)
- **(usize, Option<usize>)** - A tuple representing the lower and upper bounds of the remaining iterator length.

## fn nth(&mut self, n: usize) -> Option<<I as Iterator>::Item>

### Description
Returns the `n`th element of the iterator.

### Method
`nth`

### Parameters
#### Path Parameters
- **n** (usize) - Required - The index of the element to retrieve.

### Response
#### Success Response (200)
- **Option<Item>** - The `n`th item in the iterator, or None if `n` is out of bounds.
```

--------------------------------

### Get Entity Field Name with Rust

Source: https://docs.rs/seaography/1.1.4/seaography/query/entity_query_field/struct.EntityQueryFieldBuilder

This Rust function, `type_name`, is part of the EntityQueryFieldBuilder. It takes a generic type `T` that implements EntityTrait and returns the field name as a String.

```rust
pub fn type_name<T>(&self) -> String
where T: EntityTrait,
    <T as EntityTrait>::Model: Sync,
```

--------------------------------

### Rust Box<T> Allocation Methods

Source: https://docs.rs/seaography/1.1.4/seaography/builder_context/types_map/type.FnInputTypeConversion

Demonstrates various ways to allocate and manage memory using `Box<T>` in Rust. Includes standard `new`, `new_uninit`, `new_zeroed`, and experimental `try_new`, `try_new_uninit`, `try_new_zeroed` for fallible allocations. Also covers `pin` for creating pinned boxes.

```rust
let five = Box::new(5);

```

```rust
#![feature(new_zeroed_alloc)]

let zero = Box::<u32>::new_zeroed();
let zero = unsafe { zero.assume_init() };

assert_eq!(*zero, 0)

```

```rust
#![feature(allocator_api)]

let mut five = Box::<u32>::try_new_uninit()?;
// Deferred initialization:
five.write(5);
let five = unsafe { five.assume_init() };

assert_eq!(*five, 5);

```

--------------------------------

### PaginationInputBuilder Methods for Input Handling

Source: https://docs.rs/seaography/1.1.4/seaography/inputs/pagination_input/struct.PaginationInputBuilder

Provides methods for the `PaginationInputBuilder` to retrieve the type name, generate the input object, and parse query values into a `PaginationInput` structure. These are essential for integrating with GraphQL or similar query systems.

```rust
pub fn type_name(&self) -> String
// used to get type name

pub fn input_object(&self) -> InputObject
// used to get pagination input object

pub fn parse_object(&self, value: Option<ValueAccessor<'_>>) -> PaginationInput
// used to parse query input to pagination information structure
```

--------------------------------

### CursorInputBuilder Methods (Rust)

Source: https://docs.rs/seaography/1.1.4/seaography/inputs/cursor_input/struct.CursorInputBuilder

Provides methods for the CursorInputBuilder struct, including retrieving the type name, getting the input object, and parsing query input into a CursorInput struct.

```rust
pub fn type_name(&self) -> String
used to get type name
```

```rust
pub fn input_object(&self) -> InputObject
used to get cursor pagination options object
```

```rust
pub fn parse_object(&self, object: &ObjectAccessor<'_>) -> CursorInput
used to parse query input to cursor pagination options struct
```

--------------------------------

### Get Unsigned 64-bit Integer (Native-Endian)

Source: https://docs.rs/seaography/1.1.4/seaography/builder_context/types_map/type.FnOutputTypeConversion

Retrieves an unsigned 64-bit integer in the native byte order of the system from the source. Optimized for native system compatibility.

```rust
fn get_u64_ne(&mut self) -> u64
```

--------------------------------

### EntityObjectRelationBuilder::get_relation

Source: https://docs.rs/seaography/1.1.4/seaography/query/entity_object_relation/struct.EntityObjectRelationBuilder

This method is used to get a GraphQL field for an SeaORM entity relationship. It takes a name, a relation definition, and generic type parameters for the source and target entities.

```APIDOC
## GET /websites/rs_seaography_1_1_4/seaography::query::entity_object_relation/EntityObjectRelationBuilder/get_relation

### Description
Used to get a GraphQL field for an SeaORM entity relationship.

### Method
GET

### Endpoint
`/websites/rs_seaography_1_1_4/seaography::query::entity_object_relation/EntityObjectRelationBuilder/get_relation`

### Parameters
#### Path Parameters
- **name** (str) - Required - The name of the relationship.
- **relation_definition** (RelationDef) - Required - The definition of the relationship.

#### Query Parameters
None

#### Request Body
None

### Request Example
```json
{
  "example": "No request body for this example"
}
```

### Response
#### Success Response (200)
- **Field** (type) - Description of the returned GraphQL field.

#### Response Example
```json
{
  "example": "GraphQL Field Object"
}
```
```

--------------------------------

### Rust Box<T> Allocation Error Handling Examples

Source: https://docs.rs/seaography/1.1.4/seaography/builder_context/types_map/type.FnOutputTypeConversion

Illustrates how to handle potential allocation errors when creating a `Box<T>` in Rust using `try_new`, `try_new_uninit`, and `try_new_zeroed`. These methods return a `Result` to manage allocation failures.

```Rust
#![feature(allocator_api)]

let five = Box::try_new(5)?;

```

```Rust
#![feature(allocator_api)]

let mut five = Box::<u32>::try_new_uninit()?;
// Deferred initialization:
five.write(5);
let five = unsafe { five.assume_init() };

assert_eq!(*five, 5);

```

```Rust
#![feature(allocator_api)]

let zero = Box::<u32>::try_new_zeroed()?;
let zero = unsafe { zero.assume_init() };

assert_eq!(*zero, 0);

```

--------------------------------

### fn by_ref

Source: https://docs.rs/seaography/1.1.4/seaography/builder_context/types_map/type.FnInputTypeConversion

Creates a “by reference” adapter for this instance of `Write`.

```APIDOC
## fn by_ref

### Description
Creates a “by reference” adapter for this instance of `Write`.

### Method
`by_ref`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
Returns a mutable reference to the writer instance.

#### Response Example
```json
{
  "result": "<mutable_writer_reference>"
}
```
```

--------------------------------

### PageInfoObjectBuilder Methods (Rust)

Source: https://docs.rs/seaography/1.1.4/seaography/outputs/page_info_object/struct.PageInfoObjectBuilder

Provides implementations for key methods of the PageInfoObjectBuilder, including 'type_name' to get the type's name as a String and 'to_object' to obtain the GraphQL object representation.

```Rust
pub fn type_name(&self) -> String
```

```Rust
pub fn to_object(&self) -> Object
```

--------------------------------

### Generic Implementations for PageInfoObjectBuilder (Rust)

Source: https://docs.rs/seaography/1.1.4/seaography/outputs/page_info_object/struct.PageInfoObjectBuilder

Details various auto and blanket implementations for the PageInfoObjectBuilder, showcasing its compatibility with standard Rust traits like Send, Sync, Freeze, and generic operations like TryFrom, Into, and Instrument.

```Rust
impl Freeze for PageInfoObjectBuilder
impl !RefUnwindSafe for PageInfoObjectBuilder
impl Send for PageInfoObjectBuilder
impl Sync for PageInfoObjectBuilder
impl Unpin for PageInfoObjectBuilder
impl !UnwindSafe for PageInfoObjectBuilder
```

```Rust
impl<T> Any for T
where T: 'static + ?Sized
```

```Rust
impl<T> Borrow<T> for T
where T: ?Sized
```

```Rust
impl<T> BorrowMut<T> for T
where T: ?Sized
```

```Rust
impl<T> From<T> for T
```

```Rust
impl<T> Instrument for T
```

```Rust
impl<T, U> Into<U> for T
where U: From<T>
```

```Rust
impl<T> IntoEither for T
```

```Rust
impl<T, U> TryFrom<U> for T
where U: Into<T>
```

```Rust
impl<T, U> TryInto<U> for T
where U: TryFrom<T>
```

```Rust
impl<T> WithSubscriber for T
```

```Rust
impl<T> ErasedDestructor for T
where T: 'static
```

--------------------------------

### Implement CloneToUninit for T (Blanket Implementation - Rust)

Source: https://docs.rs/seaography/1.1.4/seaography/query/loader/struct.HashableColumn

A nightly-only experimental blanket implementation of `CloneToUninit` for types `T` that implement `Clone`. This unsafe function allows copying data to uninitialized memory, useful in low-level memory management.

```rust
impl<T> CloneToUninit for T
where T: Clone,
{
    unsafe fn clone_to_uninit(&self, dest: *mut u8) {
        // ... implementation details ...
    }
}
```

--------------------------------

### ExactSizeIterator for Box<I, A> in Rust

Source: https://docs.rs/seaography/1.1.4/seaography/builder_context/types_map/type.FnInputTypeConversion

Implements the `ExactSizeIterator` trait for `Box<I, A>`, allowing it to provide an exact count of remaining elements. It includes methods for getting the length and checking if the iterator is empty.

```Rust
impl<I, A> ExactSizeIterator for Box<I, A>
where
    I: ExactSizeIterator + ?Sized,
    A: Allocator,
{
    fn len(&self) -> usize {
        // ... implementation ...
    }

    fn is_empty(&self) -> bool {
        // ... implementation ...
    }
}
```

--------------------------------

### Get i64 (Little-Endian)

Source: https://docs.rs/seaography/1.1.4/seaography/builder_context/types_map/type.FnOutputTypeConversion

Retrieves a signed 64-bit integer from the data source in little-endian byte order. This is useful for parsing signed 64-bit integers from little-endian sources.

```rust
fn try_get_i64_le(&mut self) -> Result<i64, TryGetError>
```

--------------------------------

### try_new_zeroed_in

Source: https://docs.rs/seaography/1.1.4/seaography/builder_context/types_map/type.FnInputTypeConversion

Constructs a new `Box` with uninitialized contents, filling the memory with 0 bytes using the provided allocator. Returns an error if allocation fails. This is a nightly-only experimental API.

```APIDOC
## POST /try_new_zeroed_in

### Description
Constructs a new `Box` with uninitialized contents, with the memory being filled with `0` bytes in the provided allocator, returning an error if the allocation fails.

### Method
POST

### Endpoint
`/try_new_zeroed_in`

### Parameters
#### Query Parameters
- **alloc** (Allocator) - Required - The allocator to use for memory allocation.

### Request Body
- **content** (T) - Optional - The initial value to be placed in the box (if not zeroed).

### Request Example
```json
{
  "alloc": "System",
  "content": null
}
```

### Response
#### Success Response (200)
- **Box<MaybeUninit<T>, A>** - A boxed `MaybeUninit<T>` allocated with the specified allocator.

#### Response Example
```json
{
  "ptr": "0x...",
  "capacity": 1
}
```

**Note:** This endpoint is experimental and requires the `allocator_api` feature.
```

--------------------------------

### TryInto Trait

Source: https://docs.rs/seaography/1.1.4/seaography/query/loader/struct.HashableGroupKey

Provides a standard way to attempt a conversion from one type to another, returning a Result.

```APIDOC
## impl<T, U> TryInto<U> for T

### Description
This trait allows attempting a conversion from type `T` into type `U`, where `U` implements `TryFrom<T>`.

### Method
`try_into`

### Endpoint
N/A (This is a trait implementation, not an API endpoint)

### Parameters
N/A

### Request Example
N/A

### Response
#### Success Response
- **Ok(U)**: The converted value of type `U` if the conversion is successful.

#### Error Response
- **Err(Error)**: An error object if the conversion fails. The `Error` type is defined as `U::Error`.

#### Response Example
```rust
// Example of successful conversion
let result: Result<String, _> = 10i32.try_into();
match result {
    Ok(s) => println!("Converted: {}", s),
    Err(e) => println!("Error converting: {}", e),
}

// Example of failed conversion (if U does not implement TryFrom<T>)
// let result: Result<i32, _> = "hello".try_into();
```
```

--------------------------------

### Get u64 (Little-Endian)

Source: https://docs.rs/seaography/1.1.4/seaography/builder_context/types_map/type.FnOutputTypeConversion

Retrieves an unsigned 64-bit integer from the data source in little-endian byte order. Use this for parsing 64-bit unsigned integers in little-endian formats.

```rust
fn try_get_u64_le(&mut self) -> Result<u64, TryGetError>
```

--------------------------------

### Construct Box with Zeroed Contents (Nightly)

Source: https://docs.rs/seaography/1.1.4/seaography/builder_context/types_map/type.FnInputTypeConversion

Creates a new `Box` with uninitialized contents, filling the memory with `0` bytes using the specified allocator. Returns an `AllocError` if allocation fails. This is a nightly-only experimental API.

```rust
#![feature(allocator_api)]

use std::alloc::System;

let zero = Box::<u32, _>::try_new_zeroed_in(System)?;
let zero = unsafe { zero.assume_init() };

assert_eq!(*zero, 0);

```

--------------------------------

### Get u64 (Big-Endian)

Source: https://docs.rs/seaography/1.1.4/seaography/builder_context/types_map/type.FnOutputTypeConversion

Retrieves an unsigned 64-bit integer from the data source in big-endian byte order. This is suitable for applications requiring 64-bit integers with a big-endian format.

```rust
fn try_get_u64(&mut self) -> Result<u64, TryGetError>
```

--------------------------------

### Implement Blanket CloneToUninit for T in Rust

Source: https://docs.rs/seaography/1.1.4/seaography/inputs/pagination_input/struct.PaginationInput

Presents the experimental blanket implementation of `CloneToUninit` for types `T` that implement `Clone`. This is a nightly-only API for copying data to uninitialized memory.

```rust
impl<T> CloneToUninit for T where T: Clone {
    unsafe fn clone_to_uninit(&self, dest: *mut u8) {
        // ... implementation ...
    }
}
```

--------------------------------

### Get u32 (Little-Endian)

Source: https://docs.rs/seaography/1.1.4/seaography/builder_context/types_map/type.FnOutputTypeConversion

Retrieves an unsigned 32-bit integer from the data source in little-endian byte order. This method is suitable for data formats that use little-endian representation.

```rust
fn try_get_u32_le(&mut self) -> Result<u32, TryGetError>
```

--------------------------------

### Get Unsigned 128-bit Integer (Big-Endian)

Source: https://docs.rs/seaography/1.1.4/seaography/builder_context/types_map/type.FnOutputTypeConversion

Retrieves an unsigned 128-bit integer in big-endian byte order from the source. Handles very large unsigned integers with big-endian formatting.

```rust
fn get_u128(&mut self) -> u128
```

--------------------------------

### Get Signed 32-bit Integer (Little-Endian)

Source: https://docs.rs/seaography/1.1.4/seaography/builder_context/types_map/type.FnOutputTypeConversion

Retrieves a signed 32-bit integer in little-endian byte order from the source. Essential for systems where byte order differs from big-endian.

```rust
fn get_i32_le(&mut self) -> i32
```

--------------------------------

### Generate SeaORM Entities and Seaography Server for SQLite

Source: https://docs.rs/seaography/1.1.4/seaography/index

Generates SeaORM entities and a Seaography GraphQL server from a SQLite database file. This process follows the same pattern as MySQL and Postgres, adapting the connection URL for SQLite.

```bash
cd examples/sqlite
sea-orm-cli generate entity -o src/entities -u sqlite://sakila.db --seaography
seaography-cli ./ src/entities sqlite://sakila.db seaography-sqlite-example
cd seaography-sqlite-example
cargo run
```

--------------------------------

### Rust Struct PageInfo for Pagination

Source: https://docs.rs/seaography/1.1.4/seaography/outputs/page_info_object/struct.PageInfo

Defines the PageInfo struct used for holding pagination information, including booleans for previous/next page existence and optional cursor strings for start and end points.

```Rust
pub struct PageInfo {
    pub has_previous_page: bool,
    pub has_next_page: bool,
    pub start_cursor: Option<String>,
    pub end_cursor: Option<String>,
}
```

--------------------------------

### Generate Postgres Entities and Seaography Server

Source: https://docs.rs/seaography/1.1.4/index

Generates SeaORM entities and a Seaography GraphQL server from a PostgreSQL database. This process is similar to the MySQL example, but uses a PostgreSQL connection string and specifies 'postgres' as the database type.

```bash
cd examples/postgres
sea-orm-cli generate entity -o src/entities -u postgres://user:pw@localhost/sakila --seaography
seaography-cli ./ src/entities postgres://user:pw@localhost/sakila seaography-postgres-example
cargo run
```

--------------------------------

### Get Introspection Type Name

Source: https://docs.rs/seaography/1.1.4/seaography/builder_context/types_map/type.FnOutputTypeConversion

Retrieves the introspection type name as a `Cow<'static, str>`. This is useful for introspection queries in GraphQL. The 'static lifetime indicates the string does not change.

```rust
fn introspection_type_name(&self) -> Cow<'static, str>
```

--------------------------------

### Rust Box<T> Creation from Raw Pointer Examples

Source: https://docs.rs/seaography/1.1.4/seaography/builder_context/types_map/type.FnOutputTypeConversion

Shows how to safely construct a `Box<T>` from a raw pointer in Rust using `Box::from_raw`. This is useful when interacting with C APIs or managing memory manually, but requires careful handling to avoid memory safety issues like double-frees.

```Rust
let x = Box::new(5);
let ptr = Box::into_raw(x);
let x = unsafe { Box::from_raw(ptr) };

```

```Rust
use std::alloc::{alloc, Layout};

unsafe {
    let ptr = alloc(Layout::new::<i32>()) as *mut i32;
    // In general .write is required to avoid attempting to destruct
    // the (uninitialized) previous contents of `ptr`, though for this
    // simple example `*ptr = 5` would have worked as well.
    ptr.write(5);
    let x = Box::from_raw(ptr);
}

```

--------------------------------

### Implement TryInto<U> for T (Blanket Implementation - Rust)

Source: https://docs.rs/seaography/1.1.4/seaography/query/loader/struct.HashableColumn

A blanket implementation of `TryInto<U>` for type `T`, provided that `U` implements `TryFrom<T>`. This enables fallible conversions from `T` to `U` using the `.try_into()` method.

```rust
impl<T, U> TryInto<U> for T
where U: TryFrom<T>,
{
    type Error = <U as TryFrom<T>>::Error;

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error> {
        U::try_from(self)
    }
}
```

--------------------------------

### Get Type Name (Rust)

Source: https://docs.rs/seaography/1.1.4/seaography/builder_context/types_map/type.FnOutputTypeConversion

Returns the static type name of the `Box<T>` as a `Cow<'static, str>`. This method is part of the `OutputType` trait and is useful for reflection or debugging purposes.

```rust
fn type_name() -> Cow<'static, str>
```

--------------------------------

### Get i128 (Little-Endian)

Source: https://docs.rs/seaography/1.1.4/seaography/builder_context/types_map/type.FnOutputTypeConversion

Retrieves a signed 128-bit integer from the data source in little-endian byte order. This method is appropriate for signed 128-bit integers in little-endian encoded data.

```rust
fn try_get_i128_le(&mut self) -> Result<i128, TryGetError>
```

--------------------------------

### Default Pagination with SeaORM

Source: https://docs.rs/seaography/1.1.4/src/seaography/query/pagination.rs

Handles cases where no specific pagination input (page or offset) is provided. It fetches all data, creates Edges with cursors, and returns a Connection object with basic pagination information, indicating no previous or next pages.

```rust
let data = stmt.all(db).await?;

let edges: Vec<Edge<T>> = data
    .into_iter()
    .map(|node| {
        let values: Vec<sea_orm::Value> = T::PrimaryKey::iter()
            .map(|variant| node.get(variant.into_column()))
            .collect();

        let cursor: String = encode_cursor(values);

        Edge { cursor, node }
    })
    .collect();

let start_cursor = edges.first().map(|edge| edge.cursor.clone());
let end_cursor = edges.last().map(|edge| edge.cursor.clone());

let total = edges.len() as u64;

Ok(Connection {
    edges,
    page_info: PageInfo {
        has_previous_page: false,
        has_next_page: false,
        start_cursor,
        end_cursor,
    },
    pagination_info: Some(PaginationInfo {
        pages: 1,
        current: 1,
        offset: 0,
        total,
    }),
})
```

--------------------------------

### Get i128 (Big-Endian)

Source: https://docs.rs/seaography/1.1.4/seaography/builder_context/types_map/type.FnOutputTypeConversion

Retrieves a signed 128-bit integer from the data source in big-endian byte order. This function is necessary for handling signed 128-bit integers in big-endian formats.

```rust
fn try_get_i128(&mut self) -> Result<i128, TryGetError>
```

--------------------------------

### GraphQL Query: Complex query with filters on relations (MySQL Example)

Source: https://docs.rs/seaography/1.1.4/seaography

An advanced GraphQL query demonstrating filtering customers by `active: 0`, paginating their payments with `amount > 7`, and ordering payments. It also shows nested pagination information.

```graphql
{
  customer(
    filters: { active: { eq: 0 } }
    pagination: { cursor: { limit: 3, cursor: "Int[3]:271" } }
  ) {
    nodes {
      customerId
      lastName
      email
      address {
        address
      }
      payment(
        filters: { amount: { gt: "7" } }
        orderBy: { amount: ASC }
        pagination: { page: { limit: 1, page: 1 } }
      ) {
        nodes {
          paymentId
          amount
        }
        paginationInfo {
          pages
          current
        }
        pageInfo {
          hasPreviousPage
          hasNextPage
        }
      }
    }
    pageInfo {
      hasPreviousPage
      hasNextPage
      endCursor
    }
  }
}

```

--------------------------------

### impl<T, A> PartialEq for Box<T, A>

Source: https://docs.rs/seaography/1.1.4/seaography/builder_context/types_map/type.FnInputTypeConversion

Implementation of PartialEq for Box<T, A>.

```APIDOC
## impl<T, A> PartialEq for Box<T, A>

### Description
Implementation of `PartialEq` for `Box<T, A>`.

### Methods
#### fn eq
Tests for `self` and `other` values to be equal, and is used by `==`.

#### fn ne
Tests for `!=`. The default implementation is almost always sufficient, and should not be overridden without very good reason.
```

--------------------------------

### Get u128 (Little-Endian)

Source: https://docs.rs/seaography/1.1.4/seaography/builder_context/types_map/type.FnOutputTypeConversion

Retrieves an unsigned 128-bit integer from the data source in little-endian byte order. Use this function for unsigned 128-bit integers in little-endian data streams.

```rust
fn try_get_u128_le(&mut self) -> Result<u128, TryGetError>
```

--------------------------------

### Get u128 (Big-Endian)

Source: https://docs.rs/seaography/1.1.4/seaography/builder_context/types_map/type.FnOutputTypeConversion

Retrieves an unsigned 128-bit integer from the data source in big-endian byte order. This is designed for scenarios requiring large unsigned integers in a big-endian format.

```rust
fn try_get_u128(&mut self) -> Result<u128, TryGetError>
```

--------------------------------

### Rust: Re-export async-graphql crate

Source: https://docs.rs/seaography/1.1.4/seaography

This line indicates that the `async-graphql` crate is re-exported by the `seaography` crate. This makes the `async-graphql` library's features directly available to users of `seaography`.

```rust
pub use async_graphql;

```
Tokens:
Raw