dagger_gleam

-module(dagger@client).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/dagger/client.gleam").
-export([connect/1, raw_query/2]).

-file("src/dagger/client.gleam", 17).
-spec graphql_error_decoder() -> gleam@dynamic@decode:decoder(dagger@types:graph_q_l_error()).
graphql_error_decoder() ->
    gleam@dynamic@decode:field(
        <<"message"/utf8>>,
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(Message) ->
            gleam@dynamic@decode:field(
                <<"path"/utf8>>,
                gleam@dynamic@decode:list(
                    {decoder, fun gleam@dynamic@decode:decode_dynamic/1}
                ),
                fun(Path) ->
                    gleam@dynamic@decode:success(
                        {graph_q_l_error, Message, Path}
                    )
                end
            )
        end
    ).

-file("src/dagger/client.gleam", 23).
-spec check_graphql_errors(gleam@dynamic:dynamic_()) -> {ok,
        gleam@dynamic:dynamic_()} |
    {error, dagger@types:query_error()}.
check_graphql_errors(Dyn) ->
    case gleam@dynamic@decode:run(
        Dyn,
        gleam@dynamic@decode:at(
            [<<"errors"/utf8>>],
            gleam@dynamic@decode:list(graphql_error_decoder())
        )
    ) of
        {ok, Errors} ->
            {error, {execution_error, Errors}};

        {error, _} ->
            {ok, Dyn}
    end.

-file("src/dagger/client.gleam", 34).
-spec connect(fun((dagger@types:client()) -> FON)) -> FON.
connect(Callback) ->
    Port = begin
        _pipe = envoy_ffi:get(<<"DAGGER_SESSION_PORT"/utf8>>),
        gleam@result:unwrap(_pipe, <<"8080"/utf8>>)
    end,
    Token = begin
        _pipe@1 = envoy_ffi:get(<<"DAGGER_SESSION_TOKEN"/utf8>>),
        gleam@result:unwrap(_pipe@1, <<""/utf8>>)
    end,
    Host = begin
        _pipe@2 = envoy_ffi:get(<<"DAGGER_SESSION_HOST"/utf8>>),
        gleam@result:unwrap(_pipe@2, <<"127.0.0.1"/utf8>>)
    end,
    Endpoint = <<<<<<<<"http://"/utf8, Host/binary>>/binary, ":"/utf8>>/binary,
            Port/binary>>/binary,
        "/query"/utf8>>,
    Client = {client, Endpoint, Token},
    Callback(Client).

-file("src/dagger/client.gleam", 45).
-spec raw_query(dagger@types:client(), binary()) -> {ok,
        gleam@dynamic:dynamic_()} |
    {error, dagger@types:query_error()}.
raw_query(Client, Query_string) ->
    dagger@logger:report({'query', Query_string}),
    Body = gleam@json:object(
        [{<<"query"/utf8>>, gleam@json:string(Query_string)}]
    ),
    Auth = gleam_stdlib:base64_encode(
        gleam_stdlib:identity(<<(erlang:element(3, Client))/binary, ":"/utf8>>),
        true
    ),
    Req@1 = case gleam@http@request:to(erlang:element(2, Client)) of
        {ok, Req} -> Req;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"dagger/client"/utf8>>,
                        function => <<"raw_query"/utf8>>,
                        line => 51,
                        value => _assert_fail,
                        start => 1737,
                        'end' => 1785,
                        pattern_start => 1748,
                        pattern_end => 1755})
    end,
    Res = begin
        _pipe = Req@1,
        _pipe@1 = gleam@http@request:set_method(_pipe, post),
        _pipe@2 = gleam@http@request:set_header(
            _pipe@1,
            <<"Authorization"/utf8>>,
            <<"Basic "/utf8, Auth/binary>>
        ),
        _pipe@3 = gleam@http@request:set_header(
            _pipe@2,
            <<"Content-type"/utf8>>,
            <<"application/json"/utf8>>
        ),
        _pipe@4 = gleam@http@request:set_body(
            _pipe@3,
            gleam@json:to_string(Body)
        ),
        gleam@httpc:send(_pipe@4)
    end,
    case Res of
        {ok, Resp} when erlang:element(2, Resp) =:= 200 ->
            _pipe@5 = gleam@json:parse(
                erlang:element(4, Resp),
                {decoder, fun gleam@dynamic@decode:decode_dynamic/1}
            ),
            _pipe@6 = gleam@result:map_error(
                _pipe@5,
                fun(_) -> {decoding_error, <<"JSON invalido"/utf8>>} end
            ),
            gleam@result:'try'(_pipe@6, fun check_graphql_errors/1);

        {ok, Resp@1} ->
            {error,
                {network_error,
                    <<"Errore HTTP: "/utf8,
                        (gleam@string:inspect(erlang:element(2, Resp@1)))/binary>>}};

        {error, Err} ->
            {error,
                {network_error,
                    <<"Errore Network: "/utf8,
                        (gleam@string:inspect(Err))/binary>>}}
    end.