eventsourcing

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

-export([new/2, execute/3]).
-export_type([aggregate/4, aggregate_context/4, event_envelop/1, event_sourcing/6, event_store/5]).

-type aggregate(OBO, OBP, OBQ, OBR) :: {aggregate,
        OBO,
        fun((OBO, OBP) -> {ok, list(OBQ)} | {error, OBR}),
        fun((OBO, OBQ) -> OBO)}.

-type aggregate_context(OBS, OBT, OBU, OBV) :: {aggregate_context,
        binary(),
        aggregate(OBS, OBT, OBU, OBV),
        integer()}.

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

-opaque event_sourcing(OBX, OBY, OBZ, OCA, OCB, OCC) :: {event_sourcing,
        event_store(OBX, OBY, OBZ, OCA, OCB),
        list(fun((binary(), list(event_envelop(OCA))) -> nil))} |
    {gleam_phantom, OCC}.

-type event_store(OCD, OCE, OCF, OCG, OCH) :: {event_store,
        OCD,
        fun((OCD, binary()) -> aggregate_context(OCE, OCF, OCG, OCH)),
        fun((OCD, aggregate_context(OCE, OCF, OCG, OCH), list(OCG)) -> list(event_envelop(OCG)))}.

-spec new(
    event_store(OFP, OFQ, OFR, OFS, OFT),
    list(fun((binary(), list(event_envelop(OFS))) -> nil))
) -> event_sourcing(OFP, OFQ, OFR, OFS, OFT, any()).
new(Event_store, Queries) ->
    {event_sourcing, Event_store, Queries}.

-spec execute(
    event_sourcing(any(), any(), OCZ, any(), ODB, any()),
    binary(),
    OCZ
) -> {ok, nil} | {error, ODB}.
execute(Event_sourcing, Aggregate_id, Command) ->
    Aggregate_context = (erlang:element(3, erlang:element(2, Event_sourcing)))(
        erlang:element(2, erlang:element(2, Event_sourcing)),
        Aggregate_id
    ),
    Aggregate = erlang:element(3, Aggregate_context),
    Entity = erlang:element(2, Aggregate),
    gleam@result:map(
        (erlang:element(3, Aggregate))(Entity, Command),
        fun(Events) ->
            _pipe = Events,
            gleam@list:map(
                _pipe,
                fun(_capture) ->
                    (erlang:element(4, Aggregate))(Entity, _capture)
                end
            ),
            Commited_events = (erlang:element(
                4,
                erlang:element(2, Event_sourcing)
            ))(
                erlang:element(2, erlang:element(2, Event_sourcing)),
                Aggregate_context,
                Events
            ),
            _pipe@1 = erlang:element(3, Event_sourcing),
            gleam@list:map(
                _pipe@1,
                fun(Query) -> Query(Aggregate_id, Commited_events) end
            ),
            nil
        end
    ).