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

package/tests/aggregate/AggregateCacheTest.res.mjs

@@ -1,433 +0,0 @@
-// 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.mjs

@@ -1,143 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Effect from "effect/Effect";
-import * as Stream from "effect/Stream";
-import * as AggregateFixtures$ReventlessCore from "./AggregateFixtures.res.mjs";
-
-globalThis.beforeEach(() => {
-  AggregateFixtures$ReventlessCore.mock.reset();
-  AggregateFixtures$ReventlessCore.TestHandler.resetCache();
-});
-
-globalThis.describe("Aggregate_Callback.handleCommands:", () => {
-  globalThis.describe("single command — new aggregate", () => {
-    globalThis.test("Create returns Ok(reference) and stores 1 event", async () => {
-      let results = await Effect.runPromise(AggregateFixtures$ReventlessCore.TestHandler.handleCommands(Stream.fromIterable([AggregateFixtures$ReventlessCore.makeTopicItem(undefined, "ref-1", {
-          TAG: "Create",
-          name: "Widget"
-        })])));
-      globalThis.expect([
-        results,
-        AggregateFixtures$ReventlessCore.mock.getAll().length
-      ]).toEqual([
-        [{
-            TAG: "Ok",
-            _0: "ref-1"
-          }],
-        1
-      ]);
-    });
-  });
-  globalThis.describe("command on existing aggregate", () => {
-    globalThis.test("Rename after Create replays history and appends new event", async () => {
-      await Effect.runPromise(AggregateFixtures$ReventlessCore.TestHandler.handleCommands(Stream.fromIterable([AggregateFixtures$ReventlessCore.makeTopicItem(undefined, "ref-1", {
-          TAG: "Create",
-          name: "Widget"
-        })])));
-      let results = await Effect.runPromise(AggregateFixtures$ReventlessCore.TestHandler.handleCommands(Stream.fromIterable([AggregateFixtures$ReventlessCore.makeTopicItem(undefined, "ref-2", {
-          TAG: "Rename",
-          newName: "Gadget"
-        })])));
-      globalThis.expect([
-        results,
-        AggregateFixtures$ReventlessCore.mock.getAll().length
-      ]).toEqual([
-        [{
-            TAG: "Ok",
-            _0: "ref-2"
-          }],
-        2
-      ]);
-    });
-  });
-  globalThis.describe("behavior returns no events", () => {
-    globalThis.test("Rename on new aggregate returns Ok with no event stored", async () => {
-      let results = await Effect.runPromise(AggregateFixtures$ReventlessCore.TestHandler.handleCommands(Stream.fromIterable([AggregateFixtures$ReventlessCore.makeTopicItem(undefined, "ref-1", {
-          TAG: "Rename",
-          newName: "Gadget"
-        })])));
-      globalThis.expect([
-        results,
-        AggregateFixtures$ReventlessCore.mock.getAll().length
-      ]).toEqual([
-        [{
-            TAG: "Ok",
-            _0: "ref-1"
-          }],
-        0
-      ]);
-    });
-  });
-  globalThis.describe("append failure", () => {
-    globalThis.test("eventLog.append fails → reference returned Error", async () => {
-      AggregateFixtures$ReventlessCore.mock.failNextAppend.contents = true;
-      let results = await Effect.runPromise(AggregateFixtures$ReventlessCore.TestHandler.handleCommands(Stream.fromIterable([AggregateFixtures$ReventlessCore.makeTopicItem(undefined, "ref-1", {
-          TAG: "Create",
-          name: "Widget"
-        })])));
-      globalThis.expect(results).toEqual([{
-          TAG: "Error",
-          _0: "ref-1"
-        }]);
-    });
-  });
-  globalThis.describe("multiple commands for same aggregate ID", () => {
-    globalThis.test("Create then Rename in one batch accumulate state correctly", async () => {
-      let results = await Effect.runPromise(AggregateFixtures$ReventlessCore.TestHandler.handleCommands(Stream.fromIterable([
-        AggregateFixtures$ReventlessCore.makeTopicItem("agg-1", "ref-1", {
-          TAG: "Create",
-          name: "Widget"
-        }),
-        AggregateFixtures$ReventlessCore.makeTopicItem("agg-1", "ref-2", {
-          TAG: "Rename",
-          newName: "Gadget"
-        })
-      ])));
-      globalThis.expect([
-        results,
-        AggregateFixtures$ReventlessCore.mock.getAll().length
-      ]).toEqual([
-        [
-          {
-            TAG: "Ok",
-            _0: "ref-1"
-          },
-          {
-            TAG: "Ok",
-            _0: "ref-2"
-          }
-        ],
-        2
-      ]);
-    });
-  });
-  globalThis.describe("commands for different aggregate IDs", () => {
-    globalThis.test("each ID processed independently", async () => {
-      let results = await Effect.runPromise(AggregateFixtures$ReventlessCore.TestHandler.handleCommands(Stream.fromIterable([
-        AggregateFixtures$ReventlessCore.makeTopicItem("agg-a", "ref-a", {
-          TAG: "Create",
-          name: "Alpha"
-        }),
-        AggregateFixtures$ReventlessCore.makeTopicItem("agg-b", "ref-b", {
-          TAG: "Create",
-          name: "Beta"
-        })
-      ])));
-      globalThis.expect([
-        results.length,
-        AggregateFixtures$ReventlessCore.mock.getAll().length
-      ]).toEqual([
-        2,
-        2
-      ]);
-    });
-  });
-  globalThis.describe("empty batch", () => {
-    globalThis.test("returns empty array", async () => {
-      let results = await Effect.runPromise(AggregateFixtures$ReventlessCore.TestHandler.handleCommands(Stream.fromIterable([])));
-      globalThis.expect(results).toEqual([]);
-    });
-  });
-});
-
-/*  Not a pure module */

package/tests/aggregate/AggregateCausationTest.res.mjs

@@ -1,47 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Effect from "effect/Effect";
-import * as Stream from "effect/Stream";
-import * as AggregateFixtures$ReventlessCore from "./AggregateFixtures.res.mjs";
-
-globalThis.beforeEach(() => {
-  AggregateFixtures$ReventlessCore.mock.reset();
-  AggregateFixtures$ReventlessCore.TestHandler.resetCache();
-});
-
-globalThis.describe("Aggregate_Callback causation propagation:", () => {
-  globalThis.test("event.meta.causationId = command.meta.msgId", async () => {
-    await Effect.runPromise(AggregateFixtures$ReventlessCore.TestHandler.handleCommands(Stream.fromIterable([AggregateFixtures$ReventlessCore.makeTopicItem(undefined, "ref-1", {
-        TAG: "Create",
-        name: "Widget"
-      })])));
-    let stored = AggregateFixtures$ReventlessCore.mock.getAll()[0];
-    globalThis.expect(stored.meta.causationId).toEqual(AggregateFixtures$ReventlessCore.testMeta.msgId);
-  });
-  globalThis.test("event.meta.correlationId = command.meta.correlationId (chain root stable)", async () => {
-    await Effect.runPromise(AggregateFixtures$ReventlessCore.TestHandler.handleCommands(Stream.fromIterable([AggregateFixtures$ReventlessCore.makeTopicItem(undefined, "ref-1", {
-        TAG: "Create",
-        name: "Widget"
-      })])));
-    let stored = AggregateFixtures$ReventlessCore.mock.getAll()[0];
-    globalThis.expect(stored.meta.correlationId).toBe(AggregateFixtures$ReventlessCore.testMeta.correlationId);
-  });
-  globalThis.test("event has a fresh msgId distinct from the command's msgId", async () => {
-    await Effect.runPromise(AggregateFixtures$ReventlessCore.TestHandler.handleCommands(Stream.fromIterable([AggregateFixtures$ReventlessCore.makeTopicItem(undefined, "ref-1", {
-        TAG: "Create",
-        name: "Widget"
-      })])));
-    let stored = AggregateFixtures$ReventlessCore.mock.getAll()[0];
-    globalThis.expect(stored.meta.msgId === AggregateFixtures$ReventlessCore.testMeta.msgId).toBe(false);
-  });
-  globalThis.test("event inherits ip / user / service from the command's meta", async () => {
-    await Effect.runPromise(AggregateFixtures$ReventlessCore.TestHandler.handleCommands(Stream.fromIterable([AggregateFixtures$ReventlessCore.makeTopicItem(undefined, "ref-1", {
-        TAG: "Create",
-        name: "Widget"
-      })])));
-    let stored = AggregateFixtures$ReventlessCore.mock.getAll()[0];
-    globalThis.expect(stored.meta.service).toBe(AggregateFixtures$ReventlessCore.testMeta.service);
-  });
-});
-
-/*  Not a pure module */