@reventlessdev/reventless-core 3.0.0-alpha.169 → 3.0.0-alpha.171

package/tests/aggregate/AggregateSnapshotTest.res.mjs

@@ -1,645 +0,0 @@
-// 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 */