galchemy

-module(galchemy@orm@result).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src\\galchemy\\orm\\result.gleam").
-export([row/2, scalar/2, one/3, scalar_value/1, entity_value/1, scalar_as/2, tuple2/2, tuple3/3, map/2, many/3]).
-export_type([scalar_field/0, row/0, mapping_error/0, mapper/1]).

-type scalar_field() :: {scalar_field,
        binary(),
        galchemy@ast@expression:sql_value()}.

-type row() :: {row,
        list(scalar_field()),
        list(galchemy@orm@materializer:row_data())}.

-type mapping_error() :: {missing_scalar, binary()} |
    {missing_entity, galchemy@orm@metadata:model_metadata()} |
    {codec_error, galchemy@orm@codec:codec_error()} |
    {materialization_error, galchemy@orm@materializer:materialization_error()}.

-type mapper(MKP) :: {mapper,
        fun((row(), galchemy@orm@materializer:materializer()) -> {ok,
                {MKP, galchemy@orm@materializer:materializer()}} |
            {error, mapping_error()})}.

-file("src\\galchemy\\orm\\result.gleam", 31).
-spec row(list(scalar_field()), list(galchemy@orm@materializer:row_data())) -> row().
row(Scalars, Entities) ->
    {row, Scalars, Entities}.

-file("src\\galchemy\\orm\\result.gleam", 38).
-spec scalar(binary(), galchemy@ast@expression:sql_value()) -> scalar_field().
scalar(Name, Value) ->
    {scalar_field, Name, Value}.

-file("src\\galchemy\\orm\\result.gleam", 128).
-spec one(mapper(MLN), row(), galchemy@orm@materializer:materializer()) -> {ok,
        {MLN, galchemy@orm@materializer:materializer()}} |
    {error, mapping_error()}.
one(Mapper, Next_row, Next_materializer) ->
    (erlang:element(2, Mapper))(Next_row, Next_materializer).

-file("src\\galchemy\\orm\\result.gleam", 164).
-spec scalar_named(list(scalar_field()), binary()) -> gleam@option:option(scalar_field()).
scalar_named(Scalars, Name) ->
    case Scalars of
        [] ->
            none;

        [Next_scalar | Rest] ->
            case erlang:element(2, Next_scalar) =:= Name of
                true ->
                    {some, Next_scalar};

                false ->
                    scalar_named(Rest, Name)
            end
    end.

-file("src\\galchemy\\orm\\result.gleam", 42).
-spec scalar_value(binary()) -> mapper(galchemy@ast@expression:sql_value()).
scalar_value(Name) ->
    {mapper,
        fun(Next_row, Next_materializer) ->
            case scalar_named(erlang:element(2, Next_row), Name) of
                {some, Field} ->
                    {ok, {erlang:element(3, Field), Next_materializer}};

                none ->
                    {error, {missing_scalar, Name}}
            end
        end}.

-file("src\\galchemy\\orm\\result.gleam", 179).
-spec entity_row_named(
    list(galchemy@orm@materializer:row_data()),
    galchemy@orm@metadata:model_metadata()
) -> gleam@option:option(galchemy@orm@materializer:row_data()).
entity_row_named(Rows, Next_metadata) ->
    case Rows of
        [] ->
            none;

        [Next_row | Rest] ->
            {row_data, Table, _} = Next_row,
            case Table =:= erlang:element(2, Next_metadata) of
                true ->
                    {some, Next_row};

                false ->
                    entity_row_named(Rest, Next_metadata)
            end
    end.

-file("src\\galchemy\\orm\\result.gleam", 65).
-spec entity_value(galchemy@orm@metadata:model_metadata()) -> mapper(galchemy@orm@entity:entity()).
entity_value(Next_metadata) ->
    {mapper,
        fun(Next_row, Next_materializer) ->
            case entity_row_named(erlang:element(3, Next_row), Next_metadata) of
                {some, Entity_row} ->
                    case galchemy@orm@materializer:materialize(
                        Next_materializer,
                        Entity_row
                    ) of
                        {ok, Value} ->
                            {ok, Value};

                        {error, Error} ->
                            {error, {materialization_error, Error}}
                    end;

                none ->
                    {error, {missing_entity, Next_metadata}}
            end
        end}.

-file("src\\galchemy\\orm\\result.gleam", 196).
-spec result_try(
    {ok, MMI} | {error, MMJ},
    fun((MMI) -> {ok, MMM} | {error, MMJ})
) -> {ok, MMM} | {error, MMJ}.
result_try(Value, Next) ->
    case Value of
        {ok, Inner} ->
            Next(Inner);

        {error, Error} ->
            {error, Error}
    end.

-file("src\\galchemy\\orm\\result.gleam", 51).
-spec scalar_as(binary(), galchemy@orm@codec:codec(MKT)) -> mapper(MKT).
scalar_as(Name, Next_codec) ->
    {mapper,
        fun(Next_row, Next_materializer) ->
            result_try(
                (erlang:element(2, scalar_value(Name)))(
                    Next_row,
                    Next_materializer
                ),
                fun(_use0) ->
                    {Value, Updated_materializer} = _use0,
                    case galchemy@orm@codec:decode(Next_codec, Value) of
                        {ok, Decoded} ->
                            {ok, {Decoded, Updated_materializer}};

                        {error, Error} ->
                            {error, {codec_error, Error}}
                    end
                end
            )
        end}.

-file("src\\galchemy\\orm\\result.gleam", 80).
-spec tuple2(mapper(MKX), mapper(MKZ)) -> mapper({MKX, MKZ}).
tuple2(First, Second) ->
    {mapper,
        fun(Next_row, Next_materializer) ->
            result_try(
                (erlang:element(2, First))(Next_row, Next_materializer),
                fun(_use0) ->
                    {First_value, Materializer1} = _use0,
                    result_try(
                        (erlang:element(2, Second))(Next_row, Materializer1),
                        fun(_use0@1) ->
                            {Second_value, Materializer2} = _use0@1,
                            {ok, {{First_value, Second_value}, Materializer2}}
                        end
                    )
                end
            )
        end}.

-file("src\\galchemy\\orm\\result.gleam", 95).
-spec tuple3(mapper(MLC), mapper(MLE), mapper(MLG)) -> mapper({MLC, MLE, MLG}).
tuple3(First, Second, Third) ->
    {mapper,
        fun(Next_row, Next_materializer) ->
            result_try(
                (erlang:element(2, First))(Next_row, Next_materializer),
                fun(_use0) ->
                    {First_value, Materializer1} = _use0,
                    result_try(
                        (erlang:element(2, Second))(Next_row, Materializer1),
                        fun(_use0@1) ->
                            {Second_value, Materializer2} = _use0@1,
                            result_try(
                                (erlang:element(2, Third))(
                                    Next_row,
                                    Materializer2
                                ),
                                fun(_use0@2) ->
                                    {Third_value, Materializer3} = _use0@2,
                                    {ok,
                                        {{First_value,
                                                Second_value,
                                                Third_value},
                                            Materializer3}}
                                end
                            )
                        end
                    )
                end
            )
        end}.

-file("src\\galchemy\\orm\\result.gleam", 118).
-spec map(mapper(MLJ), fun((MLJ) -> MLL)) -> mapper(MLL).
map(Mapper, Transform) ->
    {mapper,
        fun(Next_row, Next_materializer) ->
            result_try(
                (erlang:element(2, Mapper))(Next_row, Next_materializer),
                fun(_use0) ->
                    {Value, Updated_materializer} = _use0,
                    {ok, {Transform(Value), Updated_materializer}}
                end
            )
        end}.

-file("src\\galchemy\\orm\\result.gleam", 144).
-spec many_loop(
    mapper(MLX),
    list(row()),
    galchemy@orm@materializer:materializer(),
    list(MLX)
) -> {ok, {list(MLX), galchemy@orm@materializer:materializer()}} |
    {error, mapping_error()}.
many_loop(Mapper, Rows, Next_materializer, Acc) ->
    case Rows of
        [] ->
            {ok, {lists:reverse(Acc), Next_materializer}};

        [Next_row | Rest] ->
            result_try(
                one(Mapper, Next_row, Next_materializer),
                fun(_use0) ->
                    {Mapped, Updated_materializer} = _use0,
                    many_loop(
                        Mapper,
                        Rest,
                        Updated_materializer,
                        [Mapped | Acc]
                    )
                end
            )
    end.

-file("src\\galchemy\\orm\\result.gleam", 136).
-spec many(mapper(MLR), list(row()), galchemy@orm@materializer:materializer()) -> {ok,
        {list(MLR), galchemy@orm@materializer:materializer()}} |
    {error, mapping_error()}.
many(Mapper, Rows, Next_materializer) ->
    many_loop(Mapper, Rows, Next_materializer, []).