eventsourcing

-module(eventsourcing).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([new/5, add_query/2, load_events/2, load_aggregate/2, execute_with_metadata/4, execute/3]).
-export_type([aggregate/4, event_envelop/1, event_sourcing_error/1, event_sourcing/5, event_store/5]).

-type aggregate(OFB, OFC, OFD, OFE) :: {aggregate, binary(), OFB, integer()} |
    {gleam_phantom, OFC, OFD, OFE}.

-type event_envelop(OFF) :: {memory_store_event_envelop,
        binary(),
        integer(),
        OFF,
        list({binary(), binary()})} |
    {serialized_event_envelop,
        binary(),
        integer(),
        OFF,
        list({binary(), binary()}),
        binary(),
        binary(),
        binary()}.

-type event_sourcing_error(OFG) :: {domain_error, OFG} |
    {event_store_error, binary()}.

-opaque event_sourcing(OFH, OFI, OFJ, OFK, OFL) :: {event_sourcing,
        event_store(OFH, OFI, OFJ, OFK, OFL),
        list(fun((binary(), list(event_envelop(OFK))) -> nil)),
        fun((OFI, OFJ) -> {ok, list(OFK)} | {error, OFL}),
        fun((OFI, OFK) -> OFI),
        OFI}.

-type event_store(OFM, OFN, OFO, OFP, OFQ) :: {event_store,
        OFM,
        fun((OFM, binary()) -> list(event_envelop(OFP))),
        fun((OFM, aggregate(OFN, OFO, OFP, OFQ), list(OFP), list({binary(),
            binary()})) -> list(event_envelop(OFP)))}.

-file("/Users/renata-amutio/Projects/renatillas/eventsourcing/src/eventsourcing.gleam", 83).
-spec new(
    event_store(OMN, OGH, OMP, OMQ, OMR),
    list(fun((binary(), list(event_envelop(OMQ))) -> nil)),
    fun((OGH, OMP) -> {ok, list(OMQ)} | {error, OMR}),
    fun((OGH, OMQ) -> OGH),
    OGH
) -> event_sourcing(OMN, OGH, OMP, OMQ, OMR).
new(Event_store, Queries, Handle, Apply, Empty_state) ->
    {event_sourcing, Event_store, Queries, Handle, Apply, Empty_state}.

-file("/Users/renata-amutio/Projects/renatillas/eventsourcing/src/eventsourcing.gleam", 137).
-spec execute_with_aggregate_context(
    event_sourcing(any(), OHL, OHM, OHN, OHO),
    aggregate(OHL, OHM, OHN, OHO),
    OHM,
    list({binary(), binary()})
) -> {ok, nil} | {error, event_sourcing_error(OHO)}.
execute_with_aggregate_context(Eventsourcing, Aggregate, Command, Metadata) ->
    Entity = erlang:element(3, Aggregate),
    gleam@result:'try'(
        begin
            _pipe = (erlang:element(4, Eventsourcing))(Entity, Command),
            gleam@result:map_error(
                _pipe,
                fun(Error) -> {domain_error, Error} end
            )
        end,
        fun(Events) ->
            _pipe@1 = Events,
            gleam@list:map(
                _pipe@1,
                fun(_capture) ->
                    (erlang:element(5, Eventsourcing))(Entity, _capture)
                end
            ),
            Commited_events = (erlang:element(
                4,
                erlang:element(2, Eventsourcing)
            ))(
                erlang:element(2, erlang:element(2, Eventsourcing)),
                Aggregate,
                Events,
                Metadata
            ),
            _pipe@2 = erlang:element(3, Eventsourcing),
            gleam@list:map(
                _pipe@2,
                fun(Query) ->
                    Query(erlang:element(2, Aggregate), Commited_events)
                end
            ),
            {ok, nil}
        end
    ).

-file("/Users/renata-amutio/Projects/renatillas/eventsourcing/src/eventsourcing.gleam", 195).
-spec add_query(
    event_sourcing(OIT, OIU, OIV, OIW, OIX),
    fun((binary(), list(event_envelop(OIW))) -> nil)
) -> event_sourcing(OIT, OIU, OIV, OIW, OIX).
add_query(Eventsourcing, Query) ->
    _record = Eventsourcing,
    {event_sourcing,
        erlang:element(2, _record),
        [Query | erlang:element(3, Eventsourcing)],
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record)}.

-file("/Users/renata-amutio/Projects/renatillas/eventsourcing/src/eventsourcing.gleam", 209).
-spec load_events(event_sourcing(any(), any(), any(), OJI, any()), binary()) -> list(event_envelop(OJI)).
load_events(Eventsourcing, Aggregate_id) ->
    (erlang:element(3, erlang:element(2, Eventsourcing)))(
        erlang:element(2, erlang:element(2, Eventsourcing)),
        Aggregate_id
    ).

-file("/Users/renata-amutio/Projects/renatillas/eventsourcing/src/eventsourcing.gleam", 167).
-spec load_aggregate(event_sourcing(any(), OID, OIE, OIF, OIG), binary()) -> {ok,
        aggregate(OID, OIE, OIF, OIG)} |
    {error, event_sourcing_error(OIG)}.
load_aggregate(Eventsourcing, Aggregate_id) ->
    Commited_events = load_events(Eventsourcing, Aggregate_id),
    {Instance, Sequence@1} = gleam@list:fold(
        Commited_events,
        {erlang:element(6, Eventsourcing), 0},
        fun(Aggregate_and_sequence, Event_envelop) ->
            {Aggregate, Sequence} = Aggregate_and_sequence,
            {(erlang:element(5, Eventsourcing))(
                    Aggregate,
                    erlang:element(4, Event_envelop)
                ),
                Sequence + 1}
        end
    ),
    {ok, {aggregate, Aggregate_id, Instance, Sequence@1}}.

-file("/Users/renata-amutio/Projects/renatillas/eventsourcing/src/eventsourcing.gleam", 112).
-spec execute_with_metadata(
    event_sourcing(any(), any(), OGY, any(), OHA),
    binary(),
    OGY,
    list({binary(), binary()})
) -> {ok, nil} | {error, event_sourcing_error(OHA)}.
execute_with_metadata(Event_sourcing, Aggregate_id, Command, Metadata) ->
    Aggregate_context = load_aggregate(Event_sourcing, Aggregate_id),
    case Aggregate_context of
        {ok, Aggregate_context@1} ->
            execute_with_aggregate_context(
                Event_sourcing,
                Aggregate_context@1,
                Command,
                Metadata
            );

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

-file("/Users/renata-amutio/Projects/renatillas/eventsourcing/src/eventsourcing.gleam", 94).
-spec execute(event_sourcing(any(), any(), OGL, any(), OGN), binary(), OGL) -> {ok,
        nil} |
    {error, event_sourcing_error(OGN)}.
execute(Event_sourcing, Aggregate_id, Command) ->
    execute_with_metadata(Event_sourcing, Aggregate_id, Command, []).