-module(mochi@query).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/mochi/query.gleam").
-export([with_encoder/2, with_guard/2, with_description/2, get_name/1, get_description/1, get_args/1, 'query'/3, query_with_args/4, mutation/3, mutation_with_args/4, subscription/3, subscription_with_args/4, field/4, field_with_args/5, all_of/1, any_of/1, arg/2, arg_with_desc/3, arg_with_default/3, arg_with_default_desc/4, get_string/2, get_id/2, get_int/2, get_float/2, get_bool/2, get_optional_string/2, get_optional_id/2, get_optional_int/2, get_optional_float/2, get_optional_bool/2, get_string_list/2, get_int_list/2, decode_input/3, get_dynamic/2, get_optional_dynamic/2, get_string_or/3, get_id_or/3, get_int_or/3, get_float_or/3, get_bool_or/3, to_field_def/1, new/0, add_query/2, add_mutation/2, add_subscription/2, add_type/2, add_enum/2, add_interface/2, add_union/2, add_scalar/2, add_input/2, add_queries/2, add_mutations/2, add_subscriptions/2, add_types/2, add_enums/2, add_interfaces/2, add_unions/2, add_scalars/2, add_inputs/2, with_common_scalars/1, merge/2, with_cache/1, build/1]).
-export_type([query_kind/0, mutation_kind/0, subscription_kind/0, field_kind/1, internal_resolver/1, op/2, arg_def/0, schema_builder/0]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

-type query_kind() :: query_kind.

-type mutation_kind() :: mutation_kind.

-type subscription_kind() :: subscription_kind.

-opaque field_kind(LZF) :: {field_kind, fun((LZF) -> LZF)}.

-type internal_resolver(LZG) :: {simple_resolver,
        fun((gleam@dict:dict(binary(), gleam@dynamic:dynamic_()), mochi@schema:execution_context()) -> {ok,
                LZG} |
            {error, mochi@error:graph_q_l_error()})} |
    {topic_resolver,
        fun((gleam@dict:dict(binary(), gleam@dynamic:dynamic_()), mochi@schema:execution_context()) -> {ok,
                binary()} |
            {error, mochi@error:graph_q_l_error()})} |
    {parent_resolver,
        fun((gleam@option:option(gleam@dynamic:dynamic_()), gleam@dict:dict(binary(), gleam@dynamic:dynamic_()), mochi@schema:execution_context()) -> {ok,
                LZG} |
            {error, mochi@error:graph_q_l_error()})}.

-opaque op(LZH, LZI) :: {op,
        binary(),
        gleam@option:option(binary()),
        internal_resolver(LZI),
        fun((LZI) -> gleam@dynamic:dynamic_()),
        list(arg_def()),
        mochi@schema:field_type(),
        list(fun((mochi@schema:execution_context()) -> {ok, nil} |
            {error, binary()})),
        LZH}.

-type arg_def() :: {arg_def,
        binary(),
        mochi@schema:field_type(),
        gleam@option:option(binary()),
        gleam@option:option(gleam@dynamic:dynamic_())}.

-opaque schema_builder() :: {schema_builder,
        list(mochi@schema:field_definition()),
        list(mochi@schema:field_definition()),
        list(mochi@schema:field_definition()),
        list(mochi@schema:object_type()),
        list(mochi@schema:enum_type()),
        list(mochi@schema:interface_type()),
        list(mochi@schema:union_type()),
        list(mochi@schema:scalar_type()),
        list(mochi@schema:input_object_type()),
        boolean()}.

-file("src/mochi/query.gleam", 105).
?DOC(" Override the result encoder. Works on any operation type.\n").
-spec with_encoder(op(LZZ, MAA), fun((MAA) -> gleam@dynamic:dynamic_())) -> op(LZZ, MAA).
with_encoder(Op, Encoder) ->
    {op,
        erlang:element(2, Op),
        erlang:element(3, Op),
        erlang:element(4, Op),
        Encoder,
        erlang:element(6, Op),
        erlang:element(7, Op),
        erlang:element(8, Op),
        erlang:element(9, Op)}.

-file("src/mochi/query.gleam", 110).
?DOC(" Add a guard. Works on any operation type. Guards run in the order added.\n").
-spec with_guard(
    op(MAF, MAG),
    fun((mochi@schema:execution_context()) -> {ok, nil} | {error, binary()})
) -> op(MAF, MAG).
with_guard(Op, Guard_fn) ->
    {op,
        erlang:element(2, Op),
        erlang:element(3, Op),
        erlang:element(4, Op),
        erlang:element(5, Op),
        erlang:element(6, Op),
        erlang:element(7, Op),
        lists:append(erlang:element(8, Op), [Guard_fn]),
        erlang:element(9, Op)}.

-file("src/mochi/query.gleam", 115).
?DOC(" Set the description. Works on any operation type.\n").
-spec with_description(op(MAL, MAM), binary()) -> op(MAL, MAM).
with_description(Op, Desc) ->
    {op,
        erlang:element(2, Op),
        {some, Desc},
        erlang:element(4, Op),
        erlang:element(5, Op),
        erlang:element(6, Op),
        erlang:element(7, Op),
        erlang:element(8, Op),
        erlang:element(9, Op)}.

-file("src/mochi/query.gleam", 123).
-spec get_name(op(any(), any())) -> binary().
get_name(Op) ->
    erlang:element(2, Op).

-file("src/mochi/query.gleam", 127).
-spec get_description(op(any(), any())) -> gleam@option:option(binary()).
get_description(Op) ->
    erlang:element(3, Op).

-file("src/mochi/query.gleam", 131).
-spec get_args(op(any(), any())) -> list(arg_def()).
get_args(Op) ->
    erlang:element(6, Op).

-file("src/mochi/query.gleam", 140).
?DOC(" Define a query with no arguments.\n").
-spec 'query'(
    binary(),
    mochi@schema:field_type(),
    fun((mochi@schema:execution_context()) -> {ok, MBF} |
        {error, mochi@error:graph_q_l_error()})
) -> op(query_kind(), MBF).
'query'(Name, Return_type, Resolver) ->
    {op,
        Name,
        none,
        {simple_resolver, fun(_, Ctx) -> Resolver(Ctx) end},
        fun gleam_stdlib:identity/1,
        [],
        Return_type,
        [],
        query_kind}.

-file("src/mochi/query.gleam", 158).
?DOC(" Define a query with arguments.\n").
-spec query_with_args(
    binary(),
    list(arg_def()),
    mochi@schema:field_type(),
    fun((gleam@dict:dict(binary(), gleam@dynamic:dynamic_()), mochi@schema:execution_context()) -> {ok,
            MBM} |
        {error, mochi@error:graph_q_l_error()})
) -> op(query_kind(), MBM).
query_with_args(Name, Arg_defs, Return_type, Resolver) ->
    {op,
        Name,
        none,
        {simple_resolver, Resolver},
        fun gleam_stdlib:identity/1,
        Arg_defs,
        Return_type,
        [],
        query_kind}.

-file("src/mochi/query.gleam", 181).
-spec mutation(
    binary(),
    mochi@schema:field_type(),
    fun((mochi@schema:execution_context()) -> {ok, MBQ} |
        {error, mochi@error:graph_q_l_error()})
) -> op(mutation_kind(), MBQ).
mutation(Name, Return_type, Resolver) ->
    {op,
        Name,
        none,
        {simple_resolver, fun(_, Ctx) -> Resolver(Ctx) end},
        fun gleam_stdlib:identity/1,
        [],
        Return_type,
        [],
        mutation_kind}.

-file("src/mochi/query.gleam", 198).
-spec mutation_with_args(
    binary(),
    list(arg_def()),
    mochi@schema:field_type(),
    fun((gleam@dict:dict(binary(), gleam@dynamic:dynamic_()), mochi@schema:execution_context()) -> {ok,
            MBX} |
        {error, mochi@error:graph_q_l_error()})
) -> op(mutation_kind(), MBX).
mutation_with_args(Name, Arg_defs, Return_type, Resolver) ->
    {op,
        Name,
        none,
        {simple_resolver, Resolver},
        fun gleam_stdlib:identity/1,
        Arg_defs,
        Return_type,
        [],
        mutation_kind}.

-file("src/mochi/query.gleam", 222).
?DOC(" Define a subscription with a static topic string.\n").
-spec subscription(binary(), mochi@schema:field_type(), binary()) -> op(subscription_kind(), any()).
subscription(Name, Return_type, Topic) ->
    {op,
        Name,
        none,
        {topic_resolver, fun(_, _) -> {ok, Topic} end},
        fun gleam_stdlib:identity/1,
        [],
        Return_type,
        [],
        subscription_kind}.

-file("src/mochi/query.gleam", 240).
?DOC(" Define a subscription with arguments and a dynamic topic resolver.\n").
-spec subscription_with_args(
    binary(),
    list(arg_def()),
    mochi@schema:field_type(),
    fun((gleam@dict:dict(binary(), gleam@dynamic:dynamic_()), mochi@schema:execution_context()) -> {ok,
            binary()} |
        {error, mochi@error:graph_q_l_error()})
) -> op(subscription_kind(), any()).
subscription_with_args(Name, Arg_defs, Return_type, Topic_resolver) ->
    {op,
        Name,
        none,
        {topic_resolver, Topic_resolver},
        fun gleam_stdlib:identity/1,
        Arg_defs,
        Return_type,
        [],
        subscription_kind}.

-file("src/mochi/query.gleam", 264).
?DOC(" Define a field on a type with no extra arguments.\n").
-spec field(
    binary(),
    mochi@schema:field_type(),
    fun((gleam@dynamic:dynamic_()) -> {ok, MCK} | {error, binary()}),
    fun((MCK, mochi@schema:execution_context()) -> {ok, MCN} |
        {error, mochi@error:graph_q_l_error()})
) -> op(field_kind(MCK), MCN).
field(Name, Return_type, Parent_decoder, Resolver) ->
    {op,
        Name,
        none,
        {parent_resolver,
            fun(Parent_dyn, _, Ctx) ->
                gleam@result:'try'(
                    gleam@option:to_result(
                        Parent_dyn,
                        mochi@error:new(<<"No parent value provided"/utf8>>)
                    ),
                    fun(Parent_dyn_val) ->
                        gleam@result:'try'(
                            begin
                                _pipe = Parent_decoder(Parent_dyn_val),
                                gleam@result:map_error(
                                    _pipe,
                                    fun(E) ->
                                        mochi@error:new(
                                            <<"Failed to decode parent: "/utf8,
                                                E/binary>>
                                        )
                                    end
                                )
                            end,
                            fun(P) -> Resolver(P, Ctx) end
                        )
                    end
                )
            end},
        fun gleam_stdlib:identity/1,
        [],
        Return_type,
        [],
        {field_kind, fun(X) -> X end}}.

-file("src/mochi/query.gleam", 295).
?DOC(" Define a field on a type with arguments.\n").
-spec field_with_args(
    binary(),
    list(arg_def()),
    mochi@schema:field_type(),
    fun((gleam@dynamic:dynamic_()) -> {ok, MCT} | {error, binary()}),
    fun((MCT, gleam@dict:dict(binary(), gleam@dynamic:dynamic_()), mochi@schema:execution_context()) -> {ok,
            MCY} |
        {error, mochi@error:graph_q_l_error()})
) -> op(field_kind(MCT), MCY).
field_with_args(Name, Arg_defs, Return_type, Parent_decoder, Resolver) ->
    {op,
        Name,
        none,
        {parent_resolver,
            fun(Parent_dyn, Args, Ctx) ->
                gleam@result:'try'(
                    gleam@option:to_result(
                        Parent_dyn,
                        mochi@error:new(<<"No parent value provided"/utf8>>)
                    ),
                    fun(Parent_dyn_val) ->
                        gleam@result:'try'(
                            begin
                                _pipe = Parent_decoder(Parent_dyn_val),
                                gleam@result:map_error(
                                    _pipe,
                                    fun(E) ->
                                        mochi@error:new(
                                            <<"Failed to decode parent: "/utf8,
                                                E/binary>>
                                        )
                                    end
                                )
                            end,
                            fun(P) -> Resolver(P, Args, Ctx) end
                        )
                    end
                )
            end},
        fun gleam_stdlib:identity/1,
        Arg_defs,
        Return_type,
        [],
        {field_kind, fun(X) -> X end}}.

-file("src/mochi/query.gleam", 335).
?DOC(" Combine guards with AND logic — all must pass (checked in list order).\n").
-spec all_of(
    list(fun((mochi@schema:execution_context()) -> {ok, nil} | {error, binary()}))
) -> fun((mochi@schema:execution_context()) -> {ok, nil} | {error, binary()}).
all_of(Guard_fns) ->
    fun(Ctx) -> gleam@list:try_each(Guard_fns, fun(G) -> G(Ctx) end) end.

-file("src/mochi/query.gleam", 350).
-spec try_any(
    list(fun((mochi@schema:execution_context()) -> {ok, nil} | {error, binary()})),
    mochi@schema:execution_context(),
    binary()
) -> {ok, nil} | {error, binary()}.
try_any(Guards, Ctx, Last_error) ->
    case Guards of
        [] ->
            {error, Last_error};

        [G | Rest] ->
            case G(Ctx) of
                {ok, nil} ->
                    {ok, nil};

                {error, E} ->
                    try_any(Rest, Ctx, E)
            end
    end.

-file("src/mochi/query.gleam", 341).
?DOC(
    " Combine guards with OR logic — at least one must pass.\n"
    " Fails with the last error if all fail.\n"
).
-spec any_of(
    list(fun((mochi@schema:execution_context()) -> {ok, nil} | {error, binary()}))
) -> fun((mochi@schema:execution_context()) -> {ok, nil} | {error, binary()}).
any_of(Guard_fns) ->
    fun(Ctx) -> case Guard_fns of
            [] ->
                {error, <<"No guards provided"/utf8>>};

            _ ->
                try_any(Guard_fns, Ctx, <<"No guards passed"/utf8>>)
        end end.

-file("src/mochi/query.gleam", 365).
-spec apply_gql_guards(
    list(fun((mochi@schema:execution_context()) -> {ok, nil} | {error, binary()})),
    fun((gleam@dict:dict(binary(), gleam@dynamic:dynamic_()), mochi@schema:execution_context()) -> {ok,
            MDL} |
        {error, mochi@error:graph_q_l_error()})
) -> fun((gleam@dict:dict(binary(), gleam@dynamic:dynamic_()), mochi@schema:execution_context()) -> {ok,
        MDL} |
    {error, mochi@error:graph_q_l_error()}).
apply_gql_guards(Guards, Resolver) ->
    gleam@list:fold(
        lists:reverse(Guards),
        Resolver,
        fun(Inner, G) -> fun(Args, Ctx) -> case G(Ctx) of
                    {ok, nil} ->
                        Inner(Args, Ctx);

                    {error, Msg} ->
                        {error, mochi@error:new(Msg)}
                end end end
    ).

-file("src/mochi/query.gleam", 380).
-spec apply_topic_guards(
    list(fun((mochi@schema:execution_context()) -> {ok, nil} | {error, binary()})),
    fun((gleam@dict:dict(binary(), gleam@dynamic:dynamic_()), mochi@schema:execution_context()) -> {ok,
            binary()} |
        {error, mochi@error:graph_q_l_error()})
) -> fun((gleam@dict:dict(binary(), gleam@dynamic:dynamic_()), mochi@schema:execution_context()) -> {ok,
        binary()} |
    {error, mochi@error:graph_q_l_error()}).
apply_topic_guards(Guards, Resolver) ->
    gleam@list:fold(
        lists:reverse(Guards),
        Resolver,
        fun(Inner, G) -> fun(Args, Ctx) -> case G(Ctx) of
                    {ok, nil} ->
                        Inner(Args, Ctx);

                    {error, Msg} ->
                        {error, mochi@error:new(Msg)}
                end end end
    ).

-file("src/mochi/query.gleam", 395).
-spec apply_parent_gql_guards(
    list(fun((mochi@schema:execution_context()) -> {ok, nil} | {error, binary()})),
    fun((gleam@option:option(gleam@dynamic:dynamic_()), gleam@dict:dict(binary(), gleam@dynamic:dynamic_()), mochi@schema:execution_context()) -> {ok,
            MEF} |
        {error, mochi@error:graph_q_l_error()})
) -> fun((gleam@option:option(gleam@dynamic:dynamic_()), gleam@dict:dict(binary(), gleam@dynamic:dynamic_()), mochi@schema:execution_context()) -> {ok,
        MEF} |
    {error, mochi@error:graph_q_l_error()}).
apply_parent_gql_guards(Guards, Resolver) ->
    gleam@list:fold(
        lists:reverse(Guards),
        Resolver,
        fun(Inner, G) -> fun(Parent, Args, Ctx) -> case G(Ctx) of
                    {ok, nil} ->
                        Inner(Parent, Args, Ctx);

                    {error, Msg} ->
                        {error, mochi@error:new(Msg)}
                end end end
    ).

-file("src/mochi/query.gleam", 416).
?DOC(" Create an argument definition\n").
-spec arg(binary(), mochi@schema:field_type()) -> arg_def().
arg(Name, Arg_type) ->
    {arg_def, Name, Arg_type, none, none}.

-file("src/mochi/query.gleam", 421).
?DOC(" Create an argument with description\n").
-spec arg_with_desc(binary(), mochi@schema:field_type(), binary()) -> arg_def().
arg_with_desc(Name, Arg_type, Description) ->
    {arg_def, Name, Arg_type, {some, Description}, none}.

-file("src/mochi/query.gleam", 435).
?DOC(" Create an argument with a default value\n").
-spec arg_with_default(
    binary(),
    mochi@schema:field_type(),
    gleam@dynamic:dynamic_()
) -> arg_def().
arg_with_default(Name, Arg_type, Default) ->
    {arg_def, Name, Arg_type, none, {some, Default}}.

-file("src/mochi/query.gleam", 449).
?DOC(" Create an argument with default value and description\n").
-spec arg_with_default_desc(
    binary(),
    mochi@schema:field_type(),
    gleam@dynamic:dynamic_(),
    binary()
) -> arg_def().
arg_with_default_desc(Name, Arg_type, Default, Description) ->
    {arg_def, Name, Arg_type, {some, Description}, {some, Default}}.

-file("src/mochi/query.gleam", 467).
-spec fetch_required(
    gleam@dict:dict(binary(), gleam@dynamic:dynamic_()),
    binary(),
    gleam@dynamic@decode:decoder(MEP),
    binary()
) -> {ok, MEP} | {error, mochi@error:graph_q_l_error()}.
fetch_required(Args, Key, Decoder, Type_label) ->
    case gleam_stdlib:map_get(Args, Key) of
        {error, _} ->
            {error,
                mochi@error:new(
                    <<"Missing required argument: "/utf8, Key/binary>>
                )};

        {ok, Value} ->
            _pipe = gleam@dynamic@decode:run(Value, Decoder),
            gleam@result:map_error(
                _pipe,
                fun(_) ->
                    mochi@error:new(
                        <<<<<<"Invalid type for argument '"/utf8, Key/binary>>/binary,
                                "': expected "/utf8>>/binary,
                            Type_label/binary>>
                    )
                end
            )
    end.

-file("src/mochi/query.gleam", 485).
-spec fetch_optional(
    gleam@dict:dict(binary(), gleam@dynamic:dynamic_()),
    binary(),
    gleam@dynamic@decode:decoder(MEV)
) -> gleam@option:option(MEV).
fetch_optional(Args, Key, Decoder) ->
    case gleam_stdlib:map_get(Args, Key) of
        {error, _} ->
            none;

        {ok, Value} ->
            case gleam@dynamic@decode:run(Value, Decoder) of
                {ok, V} ->
                    {some, V};

                {error, _} ->
                    none
            end
    end.

-file("src/mochi/query.gleam", 500).
-spec fetch_or(
    gleam@dict:dict(binary(), gleam@dynamic:dynamic_()),
    binary(),
    gleam@dynamic@decode:decoder(MFA),
    MFA
) -> MFA.
fetch_or(Args, Key, Decoder, Default) ->
    case gleam_stdlib:map_get(Args, Key) of
        {error, _} ->
            Default;

        {ok, Value} ->
            gleam@result:unwrap(
                gleam@dynamic@decode:run(Value, Decoder),
                Default
            )
    end.

-file("src/mochi/query.gleam", 512).
-spec get_string(gleam@dict:dict(binary(), gleam@dynamic:dynamic_()), binary()) -> {ok,
        binary()} |
    {error, mochi@error:graph_q_l_error()}.
get_string(Args, Key) ->
    fetch_required(
        Args,
        Key,
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        <<"String"/utf8>>
    ).

-file("src/mochi/query.gleam", 519).
-spec get_id(gleam@dict:dict(binary(), gleam@dynamic:dynamic_()), binary()) -> {ok,
        binary()} |
    {error, mochi@error:graph_q_l_error()}.
get_id(Args, Key) ->
    fetch_required(
        Args,
        Key,
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        <<"ID"/utf8>>
    ).

-file("src/mochi/query.gleam", 526).
-spec get_int(gleam@dict:dict(binary(), gleam@dynamic:dynamic_()), binary()) -> {ok,
        integer()} |
    {error, mochi@error:graph_q_l_error()}.
get_int(Args, Key) ->
    fetch_required(
        Args,
        Key,
        {decoder, fun gleam@dynamic@decode:decode_int/1},
        <<"Int"/utf8>>
    ).

-file("src/mochi/query.gleam", 533).
-spec get_float(gleam@dict:dict(binary(), gleam@dynamic:dynamic_()), binary()) -> {ok,
        float()} |
    {error, mochi@error:graph_q_l_error()}.
get_float(Args, Key) ->
    fetch_required(
        Args,
        Key,
        {decoder, fun gleam@dynamic@decode:decode_float/1},
        <<"Float"/utf8>>
    ).

-file("src/mochi/query.gleam", 540).
-spec get_bool(gleam@dict:dict(binary(), gleam@dynamic:dynamic_()), binary()) -> {ok,
        boolean()} |
    {error, mochi@error:graph_q_l_error()}.
get_bool(Args, Key) ->
    fetch_required(
        Args,
        Key,
        {decoder, fun gleam@dynamic@decode:decode_bool/1},
        <<"Bool"/utf8>>
    ).

-file("src/mochi/query.gleam", 547).
-spec get_optional_string(
    gleam@dict:dict(binary(), gleam@dynamic:dynamic_()),
    binary()
) -> gleam@option:option(binary()).
get_optional_string(Args, Key) ->
    fetch_optional(
        Args,
        Key,
        {decoder, fun gleam@dynamic@decode:decode_string/1}
    ).

-file("src/mochi/query.gleam", 554).
-spec get_optional_id(
    gleam@dict:dict(binary(), gleam@dynamic:dynamic_()),
    binary()
) -> gleam@option:option(binary()).
get_optional_id(Args, Key) ->
    get_optional_string(Args, Key).

-file("src/mochi/query.gleam", 561).
-spec get_optional_int(
    gleam@dict:dict(binary(), gleam@dynamic:dynamic_()),
    binary()
) -> gleam@option:option(integer()).
get_optional_int(Args, Key) ->
    fetch_optional(Args, Key, {decoder, fun gleam@dynamic@decode:decode_int/1}).

-file("src/mochi/query.gleam", 565).
-spec get_optional_float(
    gleam@dict:dict(binary(), gleam@dynamic:dynamic_()),
    binary()
) -> gleam@option:option(float()).
get_optional_float(Args, Key) ->
    fetch_optional(
        Args,
        Key,
        {decoder, fun gleam@dynamic@decode:decode_float/1}
    ).

-file("src/mochi/query.gleam", 572).
-spec get_optional_bool(
    gleam@dict:dict(binary(), gleam@dynamic:dynamic_()),
    binary()
) -> gleam@option:option(boolean()).
get_optional_bool(Args, Key) ->
    fetch_optional(Args, Key, {decoder, fun gleam@dynamic@decode:decode_bool/1}).

-file("src/mochi/query.gleam", 579).
-spec get_string_list(
    gleam@dict:dict(binary(), gleam@dynamic:dynamic_()),
    binary()
) -> {ok, list(binary())} | {error, mochi@error:graph_q_l_error()}.
get_string_list(Args, Key) ->
    fetch_required(
        Args,
        Key,
        gleam@dynamic@decode:list(
            {decoder, fun gleam@dynamic@decode:decode_string/1}
        ),
        <<"[String]"/utf8>>
    ).

-file("src/mochi/query.gleam", 586).
-spec get_int_list(
    gleam@dict:dict(binary(), gleam@dynamic:dynamic_()),
    binary()
) -> {ok, list(integer())} | {error, mochi@error:graph_q_l_error()}.
get_int_list(Args, Key) ->
    fetch_required(
        Args,
        Key,
        gleam@dynamic@decode:list(
            {decoder, fun gleam@dynamic@decode:decode_int/1}
        ),
        <<"[Int]"/utf8>>
    ).

-file("src/mochi/query.gleam", 593).
-spec decode_input(
    gleam@dict:dict(binary(), gleam@dynamic:dynamic_()),
    binary(),
    gleam@dynamic@decode:decoder(MGX)
) -> {ok, MGX} | {error, mochi@error:graph_q_l_error()}.
decode_input(Args, Key, Decoder) ->
    case gleam_stdlib:map_get(Args, Key) of
        {error, _} ->
            {error,
                mochi@error:new(
                    <<"Missing required argument: "/utf8, Key/binary>>
                )};

        {ok, Value} ->
            _pipe = gleam@dynamic@decode:run(Value, Decoder),
            gleam@result:map_error(
                _pipe,
                fun(_) ->
                    mochi@error:new(
                        <<<<"Invalid input for '"/utf8, Key/binary>>/binary,
                            "'"/utf8>>
                    )
                end
            )
    end.

-file("src/mochi/query.gleam", 608).
-spec get_dynamic(gleam@dict:dict(binary(), gleam@dynamic:dynamic_()), binary()) -> {ok,
        gleam@dynamic:dynamic_()} |
    {error, mochi@error:graph_q_l_error()}.
get_dynamic(Args, Key) ->
    _pipe = gleam_stdlib:map_get(Args, Key),
    gleam@result:map_error(
        _pipe,
        fun(_) ->
            mochi@error:new(<<"Missing required argument: "/utf8, Key/binary>>)
        end
    ).

-file("src/mochi/query.gleam", 616).
-spec get_optional_dynamic(
    gleam@dict:dict(binary(), gleam@dynamic:dynamic_()),
    binary()
) -> gleam@option:option(gleam@dynamic:dynamic_()).
get_optional_dynamic(Args, Key) ->
    _pipe = gleam_stdlib:map_get(Args, Key),
    gleam@option:from_result(_pipe).

-file("src/mochi/query.gleam", 624).
-spec get_string_or(
    gleam@dict:dict(binary(), gleam@dynamic:dynamic_()),
    binary(),
    binary()
) -> binary().
get_string_or(Args, Key, Default) ->
    fetch_or(
        Args,
        Key,
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        Default
    ).

-file("src/mochi/query.gleam", 632).
-spec get_id_or(
    gleam@dict:dict(binary(), gleam@dynamic:dynamic_()),
    binary(),
    binary()
) -> binary().
get_id_or(Args, Key, Default) ->
    get_string_or(Args, Key, Default).

-file("src/mochi/query.gleam", 640).
-spec get_int_or(
    gleam@dict:dict(binary(), gleam@dynamic:dynamic_()),
    binary(),
    integer()
) -> integer().
get_int_or(Args, Key, Default) ->
    fetch_or(
        Args,
        Key,
        {decoder, fun gleam@dynamic@decode:decode_int/1},
        Default
    ).

-file("src/mochi/query.gleam", 644).
-spec get_float_or(
    gleam@dict:dict(binary(), gleam@dynamic:dynamic_()),
    binary(),
    float()
) -> float().
get_float_or(Args, Key, Default) ->
    fetch_or(
        Args,
        Key,
        {decoder, fun gleam@dynamic@decode:decode_float/1},
        Default
    ).

-file("src/mochi/query.gleam", 652).
-spec get_bool_or(
    gleam@dict:dict(binary(), gleam@dynamic:dynamic_()),
    binary(),
    boolean()
) -> boolean().
get_bool_or(Args, Key, Default) ->
    fetch_or(
        Args,
        Key,
        {decoder, fun gleam@dynamic@decode:decode_bool/1},
        Default
    ).

-file("src/mochi/query.gleam", 664).
-spec build_gql_resolver(
    fun((gleam@dict:dict(binary(), gleam@dynamic:dynamic_()), mochi@schema:execution_context()) -> {ok,
            MHU} |
        {error, mochi@error:graph_q_l_error()}),
    fun((MHU) -> gleam@dynamic:dynamic_())
) -> fun((mochi@schema:resolver_info()) -> {ok, gleam@dynamic:dynamic_()} |
    {error,
        {binary(),
            gleam@option:option(gleam@dict:dict(binary(), gleam@dynamic:dynamic_()))}}).
build_gql_resolver(Resolver, Result_encoder) ->
    fun(Info) ->
        case Resolver(erlang:element(3, Info), erlang:element(4, Info)) of
            {error, Err} ->
                {error, mochi@error:to_payload(Err)};

            {ok, Res} ->
                {ok, Result_encoder(Res)}
        end
    end.

-file("src/mochi/query.gleam", 677).
-spec apply_desc(mochi@schema:field_definition(), gleam@option:option(binary())) -> mochi@schema:field_definition().
apply_desc(Field, Desc) ->
    case Desc of
        {some, D} ->
            mochi@schema:field_description(Field, D);

        none ->
            Field
    end.

-file("src/mochi/query.gleam", 729).
-spec add_args_to_field(mochi@schema:field_definition(), list(arg_def())) -> mochi@schema:field_definition().
add_args_to_field(Field, Args) ->
    gleam@list:fold(
        Args,
        Field,
        fun(F, A) ->
            Base_arg = mochi@schema:arg(
                erlang:element(2, A),
                erlang:element(3, A)
            ),
            With_desc = case erlang:element(4, A) of
                {some, Desc} ->
                    mochi@schema:arg_description(Base_arg, Desc);

                none ->
                    Base_arg
            end,
            Arg_def = case erlang:element(5, A) of
                {some, Default} ->
                    mochi@schema:default_value(With_desc, Default);

                none ->
                    With_desc
            end,
            mochi@schema:argument(F, Arg_def)
        end
    ).

-file("src/mochi/query.gleam", 685).
?DOC(" Convert any Op to a schema FieldDefinition.\n").
-spec to_field_def(op(any(), any())) -> mochi@schema:field_definition().
to_field_def(Op) ->
    Base = begin
        _pipe = mochi@schema:field_def(
            erlang:element(2, Op),
            erlang:element(7, Op)
        ),
        _pipe@1 = add_args_to_field(_pipe, erlang:element(6, Op)),
        apply_desc(_pipe@1, erlang:element(3, Op))
    end,
    case erlang:element(4, Op) of
        {simple_resolver, Resolver} ->
            mochi@schema:rich_resolver_fn(
                Base,
                build_gql_resolver(
                    apply_gql_guards(erlang:element(8, Op), Resolver),
                    erlang:element(5, Op)
                )
            );

        {topic_resolver, Resolver@1} ->
            Guarded_topic = apply_topic_guards(
                erlang:element(8, Op),
                Resolver@1
            ),
            _pipe@2 = Base,
            _pipe@3 = mochi@schema:resolver(
                _pipe@2,
                fun(_) ->
                    {error,
                        <<"Subscriptions must be executed through the subscription executor"/utf8>>}
                end
            ),
            (fun(Fd) ->
                {field_definition,
                    erlang:element(2, Fd),
                    erlang:element(3, Fd),
                    erlang:element(4, Fd),
                    erlang:element(5, Fd),
                    erlang:element(6, Fd),
                    erlang:element(7, Fd),
                    erlang:element(8, Fd),
                    {some, fun(Args, Ctx) -> _pipe@4 = Guarded_topic(Args, Ctx),
                            gleam@result:map_error(
                                _pipe@4,
                                fun(E) -> erlang:element(2, E) end
                            ) end},
                    erlang:element(10, Fd)}
            end)(_pipe@3);

        {parent_resolver, Resolver@2} ->
            Guarded = apply_parent_gql_guards(erlang:element(8, Op), Resolver@2),
            mochi@schema:rich_resolver_fn(
                Base,
                fun(Info) ->
                    case Guarded(
                        erlang:element(2, Info),
                        erlang:element(3, Info),
                        erlang:element(4, Info)
                    ) of
                        {error, Err} ->
                            {error, mochi@error:to_payload(Err)};

                        {ok, Res} ->
                            {ok, (erlang:element(5, Op))(Res)}
                    end
                end
            )
    end.

-file("src/mochi/query.gleam", 769).
-spec new() -> schema_builder().
new() ->
    {schema_builder, [], [], [], [], [], [], [], [], [], false}.

-file("src/mochi/query.gleam", 784).
-spec add_query(schema_builder(), op(query_kind(), any())) -> schema_builder().
add_query(Builder, Q) ->
    {schema_builder,
        [to_field_def(Q) | erlang:element(2, Builder)],
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        erlang:element(10, Builder),
        erlang:element(11, Builder)}.

-file("src/mochi/query.gleam", 788).
-spec add_mutation(schema_builder(), op(mutation_kind(), any())) -> schema_builder().
add_mutation(Builder, M) ->
    {schema_builder,
        erlang:element(2, Builder),
        [to_field_def(M) | erlang:element(3, Builder)],
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        erlang:element(10, Builder),
        erlang:element(11, Builder)}.

-file("src/mochi/query.gleam", 795).
-spec add_subscription(schema_builder(), op(subscription_kind(), any())) -> schema_builder().
add_subscription(Builder, S) ->
    {schema_builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        [to_field_def(S) | erlang:element(4, Builder)],
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        erlang:element(10, Builder),
        erlang:element(11, Builder)}.

-file("src/mochi/query.gleam", 805).
-spec add_type(schema_builder(), mochi@schema:object_type()) -> schema_builder().
add_type(Builder, T) ->
    {schema_builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        [T | erlang:element(5, Builder)],
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        erlang:element(10, Builder),
        erlang:element(11, Builder)}.

-file("src/mochi/query.gleam", 809).
-spec add_enum(schema_builder(), mochi@schema:enum_type()) -> schema_builder().
add_enum(Builder, E) ->
    {schema_builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        [E | erlang:element(6, Builder)],
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        erlang:element(10, Builder),
        erlang:element(11, Builder)}.

-file("src/mochi/query.gleam", 813).
-spec add_interface(schema_builder(), mochi@schema:interface_type()) -> schema_builder().
add_interface(Builder, I) ->
    {schema_builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        [I | erlang:element(7, Builder)],
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        erlang:element(10, Builder),
        erlang:element(11, Builder)}.

-file("src/mochi/query.gleam", 820).
-spec add_union(schema_builder(), mochi@schema:union_type()) -> schema_builder().
add_union(Builder, U) ->
    {schema_builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        [U | erlang:element(8, Builder)],
        erlang:element(9, Builder),
        erlang:element(10, Builder),
        erlang:element(11, Builder)}.

-file("src/mochi/query.gleam", 824).
-spec add_scalar(schema_builder(), mochi@schema:scalar_type()) -> schema_builder().
add_scalar(Builder, S) ->
    {schema_builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        [S | erlang:element(9, Builder)],
        erlang:element(10, Builder),
        erlang:element(11, Builder)}.

-file("src/mochi/query.gleam", 828).
-spec add_input(schema_builder(), mochi@schema:input_object_type()) -> schema_builder().
add_input(Builder, I) ->
    {schema_builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        [I | erlang:element(10, Builder)],
        erlang:element(11, Builder)}.

-file("src/mochi/query.gleam", 835).
-spec add_queries(schema_builder(), list(op(query_kind(), any()))) -> schema_builder().
add_queries(Builder, Queries) ->
    gleam@list:fold(Queries, Builder, fun(B, Q) -> add_query(B, Q) end).

-file("src/mochi/query.gleam", 842).
-spec add_mutations(schema_builder(), list(op(mutation_kind(), any()))) -> schema_builder().
add_mutations(Builder, Mutations) ->
    gleam@list:fold(Mutations, Builder, fun(B, M) -> add_mutation(B, M) end).

-file("src/mochi/query.gleam", 849).
-spec add_subscriptions(schema_builder(), list(op(subscription_kind(), any()))) -> schema_builder().
add_subscriptions(Builder, Subscriptions) ->
    gleam@list:fold(
        Subscriptions,
        Builder,
        fun(B, S) -> add_subscription(B, S) end
    ).

-file("src/mochi/query.gleam", 856).
-spec add_types(schema_builder(), list(mochi@schema:object_type())) -> schema_builder().
add_types(Builder, Types) ->
    gleam@list:fold(Types, Builder, fun(B, T) -> add_type(B, T) end).

-file("src/mochi/query.gleam", 863).
-spec add_enums(schema_builder(), list(mochi@schema:enum_type())) -> schema_builder().
add_enums(Builder, Enums) ->
    gleam@list:fold(Enums, Builder, fun(B, E) -> add_enum(B, E) end).

-file("src/mochi/query.gleam", 870).
-spec add_interfaces(schema_builder(), list(mochi@schema:interface_type())) -> schema_builder().
add_interfaces(Builder, Interfaces) ->
    gleam@list:fold(Interfaces, Builder, fun(B, I) -> add_interface(B, I) end).

-file("src/mochi/query.gleam", 877).
-spec add_unions(schema_builder(), list(mochi@schema:union_type())) -> schema_builder().
add_unions(Builder, Unions) ->
    gleam@list:fold(Unions, Builder, fun(B, U) -> add_union(B, U) end).

-file("src/mochi/query.gleam", 884).
-spec add_scalars(schema_builder(), list(mochi@schema:scalar_type())) -> schema_builder().
add_scalars(Builder, Scalars) ->
    gleam@list:fold(Scalars, Builder, fun(B, S) -> add_scalar(B, S) end).

-file("src/mochi/query.gleam", 891).
-spec add_inputs(schema_builder(), list(mochi@schema:input_object_type())) -> schema_builder().
add_inputs(Builder, Inputs) ->
    gleam@list:fold(Inputs, Builder, fun(B, I) -> add_input(B, I) end).

-file("src/mochi/query.gleam", 899).
?DOC(" Register all built-in custom scalars (DateTime, Date, UUID, Email, URL, JSON).\n").
-spec with_common_scalars(schema_builder()) -> schema_builder().
with_common_scalars(Builder) ->
    add_scalars(
        Builder,
        [mochi@scalars:date_time(),
            mochi@scalars:date(),
            mochi@scalars:uuid(),
            mochi@scalars:email(),
            mochi@scalars:url(),
            mochi@scalars:json()]
    ).

-file("src/mochi/query.gleam", 910).
-spec check_duplicates(binary(), list(MJE), list(MJE), fun((MJE) -> binary())) -> nil.
check_duplicates(Label, A_items, B_items, Name_fn) ->
    A_names = gleam@list:map(A_items, Name_fn),
    Conflicts = gleam@list:filter(
        B_items,
        fun(Item) -> gleam@list:contains(A_names, Name_fn(Item)) end
    ),
    case Conflicts of
        [] ->
            nil;

        _ ->
            erlang:error(#{gleam_error => panic,
                    message => (<<<<<<"Schema merge conflict: duplicate "/utf8,
                                Label/binary>>/binary,
                            " name(s): "/utf8>>/binary,
                        (gleam@string:join(
                            gleam@list:map(Conflicts, Name_fn),
                            <<", "/utf8>>
                        ))/binary>>),
                    file => <<?FILEPATH/utf8>>,
                    module => <<"mochi/query"/utf8>>,
                    function => <<"check_duplicates"/utf8>>,
                    line => 922})
    end.

-file("src/mochi/query.gleam", 931).
-spec merge(schema_builder(), schema_builder()) -> schema_builder().
merge(A, B) ->
    check_duplicates(
        <<"query"/utf8>>,
        erlang:element(2, A),
        erlang:element(2, B),
        fun(F) -> erlang:element(2, F) end
    ),
    check_duplicates(
        <<"mutation"/utf8>>,
        erlang:element(3, A),
        erlang:element(3, B),
        fun(F@1) -> erlang:element(2, F@1) end
    ),
    check_duplicates(
        <<"subscription"/utf8>>,
        erlang:element(4, A),
        erlang:element(4, B),
        fun(F@2) -> erlang:element(2, F@2) end
    ),
    check_duplicates(
        <<"type"/utf8>>,
        erlang:element(5, A),
        erlang:element(5, B),
        fun(T) -> erlang:element(2, T) end
    ),
    check_duplicates(
        <<"enum"/utf8>>,
        erlang:element(6, A),
        erlang:element(6, B),
        fun(E) -> erlang:element(2, E) end
    ),
    check_duplicates(
        <<"interface"/utf8>>,
        erlang:element(7, A),
        erlang:element(7, B),
        fun(I) -> erlang:element(2, I) end
    ),
    check_duplicates(
        <<"union"/utf8>>,
        erlang:element(8, A),
        erlang:element(8, B),
        fun(U) -> erlang:element(2, U) end
    ),
    check_duplicates(
        <<"scalar"/utf8>>,
        erlang:element(9, A),
        erlang:element(9, B),
        fun(S) -> erlang:element(2, S) end
    ),
    check_duplicates(
        <<"input"/utf8>>,
        erlang:element(10, A),
        erlang:element(10, B),
        fun(I@1) -> erlang:element(2, I@1) end
    ),
    {schema_builder,
        lists:append(erlang:element(2, A), erlang:element(2, B)),
        lists:append(erlang:element(3, A), erlang:element(3, B)),
        lists:append(erlang:element(4, A), erlang:element(4, B)),
        lists:append(erlang:element(5, A), erlang:element(5, B)),
        lists:append(erlang:element(6, A), erlang:element(6, B)),
        lists:append(erlang:element(7, A), erlang:element(7, B)),
        lists:append(erlang:element(8, A), erlang:element(8, B)),
        lists:append(erlang:element(9, A), erlang:element(9, B)),
        lists:append(erlang:element(10, A), erlang:element(10, B)),
        erlang:element(11, A) orelse erlang:element(11, B)}.

-file("src/mochi/query.gleam", 957).
-spec with_cache(schema_builder()) -> schema_builder().
with_cache(Builder) ->
    {schema_builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        erlang:element(10, Builder),
        true}.

-file("src/mochi/query.gleam", 961).
-spec build(schema_builder()) -> mochi@schema:schema().
build(Builder) ->
    Query_type = gleam@list:fold(
        erlang:element(2, Builder),
        mochi@schema:object(<<"Query"/utf8>>),
        fun(Obj, Field) -> mochi@schema:field(Obj, Field) end
    ),
    Base_schema = begin
        _pipe = mochi@schema:schema(),
        mochi@schema:'query'(_pipe, Query_type)
    end,
    With_mutation = case erlang:element(3, Builder) of
        [] ->
            Base_schema;

        _ ->
            Mutation_type = gleam@list:fold(
                erlang:element(3, Builder),
                mochi@schema:object(<<"Mutation"/utf8>>),
                fun(Obj@1, Field@1) -> mochi@schema:field(Obj@1, Field@1) end
            ),
            mochi@schema:mutation(Base_schema, Mutation_type)
    end,
    With_subscription = case erlang:element(4, Builder) of
        [] ->
            With_mutation;

        _ ->
            Subscription_type = gleam@list:fold(
                erlang:element(4, Builder),
                mochi@schema:object(<<"Subscription"/utf8>>),
                fun(Obj@2, Field@2) -> mochi@schema:field(Obj@2, Field@2) end
            ),
            mochi@schema:subscription(With_mutation, Subscription_type)
    end,
    With_types = gleam@list:fold(
        erlang:element(5, Builder),
        With_subscription,
        fun(S, T) -> mochi@schema:add_type(S, {object_type_def, T}) end
    ),
    With_enums = gleam@list:fold(
        erlang:element(6, Builder),
        With_types,
        fun(S@1, E) -> mochi@schema:add_type(S@1, {enum_type_def, E}) end
    ),
    With_interfaces = gleam@list:fold(
        erlang:element(7, Builder),
        With_enums,
        fun(S@2, I) -> mochi@schema:add_type(S@2, {interface_type_def, I}) end
    ),
    With_unions = gleam@list:fold(
        erlang:element(8, Builder),
        With_interfaces,
        fun(S@3, U) -> mochi@schema:add_type(S@3, {union_type_def, U}) end
    ),
    With_scalars = gleam@list:fold(
        erlang:element(9, Builder),
        With_unions,
        fun(S@4, Scalar) ->
            mochi@schema:add_type(S@4, {scalar_type_def, Scalar})
        end
    ),
    With_inputs = gleam@list:fold(
        erlang:element(10, Builder),
        With_scalars,
        fun(S@5, Input) ->
            mochi@schema:add_type(S@5, {input_object_type_def, Input})
        end
    ),
    With_directives = gleam@list:fold(
        mochi@schema:builtin_directives(),
        With_inputs,
        fun(S@6, Directive) -> mochi@schema:add_directive(S@6, Directive) end
    ),
    {schema,
        erlang:element(2, With_directives),
        erlang:element(3, With_directives),
        erlang:element(4, With_directives),
        erlang:element(5, With_directives),
        erlang:element(6, With_directives),
        {some, mochi@document_cache:new()}}.