galchemy

-module(galchemy@orm@metadata).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src\\galchemy\\orm\\metadata.gleam").
-export([has_column/2, from_snapshot/3, has_relation/2, relation_named/2]).
-export_type([model_metadata/0, metadata_error/0]).

-type model_metadata() :: {model_metadata,
        galchemy@schema@relation:table_ref(),
        list(binary()),
        list(binary()),
        list(galchemy@schema@relation:relation())}.

-type metadata_error() :: {unknown_table, galchemy@schema@relation:table_ref()} |
    {missing_identity, galchemy@schema@relation:table_ref()}.

-file("src\\galchemy\\orm\\metadata.gleam", 53).
-spec has_column(model_metadata(), binary()) -> boolean().
has_column(Metadata, Column_name) ->
    gleam@list:contains(erlang:element(4, Metadata), Column_name).

-file("src\\galchemy\\orm\\metadata.gleam", 71).
-spec derive_identity_columns(galchemy@schema@model:table_schema()) -> list(binary()).
derive_identity_columns(Table_schema) ->
    case erlang:element(5, Table_schema) of
        {some, Primary_key} ->
            erlang:element(3, Primary_key);

        none ->
            case erlang:element(6, Table_schema) of
                [First | _] ->
                    erlang:element(3, First);

                [] ->
                    []
            end
    end.

-file("src\\galchemy\\orm\\metadata.gleam", 82).
-spec find_table(
    list(galchemy@schema@model:table_schema()),
    galchemy@schema@relation:table_ref()
) -> gleam@option:option(galchemy@schema@model:table_schema()).
find_table(Tables, Table_ref) ->
    case Tables of
        [] ->
            none;

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

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

-file("src\\galchemy\\orm\\metadata.gleam", 20).
-spec from_snapshot(galchemy@schema@model:schema_snapshot(), binary(), binary()) -> {ok,
        model_metadata()} |
    {error, metadata_error()}.
from_snapshot(Snapshot, Schema_name, Table_name) ->
    Table_ref = galchemy@schema@relation:table_ref(Schema_name, Table_name),
    case find_table(erlang:element(2, Snapshot), Table_ref) of
        none ->
            {error, {unknown_table, Table_ref}};

        {some, Table_schema} ->
            Identity_columns = derive_identity_columns(Table_schema),
            Columns = gleam@list:map(
                erlang:element(4, Table_schema),
                fun(Column) -> erlang:element(2, Column) end
            ),
            Relations = case galchemy@schema@relation:for_table(
                Snapshot,
                Schema_name,
                Table_name
            ) of
                {some, Table_relations} ->
                    erlang:element(3, Table_relations);

                none ->
                    []
            end,
            case Identity_columns of
                [] ->
                    {error, {missing_identity, Table_ref}};

                _ ->
                    {ok,
                        {model_metadata,
                            Table_ref,
                            Identity_columns,
                            Columns,
                            Relations}}
            end
    end.

-file("src\\galchemy\\orm\\metadata.gleam", 100).
-spec find_relation(list(galchemy@schema@relation:relation()), binary()) -> gleam@option:option(galchemy@schema@relation:relation()).
find_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_relation(Rest, Relation_name)
            end
    end.

-file("src\\galchemy\\orm\\metadata.gleam", 57).
-spec has_relation(model_metadata(), binary()) -> boolean().
has_relation(Metadata, Relation_name) ->
    case find_relation(erlang:element(5, Metadata), Relation_name) of
        {some, _} ->
            true;

        none ->
            false
    end.

-file("src\\galchemy\\orm\\metadata.gleam", 64).
-spec relation_named(model_metadata(), binary()) -> gleam@option:option(galchemy@schema@relation:relation()).
relation_named(Metadata, Relation_name) ->
    find_relation(erlang:element(5, Metadata), Relation_name).