galchemy

-module(galchemy@examples@orm).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src\\galchemy\\examples\\orm.gleam").
-export([main/0]).

-file("src\\galchemy\\examples\\orm.gleam", 112).
-spec unwrap_entity(
    {ok, galchemy@orm@entity:entity()} |
        {error, galchemy@orm@entity:entity_error()}
) -> galchemy@orm@entity:entity().
unwrap_entity(Result) ->
    case Result of
        {ok, Value} ->
            Value;

        {error, Error} ->
            erlang:error(#{gleam_error => panic,
                    message => gleam@string:inspect(Error),
                    file => <<?FILEPATH/utf8>>,
                    module => <<"galchemy/examples/orm"/utf8>>,
                    function => <<"unwrap_entity"/utf8>>,
                    line => 117})
    end.

-file("src\\galchemy\\examples\\orm.gleam", 121).
-spec unwrap_pending(
    {ok, galchemy@session@unit_of_work:session()} |
        {error, galchemy@orm@entity:entity_error()}
) -> galchemy@session@unit_of_work:session().
unwrap_pending(Result) ->
    case Result of
        {ok, Value} ->
            Value;

        {error, Error} ->
            erlang:error(#{gleam_error => panic,
                    message => gleam@string:inspect(Error),
                    file => <<?FILEPATH/utf8>>,
                    module => <<"galchemy/examples/orm"/utf8>>,
                    function => <<"unwrap_pending"/utf8>>,
                    line => 126})
    end.

-file("src\\galchemy\\examples\\orm.gleam", 130).
-spec unwrap_registry(
    {ok, galchemy@orm@mapper_registry:mapper_registry()} |
        {error, galchemy@orm@mapper_registry:registry_error()}
) -> galchemy@orm@mapper_registry:mapper_registry().
unwrap_registry(Result) ->
    case Result of
        {ok, Value} ->
            Value;

        {error, Error} ->
            erlang:error(#{gleam_error => panic,
                    message => gleam@string:inspect(Error),
                    file => <<?FILEPATH/utf8>>,
                    module => <<"galchemy/examples/orm"/utf8>>,
                    function => <<"unwrap_registry"/utf8>>,
                    line => 135})
    end.

-file("src\\galchemy\\examples\\orm.gleam", 139).
-spec unwrap_materialized(
    {ok,
            {galchemy@orm@entity:entity(),
                galchemy@orm@materializer:materializer()}} |
        {error, galchemy@orm@materializer:materialization_error()}
) -> {galchemy@orm@entity:entity(), galchemy@orm@materializer:materializer()}.
unwrap_materialized(Result) ->
    case Result of
        {ok, Value} ->
            Value;

        {error, Error} ->
            erlang:error(#{gleam_error => panic,
                    message => gleam@string:inspect(Error),
                    file => <<?FILEPATH/utf8>>,
                    module => <<"galchemy/examples/orm"/utf8>>,
                    function => <<"unwrap_materialized"/utf8>>,
                    line => 147})
    end.

-file("src\\galchemy\\examples\\orm.gleam", 151).
-spec unwrap_hydrated(
    {ok, galchemy@orm@graph:hydrated_entity()} |
        {error, galchemy@orm@graph:hydration_error()}
) -> galchemy@orm@graph:hydrated_entity().
unwrap_hydrated(Result) ->
    case Result of
        {ok, Value} ->
            Value;

        {error, Error} ->
            erlang:error(#{gleam_error => panic,
                    message => gleam@string:inspect(Error),
                    file => <<?FILEPATH/utf8>>,
                    module => <<"galchemy/examples/orm"/utf8>>,
                    function => <<"unwrap_hydrated"/utf8>>,
                    line => 156})
    end.

-file("src\\galchemy\\examples\\orm.gleam", 160).
-spec unwrap_runtime(
    {ok, galchemy@session@runtime:session()} |
        {error, galchemy@session@runtime:track_error()}
) -> galchemy@session@runtime:session().
unwrap_runtime(Result) ->
    case Result of
        {ok, Value} ->
            Value;

        {error, Error} ->
            erlang:error(#{gleam_error => panic,
                    message => gleam@string:inspect(Error),
                    file => <<?FILEPATH/utf8>>,
                    module => <<"galchemy/examples/orm"/utf8>>,
                    function => <<"unwrap_runtime"/utf8>>,
                    line => 165})
    end.

-file("src\\galchemy\\examples\\orm.gleam", 169).
-spec unwrap_committed(
    {ok,
            {galchemy@session@execution:flush_execution(galchemy@sql@compiler:compiled_query()),
                galchemy@session@runtime:session()}} |
        {error,
            galchemy@session@runtime:session_execution_error(galchemy@sql@compiler:compile_error())}
) -> {galchemy@session@execution:flush_execution(galchemy@sql@compiler:compiled_query()),
    galchemy@session@runtime:session()}.
unwrap_committed(Result) ->
    case Result of
        {ok, Value} ->
            Value;

        {error, Error} ->
            erlang:error(#{gleam_error => panic,
                    message => gleam@string:inspect(Error),
                    file => <<?FILEPATH/utf8>>,
                    module => <<"galchemy/examples/orm"/utf8>>,
                    function => <<"unwrap_committed"/utf8>>,
                    line => 177})
    end.

-file("src\\galchemy\\examples\\orm.gleam", 185).
-spec seed_identity_map_loop(
    list(galchemy@orm@entity:entity()),
    galchemy@orm@identity_map:identity_map()
) -> galchemy@orm@identity_map:identity_map().
seed_identity_map_loop(Entities, Acc) ->
    case Entities of
        [] ->
            Acc;

        [Next_entity | Rest] ->
            Next_map = case galchemy@orm@identity_map:insert(Acc, Next_entity) of
                {ok, Value} ->
                    Value;

                {error, Error} ->
                    erlang:error(#{gleam_error => panic,
                            message => gleam@string:inspect(Error),
                            file => <<?FILEPATH/utf8>>,
                            module => <<"galchemy/examples/orm"/utf8>>,
                            function => <<"seed_identity_map_loop"/utf8>>,
                            line => 194})
            end,
            seed_identity_map_loop(Rest, Next_map)
    end.

-file("src\\galchemy\\examples\\orm.gleam", 181).
-spec seed_identity_map(list(galchemy@orm@entity:entity())) -> galchemy@orm@identity_map:identity_map().
seed_identity_map(Entities) ->
    seed_identity_map_loop(Entities, galchemy@orm@identity_map:empty()).

-file("src\\galchemy\\examples\\orm.gleam", 244).
-spec column(
    binary(),
    galchemy@schema@model:column_type(),
    boolean(),
    gleam@option:option(binary()),
    integer()
) -> galchemy@schema@model:column_schema().
column(Name, Data_type, Nullable, Default, Ordinal_position) ->
    {column_schema, Name, Data_type, Nullable, Default, Ordinal_position}.

-file("src\\galchemy\\examples\\orm.gleam", 202).
-spec blog_snapshot() -> galchemy@schema@model:schema_snapshot().
blog_snapshot() ->
    {schema_snapshot,
        [{table_schema,
                <<"public"/utf8>>,
                <<"users"/utf8>>,
                [column(<<"id"/utf8>>, integer_type, false, none, 1),
                    column(<<"name"/utf8>>, text_type, false, none, 2)],
                {some, {primary_key, <<"users_pkey"/utf8>>, [<<"id"/utf8>>]}},
                [],
                [],
                []},
            {table_schema,
                <<"public"/utf8>>,
                <<"posts"/utf8>>,
                [column(<<"id"/utf8>>, integer_type, false, none, 1),
                    column(<<"user_id"/utf8>>, integer_type, false, none, 2),
                    column(<<"title"/utf8>>, text_type, false, none, 3)],
                {some, {primary_key, <<"posts_pkey"/utf8>>, [<<"id"/utf8>>]}},
                [],
                [{foreign_key,
                        <<"posts_user_id_fkey"/utf8>>,
                        [<<"user_id"/utf8>>],
                        <<"public"/utf8>>,
                        <<"users"/utf8>>,
                        [<<"id"/utf8>>]}],
                []}]}.

-file("src\\galchemy\\examples\\orm.gleam", 18).
-spec main() -> nil.
main() ->
    Snapshot = blog_snapshot(),
    Users_metadata = case galchemy@orm@metadata:from_snapshot(
        Snapshot,
        <<"public"/utf8>>,
        <<"users"/utf8>>
    ) of
        {ok, Value} ->
            Value;

        {error, Error} ->
            erlang:error(#{gleam_error => panic,
                    message => gleam@string:inspect(Error),
                    file => <<?FILEPATH/utf8>>,
                    module => <<"galchemy/examples/orm"/utf8>>,
                    function => <<"main"/utf8>>,
                    line => 24})
    end,
    Inserted_user = case galchemy@orm@entity:new_(
        Users_metadata,
        [galchemy@session@unit_of_work:field(<<"id"/utf8>>, {int, 1}),
            galchemy@session@unit_of_work:field(
                <<"name"/utf8>>,
                {text, <<"Ann"/utf8>>}
            )]
    ) of
        {ok, Value@1} ->
            Value@1;

        {error, Error@1} ->
            erlang:error(#{gleam_error => panic,
                    message => gleam@string:inspect(Error@1),
                    file => <<?FILEPATH/utf8>>,
                    module => <<"galchemy/examples/orm"/utf8>>,
                    function => <<"main"/utf8>>,
                    line => 34})
    end,
    Updated_user = begin
        _pipe = case galchemy@orm@entity:materialize(
            Users_metadata,
            [galchemy@session@unit_of_work:field(<<"id"/utf8>>, {int, 2}),
                galchemy@session@unit_of_work:field(
                    <<"name"/utf8>>,
                    {text, <<"Bob"/utf8>>}
                )]
        ) of
            {ok, Value@2} ->
                Value@2;

            {error, Error@2} ->
                erlang:error(#{gleam_error => panic,
                        message => gleam@string:inspect(Error@2),
                        file => <<?FILEPATH/utf8>>,
                        module => <<"galchemy/examples/orm"/utf8>>,
                        function => <<"main"/utf8>>,
                        line => 45})
        end,
        _pipe@1 = galchemy@orm@entity:change(
            _pipe,
            [galchemy@session@unit_of_work:field(
                    <<"name"/utf8>>,
                    {text, <<"Bobby"/utf8>>}
                )]
        ),
        unwrap_entity(_pipe@1)
    end,
    Registry = begin
        _pipe@2 = blog_snapshot(),
        _pipe@3 = galchemy@orm@mapper_registry:from_snapshot(_pipe@2),
        unwrap_registry(_pipe@3)
    end,
    {Loaded_user, _} = begin
        _pipe@4 = galchemy@orm@materializer:new(Registry),
        _pipe@5 = galchemy@orm@materializer:materialize(
            _pipe@4,
            galchemy@orm@materializer:row(
                <<"public"/utf8>>,
                <<"users"/utf8>>,
                [galchemy@session@unit_of_work:field(<<"id"/utf8>>, {int, 3}),
                    galchemy@session@unit_of_work:field(
                        <<"name"/utf8>>,
                        {text, <<"Cara"/utf8>>}
                    )]
            )
        ),
        unwrap_materialized(_pipe@5)
    end,
    Posts_metadata = case galchemy@orm@metadata:from_snapshot(
        Snapshot,
        <<"public"/utf8>>,
        <<"posts"/utf8>>
    ) of
        {ok, Value@3} ->
            Value@3;

        {error, Error@3} ->
            erlang:error(#{gleam_error => panic,
                    message => gleam@string:inspect(Error@3),
                    file => <<?FILEPATH/utf8>>,
                    module => <<"galchemy/examples/orm"/utf8>>,
                    function => <<"main"/utf8>>,
                    line => 64})
    end,
    Related_post = begin
        _pipe@6 = galchemy@orm@entity:materialize(
            Posts_metadata,
            [galchemy@session@unit_of_work:field(<<"id"/utf8>>, {int, 20}),
                galchemy@session@unit_of_work:field(
                    <<"user_id"/utf8>>,
                    {int, 3}
                ),
                galchemy@session@unit_of_work:field(
                    <<"title"/utf8>>,
                    {text, <<"Hydrated"/utf8>>}
                )]
        ),
        unwrap_entity(_pipe@6)
    end,
    Hydrated_user = begin
        _pipe@7 = galchemy@orm@graph:hydrate_only(
            Loaded_user,
            [<<"posts"/utf8>>],
            seed_identity_map([Loaded_user, Related_post])
        ),
        unwrap_hydrated(_pipe@7)
    end,
    Pending_work = begin
        _pipe@8 = galchemy@session@unit_of_work:new(Snapshot),
        _pipe@9 = galchemy@orm@entity:stage(_pipe@8, Inserted_user),
        _pipe@10 = unwrap_pending(_pipe@9),
        _pipe@11 = galchemy@orm@entity:stage(_pipe@10, Updated_user),
        unwrap_pending(_pipe@11)
    end,
    Flush_plan = case galchemy@session@unit_of_work:flush_plan(Pending_work) of
        {ok, Value@4} ->
            Value@4;

        {error, Error@4} ->
            erlang:error(#{gleam_error => panic,
                    message => gleam@string:inspect(Error@4),
                    file => <<?FILEPATH/utf8>>,
                    module => <<"galchemy/examples/orm"/utf8>>,
                    function => <<"main"/utf8>>,
                    line => 90})
    end,
    {Committed_flush, Committed_session} = begin
        _pipe@12 = galchemy@session@runtime:new(Snapshot),
        _pipe@13 = galchemy@session@runtime:track(_pipe@12, Loaded_user),
        _pipe@14 = unwrap_runtime(_pipe@13),
        _pipe@15 = galchemy@session@runtime:stage(_pipe@14, Inserted_user),
        _pipe@16 = unwrap_runtime(_pipe@15),
        _pipe@17 = galchemy@session@runtime:stage(_pipe@16, Updated_user),
        _pipe@18 = unwrap_runtime(_pipe@17),
        _pipe@19 = galchemy@session@runtime:commit(
            _pipe@18,
            fun galchemy:compile/1
        ),
        unwrap_committed(_pipe@19)
    end,
    gleam_stdlib:println(<<"ORM example"/utf8>>),
    gleam_stdlib:println(gleam@string:inspect(Users_metadata)),
    gleam_stdlib:println(gleam@string:inspect(Loaded_user)),
    gleam_stdlib:println(gleam@string:inspect(Hydrated_user)),
    gleam_stdlib:println(gleam@string:inspect(Flush_plan)),
    gleam_stdlib:println(gleam@string:inspect(Committed_flush)),
    gleam_stdlib:println(
        gleam@string:inspect(
            galchemy@session@runtime:tracked_entities(Committed_session)
        )
    ).