galchemy

-module(galchemy@orm@graph).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src\\galchemy\\orm\\graph.gleam").
-export([hydrated_entity/1, relation_named/2, hydrate_only_with_hooks/4, hydrate_with_hooks/3, hydrate/2, hydrate_only/3, hydrate_many_with_hooks/4, hydrate_many/3]).
-export_type([relation_value/0, hydrated_relation/0, hydrated_entity/0, hydration_error/0, hydration_hook_error/1]).

-type relation_value() :: {to_one,
        gleam@option:option(galchemy@orm@entity:entity())} |
    {to_many, list(galchemy@orm@entity:entity())}.

-type hydrated_relation() :: {hydrated_relation, binary(), relation_value()}.

-type hydrated_entity() :: {hydrated_entity,
        galchemy@orm@entity:entity(),
        list(hydrated_relation())}.

-type hydration_error() :: {entity_error, galchemy@orm@entity:entity_error()} |
    {unknown_relation, galchemy@schema@relation:table_ref(), binary()}.

-type hydration_hook_error(JWW) :: {hydration_error, hydration_error()} |
    {hook_error, JWW}.

-file("src\\galchemy\\orm\\graph.gleam", 116).
-spec hydrated_entity(hydrated_entity()) -> galchemy@orm@entity:entity().
hydrated_entity(Hydrated) ->
    erlang:element(2, Hydrated).

-file("src\\galchemy\\orm\\graph.gleam", 207).
-spec relation_value(
    galchemy@schema@relation:relation(),
    list(galchemy@orm@entity:entity())
) -> relation_value().
relation_value(Next_relation, Related_entities) ->
    case erlang:element(4, Next_relation) of
        belongs_to ->
            case Related_entities of
                [First | _] ->
                    {to_one, {some, First}};

                [] ->
                    {to_one, none}
            end;

        has_many ->
            {to_many, Related_entities}
    end.

-file("src\\galchemy\\orm\\graph.gleam", 263).
-spec find_field_value(
    list(galchemy@session@unit_of_work:field_value()),
    binary()
) -> gleam@option:option(galchemy@ast@expression:sql_value()).
find_field_value(Fields, Column_name) ->
    case Fields of
        [] ->
            none;

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

                false ->
                    find_field_value(Rest, Column_name)
            end
    end.

-file("src\\galchemy\\orm\\graph.gleam", 248).
-spec pair_matches(
    galchemy@orm@entity:entity(),
    galchemy@orm@entity:entity(),
    galchemy@schema@relation:column_pair()
) -> boolean().
pair_matches(Next_entity, Related_entity, Pair) ->
    case find_field_value(
        erlang:element(3, Next_entity),
        erlang:element(2, Pair)
    ) of
        none ->
            false;

        {some, Local_value} ->
            case find_field_value(
                erlang:element(3, Related_entity),
                erlang:element(3, Pair)
            ) of
                none ->
                    false;

                {some, Related_value} ->
                    Local_value =:= Related_value
            end
    end.

-file("src\\galchemy\\orm\\graph.gleam", 235).
-spec remaining_pairs_match(
    galchemy@orm@entity:entity(),
    galchemy@orm@entity:entity(),
    list(galchemy@schema@relation:column_pair())
) -> boolean().
remaining_pairs_match(Next_entity, Related_entity, Pairs) ->
    case Pairs of
        [] ->
            true;

        [Pair | Rest] ->
            pair_matches(Next_entity, Related_entity, Pair) andalso remaining_pairs_match(
                Next_entity,
                Related_entity,
                Rest
            )
    end.

-file("src\\galchemy\\orm\\graph.gleam", 221).
-spec related_matches(
    galchemy@orm@entity:entity(),
    galchemy@schema@relation:relation(),
    galchemy@orm@entity:entity()
) -> boolean().
related_matches(Next_entity, Next_relation, Related_entity) ->
    case erlang:element(6, Next_relation) of
        [] ->
            false;

        [First | Rest] ->
            pair_matches(Next_entity, Related_entity, First) andalso remaining_pairs_match(
                Next_entity,
                Related_entity,
                Rest
            )
    end.

-file("src\\galchemy\\orm\\graph.gleam", 291).
-spec find_hydrated_relation(list(hydrated_relation()), binary()) -> gleam@option:option(hydrated_relation()).
find_hydrated_relation(Relations, Relation_name) ->
    case Relations of
        [] ->
            none;

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

                false ->
                    find_hydrated_relation(Rest, Relation_name)
            end
    end.

-file("src\\galchemy\\orm\\graph.gleam", 109).
-spec relation_named(hydrated_entity(), binary()) -> gleam@option:option(hydrated_relation()).
relation_named(Hydrated, Relation_name) ->
    find_hydrated_relation(erlang:element(3, Hydrated), Relation_name).

-file("src\\galchemy\\orm\\graph.gleam", 306).
-spec result_try(
    {ok, JZH} | {error, JZI},
    fun((JZH) -> {ok, JZL} | {error, JZI})
) -> {ok, JZL} | {error, JZI}.
result_try(Value, Next) ->
    case Value of
        {ok, Inner} ->
            Next(Inner);

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

-file("src\\galchemy\\orm\\graph.gleam", 313).
-spec map_hook_error({ok, galchemy@orm@entity:entity()} | {error, JZQ}) -> {ok,
        galchemy@orm@entity:entity()} |
    {error, hydration_hook_error(JZQ)}.
map_hook_error(Value) ->
    case Value of
        {ok, Inner} ->
            {ok, Inner};

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

-file("src\\galchemy\\orm\\graph.gleam", 278).
-spec mark_relation_loaded(
    galchemy@orm@entity:entity(),
    binary(),
    galchemy@orm@hook:entity_hooks(JZA)
) -> {ok, galchemy@orm@entity:entity()} | {error, hydration_hook_error(JZA)}.
mark_relation_loaded(Next_entity, Relation_name, Hooks) ->
    case galchemy@orm@entity:mark_relation_loaded(Next_entity, Relation_name) of
        {ok, Updated_entity} ->
            _pipe = galchemy@orm@hook:after_relation_loaded(
                Hooks,
                Updated_entity,
                Relation_name
            ),
            map_hook_error(_pipe);

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

-file("src\\galchemy\\orm\\graph.gleam", 170).
-spec hydrate_relation(
    galchemy@orm@entity:entity(),
    binary(),
    galchemy@orm@identity_map:identity_map(),
    galchemy@orm@hook:entity_hooks(JYR)
) -> {ok, {galchemy@orm@entity:entity(), hydrated_relation()}} |
    {error, hydration_hook_error(JYR)}.
hydrate_relation(Next_entity, Relation_name, Identities, Hooks) ->
    case galchemy@orm@metadata:relation_named(
        erlang:element(2, Next_entity),
        Relation_name
    ) of
        none ->
            {error,
                {hydration_error,
                    {unknown_relation,
                        erlang:element(2, erlang:element(2, Next_entity)),
                        Relation_name}}};

        {some, Next_relation} ->
            Related_entities = begin
                _pipe = galchemy@orm@identity_map:values_for_table(
                    Identities,
                    erlang:element(5, Next_relation)
                ),
                gleam@list:filter(
                    _pipe,
                    fun(Candidate) ->
                        related_matches(Next_entity, Next_relation, Candidate)
                    end
                )
            end,
            result_try(
                mark_relation_loaded(Next_entity, Relation_name, Hooks),
                fun(Loaded_entity) ->
                    {ok,
                        {Loaded_entity,
                            {hydrated_relation,
                                Relation_name,
                                relation_value(Next_relation, Related_entities)}}}
                end
            )
    end.

-file("src\\galchemy\\orm\\graph.gleam", 120).
-spec hydrate_relations(
    galchemy@orm@entity:entity(),
    list(binary()),
    galchemy@orm@identity_map:identity_map(),
    galchemy@orm@hook:entity_hooks(JYC),
    list(hydrated_relation())
) -> {ok, hydrated_entity()} | {error, hydration_hook_error(JYC)}.
hydrate_relations(Next_entity, Relation_names, Identities, Hooks, Acc) ->
    case Relation_names of
        [] ->
            {ok, {hydrated_entity, Next_entity, lists:reverse(Acc)}};

        [Relation_name | Rest] ->
            result_try(
                hydrate_relation(Next_entity, Relation_name, Identities, Hooks),
                fun(_use0) ->
                    {Updated_entity, Hydrated_relation} = _use0,
                    hydrate_relations(
                        Updated_entity,
                        Rest,
                        Identities,
                        Hooks,
                        [Hydrated_relation | Acc]
                    )
                end
            )
    end.

-file("src\\galchemy\\orm\\graph.gleam", 77).
-spec hydrate_only_with_hooks(
    galchemy@orm@entity:entity(),
    list(binary()),
    galchemy@orm@identity_map:identity_map(),
    galchemy@orm@hook:entity_hooks(JXI)
) -> {ok, hydrated_entity()} | {error, hydration_hook_error(JXI)}.
hydrate_only_with_hooks(Next_entity, Relation_names, Identities, Hooks) ->
    hydrate_relations(Next_entity, Relation_names, Identities, Hooks, []).

-file("src\\galchemy\\orm\\graph.gleam", 45).
-spec hydrate_with_hooks(
    galchemy@orm@entity:entity(),
    galchemy@orm@identity_map:identity_map(),
    galchemy@orm@hook:entity_hooks(JWZ)
) -> {ok, hydrated_entity()} | {error, hydration_hook_error(JWZ)}.
hydrate_with_hooks(Next_entity, Identities, Hooks) ->
    Relation_names = gleam@list:map(
        erlang:element(5, erlang:element(2, Next_entity)),
        fun(Next_relation) -> erlang:element(2, Next_relation) end
    ),
    hydrate_only_with_hooks(Next_entity, Relation_names, Identities, Hooks).

-file("src\\galchemy\\orm\\graph.gleam", 34).
-spec hydrate(
    galchemy@orm@entity:entity(),
    galchemy@orm@identity_map:identity_map()
) -> {ok, hydrated_entity()} | {error, hydration_error()}.
hydrate(Next_entity, Identities) ->
    case hydrate_with_hooks(Next_entity, Identities, galchemy@orm@hook:none()) of
        {ok, Value} ->
            {ok, Value};

        {error, {hydration_error, Error}} ->
            {error, Error};

        {error, {hook_error, _}} ->
            erlang:error(#{gleam_error => panic,
                    message => <<"unreachable hook error for hook.none()"/utf8>>,
                    file => <<?FILEPATH/utf8>>,
                    module => <<"galchemy/orm/graph"/utf8>>,
                    function => <<"hydrate"/utf8>>,
                    line => 41})
    end.

-file("src\\galchemy\\orm\\graph.gleam", 58).
-spec hydrate_only(
    galchemy@orm@entity:entity(),
    list(binary()),
    galchemy@orm@identity_map:identity_map()
) -> {ok, hydrated_entity()} | {error, hydration_error()}.
hydrate_only(Next_entity, Relation_names, Identities) ->
    case hydrate_only_with_hooks(
        Next_entity,
        Relation_names,
        Identities,
        galchemy@orm@hook:none()
    ) of
        {ok, Value} ->
            {ok, Value};

        {error, {hydration_error, Error}} ->
            {error, Error};

        {error, {hook_error, _}} ->
            erlang:error(#{gleam_error => panic,
                    message => <<"unreachable hook error for hook.none()"/utf8>>,
                    file => <<?FILEPATH/utf8>>,
                    module => <<"galchemy/orm/graph"/utf8>>,
                    function => <<"hydrate_only"/utf8>>,
                    line => 73})
    end.

-file("src\\galchemy\\orm\\graph.gleam", 145).
-spec hydrate_many_loop(
    list(galchemy@orm@entity:entity()),
    list(binary()),
    galchemy@orm@identity_map:identity_map(),
    galchemy@orm@hook:entity_hooks(JYK),
    list(hydrated_entity())
) -> {ok, list(hydrated_entity())} | {error, hydration_hook_error(JYK)}.
hydrate_many_loop(Entities, Relation_names, Identities, Hooks, Acc) ->
    case Entities of
        [] ->
            {ok, lists:reverse(Acc)};

        [Next_entity | Rest] ->
            result_try(
                hydrate_only_with_hooks(
                    Next_entity,
                    Relation_names,
                    Identities,
                    Hooks
                ),
                fun(Hydrated) ->
                    hydrate_many_loop(
                        Rest,
                        Relation_names,
                        Identities,
                        Hooks,
                        [Hydrated | Acc]
                    )
                end
            )
    end.

-file("src\\galchemy\\orm\\graph.gleam", 100).
-spec hydrate_many_with_hooks(
    list(galchemy@orm@entity:entity()),
    list(binary()),
    galchemy@orm@identity_map:identity_map(),
    galchemy@orm@hook:entity_hooks(JXU)
) -> {ok, list(hydrated_entity())} | {error, hydration_hook_error(JXU)}.
hydrate_many_with_hooks(Entities, Relation_names, Identities, Hooks) ->
    hydrate_many_loop(Entities, Relation_names, Identities, Hooks, []).

-file("src\\galchemy\\orm\\graph.gleam", 86).
-spec hydrate_many(
    list(galchemy@orm@entity:entity()),
    list(binary()),
    galchemy@orm@identity_map:identity_map()
) -> {ok, list(hydrated_entity())} | {error, hydration_error()}.
hydrate_many(Entities, Relation_names, Identities) ->
    case hydrate_many_with_hooks(
        Entities,
        Relation_names,
        Identities,
        galchemy@orm@hook:none()
    ) of
        {ok, Value} ->
            {ok, Value};

        {error, {hydration_error, Error}} ->
            {error, Error};

        {error, {hook_error, _}} ->
            erlang:error(#{gleam_error => panic,
                    message => <<"unreachable hook error for hook.none()"/utf8>>,
                    file => <<?FILEPATH/utf8>>,
                    module => <<"galchemy/orm/graph"/utf8>>,
                    function => <<"hydrate_many"/utf8>>,
                    line => 96})
    end.