galchemy

-module(galchemy@orm@runtime_registry).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src\\galchemy\\orm\\runtime_registry.gleam").
-export([empty/0, all/1, snapshot/1, lookup/3, get/3, register_model/2, model_metadata/3, table_schema/3, has_column/4, has_relation/4, relation_named/4, from_snapshot/1, from_models/1, to_mapper_registry/1]).
-export_type([runtime_registry/0, runtime_model/0, registry_error/0]).

-type runtime_registry() :: {runtime_registry,
        galchemy@schema@model:schema_snapshot(),
        list(runtime_model())}.

-type runtime_model() :: {runtime_model,
        galchemy@schema@relation:table_ref(),
        galchemy@schema@model:table_schema(),
        galchemy@orm@metadata:model_metadata()}.

-type registry_error() :: {duplicate_model,
        galchemy@schema@relation:table_ref()} |
    {unknown_model, galchemy@schema@relation:table_ref()} |
    {metadata_error, galchemy@orm@metadata:metadata_error()} |
    {declarative_error, galchemy@orm@declarative:declarative_error()} |
    {mapper_registry_error, galchemy@orm@mapper_registry:registry_error()}.

-file("src\\galchemy\\orm\\runtime_registry.gleam", 30).
-spec empty() -> runtime_registry().
empty() ->
    {runtime_registry, {schema_snapshot, []}, []}.

-file("src\\galchemy\\orm\\runtime_registry.gleam", 97).
-spec all(runtime_registry()) -> list(runtime_model()).
all(Registry) ->
    erlang:element(3, Registry).

-file("src\\galchemy\\orm\\runtime_registry.gleam", 101).
-spec snapshot(runtime_registry()) -> galchemy@schema@model:schema_snapshot().
snapshot(Registry) ->
    erlang:element(2, Registry).

-file("src\\galchemy\\orm\\runtime_registry.gleam", 237).
-spec find_model(list(runtime_model()), galchemy@schema@relation:table_ref()) -> gleam@option:option(runtime_model()).
find_model(Models, Table_ref) ->
    case Models of
        [] ->
            none;

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

                false ->
                    find_model(Rest, Table_ref)
            end
    end.

-file("src\\galchemy\\orm\\runtime_registry.gleam", 76).
-spec lookup(runtime_registry(), binary(), binary()) -> gleam@option:option(runtime_model()).
lookup(Registry, Schema_name, Table_name) ->
    find_model(
        erlang:element(3, Registry),
        galchemy@schema@relation:table_ref(Schema_name, Table_name)
    ).

-file("src\\galchemy\\orm\\runtime_registry.gleam", 84).
-spec get(runtime_registry(), binary(), binary()) -> {ok, runtime_model()} |
    {error, registry_error()}.
get(Registry, Schema_name, Table_name) ->
    Table_ref = galchemy@schema@relation:table_ref(Schema_name, Table_name),
    case find_model(erlang:element(3, Registry), Table_ref) of
        {some, Value} ->
            {ok, Value};

        none ->
            {error, {unknown_model, Table_ref}}
    end.

-file("src\\galchemy\\orm\\runtime_registry.gleam", 227).
-spec ensure_not_registered(
    list(runtime_model()),
    galchemy@schema@relation:table_ref()
) -> {ok, nil} | {error, registry_error()}.
ensure_not_registered(Models, Table_ref) ->
    case find_model(Models, Table_ref) of
        {some, _} ->
            {error, {duplicate_model, Table_ref}};

        none ->
            {ok, nil}
    end.

-file("src\\galchemy\\orm\\runtime_registry.gleam", 252).
-spec result_try(
    {ok, MSY} | {error, MSZ},
    fun((MSY) -> {ok, MTC} | {error, MSZ})
) -> {ok, MTC} | {error, MSZ}.
result_try(Value, Next) ->
    case Value of
        {ok, Inner} ->
            Next(Inner);

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

-file("src\\galchemy\\orm\\runtime_registry.gleam", 47).
-spec register_model(runtime_registry(), galchemy@orm@declarative:model()) -> {ok,
        runtime_registry()} |
    {error, registry_error()}.
register_model(Registry, Next_model) ->
    result_try(
        begin
            _pipe = galchemy@orm@declarative:to_table_schema(Next_model),
            gleam@result:map_error(
                _pipe,
                fun(Field@0) -> {declarative_error, Field@0} end
            )
        end,
        fun(Table_schema) ->
            Table_ref = galchemy@schema@relation:table_ref(
                erlang:element(2, Table_schema),
                erlang:element(3, Table_schema)
            ),
            result_try(
                ensure_not_registered(erlang:element(3, Registry), Table_ref),
                fun(_) ->
                    result_try(
                        begin
                            _pipe@1 = galchemy@orm@declarative:to_metadata(
                                Next_model
                            ),
                            gleam@result:map_error(
                                _pipe@1,
                                fun(Field@0) -> {declarative_error, Field@0} end
                            )
                        end,
                        fun(Next_metadata) ->
                            {ok,
                                {runtime_registry,
                                    {schema_snapshot,
                                        lists:append(
                                            erlang:element(
                                                2,
                                                erlang:element(2, Registry)
                                            ),
                                            [Table_schema]
                                        )},
                                    lists:append(
                                        erlang:element(3, Registry),
                                        [{runtime_model,
                                                Table_ref,
                                                Table_schema,
                                                Next_metadata}]
                                    )}}
                        end
                    )
                end
            )
        end
    ).

-file("src\\galchemy\\orm\\runtime_registry.gleam", 105).
-spec model_metadata(runtime_registry(), binary(), binary()) -> {ok,
        galchemy@orm@metadata:model_metadata()} |
    {error, registry_error()}.
model_metadata(Registry, Schema_name, Table_name) ->
    result_try(
        get(Registry, Schema_name, Table_name),
        fun(Next_model) -> {ok, erlang:element(4, Next_model)} end
    ).

-file("src\\galchemy\\orm\\runtime_registry.gleam", 114).
-spec table_schema(runtime_registry(), binary(), binary()) -> {ok,
        galchemy@schema@model:table_schema()} |
    {error, registry_error()}.
table_schema(Registry, Schema_name, Table_name) ->
    result_try(
        get(Registry, Schema_name, Table_name),
        fun(Next_model) -> {ok, erlang:element(3, Next_model)} end
    ).

-file("src\\galchemy\\orm\\runtime_registry.gleam", 123).
-spec has_column(runtime_registry(), binary(), binary(), binary()) -> {ok,
        boolean()} |
    {error, registry_error()}.
has_column(Registry, Schema_name, Table_name, Column_name) ->
    result_try(
        model_metadata(Registry, Schema_name, Table_name),
        fun(Next_metadata) ->
            {ok, galchemy@orm@metadata:has_column(Next_metadata, Column_name)}
        end
    ).

-file("src\\galchemy\\orm\\runtime_registry.gleam", 137).
-spec has_relation(runtime_registry(), binary(), binary(), binary()) -> {ok,
        boolean()} |
    {error, registry_error()}.
has_relation(Registry, Schema_name, Table_name, Relation_name) ->
    result_try(
        model_metadata(Registry, Schema_name, Table_name),
        fun(Next_metadata) ->
            {ok,
                galchemy@orm@metadata:has_relation(Next_metadata, Relation_name)}
        end
    ).

-file("src\\galchemy\\orm\\runtime_registry.gleam", 151).
-spec relation_named(runtime_registry(), binary(), binary(), binary()) -> {ok,
        gleam@option:option(galchemy@schema@relation:relation())} |
    {error, registry_error()}.
relation_named(Registry, Schema_name, Table_name, Relation_name) ->
    result_try(
        model_metadata(Registry, Schema_name, Table_name),
        fun(Next_metadata) ->
            {ok,
                galchemy@orm@metadata:relation_named(
                    Next_metadata,
                    Relation_name
                )}
        end
    ).

-file("src\\galchemy\\orm\\runtime_registry.gleam", 173).
-spec models_from_snapshot(
    galchemy@schema@model:schema_snapshot(),
    list(galchemy@schema@model:table_schema()),
    list(runtime_model())
) -> {ok, list(runtime_model())} | {error, registry_error()}.
models_from_snapshot(Snapshot, Tables, Acc) ->
    case Tables of
        [] ->
            {ok, Acc};

        [Table_schema | Rest] ->
            result_try(
                begin
                    _pipe = galchemy@orm@metadata:from_snapshot(
                        Snapshot,
                        erlang:element(2, Table_schema),
                        erlang:element(3, Table_schema)
                    ),
                    gleam@result:map_error(
                        _pipe,
                        fun(Field@0) -> {metadata_error, Field@0} end
                    )
                end,
                fun(Next_metadata) ->
                    models_from_snapshot(
                        Snapshot,
                        Rest,
                        [{runtime_model,
                                galchemy@schema@relation:table_ref(
                                    erlang:element(2, Table_schema),
                                    erlang:element(3, Table_schema)
                                ),
                                Table_schema,
                                Next_metadata} |
                            Acc]
                    )
                end
            )
    end.

-file("src\\galchemy\\orm\\runtime_registry.gleam", 34).
-spec from_snapshot(galchemy@schema@model:schema_snapshot()) -> {ok,
        runtime_registry()} |
    {error, registry_error()}.
from_snapshot(Snapshot) ->
    result_try(
        models_from_snapshot(Snapshot, erlang:element(2, Snapshot), []),
        fun(Models) ->
            {ok, {runtime_registry, Snapshot, lists:reverse(Models)}}
        end
    ).

-file("src\\galchemy\\orm\\runtime_registry.gleam", 198).
-spec registry_from_models(
    list(galchemy@orm@declarative:model()),
    runtime_registry()
) -> {ok, runtime_registry()} | {error, registry_error()}.
registry_from_models(Models, Registry) ->
    case Models of
        [] ->
            {ok, Registry};

        [Next_model | Rest] ->
            result_try(
                register_model(Registry, Next_model),
                fun(Next_registry) ->
                    registry_from_models(Rest, Next_registry)
                end
            )
    end.

-file("src\\galchemy\\orm\\runtime_registry.gleam", 41).
-spec from_models(list(galchemy@orm@declarative:model())) -> {ok,
        runtime_registry()} |
    {error, registry_error()}.
from_models(Models) ->
    registry_from_models(Models, empty()).

-file("src\\galchemy\\orm\\runtime_registry.gleam", 211).
-spec mapper_registry_from_metadata(
    list(galchemy@orm@metadata:model_metadata()),
    galchemy@orm@mapper_registry:mapper_registry()
) -> {ok, galchemy@orm@mapper_registry:mapper_registry()} |
    {error, registry_error()}.
mapper_registry_from_metadata(Metadatas, Registry) ->
    case Metadatas of
        [] ->
            {ok, Registry};

        [Next_metadata | Rest] ->
            result_try(
                begin
                    _pipe = galchemy@orm@mapper_registry:register(
                        Registry,
                        Next_metadata
                    ),
                    gleam@result:map_error(
                        _pipe,
                        fun(Field@0) -> {mapper_registry_error, Field@0} end
                    )
                end,
                fun(Next_registry) ->
                    mapper_registry_from_metadata(Rest, Next_registry)
                end
            )
    end.

-file("src\\galchemy\\orm\\runtime_registry.gleam", 165).
-spec to_mapper_registry(runtime_registry()) -> {ok,
        galchemy@orm@mapper_registry:mapper_registry()} |
    {error, registry_error()}.
to_mapper_registry(Registry) ->
    _pipe = erlang:element(3, Registry),
    _pipe@1 = gleam@list:map(
        _pipe,
        fun(Next_model) -> erlang:element(4, Next_model) end
    ),
    mapper_registry_from_metadata(_pipe@1, galchemy@orm@mapper_registry:empty()).