dagger_gleam

-module(dagger@types).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/dagger/types.gleam").
-export([pure/1, bind/2, continue/2, get_query/1, make_path/1, nest/1, serialize/1]).
-export_type([client/0, query_error/0, graph_q_l_error/0, dagger_op/1, field/0, value/0]).

-type client() :: {client, binary(), binary()}.

-type query_error() :: {network_error, binary()} |
    {decoding_error, binary()} |
    {execution_error, list(graph_q_l_error())}.

-type graph_q_l_error() :: {graph_q_l_error,
        binary(),
        list(gleam@dynamic:dynamic_())}.

-type dagger_op(FLG) :: {pure, FLG} |
    {fetch,
        list(field()),
        gleam@dynamic@decode:decoder(gleam@dynamic:dynamic_()),
        fun((gleam@dynamic:dynamic_()) -> dagger_op(FLG))}.

-type field() :: {field, binary(), list({binary(), value()}), list(field())}.

-type value() :: {g_string, binary()} |
    {g_int, integer()} |
    {g_float, float()} |
    {g_bool, boolean()} |
    {g_list, list(value())} |
    {g_object, list({binary(), value()})} |
    g_null |
    {g_deferred, dagger_op(list(field()))}.

-file("src/dagger/types.gleam", 40).
-spec pure(FLK) -> dagger_op(FLK).
pure(Val) ->
    {pure, Val}.

-file("src/dagger/types.gleam", 44).
-spec bind(dagger_op(FLM), fun((FLM) -> dagger_op(FLO))) -> dagger_op(FLO).
bind(Op, Callback) ->
    case Op of
        {pure, Val} ->
            Callback(Val);

        {fetch, Fields, Decoder, Next} ->
            {fetch, Fields, Decoder, fun(Dyn) -> bind(Next(Dyn), Callback) end}
    end.

-file("src/dagger/types.gleam", 55).
-spec continue(dagger_op(FLR), fun((FLR) -> dagger_op(FLT))) -> dagger_op(FLT).
continue(Op, Callback) ->
    case Op of
        {pure, A} ->
            Callback(A);

        {fetch, Fields, Decoder, Next} ->
            {fetch,
                Fields,
                Decoder,
                fun(Dyn) -> continue(Next(Dyn), Callback) end}
    end.

-file("src/dagger/types.gleam", 63).
-spec get_query(dagger_op(list(field()))) -> list(field()).
get_query(Op) ->
    case Op of
        {pure, Q} ->
            Q;

        {fetch, Q@1, _, _} ->
            Q@1
    end.

-file("src/dagger/types.gleam", 91).
-spec make_path(list(field())) -> list(binary()).
make_path(Fields) ->
    Names = gleam@list:map(Fields, fun(F) -> erlang:element(2, F) end),
    [<<"data"/utf8>> | Names].

-file("src/dagger/types.gleam", 150).
-spec nest(list(field())) -> list(field()).
nest(Fields) ->
    case lists:reverse(Fields) of
        [] ->
            [];

        [Last | Rest] ->
            _pipe = gleam@list:fold(
                Rest,
                Last,
                fun(Acc, F) ->
                    {field, erlang:element(2, F), erlang:element(3, F), [Acc]}
                end
            ),
            gleam@list:wrap(_pipe)
    end.

-file("src/dagger/types.gleam", 119).
-spec serialize_value(value()) -> binary().
serialize_value(Value) ->
    case Value of
        {g_string, S} ->
            gleam@json:to_string(gleam@json:string(S));

        {g_int, I} ->
            erlang:integer_to_binary(I);

        {g_float, F} ->
            gleam_stdlib:float_to_string(F);

        {g_bool, true} ->
            <<"true"/utf8>>;

        {g_bool, false} ->
            <<"false"/utf8>>;

        {g_list, Items} ->
            <<<<"["/utf8,
                    (begin
                        _pipe = gleam@list:map(Items, fun serialize_value/1),
                        gleam@string:join(_pipe, <<", "/utf8>>)
                    end)/binary>>/binary,
                "]"/utf8>>;

        {g_object, Fields} ->
            <<<<"{"/utf8,
                    (begin
                        _pipe@1 = gleam@list:map(
                            Fields,
                            fun(F@1) ->
                                <<<<(erlang:element(1, F@1))/binary, ": "/utf8>>/binary,
                                    (serialize_value(erlang:element(2, F@1)))/binary>>
                            end
                        ),
                        gleam@string:join(_pipe@1, <<", "/utf8>>)
                    end)/binary>>/binary,
                "}"/utf8>>;

        g_null ->
            <<"null"/utf8>>;

        {g_deferred, Op} ->
            Fields@1 = get_query(Op),
            case nest(Fields@1) of
                [Field] ->
                    serialize_field(Field);

                _ ->
                    erlang:error(#{gleam_error => panic,
                            message => <<"GDeferred deve avere un solo campo radice"/utf8>>,
                            file => <<?FILEPATH/utf8>>,
                            module => <<"dagger/types"/utf8>>,
                            function => <<"serialize_value"/utf8>>,
                            line => 144})
            end
    end.

-file("src/dagger/types.gleam", 101).
-spec serialize_field(field()) -> binary().
serialize_field(Field) ->
    Args@1 = case erlang:element(3, Field) of
        [] ->
            <<""/utf8>>;

        Args ->
            <<<<"("/utf8, (serialize_args(Args))/binary>>/binary, ")"/utf8>>
    end,
    Subs@1 = case erlang:element(4, Field) of
        [] ->
            <<""/utf8>>;

        Subs ->
            <<<<" { "/utf8,
                    (begin
                        _pipe = gleam@list:map(Subs, fun serialize_field/1),
                        gleam@string:join(_pipe, <<" "/utf8>>)
                    end)/binary>>/binary,
                " }"/utf8>>
    end,
    <<<<(erlang:element(2, Field))/binary, Args@1/binary>>/binary,
        Subs@1/binary>>.

-file("src/dagger/types.gleam", 113).
-spec serialize_args(list({binary(), value()})) -> binary().
serialize_args(Args) ->
    _pipe = Args,
    _pipe@1 = gleam@list:map(
        _pipe,
        fun(Arg) ->
            <<<<(erlang:element(1, Arg))/binary, ": "/utf8>>/binary,
                (serialize_value(erlang:element(2, Arg)))/binary>>
        end
    ),
    gleam@string:join(_pipe@1, <<", "/utf8>>).

-file("src/dagger/types.gleam", 96).
-spec serialize(list(field())) -> binary().
serialize(Fields) ->
    Nested_fields = nest(Fields),
    <<<<"{ "/utf8,
            (begin
                _pipe = gleam@list:map(Nested_fields, fun serialize_field/1),
                gleam@string:join(_pipe, <<" "/utf8>>)
            end)/binary>>/binary,
        " }"/utf8>>.