dagger_gleam

-module(dagger@dsl@generator_group).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/dagger/dsl/generator_group.gleam").
-export([none/1, opt_on_conflict/2, generator_group/1, list/4, changes/2, id/1, is_empty/3, run/1]).
-export_type([for_changes/0, opts/1]).

-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 for_changes() :: any().

-opaque opts(YQW) :: {opts,
        gleam@option:option(dagger@dsl@types:changesets_merge_conflict())} |
    {gleam_phantom, YQW}.

-file("src/dagger/dsl/generator_group.gleam", 18).
-spec defaults() -> opts(any()).
defaults() ->
    {opts, none}.

-file("src/dagger/dsl/generator_group.gleam", 24).
-spec none(opts(YQZ)) -> opts(YQZ).
none(Opts) ->
    Opts.

-file("src/dagger/dsl/generator_group.gleam", 28).
-spec opt_on_conflict(
    opts(for_changes()),
    dagger@dsl@types:changesets_merge_conflict()
) -> opts(for_changes()).
opt_on_conflict(Opts, Val) ->
    {opts, {some, Val}}.

-file("src/dagger/dsl/generator_group.gleam", 32).
-spec generator_group(dagger@dsl@types:generator_group()) -> dagger@dsl@types:generator_group().
generator_group(Id) ->
    Field = {field,
        <<"loadGeneratorGroupFromID"/utf8>>,
        [{<<"id"/utf8>>, {g_deferred, erlang:element(2, Id)}}],
        []},
    {generator_group, {pure, [Field]}}.

-file("src/dagger/dsl/generator_group.gleam", 91).
?DOC(" Return a list of individual generators and their details\n").
-spec list(
    dagger@dsl@types:generator_group(),
    fun((dagger@dsl@types:generator()) -> list(dagger@types:field())),
    dagger@types:client(),
    fun(({ok, list(dagger@dsl@types:generator())} |
        {error, dagger@types:query_error()}) -> YRO)
) -> YRO.
list(Parent, Select, Client, Handler) ->
    Subfields = Select({generator, {pure, []}}),
    Field = {field, <<"list"/utf8>>, [], Subfields},
    Op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) ->
                Full_query = lists:append(Q, [Field]),
                {fetch,
                    Full_query,
                    {decoder, fun gleam@dynamic@decode:decode_dynamic/1},
                    fun(Dyn) ->
                        Path = dagger@types:make_path(Full_query),
                        case gleam@dynamic@decode:run(
                            Dyn,
                            gleam@dynamic@decode:at(
                                Path,
                                gleam@dynamic@decode:list(
                                    {decoder,
                                        fun gleam@dynamic@decode:decode_dynamic/1}
                                )
                            )
                        ) of
                            {ok, Items} ->
                                {pure,
                                    {ok,
                                        gleam@list:map(
                                            Items,
                                            fun(_) ->
                                                {generator, {pure, Full_query}}
                                            end
                                        )}};

                            {error, _} ->
                                {pure,
                                    {error, {decoding_error, <<"list"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).

-file("src/dagger/dsl/generator_group.gleam", 37).
-spec encode_changes(opts(any())) -> list({binary(), dagger@types:value()}).
encode_changes(Opts) ->
    gleam@list:filter_map([case erlang:element(2, Opts) of
                {some, Val} ->
                    {ok,
                        {<<"onConflict"/utf8>>,
                            {g_string,
                                dagger@dsl@types:changesets_merge_conflict_to_json(
                                    Val
                                )}}};

                none ->
                    {error, nil}
            end], fun(X) -> X end).

-file("src/dagger/dsl/generator_group.gleam", 49).
?DOC(
    " The combined changes from the generators execution\n"
    " If any conflict occurs, for instance if the same file is modified by multiple generators, or if a file is both modified and deleted, an error is raised and the merge of the changesets will failed.\n"
    " Set 'continueOnConflicts' flag to force to merge the changes in a 'last write wins' strategy.\n"
).
-spec changes(
    dagger@dsl@types:generator_group(),
    fun((opts(for_changes())) -> opts(for_changes()))
) -> dagger@dsl@types:changeset().
changes(Parent, With_fn) ->
    Opts = With_fn(defaults()),
    Field = {field, <<"changes"/utf8>>, encode_changes(Opts), []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {changeset, New_op}.

-file("src/dagger/dsl/generator_group.gleam", 60).
?DOC(" A unique identifier for this GeneratorGroup.\n").
-spec id(dagger@dsl@types:generator_group()) -> dagger@dsl@types:generator_group().
id(Parent) ->
    Field = {field, <<"id"/utf8>>, [], []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {generator_group, New_op}.

-file("src/dagger/dsl/generator_group.gleam", 70).
?DOC(" Whether the generated changeset is empty or not\n").
-spec is_empty(
    dagger@dsl@types:generator_group(),
    dagger@types:client(),
    fun(({ok, boolean()} | {error, dagger@types:query_error()}) -> YRK)
) -> YRK.
is_empty(Parent, Client, Handler) ->
    Field = {field, <<"isEmpty"/utf8>>, [], []},
    Op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) ->
                Full_query = lists:append(Q, [Field]),
                {fetch,
                    Full_query,
                    {decoder, fun gleam@dynamic@decode:decode_dynamic/1},
                    fun(Dyn) ->
                        Path = dagger@types:make_path(Full_query),
                        case gleam@dynamic@decode:run(
                            Dyn,
                            gleam@dynamic@decode:at(
                                Path,
                                {decoder,
                                    fun gleam@dynamic@decode:decode_bool/1}
                            )
                        ) of
                            {ok, Val} ->
                                {pure, {ok, Val}};

                            {error, _} ->
                                {pure,
                                    {error,
                                        {decoding_error, <<"isEmpty"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).

-file("src/dagger/dsl/generator_group.gleam", 113).
?DOC(" Execute all selected generators\n").
-spec run(dagger@dsl@types:generator_group()) -> dagger@dsl@types:generator_group().
run(Parent) ->
    Field = {field, <<"run"/utf8>>, [], []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {generator_group, New_op}.