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

package/tests/aggregate/AggregateSnapshotTest.res.mjs

@@ -0,0 +1,645 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Effect from "effect/Effect";
+import * as Stream$1 from "effect/Stream";
+import * as Aggregate_Callback$ReventlessCore from "../../src/components/Aggregate/Aggregate_Callback.res.mjs";
+
+S.enableJson();
+
+let name = "SnapshotTestAggregate";
+
+let commandSchema = S.union([
+  S.schema(s => ({
+    TAG: "Add",
+    item: s.m(S.string)
+  })),
+  S.literal("Noop")
+]);
+
+let eventSchema = S.schema(s => ({
+  TAG: "Added",
+  item: s.m(S.string)
+}));
+
+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 stateSchema = S.schema(s => ({
+  items: s.m(S.array(S.string))
+}));
+
+let initialState = {
+  items: []
+};
+
+let snapshot = {
+  interval: 10,
+  stateSchema: stateSchema
+};
+
+let moduleUrl$1 = import.meta.url;
+
+function evolve(state, event) {
+  return {
+    items: state.items.concat([event.item])
+  };
+}
+
+function decide(_state, command) {
+  if (typeof command !== "object") {
+    return {
+      TAG: "Ok",
+      _0: []
+    };
+  } else {
+    return {
+      TAG: "Ok",
+      _0: [{
+          TAG: "Added",
+          item: command.item
+        }]
+    };
+  }
+}
+
+let TestBehavior = {
+  Spec: undefined,
+  stateSchema: stateSchema,
+  initialState: initialState,
+  snapshot: snapshot,
+  moduleUrl: moduleUrl$1,
+  evolve: evolve,
+  decide: decide
+};
+
+let testMeta = {
+  service: "SnapshotTestAggregate",
+  time: "2024-01-01T00:00:00Z",
+  ip: "127.0.0.1",
+  user: "test-user",
+  msgId: "msg-1",
+  correlationId: "corr-1"
+};
+
+function makeMockEL() {
+  let stored = {
+    contents: []
+  };
+  let snapshots = {};
+  let replayCount = {
+    contents: 0
+  };
+  let lastFromSeq = {
+    contents: -1
+  };
+  let snapReads = {
+    contents: 0
+  };
+  let snapWrites = {
+    contents: 0
+  };
+  let failWrite = {
+    contents: false
+  };
+  let eventsFor = id => stored.contents.filter(e => e.id === id);
+  let appendFn = async (seqNr, id, newEvents) => {
+    if (seqNr !== eventsFor(id).length) {
+      return {
+        TAG: "Error",
+        _0: "Conflict"
+      };
+    } else {
+      stored.contents = stored.contents.concat(newEvents);
+      return {
+        TAG: "Ok",
+        _0: undefined
+      };
+    }
+  };
+  let replayStreamFn = (id, fromSeqOpt) => {
+    let fromSeq = fromSeqOpt !== undefined ? fromSeqOpt : 0;
+    replayCount.contents = replayCount.contents + 1 | 0;
+    lastFromSeq.contents = fromSeq;
+    return Stream$1.fromIterable(eventsFor(id).map(e => e.event).filter((param, i) => i >= fromSeq));
+  };
+  let latestSnapshotFn = async id => {
+    snapReads.contents = snapReads.contents + 1 | 0;
+    return {
+      TAG: "Ok",
+      _0: snapshots[id]
+    };
+  };
+  let writeSnapshotFn = async (id, snap) => {
+    if (failWrite.contents) {
+      failWrite.contents = false;
+      return {
+        TAG: "Error",
+        _0: "mock write failure"
+      };
+    } else {
+      snapWrites.contents = snapWrites.contents + 1 | 0;
+      snapshots[id] = snap;
+      return {
+        TAG: "Ok",
+        _0: undefined
+      };
+    }
+  };
+  return {
+    appendFn: appendFn,
+    replayStreamFn: replayStreamFn,
+    latestSnapshotFn: latestSnapshotFn,
+    writeSnapshotFn: writeSnapshotFn,
+    getAll: () => stored.contents,
+    getSnapshot: id => snapshots[id],
+    setSnapshot: (id, snap) => {
+      snapshots[id] = snap;
+    },
+    replayCallCount: replayCount,
+    lastReplayFromSeq: lastFromSeq,
+    snapshotReadCount: snapReads,
+    snapshotWriteCount: snapWrites,
+    failNextWrite: failWrite,
+    reset: () => {
+      stored.contents = [];
+      Stdlib_Dict.forEachWithKey(snapshots, (param, k) => Stdlib_Dict.$$delete(snapshots, k));
+      replayCount.contents = 0;
+      lastFromSeq.contents = -1;
+      snapReads.contents = 0;
+      snapWrites.contents = 0;
+      failWrite.contents = false;
+    }
+  };
+}
+
+let mock = makeMockEL();
+
+function MakeOps(B) {
+  let Spec_name = B.name;
+  let Spec = {
+    Id: undefined,
+    name: Spec_name,
+    eventSchema: eventSchema
+  };
+  let make = (param, param$1) => 0;
+  let EventLog = {
+    Spec: Spec,
+    make: make
+  };
+  let eventLog_append = mock.appendFn;
+  let eventLog_replay = async id => await Effect.runPromise(Stream.runCollect(mock.replayStreamFn(id, undefined)));
+  let eventLog_replayStream = mock.replayStreamFn;
+  let eventLog_appendStream = (_startingSeqNr, _id, stream) => Stream$1.runDrain(stream);
+  let eventLog_latestSnapshot = mock.latestSnapshotFn;
+  let eventLog_writeSnapshot = mock.writeSnapshotFn;
+  let eventLog = {
+    append: eventLog_append,
+    replay: eventLog_replay,
+    replayStream: eventLog_replayStream,
+    appendStream: eventLog_appendStream,
+    latestSnapshot: eventLog_latestSnapshot,
+    writeSnapshot: eventLog_writeSnapshot
+  };
+  return {
+    Spec: undefined,
+    EventLog: EventLog,
+    eventLog: eventLog
+  };
+}
+
+let Spec = {
+  Id: undefined,
+  name: "SnapshotMockEventLog",
+  eventSchema: eventSchema
+};
+
+function make(param, param$1) {
+  return 0;
+}
+
+let EventLog = {
+  Spec: Spec,
+  make: make
+};
+
+let eventLog_append = mock.appendFn;
+
+async function eventLog_replay(id) {
+  return await Effect.runPromise(Stream.runCollect(mock.replayStreamFn(id, undefined)));
+}
+
+let eventLog_replayStream = mock.replayStreamFn;
+
+function eventLog_appendStream(_startingSeqNr, _id, stream) {
+  return Stream$1.runDrain(stream);
+}
+
+let eventLog_latestSnapshot = mock.latestSnapshotFn;
+
+let eventLog_writeSnapshot = mock.writeSnapshotFn;
+
+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: snapshot,
+  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: "SnapshotMockEventLog",
+      eventSchema: eventSchema
+    },
+    make: make
+  },
+  eventLog: eventLog
+});
+
+let stateSchema$1 = S.schema(s => ({
+  items: s.m(S.array(S.string))
+}));
+
+let initialState$1 = {
+  items: []
+};
+
+let moduleUrl$2 = import.meta.url;
+
+function evolve$1(state, event) {
+  return {
+    items: state.items.concat([event.item])
+  };
+}
+
+function decide$1(_state, command) {
+  if (typeof command !== "object") {
+    return {
+      TAG: "Ok",
+      _0: []
+    };
+  } else {
+    return {
+      TAG: "Ok",
+      _0: [{
+          TAG: "Added",
+          item: command.item
+        }]
+    };
+  }
+}
+
+let PlainBehavior = {
+  Spec: undefined,
+  stateSchema: stateSchema$1,
+  initialState: initialState$1,
+  snapshot: undefined,
+  moduleUrl: moduleUrl$2,
+  evolve: evolve$1,
+  decide: decide$1
+};
+
+let Spec$1 = {
+  Id: undefined,
+  name: "PlainMockEventLog",
+  eventSchema: eventSchema
+};
+
+function make$1(param, param$1) {
+  return 0;
+}
+
+let EventLog$1 = {
+  Spec: Spec$1,
+  make: make$1
+};
+
+let eventLog_append$1 = mock.appendFn;
+
+async function eventLog_replay$1(id) {
+  return await Effect.runPromise(Stream.runCollect(mock.replayStreamFn(id, undefined)));
+}
+
+let eventLog_replayStream$1 = mock.replayStreamFn;
+
+function eventLog_appendStream$1(_startingSeqNr, _id, stream) {
+  return Stream$1.runDrain(stream);
+}
+
+let eventLog_latestSnapshot$1 = mock.latestSnapshotFn;
+
+let eventLog_writeSnapshot$1 = mock.writeSnapshotFn;
+
+let eventLog$1 = {
+  append: eventLog_append$1,
+  replay: eventLog_replay$1,
+  replayStream: eventLog_replayStream$1,
+  appendStream: eventLog_appendStream$1,
+  latestSnapshot: eventLog_latestSnapshot$1,
+  writeSnapshot: eventLog_writeSnapshot$1
+};
+
+let PlainOps = {
+  Spec: undefined,
+  EventLog: EventLog$1,
+  eventLog: eventLog$1
+};
+
+let PlainHandler = 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$1,
+  evolve: evolve$1,
+  decide: decide$1,
+  snapshot: undefined,
+  moduleUrl: moduleUrl$2
+})({
+  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: "PlainMockEventLog",
+      eventSchema: eventSchema
+    },
+    make: make$1
+  },
+  eventLog: eventLog$1
+});
+
+function makeItem(idOpt, reference, command) {
+  let id = idOpt !== undefined ? idOpt : "agg-1";
+  return {
+    command: {
+      id: id,
+      meta: testMeta,
+      command: command
+    },
+    reference: reference
+  };
+}
+
+async function run(handler, idOpt, command) {
+  let id = idOpt !== undefined ? idOpt : "agg-1";
+  return await Effect.runPromise(handler(Stream$1.fromIterable([makeItem(id, "ref", command)])));
+}
+
+function tick() {
+  return Promise.resolve().then(() => Promise.resolve());
+}
+
+globalThis.beforeEach(() => {
+  mock.reset();
+  TestHandler.resetCache();
+  PlainHandler.resetCache();
+});
+
+globalThis.describe("Aggregate_Callback — snapshots:", () => {
+  globalThis.test("writes a snapshot each time an interval boundary is crossed", async () => {
+    for (let i = 1; i <= 25; ++i) {
+      await run(TestHandler.handleCommands, undefined, {
+        TAG: "Add",
+        item: `i` + i.toString()
+      });
+    }
+    await tick();
+    globalThis.expect(mock.snapshotWriteCount.contents).toBe(2);
+    let snap = mock.getSnapshot("agg-1");
+    if (snap !== undefined) {
+      globalThis.expect(snap.seqNr).toBe(20);
+    } else {
+      globalThis.expect("expected a snapshot").toBe("none");
+    }
+  });
+  globalThis.test("cold replay seeds from the snapshot and reads only the delta", async () => {
+    for (let i = 1; i <= 12; ++i) {
+      await run(TestHandler.handleCommands, undefined, {
+        TAG: "Add",
+        item: `i` + i.toString()
+      });
+    }
+    await tick();
+    TestHandler.resetCache();
+    mock.replayCallCount.contents = 0;
+    await run(TestHandler.handleCommands, undefined, {
+      TAG: "Add",
+      item: "i13"
+    });
+    globalThis.expect(mock.snapshotReadCount.contents >= 1).toBe(true);
+    globalThis.expect(mock.lastReplayFromSeq.contents).toBe(10);
+    globalThis.expect(mock.getAll().length).toBe(13);
+  });
+  globalThis.test("state seeded from snapshot equals a full-replay fold", async () => {
+    for (let i = 1; i <= 15; ++i) {
+      await run(TestHandler.handleCommands, undefined, {
+        TAG: "Add",
+        item: `x` + i.toString()
+      });
+    }
+    await tick();
+    TestHandler.resetCache();
+    await run(TestHandler.handleCommands, undefined, "Noop");
+    let seededSnap = mock.getSnapshot("agg-1");
+    for (let i$1 = 16; i$1 <= 20; ++i$1) {
+      await run(TestHandler.handleCommands, undefined, {
+        TAG: "Add",
+        item: `x` + i$1.toString()
+      });
+    }
+    await tick();
+    let snap = mock.getSnapshot("agg-1");
+    if (snap !== undefined) {
+      globalThis.expect(snap.seqNr).toBe(20);
+      let decoded = S.parseJsonOrThrow(snap.state, stateSchema);
+      globalThis.expect(decoded.items.length).toBe(20);
+    } else {
+      globalThis.expect("expected snapshot at 20").toBe("none");
+    }
+    if (seededSnap !== undefined) {
+      globalThis.expect(seededSnap.seqNr).toBe(10);
+    } else {
+      globalThis.expect("expected seeded snapshot").toBe("none");
+    }
+  });
+  globalThis.test("schema-drift snapshot is ignored → full replay from 0", async () => {
+    for (let i = 1; i <= 12; ++i) {
+      await run(TestHandler.handleCommands, undefined, {
+        TAG: "Add",
+        item: `i` + i.toString()
+      });
+    }
+    await tick();
+    let snap = mock.getSnapshot("agg-1");
+    if (snap !== undefined) {
+      mock.setSnapshot("agg-1", {
+        seqNr: snap.seqNr,
+        state: snap.state,
+        schemaHash: "STALE-HASH"
+      });
+    }
+    TestHandler.resetCache();
+    mock.replayCallCount.contents = 0;
+    await run(TestHandler.handleCommands, undefined, "Noop");
+    globalThis.expect(mock.lastReplayFromSeq.contents).toBe(0);
+  });
+  globalThis.test("snapshot write failure does not fail the command", async () => {
+    for (let i = 1; i <= 9; ++i) {
+      await run(TestHandler.handleCommands, undefined, {
+        TAG: "Add",
+        item: `i` + i.toString()
+      });
+    }
+    mock.failNextWrite.contents = true;
+    let result = await run(TestHandler.handleCommands, undefined, {
+      TAG: "Add",
+      item: "i10"
+    });
+    await tick();
+    globalThis.expect(result).toEqual([{
+        TAG: "Ok",
+        _0: "ref"
+      }]);
+    globalThis.expect(mock.getAll().length).toBe(10);
+    globalThis.expect(mock.getSnapshot("agg-1")).toEqual(undefined);
+  });
+  globalThis.test("disabled aggregate does zero snapshot reads and writes", async () => {
+    for (let i = 1; i <= 12; ++i) {
+      await run(PlainHandler.handleCommands, undefined, {
+        TAG: "Add",
+        item: `i` + i.toString()
+      });
+    }
+    await tick();
+    PlainHandler.resetCache();
+    await run(PlainHandler.handleCommands, undefined, "Noop");
+    globalThis.expect([
+      mock.snapshotReadCount.contents,
+      mock.snapshotWriteCount.contents
+    ]).toEqual([
+      0,
+      0
+    ]);
+    globalThis.expect(mock.lastReplayFromSeq.contents).toBe(0);
+  });
+});
+
+let OuterEventLog;
+
+export {
+  AggSpec,
+  TestBehavior,
+  testMeta,
+  makeMockEL,
+  mock,
+  OuterEventLog,
+  MakeOps,
+  TestOps,
+  TestHandler,
+  PlainBehavior,
+  PlainOps,
+  PlainHandler,
+  makeItem,
+  run,
+  tick,
+}
+/*  Not a pure module */

package/tests/eventlog/EventLogFixtures.res

@@ -17,6 +17,7 @@ module ItemEventLogSpec = {
 // ─────────────────────────────────────────────────────────────
 
 let storedEvents: ref<dict<array<JSON.t>>> = ref(Dict.make())
+let storedSnapshots: ref<dict<EventLog.snapshot>> = ref(Dict.make())
 let failNextAppend = ref(false)
 // Inject N transient failures: each call decrements the counter and returns ThrottlingException
 let failNextAppendsWithTransient: ref<int> = ref(0)
@@ -41,8 +42,12 @@ let mockStorage: EventLog_Adapter.operations = {
   replay: async id => {
     storedEvents.contents->Dict.get(id)->Option.getOr([])
   },
-  replayStream: id =>
-    storedEvents.contents->Dict.get(id)->Option.getOr([])->Stream.fromIterable,
+  replayStream: (id, ~fromSeq=0) =>
+    storedEvents.contents
+    ->Dict.get(id)
+    ->Option.getOr([])
+    ->Array.slice(~start=fromSeq)
+    ->Stream.fromIterable,
   appendStream: (_startingSeqNr, id, stream) =>
     stream->Stream.runForEach(json =>
       Effect.sync(() => {
@@ -50,6 +55,11 @@ let mockStorage: EventLog_Adapter.operations = {
         storedEvents.contents->Dict.set(id, existing->Array.concat([json]))
       })
     ),
+  latestSnapshot: async id => Ok(storedSnapshots.contents->Dict.get(id)),
+  writeSnapshot: async (id, snap) => {
+    storedSnapshots.contents->Dict.set(id, snap)
+    Ok()
+  },
 }
 
 // ─────────────────────────────────────────────────────────────
@@ -106,6 +116,7 @@ let makeEvent' = (id, event) => {
 
 let reset = () => {
   storedEvents := Dict.make()
+  storedSnapshots := Dict.make()
   failNextAppend := false
   failNextAppendsWithTransient := 0
   appendCallCount := 0