mochi/query

Types

ArgDef

Argument definition for schema generation

pub type ArgDef {
  ArgDef(
    name: String,
    arg_type: schema.FieldType,
    description: option.Option(String),
    default_value: option.Option(dynamic.Dynamic),
  )
}

Constructors

ArgDef(
  name: String,
  arg_type: schema.FieldType,
  description: option.Option(String),
  default_value: option.Option(dynamic.Dynamic),
)

FieldKind

opaque </>

pub opaque type FieldKind(parent)

FieldOp

</>

pub type FieldOp(parent, result) =
  Op(FieldKind(parent), result)

Guard

</>

pub type Guard =
  fn(schema.ExecutionContext) -> Result(Nil, String)

MutationOp

</>

pub type MutationOp(result) =
  Op(MutationKind, result)

Unified operation type for queries, mutations, subscriptions, and fields. The kind parameter encodes what kind of operation this is at the type level. Use the type aliases QueryOp, MutationOp, SubscriptionOp, FieldOp in annotations.

pub opaque type Op(kind, result)

QueryKind

</>

pub type QueryKind {
  QueryKind
}

Constructors

```
QueryKind
```

QueryOp

</>

pub type QueryOp(result) =
  Op(QueryKind, result)

SchemaBuilder

opaque </>

pub opaque type SchemaBuilder

SubscriptionKind

</>

pub type SubscriptionKind {
  SubscriptionKind
}

Constructors

```
SubscriptionKind
```

SubscriptionOp

</>

pub type SubscriptionOp(event) =
  Op(SubscriptionKind, event)

Values

add_enum

</>

pub fn add_enum(
  builder: SchemaBuilder,
  e: schema.EnumType,
) -> SchemaBuilder

add_enums

</>

pub fn add_enums(
  builder: SchemaBuilder,
  enums: List(schema.EnumType),
) -> SchemaBuilder

add_input

</>

pub fn add_input(
  builder: SchemaBuilder,
  i: schema.InputObjectType,
) -> SchemaBuilder

add_inputs

</>

pub fn add_inputs(
  builder: SchemaBuilder,
  inputs: List(schema.InputObjectType),
) -> SchemaBuilder

add_interface

</>

pub fn add_interface(
  builder: SchemaBuilder,
  i: schema.InterfaceType,
) -> SchemaBuilder

add_interfaces

</>

pub fn add_interfaces(
  builder: SchemaBuilder,
  interfaces: List(schema.InterfaceType),
) -> SchemaBuilder

add_mutation

</>

pub fn add_mutation(
  builder: SchemaBuilder,
  m: Op(MutationKind, r),
) -> SchemaBuilder

add_mutations

</>

pub fn add_mutations(
  builder: SchemaBuilder,
  mutations: List(Op(MutationKind, r)),
) -> SchemaBuilder

add_queries

</>

pub fn add_queries(
  builder: SchemaBuilder,
  queries: List(Op(QueryKind, r)),
) -> SchemaBuilder

add_query

</>

pub fn add_query(
  builder: SchemaBuilder,
  q: Op(QueryKind, r),
) -> SchemaBuilder

add_scalar

</>

pub fn add_scalar(
  builder: SchemaBuilder,
  s: schema.ScalarType,
) -> SchemaBuilder

add_scalars

</>

pub fn add_scalars(
  builder: SchemaBuilder,
  scalars: List(schema.ScalarType),
) -> SchemaBuilder

add_subscription

</>

pub fn add_subscription(
  builder: SchemaBuilder,
  s: Op(SubscriptionKind, e),
) -> SchemaBuilder

add_subscriptions

</>

pub fn add_subscriptions(
  builder: SchemaBuilder,
  subscriptions: List(Op(SubscriptionKind, e)),
) -> SchemaBuilder

add_type

</>

pub fn add_type(
  builder: SchemaBuilder,
  t: schema.ObjectType,
) -> SchemaBuilder

add_types

</>

pub fn add_types(
  builder: SchemaBuilder,
  types: List(schema.ObjectType),
) -> SchemaBuilder

add_union

</>

pub fn add_union(
  builder: SchemaBuilder,
  u: schema.UnionType,
) -> SchemaBuilder

add_unions

</>

pub fn add_unions(
  builder: SchemaBuilder,
  unions: List(schema.UnionType),
) -> SchemaBuilder

all_of

</>

pub fn all_of(
  guard_fns: List(
    fn(schema.ExecutionContext) -> Result(Nil, String),
  ),
) -> fn(schema.ExecutionContext) -> Result(Nil, String)

Combine guards with AND logic — all must pass (checked in list order).

any_of

</>

pub fn any_of(
  guard_fns: List(
    fn(schema.ExecutionContext) -> Result(Nil, String),
  ),
) -> fn(schema.ExecutionContext) -> Result(Nil, String)

Combine guards with OR logic — at least one must pass. Fails with the last error if all fail.

arg

</>

pub fn arg(name: String, arg_type: schema.FieldType) -> ArgDef

Create an argument definition

arg_with_default

</>

pub fn arg_with_default(
  name: String,
  arg_type: schema.FieldType,
  default: dynamic.Dynamic,
) -> ArgDef

Create an argument with a default value

arg_with_default_desc

</>

pub fn arg_with_default_desc(
  name: String,
  arg_type: schema.FieldType,
  default: dynamic.Dynamic,
  description: String,
) -> ArgDef

Create an argument with default value and description

arg_with_desc

</>

pub fn arg_with_desc(
  name: String,
  arg_type: schema.FieldType,
  description: String,
) -> ArgDef

Create an argument with description

build

</>

pub fn build(builder: SchemaBuilder) -> schema.Schema

decode_input

</>

pub fn decode_input(
  args: args.Args,
  key: String,
  decoder: decode.Decoder(a),
) -> Result(a, error.GraphQLError)

field

</>

pub fn field(
  name name: String,
  returns return_type: schema.FieldType,
  decode parent_decoder: fn(dynamic.Dynamic) -> Result(
    parent,
    String,
  ),
  resolve resolver: fn(parent, schema.ExecutionContext) -> Result(
    result,
    error.GraphQLError,
  ),
) -> Op(FieldKind(parent), result)

Define a field on a type with no extra arguments.

field_with_args

</>

pub fn field_with_args(
  name name: String,
  args arg_defs: List(ArgDef),
  returns return_type: schema.FieldType,
  decode parent_decoder: fn(dynamic.Dynamic) -> Result(
    parent,
    String,
  ),
  resolve resolver: fn(parent, args.Args, schema.ExecutionContext) -> Result(
    result,
    error.GraphQLError,
  ),
) -> Op(FieldKind(parent), result)

Define a field on a type with arguments.

get_args

</>

pub fn get_args(op: Op(k, r)) -> List(ArgDef)

get_bool

</>

pub fn get_bool(
  args: args.Args,
  key: String,
) -> Result(Bool, error.GraphQLError)

get_bool_or

</>

pub fn get_bool_or(
  args: args.Args,
  key: String,
  default: Bool,
) -> Bool

get_description

</>

pub fn get_description(op: Op(k, r)) -> option.Option(String)

get_dynamic

</>

pub fn get_dynamic(
  args: args.Args,
  key: String,
) -> Result(dynamic.Dynamic, error.GraphQLError)

get_float

</>

pub fn get_float(
  args: args.Args,
  key: String,
) -> Result(Float, error.GraphQLError)

get_float_or

</>

pub fn get_float_or(
  args: args.Args,
  key: String,
  default: Float,
) -> Float

get_id

</>

pub fn get_id(
  args: args.Args,
  key: String,
) -> Result(String, error.GraphQLError)

get_id_or

</>

pub fn get_id_or(
  args: args.Args,
  key: String,
  default: String,
) -> String

get_int

</>

pub fn get_int(
  args: args.Args,
  key: String,
) -> Result(Int, error.GraphQLError)

get_int_list

</>

pub fn get_int_list(
  args: args.Args,
  key: String,
) -> Result(List(Int), error.GraphQLError)

get_int_or

</>

pub fn get_int_or(
  args: args.Args,
  key: String,
  default: Int,
) -> Int

get_name

</>

pub fn get_name(op: Op(k, r)) -> String

get_optional_bool

</>

pub fn get_optional_bool(
  args: args.Args,
  key: String,
) -> option.Option(Bool)

get_optional_dynamic

</>

pub fn get_optional_dynamic(
  args: args.Args,
  key: String,
) -> option.Option(dynamic.Dynamic)

get_optional_float

</>

pub fn get_optional_float(
  args: args.Args,
  key: String,
) -> option.Option(Float)

get_optional_id

</>

pub fn get_optional_id(
  args: args.Args,
  key: String,
) -> option.Option(String)

get_optional_int

</>

pub fn get_optional_int(
  args: args.Args,
  key: String,
) -> option.Option(Int)

get_optional_string

</>

pub fn get_optional_string(
  args: args.Args,
  key: String,
) -> option.Option(String)

get_string

</>

pub fn get_string(
  args: args.Args,
  key: String,
) -> Result(String, error.GraphQLError)

get_string_list

</>

pub fn get_string_list(
  args: args.Args,
  key: String,
) -> Result(List(String), error.GraphQLError)

get_string_or

</>

pub fn get_string_or(
  args: args.Args,
  key: String,
  default: String,
) -> String

merge

</>

pub fn merge(a: SchemaBuilder, b: SchemaBuilder) -> SchemaBuilder

mutation

</>

pub fn mutation(
  name name: String,
  returns return_type: schema.FieldType,
  resolve resolver: fn(schema.ExecutionContext) -> Result(
    result,
    error.GraphQLError,
  ),
) -> Op(MutationKind, result)

mutation_with_args

</>

pub fn mutation_with_args(
  name name: String,
  args arg_defs: List(ArgDef),
  returns return_type: schema.FieldType,
  resolve resolver: fn(args.Args, schema.ExecutionContext) -> Result(
    result,
    error.GraphQLError,
  ),
) -> Op(MutationKind, result)

new

</>

pub fn new() -> SchemaBuilder

query

</>

pub fn query(
  name name: String,
  returns return_type: schema.FieldType,
  resolve resolver: fn(schema.ExecutionContext) -> Result(
    result,
    error.GraphQLError,
  ),
) -> Op(QueryKind, result)

Define a query with no arguments.

query_with_args

</>

pub fn query_with_args(
  name name: String,
  args arg_defs: List(ArgDef),
  returns return_type: schema.FieldType,
  resolve resolver: fn(args.Args, schema.ExecutionContext) -> Result(
    result,
    error.GraphQLError,
  ),
) -> Op(QueryKind, result)

Define a query with arguments.

subscription

</>

pub fn subscription(
  name name: String,
  returns return_type: schema.FieldType,
  topic topic: String,
) -> Op(SubscriptionKind, event)

Define a subscription with a static topic string.

subscription_with_args

</>

pub fn subscription_with_args(
  name name: String,
  args arg_defs: List(ArgDef),
  returns return_type: schema.FieldType,
  topic topic_resolver: fn(args.Args, schema.ExecutionContext) -> Result(
    String,
    error.GraphQLError,
  ),
) -> Op(SubscriptionKind, event)

Define a subscription with arguments and a dynamic topic resolver.

to_field_def

</>

pub fn to_field_def(op: Op(k, r)) -> schema.FieldDefinition

Convert any Op to a schema FieldDefinition.

with_cache

</>

pub fn with_cache(builder: SchemaBuilder) -> SchemaBuilder

with_common_scalars

</>

pub fn with_common_scalars(
  builder: SchemaBuilder,
) -> SchemaBuilder

with_description

</>

pub fn with_description(op: Op(k, r), desc: String) -> Op(k, r)

Set the description. Works on any operation type.

with_encoder

</>

pub fn with_encoder(
  op: Op(k, r),
  encoder: fn(r) -> dynamic.Dynamic,
) -> Op(k, r)

Override the result encoder. Works on any operation type.

with_guard

</>

pub fn with_guard(
  op: Op(k, r),
  guard_fn: fn(schema.ExecutionContext) -> Result(Nil, String),
) -> Op(k, r)

Add a guard. Works on any operation type. Guards run in the order added.