gleamql

-module(gleamql).
-compile(no_auto_import).

-export([new/0, set_query/2, set_variable/3, send/1, set_host/2, set_path/2, set_header/3]).
-export_type([request/0, graph_ql_error/0, gql_success/0, gql_errors/0, gql_error/0]).

-type request() :: {request,
        gleam@http@request:request(binary()),
        gleam@option:option(binary()),
        gleam@option:option(list({binary(), gleam@json:json()}))}.

-type graph_ql_error() :: {error_message, binary()} |
    {unexpected_status, integer()} |
    {unrecognised_response, binary()} |
    {unknown_error, gleam@dynamic:dynamic()}.

-type gql_success() :: {success_response, gleam@dynamic:dynamic()}.

-type gql_errors() :: {error_response, list(gql_error())}.

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

-spec new() -> request().
new() ->
    {request,
        begin
            _pipe = gleam@http@request:new(),
            gleam@http@request:set_method(_pipe, post)
        end,
        none,
        none}.

-spec set_query(request(), binary()) -> request().
set_query(Req, Query) ->
    erlang:setelement(3, Req, {some, Query}).

-spec set_variable(request(), binary(), gleam@json:json()) -> request().
set_variable(Req, Key, Value) ->
    Variables = [{Key, Value} |
        begin
            _pipe = erlang:element(4, Req),
            gleam@option:unwrap(_pipe, gleam@list:new())
        end],
    erlang:setelement(4, Req, {some, Variables}).

-spec send(request()) -> {ok, gleam@dynamic:dynamic()} |
    {error, graph_ql_error()}.
send(Req) ->
    Req@1 = begin
        _pipe = erlang:element(2, Req),
        gleam@http@request:set_body(
            _pipe,
            begin
                _pipe@4 = gleam@json:object(
                    [{<<"query"/utf8>>,
                            begin
                                _pipe@1 = erlang:element(3, Req),
                                _pipe@2 = gleam@option:unwrap(
                                    _pipe@1,
                                    <<""/utf8>>
                                ),
                                gleam@json:string(_pipe@2)
                            end},
                        {<<"variables"/utf8>>,
                            gleam@json:object(
                                begin
                                    _pipe@3 = erlang:element(4, Req),
                                    gleam@option:unwrap(
                                        _pipe@3,
                                        gleam@list:new()
                                    )
                                end
                            )}]
                ),
                gleam@json:to_string(_pipe@4)
            end
        )
    end,
    case begin
        _pipe@5 = gleam@hackney:send(Req@1),
        gleam@result:map_error(
            _pipe@5,
            fun(E) -> {unknown_error, gleam@dynamic:from(E)} end
        )
    end of
        {error, _try} -> {error, _try};
        {ok, Resp} ->
            Response_decoder = gleam@dynamic:decode1(
                fun(Field@0) -> {success_response, Field@0} end,
                gleam@dynamic:field(
                    <<"data"/utf8>>,
                    fun gleam@dynamic:dynamic/1
                )
            ),
            Errors_decoder = gleam@dynamic:decode1(
                fun(Field@0) -> {error_response, Field@0} end,
                gleam@dynamic:field(
                    <<"errors"/utf8>>,
                    gleam@dynamic:list(
                        gleam@dynamic:decode1(
                            fun(Field@0) -> {gql_error, Field@0} end,
                            gleam@dynamic:field(
                                <<"message"/utf8>>,
                                fun gleam@dynamic:string/1
                            )
                        )
                    )
                )
            ),
            case begin
                _pipe@6 = erlang:element(2, Resp),
                status_is_ok(_pipe@6)
            end of
                true ->
                    case gleam@json:decode(
                        erlang:element(4, Resp),
                        Response_decoder
                    ) of
                        {ok, Response} ->
                            {ok, erlang:element(2, Response)};

                        {error, _@1} ->
                            {error,
                                {unrecognised_response, erlang:element(4, Resp)}}
                    end;

                false ->
                    case gleam@json:decode(
                        erlang:element(4, Resp),
                        Errors_decoder
                    ) of
                        {ok, Response@1} ->
                            case begin
                                _pipe@7 = erlang:element(2, Response@1),
                                gleam@list:first(_pipe@7)
                            end of
                                {ok, Error} ->
                                    {error,
                                        {error_message,
                                            erlang:element(2, Error)}};

                                {error, _@2} ->
                                    {error,
                                        {unrecognised_response,
                                            erlang:element(4, Resp)}}
                            end;

                        {error, _@3} ->
                            {error,
                                {unexpected_status, erlang:element(2, Resp)}}
                    end
            end
    end.

-spec set_host(request(), binary()) -> request().
set_host(Req, Host) ->
    erlang:setelement(
        2,
        Req,
        begin
            _pipe = erlang:element(2, Req),
            gleam@http@request:set_host(_pipe, Host)
        end
    ).

-spec set_path(request(), binary()) -> request().
set_path(Req, Path) ->
    erlang:setelement(
        2,
        Req,
        begin
            _pipe = erlang:element(2, Req),
            gleam@http@request:set_path(_pipe, Path)
        end
    ).

-spec set_header(request(), binary(), binary()) -> request().
set_header(Req, Key, Value) ->
    erlang:setelement(
        2,
        Req,
        begin
            _pipe = erlang:element(2, Req),
            gleam@http@request:set_header(_pipe, Key, Value)
        end
    ).

-spec status_is_ok(integer()) -> boolean().
status_is_ok(Status) ->
    Status =:= 200.