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

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 */

package/tests/aggregate/AggregateConflictTest.res.mjs

@@ -1,386 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as S from "sury/src/S.res.mjs";
-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 = "ConflictTestAggregate";
-
-let commandSchema = S.schema(s => ({
-  TAG: "Create",
-  name: s.m(S.string)
-}));
-
-let eventSchema = S.schema(s => ({
-  TAG: "Created",
-  name: s.m(S.string)
-}));
-
-let errorSchema = S.literal("AlreadyExists");
-
-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 = {
-  name: ""
-};
-
-let moduleUrl$1 = import.meta.url;
-
-function evolve(_state, event) {
-  return {
-    name: event.name
-  };
-}
-
-function decide(_state, command) {
-  return {
-    TAG: "Ok",
-    _0: [{
-        TAG: "Created",
-        name: command.name
-      }]
-  };
-}
-
-let TestBehavior = {
-  Spec: undefined,
-  initialState: initialState,
-  snapshot: undefined,
-  moduleUrl: moduleUrl$1,
-  evolve: evolve,
-  decide: decide
-};
-
-function makeMockEL() {
-  let storedRef = {
-    contents: []
-  };
-  let failConflictRef = {
-    contents: 0
-  };
-  let appendCount = {
-    contents: 0
-  };
-  let replayCount = {
-    contents: 0
-  };
-  let appendFn = async (_seqNr, _id, newEvents) => {
-    appendCount.contents = appendCount.contents + 1 | 0;
-    if (failConflictRef.contents > 0) {
-      failConflictRef.contents = failConflictRef.contents - 1 | 0;
-      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 storedRef.contents.filter(e => e.id === id).map(e => e.event);
-  };
-  let replayStreamFn = id => {
-    replayCount.contents = replayCount.contents + 1 | 0;
-    return Stream.fromIterable(storedRef.contents.filter(e => e.id === id).map(e => e.event));
-  };
-  return {
-    appendFn: appendFn,
-    replayFn: replayFn,
-    replayStreamFn: replayStreamFn,
-    getAll: () => storedRef.contents,
-    failNextAppendsWithConflict: failConflictRef,
-    appendCallCount: appendCount,
-    replayCallCount: replayCount,
-    reset: () => {
-      storedRef.contents = [];
-      failConflictRef.contents = 0;
-      appendCount.contents = 0;
-      replayCount.contents = 0;
-    }
-  };
-}
-
-let mock = makeMockEL();
-
-let name$1 = "ConflictMockEventLog";
-
-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
-});
-
-let testMeta = {
-  service: "ConflictTestAggregate",
-  time: "2024-01-01T00:00:00Z",
-  ip: "127.0.0.1",
-  user: "test-user",
-  msgId: "msg-1",
-  correlationId: "corr-1"
-};
-
-function makeTopicItem(reference, command) {
-  return {
-    command: {
-      id: "agg-1",
-      meta: testMeta,
-      command: command
-    },
-    reference: reference
-  };
-}
-
-globalThis.beforeEach(() => {
-  mock.reset();
-  TestHandler.resetCache();
-});
-
-globalThis.describe("Aggregate_Callback — conflict retry:", () => {
-  globalThis.test("1 conflict retries and succeeds", async () => {
-    mock.failNextAppendsWithConflict.contents = 1;
-    let results = await Effect.runPromise(TestHandler.handleCommands(Stream.fromIterable([{
-        command: {
-          id: "agg-1",
-          meta: testMeta,
-          command: {
-            TAG: "Create",
-            name: "Widget"
-          }
-        },
-        reference: "ref-1"
-      }])));
-    globalThis.expect(results).toEqual([{
-        TAG: "Ok",
-        _0: "ref-1"
-      }]);
-    globalThis.expect(mock.appendCallCount.contents).toBe(2);
-  });
-  globalThis.test("conflict triggers re-replay", async () => {
-    mock.failNextAppendsWithConflict.contents = 1;
-    await Effect.runPromise(TestHandler.handleCommands(Stream.fromIterable([{
-        command: {
-          id: "agg-1",
-          meta: testMeta,
-          command: {
-            TAG: "Create",
-            name: "Widget"
-          }
-        },
-        reference: "ref-1"
-      }])));
-    globalThis.expect(mock.replayCallCount.contents).toBe(2);
-  });
-  globalThis.test("2 conflicts retry twice and succeed", async () => {
-    mock.failNextAppendsWithConflict.contents = 2;
-    let results = await Effect.runPromise(TestHandler.handleCommands(Stream.fromIterable([{
-        command: {
-          id: "agg-1",
-          meta: testMeta,
-          command: {
-            TAG: "Create",
-            name: "Widget"
-          }
-        },
-        reference: "ref-1"
-      }])));
-    globalThis.expect(results).toEqual([{
-        TAG: "Ok",
-        _0: "ref-1"
-      }]);
-    globalThis.expect(mock.appendCallCount.contents).toBe(3);
-  });
-  globalThis.test("max retries exhausted returns Error with detail message", async () => {
-    mock.failNextAppendsWithConflict.contents = 4;
-    let results = await Effect.runPromise(TestHandler.handleCommands(Stream.fromIterable([{
-        command: {
-          id: "agg-1",
-          meta: testMeta,
-          command: {
-            TAG: "Create",
-            name: "Widget"
-          }
-        },
-        reference: "ref-1"
-      }])));
-    globalThis.expect(results).toEqual([{
-        TAG: "Error",
-        _0: "concurrent modification (3 retries exhausted): conflict"
-      }]);
-    globalThis.expect(mock.appendCallCount.contents).toBe(4);
-  });
-  globalThis.test("successful append after conflict stores event", async () => {
-    mock.failNextAppendsWithConflict.contents = 1;
-    await Effect.runPromise(TestHandler.handleCommands(Stream.fromIterable([{
-        command: {
-          id: "agg-1",
-          meta: testMeta,
-          command: {
-            TAG: "Create",
-            name: "Widget"
-          }
-        },
-        reference: "ref-1"
-      }])));
-    globalThis.expect(mock.getAll().length).toBe(1);
-  });
-  globalThis.test("no conflict does not retry", async () => {
-    let results = await Effect.runPromise(TestHandler.handleCommands(Stream.fromIterable([{
-        command: {
-          id: "agg-1",
-          meta: testMeta,
-          command: {
-            TAG: "Create",
-            name: "Widget"
-          }
-        },
-        reference: "ref-1"
-      }])));
-    globalThis.expect(results).toEqual([{
-        TAG: "Ok",
-        _0: "ref-1"
-      }]);
-    globalThis.expect(mock.appendCallCount.contents).toBe(1);
-    globalThis.expect(mock.replayCallCount.contents).toBe(1);
-  });
-});
-
-let OuterEventLog;
-
-export {
-  AggSpec,
-  TestBehavior,
-  makeMockEL,
-  mock,
-  OuterEventLog,
-  TestOps,
-  TestHandler,
-  testMeta,
-  makeTopicItem,
-}
-/*  Not a pure module */