@reventlessdev/reventless-core 3.0.0-alpha.134

package/tests/aggregate/AggregateFixtures.res.mjs

@@ -0,0 +1,285 @@
+// 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 Stream from "effect/Stream";
+import * as Aggregate_Callback$ReventlessCore from "../../src/components/Aggregate/Aggregate_Callback.res.mjs";
+
+S.enableJson();
+
+let name = "TestAggregate";
+
+let commandSchema = S.union([
+  S.schema(s => ({
+    TAG: "Create",
+    name: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "Rename",
+    newName: s.m(S.string)
+  }))
+]);
+
+let eventSchema = S.union([
+  S.schema(s => ({
+    TAG: "Created",
+    name: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "Renamed",
+    newName: s.m(S.string)
+  }))
+]);
+
+let errorSchema = S.union([
+  S.literal("AlreadyExists"),
+  S.literal("NotFound")
+]);
+
+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.union([
+  S.literal("NotCreated"),
+  S.schema(s => ({
+    TAG: "Created",
+    name: s.m(S.string)
+  }))
+]);
+
+let moduleUrl$1 = import.meta.url;
+
+function evolve(_state, event) {
+  if (event.TAG === "Created") {
+    return {
+      TAG: "Created",
+      name: event.name
+    };
+  } else {
+    return {
+      TAG: "Created",
+      name: event.newName
+    };
+  }
+}
+
+function decide(state, command) {
+  if (typeof state !== "object") {
+    if (command.TAG === "Create") {
+      return {
+        TAG: "Ok",
+        _0: [{
+            TAG: "Created",
+            name: command.name
+          }]
+      };
+    } else {
+      return {
+        TAG: "Error",
+        _0: "NotFound"
+      };
+    }
+  } else if (command.TAG === "Create") {
+    return {
+      TAG: "Error",
+      _0: "AlreadyExists"
+    };
+  } else {
+    return {
+      TAG: "Ok",
+      _0: [{
+          TAG: "Renamed",
+          newName: command.newName
+        }]
+    };
+  }
+}
+
+let TestBehavior = {
+  Spec: undefined,
+  stateSchema: stateSchema,
+  initialState: "NotCreated",
+  moduleUrl: moduleUrl$1,
+  evolve: evolve,
+  decide: decide
+};
+
+function makeMockEL() {
+  let storedRef = {
+    contents: []
+  };
+  let failRef = {
+    contents: false
+  };
+  let appendFn = async (_seqNr, _id, newEvents) => {
+    if (failRef.contents) {
+      failRef.contents = false;
+      return {
+        TAG: "Error",
+        _0: "append failed"
+      };
+    } else {
+      storedRef.contents = storedRef.contents.concat(newEvents);
+      return {
+        TAG: "Ok",
+        _0: undefined
+      };
+    }
+  };
+  let replayFn = async id => storedRef.contents.filter(e => e.id === id).map(e => e.event);
+  let replayStreamFn = id => Stream.fromIterable(storedRef.contents.filter(e => e.id === id).map(e => e.event));
+  return {
+    appendFn: appendFn,
+    replayFn: replayFn,
+    replayStreamFn: replayStreamFn,
+    getAll: () => storedRef.contents,
+    failNextAppend: failRef,
+    reset: () => {
+      storedRef.contents = [];
+      failRef.contents = false;
+    }
+  };
+}
+
+let mock = makeMockEL();
+
+let name$1 = "MockEventLog";
+
+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;
+
+let eventLog_replayStream = mock.replayStreamFn;
+
+function eventLog_appendStream(_startingSeqNr, _id, stream) {
+  return Stream.runDrain(stream);
+}
+
+let eventLog = {
+  append: eventLog_append,
+  replay: eventLog_replay,
+  replayStream: eventLog_replayStream,
+  appendStream: eventLog_appendStream
+};
+
+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: "NotCreated",
+  evolve: evolve,
+  decide: decide,
+  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: "TestAggregate",
+  time: "2024-01-01T00:00:00Z",
+  ip: "127.0.0.1",
+  user: "test-user",
+  msgId: "msg-1",
+  correlationId: "corr-1"
+};
+
+function makeTopicItem(aggIdOpt, reference, command) {
+  let aggId = aggIdOpt !== undefined ? aggIdOpt : "agg-1";
+  return {
+    command: {
+      id: aggId,
+      meta: testMeta,
+      command: command
+    },
+    reference: reference
+  };
+}
+
+let OuterEventLog;
+
+export {
+  AggSpec,
+  TestBehavior,
+  makeMockEL,
+  mock,
+  OuterEventLog,
+  TestOps,
+  TestHandler,
+  testMeta,
+  makeTopicItem,
+}
+/*  Not a pure module */

package/tests/aggregate/AggregateRejectionTest.res

@@ -0,0 +1,139 @@
+// Tests for the Aggregate decide-rejection propagation path.
+// Verifies that domain rejections from Behavior.decide:
+//   1. Surface to producers via CommandTopic_Helpers.rejectedResultChannel (with errorCode + detail)
+//   2. Return Ok(reference) so async (SQS) consumers delete the message — domain rejections don't redeliver
+//   3. Don't cancel surviving commands inside the same batch
+
+open JestGlobals
+open AggregateFixtures
+
+let _ = beforeEach(() => mock.reset())
+
+// Captures whatever flows through CommandTopic_Helpers.reportRejected during a test.
+let capturedRejections: ref<array<(string, CommandTopic_Helpers.rejectedResult)>> = ref([])
+let capturedAccepts: ref<array<(string, CommandTopic_Helpers.acceptedResult)>> = ref([])
+
+let installChannels = () => {
+  capturedRejections := []
+  capturedAccepts := []
+  CommandTopic_Helpers.rejectedResultChannel.contents = Some(
+    (ref, info) => capturedRejections := capturedRejections.contents->Array.concat([(ref, info)]),
+  )
+  CommandTopic_Helpers.acceptedResultChannel.contents = Some(
+    (ref, info) => capturedAccepts := capturedAccepts.contents->Array.concat([(ref, info)]),
+  )
+}
+
+let uninstallChannels = () => {
+  CommandTopic_Helpers.rejectedResultChannel.contents = None
+  CommandTopic_Helpers.acceptedResultChannel.contents = None
+}
+
+describe("Aggregate decide-rejection propagation:", () => {
+  describe("single rejected command", () => {
+    testPromise("Create on existing aggregate reports Rejected with errorCode", async () => {
+      // Seed: aggregate already created → second Create rejects with AlreadyExists.
+      let _ =
+        await Stream.fromIterable([
+          makeTopicItem("ref-seed", AggSpec.Create({name: "Widget"})),
+        ])->TestHandler.handleCommands->Effect.runPromise
+
+      installChannels()
+      let results =
+        await Stream.fromIterable([
+          makeTopicItem("ref-1", AggSpec.Create({name: "Widget"})),
+        ])->TestHandler.handleCommands->Effect.runPromise
+      uninstallChannels()
+
+      // Producer sees Rejected on the channel; SQS sees Ok (delete — don't redeliver).
+      expect(results)->toEqual([Ok("ref-1")])
+      expect(capturedRejections.contents->Array.length)->toBe(1)
+      let (ref, info) = capturedRejections.contents->Array.getUnsafe(0)
+      expect(ref)->toEqual("ref-1")
+      expect(info.errorCode)->toEqual("AlreadyExists")
+      // No event was appended.
+      expect(mock.getAll()->Array.length)->toBe(1)
+    })
+  })
+
+  describe("mixed batch", () => {
+    testPromise("rejected command does not cancel surviving commands", async () => {
+      // Seed.
+      let _ =
+        await Stream.fromIterable([
+          makeTopicItem(~aggId="agg-1", "ref-seed", AggSpec.Create({name: "Widget"})),
+        ])->TestHandler.handleCommands->Effect.runPromise
+
+      installChannels()
+      // Batch on the same aggregate: Rename (ok) → Create (rejects) → Rename (ok)
+      let results =
+        await Stream.fromIterable([
+          makeTopicItem(~aggId="agg-1", "ref-1", AggSpec.Rename({newName: "First"})),
+          makeTopicItem(~aggId="agg-1", "ref-2", AggSpec.Create({name: "Boom"})),
+          makeTopicItem(~aggId="agg-1", "ref-3", AggSpec.Rename({newName: "Last"})),
+        ])->TestHandler.handleCommands->Effect.runPromise
+      uninstallChannels()
+
+      // All three references map to Ok (rejected ones still Ok — SQS deletes).
+      expect(results->Array.length)->toBe(3)
+      results->Array.forEach(r =>
+        switch r {
+        | Ok(_) => ()
+        | Error(_) => expect("expected all Ok")->toEqual("got Error")
+        }
+      )
+      // Two Renamed events appended (the rejected Create produced none).
+      // Seed = 1, plus 2 Renamed = 3 stored.
+      expect(mock.getAll()->Array.length)->toBe(3)
+      // ref-2 reported as Rejected with AlreadyExists.
+      let rejected = capturedRejections.contents
+      expect(rejected->Array.length)->toBe(1)
+      let (rRef, rInfo) = rejected->Array.getUnsafe(0)
+      expect(rRef)->toEqual("ref-2")
+      expect(rInfo.errorCode)->toEqual("AlreadyExists")
+      // ref-1 and ref-3 reported as Accepted (eventCount > 0 against the appended batch).
+      let accepted = capturedAccepts.contents
+      expect(accepted->Array.length)->toBe(2)
+    })
+  })
+
+  describe("all-reject batch", () => {
+    testPromise("3 rejecting commands → no append, all reported Rejected, no Accepted", async () => {
+      // No seed → empty history. Rename on a NotCreated aggregate rejects with NotFound.
+      installChannels()
+      let results =
+        await Stream.fromIterable([
+          makeTopicItem(~aggId="agg-x", "ref-1", AggSpec.Rename({newName: "A"})),
+          makeTopicItem(~aggId="agg-x", "ref-2", AggSpec.Rename({newName: "B"})),
+          makeTopicItem(~aggId="agg-x", "ref-3", AggSpec.Rename({newName: "C"})),
+        ])->TestHandler.handleCommands->Effect.runPromise
+      uninstallChannels()
+
+      expect(results)->toEqual([Ok("ref-1"), Ok("ref-2"), Ok("ref-3")])
+      // No events appended.
+      expect(mock.getAll()->Array.length)->toBe(0)
+      // All three reported as Rejected.
+      expect(capturedRejections.contents->Array.length)->toBe(3)
+      capturedRejections.contents->Array.forEach(((_ref, info)) =>
+        expect(info.errorCode)->toEqual("NotFound")
+      )
+      // No Accepted callbacks fired (when nothing is appended and nothing is OK).
+      expect(capturedAccepts.contents->Array.length)->toBe(0)
+    })
+  })
+
+  describe("payload-less variant errors", () => {
+    testPromise("errorDetail is empty string for unit-payload variants", async () => {
+      // AggSpec.error variants are all payload-less (NotFound | AlreadyExists).
+      installChannels()
+      let _ =
+        await Stream.fromIterable([
+          makeTopicItem("ref-1", AggSpec.Rename({newName: "X"})),
+        ])->TestHandler.handleCommands->Effect.runPromise
+      uninstallChannels()
+
+      let (_ref, info) = capturedRejections.contents->Array.getUnsafe(0)
+      expect(info.errorDetail)->toEqual("")
+    })
+  })
+})

package/tests/aggregate/AggregateRejectionTest.res.mjs

@@ -0,0 +1,163 @@
+// 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";
+import * as CommandTopic_Helpers$ReventlessCore from "../../src/components/CommandTopic/CommandTopic_Helpers.res.mjs";
+
+globalThis.beforeEach(() => AggregateFixtures$ReventlessCore.mock.reset());
+
+let capturedRejections = {
+  contents: []
+};
+
+let capturedAccepts = {
+  contents: []
+};
+
+function installChannels() {
+  capturedRejections.contents = [];
+  capturedAccepts.contents = [];
+  CommandTopic_Helpers$ReventlessCore.rejectedResultChannel.contents = (ref, info) => {
+    capturedRejections.contents = capturedRejections.contents.concat([[
+        ref,
+        info
+      ]]);
+  };
+  CommandTopic_Helpers$ReventlessCore.acceptedResultChannel.contents = (ref, info) => {
+    capturedAccepts.contents = capturedAccepts.contents.concat([[
+        ref,
+        info
+      ]]);
+  };
+}
+
+function uninstallChannels() {
+  CommandTopic_Helpers$ReventlessCore.rejectedResultChannel.contents = undefined;
+  CommandTopic_Helpers$ReventlessCore.acceptedResultChannel.contents = undefined;
+}
+
+globalThis.describe("Aggregate decide-rejection propagation:", () => {
+  globalThis.describe("single rejected command", () => {
+    globalThis.test("Create on existing aggregate reports Rejected with errorCode", async () => {
+      await Effect.runPromise(AggregateFixtures$ReventlessCore.TestHandler.handleCommands(Stream.fromIterable([AggregateFixtures$ReventlessCore.makeTopicItem(undefined, "ref-seed", {
+          TAG: "Create",
+          name: "Widget"
+        })])));
+      installChannels();
+      let results = await Effect.runPromise(AggregateFixtures$ReventlessCore.TestHandler.handleCommands(Stream.fromIterable([AggregateFixtures$ReventlessCore.makeTopicItem(undefined, "ref-1", {
+          TAG: "Create",
+          name: "Widget"
+        })])));
+      uninstallChannels();
+      globalThis.expect(results).toEqual([{
+          TAG: "Ok",
+          _0: "ref-1"
+        }]);
+      globalThis.expect(capturedRejections.contents.length).toBe(1);
+      let match = capturedRejections.contents[0];
+      globalThis.expect(match[0]).toEqual("ref-1");
+      globalThis.expect(match[1].errorCode).toEqual("AlreadyExists");
+      globalThis.expect(AggregateFixtures$ReventlessCore.mock.getAll().length).toBe(1);
+    });
+  });
+  globalThis.describe("mixed batch", () => {
+    globalThis.test("rejected command does not cancel surviving commands", async () => {
+      await Effect.runPromise(AggregateFixtures$ReventlessCore.TestHandler.handleCommands(Stream.fromIterable([AggregateFixtures$ReventlessCore.makeTopicItem("agg-1", "ref-seed", {
+          TAG: "Create",
+          name: "Widget"
+        })])));
+      installChannels();
+      let results = await Effect.runPromise(AggregateFixtures$ReventlessCore.TestHandler.handleCommands(Stream.fromIterable([
+        AggregateFixtures$ReventlessCore.makeTopicItem("agg-1", "ref-1", {
+          TAG: "Rename",
+          newName: "First"
+        }),
+        AggregateFixtures$ReventlessCore.makeTopicItem("agg-1", "ref-2", {
+          TAG: "Create",
+          name: "Boom"
+        }),
+        AggregateFixtures$ReventlessCore.makeTopicItem("agg-1", "ref-3", {
+          TAG: "Rename",
+          newName: "Last"
+        })
+      ])));
+      uninstallChannels();
+      globalThis.expect(results.length).toBe(3);
+      results.forEach(r => {
+        if (r.TAG === "Ok") {
+          return;
+        }
+        globalThis.expect("expected all Ok").toEqual("got Error");
+      });
+      globalThis.expect(AggregateFixtures$ReventlessCore.mock.getAll().length).toBe(3);
+      let rejected = capturedRejections.contents;
+      globalThis.expect(rejected.length).toBe(1);
+      let match = rejected[0];
+      globalThis.expect(match[0]).toEqual("ref-2");
+      globalThis.expect(match[1].errorCode).toEqual("AlreadyExists");
+      let accepted = capturedAccepts.contents;
+      globalThis.expect(accepted.length).toBe(2);
+    });
+  });
+  globalThis.describe("all-reject batch", () => {
+    globalThis.test("3 rejecting commands → no append, all reported Rejected, no Accepted", async () => {
+      installChannels();
+      let results = await Effect.runPromise(AggregateFixtures$ReventlessCore.TestHandler.handleCommands(Stream.fromIterable([
+        AggregateFixtures$ReventlessCore.makeTopicItem("agg-x", "ref-1", {
+          TAG: "Rename",
+          newName: "A"
+        }),
+        AggregateFixtures$ReventlessCore.makeTopicItem("agg-x", "ref-2", {
+          TAG: "Rename",
+          newName: "B"
+        }),
+        AggregateFixtures$ReventlessCore.makeTopicItem("agg-x", "ref-3", {
+          TAG: "Rename",
+          newName: "C"
+        })
+      ])));
+      uninstallChannels();
+      globalThis.expect(results).toEqual([
+        {
+          TAG: "Ok",
+          _0: "ref-1"
+        },
+        {
+          TAG: "Ok",
+          _0: "ref-2"
+        },
+        {
+          TAG: "Ok",
+          _0: "ref-3"
+        }
+      ]);
+      globalThis.expect(AggregateFixtures$ReventlessCore.mock.getAll().length).toBe(0);
+      globalThis.expect(capturedRejections.contents.length).toBe(3);
+      capturedRejections.contents.forEach(param => {
+        globalThis.expect(param[1].errorCode).toEqual("NotFound");
+      });
+      globalThis.expect(capturedAccepts.contents.length).toBe(0);
+    });
+  });
+  globalThis.describe("payload-less variant errors", () => {
+    globalThis.test("errorDetail is empty string for unit-payload variants", async () => {
+      installChannels();
+      await Effect.runPromise(AggregateFixtures$ReventlessCore.TestHandler.handleCommands(Stream.fromIterable([AggregateFixtures$ReventlessCore.makeTopicItem(undefined, "ref-1", {
+          TAG: "Rename",
+          newName: "X"
+        })])));
+      uninstallChannels();
+      let match = capturedRejections.contents[0];
+      globalThis.expect(match[1].errorDetail).toEqual("");
+    });
+  });
+});
+
+export {
+  capturedRejections,
+  capturedAccepts,
+  installChannels,
+  uninstallChannels,
+}
+/*  Not a pure module */

package/tests/api/ApiNoApiTest.res

@@ -0,0 +1,62 @@
+open JestGlobals
+open ApiNoApiHelpers
+
+describe("ApiNoApiHelpers:", () => {
+  testSync("isNoApi returns false for schema without noApi metadata", () => {
+    let schema = S.string->S.castToUnknown
+    expect(isNoApi(schema))->toBe(false)
+  })
+
+  testSync("isNoApi returns true for schema with noApi metadata set to true", () => {
+    let schema = S.string->S.castToUnknown
+    let schema' = schema->S.Metadata.set(~id=ReventlessInfra.Api.noApiId, true)
+    expect(isNoApi(schema'))->toBe(true)
+  })
+
+  testSync("getExcludedVariants returns None for schema without noApiVariants metadata", () => {
+    let schema = S.string->S.castToUnknown
+    expect(getExcludedVariants(schema))->toBe(None)
+  })
+
+  testSync("getExcludedVariants returns Some with DeleteItem when set", () => {
+    let schema = S.string->S.castToUnknown
+    let excluded = Set.fromArray(["DeleteItem", "UpdateItem"])
+    let schema' = schema->S.Metadata.set(~id=ReventlessInfra.Api.noApiVariantsId, excluded)
+    let result = getExcludedVariants(schema')
+    expect(result->Option.map(set => set->Set.has("DeleteItem"))->Option.getOr(false))->toBe(true)
+  })
+
+  testSync("filterNoApiVariants returns all field names when no variants are excluded", () => {
+    let schema = S.string->S.castToUnknown
+    let fieldNames = ["CreateItem", "DeleteItem", "UpdateItem"]
+    let filtered = filterNoApiVariants(fieldNames, schema)
+    expect(filtered)->toEqual(["CreateItem", "DeleteItem", "UpdateItem"])
+  })
+
+  testSync("filterNoApiVariants filters out excluded variants", () => {
+    let schema = S.string->S.castToUnknown
+    let excluded = Set.fromArray(["DeleteItem"])
+    let schema' = schema->S.Metadata.set(~id=ReventlessInfra.Api.noApiVariantsId, excluded)
+    let fieldNames = ["CreateItem", "DeleteItem", "UpdateItem"]
+    let filtered = filterNoApiVariants(fieldNames, schema')
+    expect(filtered)->toEqual(["CreateItem", "UpdateItem"])
+  })
+
+  testSync("filterNoApiVariants filters out multiple excluded variants", () => {
+    let schema = S.string->S.castToUnknown
+    let excluded = Set.fromArray(["DeleteItem", "UpdateItem"])
+    let schema' = schema->S.Metadata.set(~id=ReventlessInfra.Api.noApiVariantsId, excluded)
+    let fieldNames = ["CreateItem", "DeleteItem", "UpdateItem", "GetItem"]
+    let filtered = filterNoApiVariants(fieldNames, schema')
+    expect(filtered)->toEqual(["CreateItem", "GetItem"])
+  })
+
+  testSync("filterNoApiVariants returns empty array when all variants are excluded", () => {
+    let schema = S.string->S.castToUnknown
+    let excluded = Set.fromArray(["CreateItem", "DeleteItem", "UpdateItem"])
+    let schema' = schema->S.Metadata.set(~id=ReventlessInfra.Api.noApiVariantsId, excluded)
+    let fieldNames = ["CreateItem", "DeleteItem", "UpdateItem"]
+    let filtered = filterNoApiVariants(fieldNames, schema')
+    expect(filtered)->toEqual([])
+  })
+})