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", 18).
-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", 24).
-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", 35).
-spec connect(fun((dagger@types:client()) -> FQB)) -> FQB.
connect(Callback) ->
    case envoy_ffi:get(<<"DAGGER_SESSION_PORT"/utf8>>) of
        {ok, Port} ->
            Token = begin
                _pipe = envoy_ffi:get(<<"DAGGER_SESSION_TOKEN"/utf8>>),
                gleam@result:unwrap(_pipe, <<""/utf8>>)
            end,
            Host = begin
                _pipe@1 = envoy_ffi:get(<<"DAGGER_SESSION_HOST"/utf8>>),
                gleam@result:unwrap(_pipe@1, <<"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);

        {error, _} ->
            Result@1 = case dagger@session:with_session(Callback) of
                {ok, Result} -> Result;
                _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 => <<"connect"/utf8>>,
                                line => 49,
                                value => _assert_fail,
                                start => 1674,
                                'end' => 1728,
                                pattern_start => 1685,
                                pattern_end => 1695})
            end,
            Result@1
    end.

-file("src/dagger/client.gleam", 55).
-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 => 61,
                        value => _assert_fail,
                        start => 2033,
                        'end' => 2081,
                        pattern_start => 2044,
                        pattern_end => 2051})
    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.