swell - v2.1.3

swell/schema

Types

Argument

opaque </>

GraphQL Argument

pub opaque type Argument

Context

</>

Resolver context - will contain request context, data loaders, etc.

pub type Context {
  Context(
    data: option.Option(value.Value),
    arguments: dict.Dict(String, value.Value),
    variables: dict.Dict(String, value.Value),
  )
}

Constructors

EnumValue

opaque </>

GraphQL Enum Value

pub opaque type EnumValue

Field

opaque </>

GraphQL Field

pub opaque type Field

InputField

opaque </>

GraphQL Input Field (for InputObject types)

pub opaque type InputField

Resolver

</>

Field resolver function type

pub type Resolver =
  fn(Context) -> Result(value.Value, String)

Schema

opaque </>

GraphQL Schema

pub opaque type Schema

Type

opaque </>

GraphQL Type

pub opaque type Type

Values

argument

</> 
pub fn argument(
  name: String,
  arg_type: Type,
  description: String,
  default_value: option.Option(value.Value),
) -> Argument

argument_description

</> 
pub fn argument_description(arg: Argument) -> String

Get argument description

argument_name

</> 
pub fn argument_name(arg: Argument) -> String

Get argument name

argument_type

</> 
pub fn argument_type(arg: Argument) -> Type

Get argument type

boolean_type

</> 
pub fn boolean_type() -> Type

context

</> 
pub fn context(data: option.Option(value.Value)) -> Context

Helper to create a context without arguments or variables

context_with_variables

</> 
pub fn context_with_variables(
  data: option.Option(value.Value),
  variables: dict.Dict(String, value.Value),
) -> Context

Helper to create a context with variables

enum_type

</> 
pub fn enum_type(
  name: String,
  description: String,
  values: List(EnumValue),
) -> Type

enum_value

</> 
pub fn enum_value(name: String, description: String) -> EnumValue

enum_value_description

</> 
pub fn enum_value_description(enum_value: EnumValue) -> String

Get enum value description

enum_value_name

</> 
pub fn enum_value_name(enum_value: EnumValue) -> String

Get enum value name

field

</> 
pub fn field(
  name: String,
  field_type: Type,
  description: String,
  resolver: fn(Context) -> Result(value.Value, String),
) -> Field

field_arguments

</> 
pub fn field_arguments(field: Field) -> List(Argument)

Get field arguments

field_description

</> 
pub fn field_description(field: Field) -> String

Get field description

field_name

</> 
pub fn field_name(f: Field) -> String

field_type

</> 
pub fn field_type(field: Field) -> Type

Get the type of a field

field_with_args

</> 
pub fn field_with_args(
  name: String,
  field_type: Type,
  description: String,
  arguments: List(Argument),
  resolver: fn(Context) -> Result(value.Value, String),
) -> Field

float_type

</> 
pub fn float_type() -> Type

get_argument

</> 
pub fn get_argument(
  ctx: Context,
  name: String,
) -> option.Option(value.Value)

Helper to get an argument value from context

get_enum_values

</> 
pub fn get_enum_values(t: Type) -> List(EnumValue)

Get all enum values from an EnumType

get_field

</> 
pub fn get_field(
  t: Type,
  field_name: String,
) -> option.Option(Field)

get_fields

</> 
pub fn get_fields(t: Type) -> List(Field)

Get all fields from an ObjectType

get_input_fields

</> 
pub fn get_input_fields(t: Type) -> List(InputField)

Get all input fields from an InputObjectType

get_mutation_type

</> 
pub fn get_mutation_type(s: Schema) -> option.Option(Type)

get_possible_types

</> 
pub fn get_possible_types(t: Type) -> List(Type)

Get the possible types from a union

get_subscription_type

</> 
pub fn get_subscription_type(s: Schema) -> option.Option(Type)

get_union_type_resolver

</> 
pub fn get_union_type_resolver(
  t: Type,
) -> fn(Context) -> Result(String, String)

Get the type resolver function from a union type. The type resolver is called at runtime to determine which concrete type a union value represents, based on the data in the context. Returns a default resolver that always errors for non-union types. This is primarily used internally for union type normalization.

get_variable

</> 
pub fn get_variable(
  ctx: Context,
  name: String,
) -> option.Option(value.Value)

Helper to get a variable value from context

id_type

</> 
pub fn id_type() -> Type

inner_type

</> 
pub fn inner_type(t: Type) -> option.Option(Type)

Get the inner type from a wrapping type (List or NonNull)

input_field

</> 
pub fn input_field(
  name: String,
  field_type: Type,
  description: String,
  default_value: option.Option(value.Value),
) -> InputField

input_field_description

</> 
pub fn input_field_description(input_field: InputField) -> String

Get input field description

input_field_name

</> 
pub fn input_field_name(input_field: InputField) -> String

Get input field name

input_field_type

</> 
pub fn input_field_type(input_field: InputField) -> Type

Get input field type

input_object_type

</> 
pub fn input_object_type(
  name: String,
  description: String,
  fields: List(InputField),
) -> Type

int_type

</> 
pub fn int_type() -> Type

is_enum

</> 
pub fn is_enum(t: Type) -> Bool

Check if type is an enum

is_input_object

</> 
pub fn is_input_object(t: Type) -> Bool

is_list

</> 
pub fn is_list(t: Type) -> Bool

is_non_null

</> 
pub fn is_non_null(t: Type) -> Bool

is_object

</> 
pub fn is_object(t: Type) -> Bool

Check if type is an object

is_scalar

</> 
pub fn is_scalar(t: Type) -> Bool

Check if type is a scalar

is_union

</> 
pub fn is_union(t: Type) -> Bool

Check if type is a union

list_type

</> 
pub fn list_type(inner_type: Type) -> Type

named_type_name

</> 
pub fn named_type_name(t: Type) -> String

Get the named (base) type name, unwrapping List and NonNull wrappers. This is used for fragment type condition matching and __typename where we need the concrete type name without modifiers.

non_null

</> 
pub fn non_null(inner_type: Type) -> Type

object_type

</> 
pub fn object_type(
  name: String,
  description: String,
  fields: List(Field),
) -> Type

query_type

</> 
pub fn query_type(s: Schema) -> Type

resolve_field

</> 
pub fn resolve_field(
  field: Field,
  ctx: Context,
) -> Result(value.Value, String)

resolve_union_type

</> 
pub fn resolve_union_type(
  t: Type,
  ctx: Context,
) -> Result(Type, String)

Resolve a union type to its concrete type using the type resolver

resolve_union_type_with_registry

</> 
pub fn resolve_union_type_with_registry(
  t: Type,
  ctx: Context,
  type_registry: dict.Dict(String, Type),
) -> Result(Type, String)

Resolve a union type using a canonical type registry This looks up the concrete type by name from the registry instead of from the union’s possible_types, ensuring we get the most complete type definition

schema

</> 
pub fn schema(
  query_type: Type,
  mutation_type: option.Option(Type),
) -> Schema

schema_with_subscriptions

</> 
pub fn schema_with_subscriptions(
  query_type: Type,
  mutation_type: option.Option(Type),
  subscription_type: option.Option(Type),
) -> Schema

string_type

</> 
pub fn string_type() -> Type

type_description

</> 
pub fn type_description(t: Type) -> String

type_kind

</> 
pub fn type_kind(t: Type) -> String

Get the kind of a type as a string for introspection

type_name

</> 
pub fn type_name(t: Type) -> String

union_type

</> 
pub fn union_type(
  name: String,
  description: String,
  possible_types: List(Type),
  type_resolver: fn(Context) -> Result(String, String),
) -> Type
✨ Search Document