@reventlessdev/reventless-core 3.0.0-alpha.136 → 3.0.0-alpha.137

package/tests/aggregate/AggregateCacheTest.res

@@ -0,0 +1,271 @@
+// Tests for the Aggregate_Callback in-process replay cache (Phase 1 of
+// docs/plans/aggregate-snapshotting.md): a warm same-id command skips the
+// event-log replay and decides on the cached (state, sequenceNr); the OCC
+// append fences staleness — a stale cache conflicts, invalidates, and the
+// retry replays cold.
+//
+// Unlike the other aggregate mocks, this one enforces optimistic concurrency
+// (append conflicts unless seqNr matches the stored count), because the cache's
+// correctness argument rests on exactly that fence. The Checkpoint command
+// records the decision state's size as an event, making the cached fold state
+// observable through ordinary domain behavior.
+
+open JestGlobals
+
+S.enableJson()
+
+module AggSpec = {
+  module Id = Reventless.Id.StringPure
+  let name = "CacheTestAggregate"
+
+  @schema
+  type command =
+    | Add({name: string})
+    | Checkpoint
+    | Noop
+
+  @schema
+  type event =
+    | Added({name: string})
+    | CheckpointTaken({count: int})
+
+  @schema
+  type error = | Never
+
+  let moduleUrl: string = %raw(`import.meta.url`)
+}
+
+module TestBehavior = {
+  module Spec = AggSpec
+  type state = {names: array<string>}
+
+  let initialState = {names: []}
+
+  // Hand-written behavior (no @@reventless.behavior PPX) — satisfy the
+  // Behavior.T snapshot field manually.
+  let snapshot = None
+
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  let evolve = (state: state, event: AggSpec.event): state =>
+    switch event {
+    | Added({name}) => {names: state.names->Array.concat([name])}
+    | CheckpointTaken(_) => state
+    }
+
+  let decide = (state: state, command: AggSpec.command): result<
+    array<AggSpec.event>,
+    AggSpec.error,
+  > =>
+    switch command {
+    | Add({name}) => Ok([AggSpec.Added({name: name})])
+    | Checkpoint => Ok([AggSpec.CheckpointTaken({count: state.names->Array.length})])
+    | Noop => Ok([])
+    }
+}
+
+let testMeta: Message.meta = {
+  service: "CacheTestAggregate",
+  time: "2024-01-01T00:00:00Z",
+  ip: "127.0.0.1",
+  user: "test-user",
+  msgId: "msg-1",
+  correlationId: "corr-1",
+}
+
+type mockEL = {
+  appendFn: (
+    int,
+    string,
+    array<Message.event'<string, AggSpec.event>>,
+  ) => promise<result<unit, EventLog.appendError>>,
+  replayFn: string => promise<array<AggSpec.event>>,
+  replayStreamFn: string => Stream.t<AggSpec.event, string, unit>,
+  getAll: unit => array<Message.event'<string, AggSpec.event>>,
+  // Appends directly to storage, bypassing the handler — simulates a second
+  // writer the warm cache doesn't know about.
+  injectExternal: (string, AggSpec.event) => unit,
+  appendCallCount: ref<int>,
+  replayCallCount: ref<int>,
+  reset: unit => unit,
+}
+
+let makeMockEL = (): mockEL => {
+  let storedRef: ref<array<Message.event'<string, AggSpec.event>>> = ref([])
+  let appendCount = ref(0)
+  let replayCount = ref(0)
+
+  let eventsFor = id => storedRef.contents->Array.filter(e => e.id == id)
+
+  // Real OCC: the append succeeds only when seqNr matches the current count.
+  let appendFn = async (seqNr, id, newEvents) => {
+    appendCount := appendCount.contents + 1
+    if seqNr != eventsFor(id)->Array.length {
+      Error(EventLog.Conflict)
+    } else {
+      storedRef := storedRef.contents->Array.concat(newEvents)
+      Ok(())
+    }
+  }
+
+  let replayFn = async id => {
+    replayCount := replayCount.contents + 1
+    eventsFor(id)->Array.map(e => e.event)
+  }
+
+  let replayStreamFn = id => {
+    replayCount := replayCount.contents + 1
+    eventsFor(id)->Array.map(e => e.event)->Stream.fromIterable
+  }
+
+  {
+    appendFn,
+    replayFn,
+    replayStreamFn,
+    getAll: () => storedRef.contents,
+    injectExternal: (id, event) =>
+      storedRef := storedRef.contents->Array.concat([{Message.id, meta: testMeta, event}]),
+    appendCallCount: appendCount,
+    replayCallCount: replayCount,
+    reset: () => {
+      storedRef := []
+      appendCount := 0
+      replayCount := 0
+    },
+  }
+}
+
+let mock = makeMockEL()
+
+module OuterEventLog = EventLog
+
+module TestOps = {
+  module Spec = AggSpec
+  module EventLog = {
+    module Spec = {
+      module Id = AggSpec.Id
+      let name = "CacheMockEventLog"
+      @schema
+      type event = AggSpec.event
+    }
+    type operations = {
+      append: (
+        int,
+        string,
+        array<Message.event'<string, AggSpec.event>>,
+      ) => promise<result<unit, EventLog.appendError>>,
+      replay: string => promise<array<AggSpec.event>>,
+      replayStream: (string, ~fromSeq: int=?) => Stream.t<AggSpec.event, string, unit>,
+      appendStream: (int, string, Stream.t<AggSpec.event, string, unit>) => Effect.t<
+        unit,
+        string,
+        unit,
+      >,
+      latestSnapshot: string => promise<result<option<EventLog.snapshot>, string>>,
+      writeSnapshot: (string, EventLog.snapshot) => promise<result<unit, string>>,
+    }
+    type component = Component.t<OuterEventLog.t, OuterEventLog.outputs, operations>
+    // Never called — satisfies module type only
+    let make = (~name as _: string, ~opts as _=?): component => Obj.magic(0)
+  }
+  let eventLog: EventLog.operations = {
+    append: mock.appendFn,
+    replay: mock.replayFn,
+    replayStream: (id, ~fromSeq as _=?) => mock.replayStreamFn(id),
+    appendStream: (_startingSeqNr, _id, stream) => stream->Stream.runDrain,
+    latestSnapshot: async _ => Ok(None),
+    writeSnapshot: async (_, _) => Ok(),
+  }
+}
+
+module TestHandler = Aggregate_Callback.Make(AggSpec, TestBehavior, TestOps)
+
+let makeTopicItem = (reference, command): CommandTopic.topicItem<
+  Message.command'<string, AggSpec.command>,
+> => {
+  command: {
+    id: "agg-1",
+    meta: testMeta,
+    command,
+  },
+  reference,
+}
+
+let run = async command =>
+  await Stream.fromIterable([makeTopicItem("ref", command)])
+  ->TestHandler.handleCommands
+  ->Effect.runPromise
+
+let _ = beforeEach(() => {
+  mock.reset()
+  TestHandler.resetCache()
+})
+
+describe("Aggregate_Callback — replay cache:", () => {
+  testPromise("warm same-id command skips the replay", async () => {
+    let r1 = await run(AggSpec.Add({name: "a"}))
+    let r2 = await run(AggSpec.Add({name: "b"}))
+    expect((r1, r2))->toEqual(([Ok("ref")], [Ok("ref")]))
+    // Only the first command replayed; the second decided on the cached state.
+    expect(mock.replayCallCount.contents)->toBe(1)
+    // Both appends landed at their correct OCC positions (no conflict retries).
+    expect((mock.appendCallCount.contents, mock.getAll()->Array.length))->toEqual((2, 2))
+  })
+
+  testPromise("cached fold state equals a cold replay of the log", async () => {
+    let _ = await run(AggSpec.Add({name: "a"}))
+    let _ = await run(AggSpec.Add({name: "b"}))
+    let _ = await run(AggSpec.Add({name: "c"}))
+    // Warm checkpoint: decided on the cached state (no replay since call 1).
+    let _ = await run(AggSpec.Checkpoint)
+    expect(mock.replayCallCount.contents)->toBe(1)
+    // Cold checkpoint: same aggregate replayed from the log.
+    TestHandler.resetCache()
+    let _ = await run(AggSpec.Checkpoint)
+    expect(mock.replayCallCount.contents)->toBe(2)
+    // Both checkpoints observed the same state — cached fold ≡ replayed fold.
+    let checkpoints =
+      mock.getAll()
+      ->Array.filterMap(e =>
+        switch e.event {
+        | CheckpointTaken({count}) => Some(count)
+        | _ => None
+        }
+      )
+    expect(checkpoints)->toEqual([3, 3])
+  })
+
+  testPromise("stale cache conflicts, invalidates, and self-heals", async () => {
+    let _ = await run(AggSpec.Add({name: "a"}))
+    // A second writer appends behind the warm cache's back.
+    mock.injectExternal("agg-1", AggSpec.Added({name: "external"}))
+    // Warm path appends at the stale seq → OCC conflict → invalidate →
+    // cold retry reads the authoritative log and succeeds.
+    let results = await run(AggSpec.Add({name: "b"}))
+    expect(results)->toEqual([Ok("ref")])
+    // Replays: initial cold + post-conflict cold (the warm attempt skipped).
+    expect(mock.replayCallCount.contents)->toBe(2)
+    expect(mock.getAll()->Array.length)->toBe(3)
+    // The refreshed state includes the external event.
+    let _ = await run(AggSpec.Checkpoint)
+    let last = mock.getAll()->Array.getUnsafe(3)
+    expect(last.event)->toEqual(AggSpec.CheckpointTaken({count: 3}))
+  })
+
+  testPromise("Ok([]) keeps the read snapshot warm", async () => {
+    let _ = await run(AggSpec.Add({name: "a"}))
+    let _ = await run(AggSpec.Noop)
+    let _ = await run(AggSpec.Add({name: "b"}))
+    // Neither the Noop nor the third command replayed.
+    expect(mock.replayCallCount.contents)->toBe(1)
+    expect(mock.getAll()->Array.length)->toBe(2)
+  })
+
+  testPromise("resetCache forces the next command to replay cold", async () => {
+    let _ = await run(AggSpec.Add({name: "a"}))
+    TestHandler.resetCache()
+    let _ = await run(AggSpec.Add({name: "b"}))
+    expect(mock.replayCallCount.contents)->toBe(2)
+    expect(mock.getAll()->Array.length)->toBe(2)
+  })
+})

package/tests/aggregate/AggregateCacheTest.res.mjs

@@ -0,0 +1,433 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as Aggregate_Callback$ReventlessCore from "../../src/components/Aggregate/Aggregate_Callback.res.mjs";
+
+S.enableJson();
+
+let name = "CacheTestAggregate";
+
+let commandSchema = S.union([
+  S.schema(s => ({
+    TAG: "Add",
+    name: s.m(S.string)
+  })),
+  S.literal("Checkpoint"),
+  S.literal("Noop")
+]);
+
+let eventSchema = S.union([
+  S.schema(s => ({
+    TAG: "Added",
+    name: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "CheckpointTaken",
+    count: s.m(S.int)
+  }))
+]);
+
+let errorSchema = S.literal("Never");
+
+let moduleUrl = import.meta.url;
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let AggSpec = {
+  Id: undefined,
+  name: name,
+  commandSchema: commandSchema,
+  eventSchema: eventSchema,
+  errorSchema: errorSchema,
+  moduleUrl: moduleUrl,
+  commandAuthorization: commandAuthorization
+};
+
+let initialState = {
+  names: []
+};
+
+let moduleUrl$1 = import.meta.url;
+
+function evolve(state, event) {
+  if (event.TAG === "Added") {
+    return {
+      names: state.names.concat([event.name])
+    };
+  } else {
+    return state;
+  }
+}
+
+function decide(state, command) {
+  if (typeof command !== "object") {
+    if (command === "Checkpoint") {
+      return {
+        TAG: "Ok",
+        _0: [{
+            TAG: "CheckpointTaken",
+            count: state.names.length
+          }]
+      };
+    } else {
+      return {
+        TAG: "Ok",
+        _0: []
+      };
+    }
+  } else {
+    return {
+      TAG: "Ok",
+      _0: [{
+          TAG: "Added",
+          name: command.name
+        }]
+    };
+  }
+}
+
+let TestBehavior = {
+  Spec: undefined,
+  initialState: initialState,
+  snapshot: undefined,
+  moduleUrl: moduleUrl$1,
+  evolve: evolve,
+  decide: decide
+};
+
+let testMeta = {
+  service: "CacheTestAggregate",
+  time: "2024-01-01T00:00:00Z",
+  ip: "127.0.0.1",
+  user: "test-user",
+  msgId: "msg-1",
+  correlationId: "corr-1"
+};
+
+function makeMockEL() {
+  let storedRef = {
+    contents: []
+  };
+  let appendCount = {
+    contents: 0
+  };
+  let replayCount = {
+    contents: 0
+  };
+  let eventsFor = id => storedRef.contents.filter(e => e.id === id);
+  let appendFn = async (seqNr, id, newEvents) => {
+    appendCount.contents = appendCount.contents + 1 | 0;
+    if (seqNr !== eventsFor(id).length) {
+      return {
+        TAG: "Error",
+        _0: "Conflict"
+      };
+    } else {
+      storedRef.contents = storedRef.contents.concat(newEvents);
+      return {
+        TAG: "Ok",
+        _0: undefined
+      };
+    }
+  };
+  let replayFn = async id => {
+    replayCount.contents = replayCount.contents + 1 | 0;
+    return eventsFor(id).map(e => e.event);
+  };
+  let replayStreamFn = id => {
+    replayCount.contents = replayCount.contents + 1 | 0;
+    return Stream.fromIterable(eventsFor(id).map(e => e.event));
+  };
+  return {
+    appendFn: appendFn,
+    replayFn: replayFn,
+    replayStreamFn: replayStreamFn,
+    getAll: () => storedRef.contents,
+    injectExternal: (id, event) => {
+      storedRef.contents = storedRef.contents.concat([{
+          id: id,
+          meta: testMeta,
+          event: event
+        }]);
+    },
+    appendCallCount: appendCount,
+    replayCallCount: replayCount,
+    reset: () => {
+      storedRef.contents = [];
+      appendCount.contents = 0;
+      replayCount.contents = 0;
+    }
+  };
+}
+
+let mock = makeMockEL();
+
+let name$1 = "CacheMockEventLog";
+
+let Spec = {
+  Id: undefined,
+  name: name$1,
+  eventSchema: eventSchema
+};
+
+function make(param, param$1) {
+  return 0;
+}
+
+let EventLog = {
+  Spec: Spec,
+  make: make
+};
+
+let eventLog_append = mock.appendFn;
+
+let eventLog_replay = mock.replayFn;
+
+function eventLog_replayStream(id, param) {
+  return mock.replayStreamFn(id);
+}
+
+function eventLog_appendStream(_startingSeqNr, _id, stream) {
+  return Stream.runDrain(stream);
+}
+
+async function eventLog_latestSnapshot(param) {
+  return {
+    TAG: "Ok",
+    _0: undefined
+  };
+}
+
+async function eventLog_writeSnapshot(param, param$1) {
+  return {
+    TAG: "Ok",
+    _0: undefined
+  };
+}
+
+let eventLog = {
+  append: eventLog_append,
+  replay: eventLog_replay,
+  replayStream: eventLog_replayStream,
+  appendStream: eventLog_appendStream,
+  latestSnapshot: eventLog_latestSnapshot,
+  writeSnapshot: eventLog_writeSnapshot
+};
+
+let TestOps = {
+  Spec: undefined,
+  EventLog: EventLog,
+  eventLog: eventLog
+};
+
+let TestHandler = Aggregate_Callback$ReventlessCore.Make({
+  Id: {
+    schema: Id$Reventless.StringPure.schema,
+    make: prim => prim,
+    makeFromString: prim => prim,
+    toString: prim => prim,
+    cmp: Id$Reventless.StringPure.cmp
+  },
+  name: name,
+  eventSchema: eventSchema,
+  errorSchema: errorSchema,
+  commandSchema: commandSchema,
+  moduleUrl: moduleUrl,
+  commandAuthorization: commandAuthorization
+})({
+  initialState: initialState,
+  evolve: evolve,
+  decide: decide,
+  snapshot: undefined,
+  moduleUrl: moduleUrl$1
+})({
+  Spec: {
+    Id: {
+      schema: Id$Reventless.StringPure.schema,
+      make: prim => prim,
+      makeFromString: prim => prim,
+      toString: prim => prim,
+      cmp: Id$Reventless.StringPure.cmp
+    },
+    name: name,
+    eventSchema: eventSchema,
+    errorSchema: errorSchema,
+    commandSchema: commandSchema,
+    moduleUrl: moduleUrl,
+    commandAuthorization: commandAuthorization
+  },
+  EventLog: {
+    Spec: {
+      Id: {
+        schema: Id$Reventless.StringPure.schema,
+        make: prim => prim,
+        makeFromString: prim => prim,
+        toString: prim => prim,
+        cmp: Id$Reventless.StringPure.cmp
+      },
+      name: name$1,
+      eventSchema: eventSchema
+    },
+    make: make
+  },
+  eventLog: eventLog
+});
+
+function makeTopicItem(reference, command) {
+  return {
+    command: {
+      id: "agg-1",
+      meta: testMeta,
+      command: command
+    },
+    reference: reference
+  };
+}
+
+async function run(command) {
+  return await Effect.runPromise(TestHandler.handleCommands(Stream.fromIterable([makeTopicItem("ref", command)])));
+}
+
+globalThis.beforeEach(() => {
+  mock.reset();
+  TestHandler.resetCache();
+});
+
+globalThis.describe("Aggregate_Callback — replay cache:", () => {
+  globalThis.test("warm same-id command skips the replay", async () => {
+    let r1 = await run({
+      TAG: "Add",
+      name: "a"
+    });
+    let r2 = await run({
+      TAG: "Add",
+      name: "b"
+    });
+    globalThis.expect([
+      r1,
+      r2
+    ]).toEqual([
+      [{
+          TAG: "Ok",
+          _0: "ref"
+        }],
+      [{
+          TAG: "Ok",
+          _0: "ref"
+        }]
+    ]);
+    globalThis.expect(mock.replayCallCount.contents).toBe(1);
+    globalThis.expect([
+      mock.appendCallCount.contents,
+      mock.getAll().length
+    ]).toEqual([
+      2,
+      2
+    ]);
+  });
+  globalThis.test("cached fold state equals a cold replay of the log", async () => {
+    await run({
+      TAG: "Add",
+      name: "a"
+    });
+    await run({
+      TAG: "Add",
+      name: "b"
+    });
+    await run({
+      TAG: "Add",
+      name: "c"
+    });
+    await run("Checkpoint");
+    globalThis.expect(mock.replayCallCount.contents).toBe(1);
+    TestHandler.resetCache();
+    await run("Checkpoint");
+    globalThis.expect(mock.replayCallCount.contents).toBe(2);
+    let checkpoints = Stdlib_Array.filterMap(mock.getAll(), e => {
+      let match = e.event;
+      if (match.TAG === "Added") {
+        return;
+      } else {
+        return match.count;
+      }
+    });
+    globalThis.expect(checkpoints).toEqual([
+      3,
+      3
+    ]);
+  });
+  globalThis.test("stale cache conflicts, invalidates, and self-heals", async () => {
+    await run({
+      TAG: "Add",
+      name: "a"
+    });
+    mock.injectExternal("agg-1", {
+      TAG: "Added",
+      name: "external"
+    });
+    let results = await run({
+      TAG: "Add",
+      name: "b"
+    });
+    globalThis.expect(results).toEqual([{
+        TAG: "Ok",
+        _0: "ref"
+      }]);
+    globalThis.expect(mock.replayCallCount.contents).toBe(2);
+    globalThis.expect(mock.getAll().length).toBe(3);
+    await run("Checkpoint");
+    let last = mock.getAll()[3];
+    globalThis.expect(last.event).toEqual({
+      TAG: "CheckpointTaken",
+      count: 3
+    });
+  });
+  globalThis.test("Ok([]) keeps the read snapshot warm", async () => {
+    await run({
+      TAG: "Add",
+      name: "a"
+    });
+    await run("Noop");
+    await run({
+      TAG: "Add",
+      name: "b"
+    });
+    globalThis.expect(mock.replayCallCount.contents).toBe(1);
+    globalThis.expect(mock.getAll().length).toBe(2);
+  });
+  globalThis.test("resetCache forces the next command to replay cold", async () => {
+    await run({
+      TAG: "Add",
+      name: "a"
+    });
+    TestHandler.resetCache();
+    await run({
+      TAG: "Add",
+      name: "b"
+    });
+    globalThis.expect(mock.replayCallCount.contents).toBe(2);
+    globalThis.expect(mock.getAll().length).toBe(2);
+  });
+});
+
+let OuterEventLog;
+
+export {
+  AggSpec,
+  TestBehavior,
+  testMeta,
+  makeMockEL,
+  mock,
+  OuterEventLog,
+  TestOps,
+  TestHandler,
+  makeTopicItem,
+  run,
+}
+/*  Not a pure module */

package/tests/aggregate/AggregateCallbackTest.res

@@ -1,7 +1,10 @@
 open JestGlobals
 open AggregateFixtures
 
-let _ = beforeEach(() => mock.reset())
+let _ = beforeEach(() => {
+  mock.reset()
+  TestHandler.resetCache()
+})
 
 describe("Aggregate_Callback.handleCommands:", () => {
   describe("single command — new aggregate", () => {