@reventlessdev/reventless-core 3.0.0-alpha.134

package/tests/commandgenerator/CommandGeneratorCallbackTest.res

@@ -0,0 +1,128 @@
+open JestGlobals
+open CommandGeneratorFixtures
+
+let _ = beforeEach(() => reset())
+
+describe("CommandGenerator_Callback.generateCommand:", () => {
+  describe("zero-param command", () => {
+    testPromise("publishJsons called with plain string commandJson", async () => {
+      let payload = makeZeroParamPayload(~id="agg-1", ~command="Create")
+      let _msgId = await TestGenerator.generateCommand(payload)->Effect.runPromise
+      let publishedCmd = capturedCmds.contents->Array.getUnsafe(0)
+      // Zero-param command serializes as a plain JSON string
+      expect(publishedCmd.commandJson)->toEqual(JSON.Encode.string("Create"))
+    })
+
+    testPromise("returns a Pending outcome with non-empty msgId", async () => {
+      let payload = makeZeroParamPayload(~id="agg-1", ~command="Create")
+      let outcome = await TestGenerator.generateCommand(payload)->Effect.runPromise
+      let msgId = switch outcome {
+      | CommandTopic.Pending({msgId}) => msgId
+      | _ => ""
+      }
+      expect(msgId->String.length > 0)->toBe(true)
+    })
+
+    testPromise("meta.service equals AggregateSpec.name", async () => {
+      let payload = makeZeroParamPayload(~id="agg-1", ~command="Create")
+      let _outcome = await TestGenerator.generateCommand(payload)->Effect.runPromise
+      let publishedCmd = capturedCmds.contents->Array.getUnsafe(0)
+      expect(publishedCmd.meta.service)->toBe(CmdGenAggSpec.name)
+    })
+
+    testPromise("meta.msgId equals meta.correlationId", async () => {
+      let payload = makeZeroParamPayload(~id="agg-1", ~command="Create")
+      let outcome = await TestGenerator.generateCommand(payload)->Effect.runPromise
+      let publishedCmd = capturedCmds.contents->Array.getUnsafe(0)
+      let msgId = switch outcome {
+      | CommandTopic.Pending({msgId}) => msgId
+      | _ => ""
+      }
+      expect((publishedCmd.meta.msgId, publishedCmd.meta.correlationId))->toEqual((msgId, msgId))
+    })
+  })
+
+  describe("multi-param command", () => {
+    testPromise("publishJsons called with object commandJson {TAG, param}", async () => {
+      let payload =
+        makeOneParamPayload(~id="agg-1", ~command="CreateWithName", ~paramName="name", ~paramValue="Widget")
+      let _msgId = await TestGenerator.generateCommand(payload)->Effect.runPromise
+      let publishedCmd = capturedCmds.contents->Array.getUnsafe(0)
+      // Multi-param command serializes as {TAG: "CreateWithName", name: "Widget"}
+      let cmdObj = publishedCmd.commandJson->JSON.Decode.object->Option.getOrThrow
+      expect(cmdObj->Dict.get("TAG"))->toEqual(Some(JSON.Encode.string("CreateWithName")))
+      expect(cmdObj->Dict.get("name"))->toEqual(Some(JSON.Encode.string("Widget")))
+    })
+  })
+
+  describe("schema validation failure", () => {
+    testPromise("invalid command name throws an error", async () => {
+      let payload = makeZeroParamPayload(~id="agg-1", ~command="NonExistentCommand")
+      let threw = ref(false)
+      switch await TestGenerator.generateCommand(payload)->Effect.runPromise {
+      | _ => ()
+      | exception _ => threw := true
+      }
+      expect(threw.contents)->toBe(true)
+    })
+  })
+
+  describe("StateChangeSlice envelope id derivation", () => {
+    testPromise("single @partitionTag: id derived from tagged field when args have no id", async () => {
+      let payload = makeSlicePayload(
+        ~command="CreateItem",
+        ~args=Dict.fromArray([
+          ("itemId", JSON.Encode.string("item-42")),
+          ("name", JSON.Encode.string("Widget")),
+        ]),
+      )
+      let outcome = await singleTagSliceGen(payload)->Effect.runPromise
+      let publishedCmd = capturedCmds.contents->Array.getUnsafe(0)
+      expect(publishedCmd.id)->toBe("item-42")
+      // sanity: outcome is well-formed
+      let msgId = switch outcome {
+      | CommandTopic.Pending({msgId}) => msgId
+      | _ => ""
+      }
+      expect(msgId->String.length > 0)->toBe(true)
+    })
+
+    testPromise("composite @compositePartitionTag: id is joined partition-key value", async () => {
+      let payload = makeSlicePayload(
+        ~command="DeployVersion",
+        ~args=Dict.fromArray([
+          ("environment", JSON.Encode.string("prod")),
+          ("service", JSON.Encode.string("checkout")),
+          ("version", JSON.Encode.string("1.2.3")),
+        ]),
+      )
+      let _outcome = await compositeTagSliceGen(payload)->Effect.runPromise
+      let publishedCmd = capturedCmds.contents->Array.getUnsafe(0)
+      // Composite key joins position-0 value, then sep[0] = "-", then position-1 value
+      expect(publishedCmd.id)->toBe("prod-checkout")
+    })
+
+    testPromise("explicit id in args wins over derivation (regression check)", async () => {
+      let payload = makeSlicePayload(
+        ~command="CreateItem",
+        ~args=Dict.fromArray([
+          ("id", JSON.Encode.string("explicit-id")),
+          ("itemId", JSON.Encode.string("item-99")),
+          ("name", JSON.Encode.string("Gadget")),
+        ]),
+      )
+      let _outcome = await singleTagSliceGen(payload)->Effect.runPromise
+      let publishedCmd = capturedCmds.contents->Array.getUnsafe(0)
+      expect(publishedCmd.id)->toBe("explicit-id")
+    })
+  })
+
+  describe("Aggregate envelope id (regression)", () => {
+    testPromise("explicit id in args is preserved unchanged", async () => {
+      let payload = makeZeroParamPayload(~id="agg-7", ~command="Create")
+      let _outcome = await TestGenerator.generateCommand(payload)->Effect.runPromise
+      let publishedCmd = capturedCmds.contents->Array.getUnsafe(0)
+      expect(publishedCmd.id)->toBe("agg-7")
+    })
+  })
+})

package/tests/commandgenerator/CommandGeneratorCallbackTest.res.mjs

@@ -0,0 +1,160 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as CommandGeneratorFixtures$ReventlessCore from "./CommandGeneratorFixtures.res.mjs";
+
+globalThis.beforeEach(() => CommandGeneratorFixtures$ReventlessCore.reset());
+
+globalThis.describe("CommandGenerator_Callback.generateCommand:", () => {
+  globalThis.describe("zero-param command", () => {
+    globalThis.test("publishJsons called with plain string commandJson", async () => {
+      let payload = CommandGeneratorFixtures$ReventlessCore.makeZeroParamPayload("agg-1", "Create");
+      await Effect.runPromise(CommandGeneratorFixtures$ReventlessCore.TestGenerator.generateCommand(payload));
+      let publishedCmd = CommandGeneratorFixtures$ReventlessCore.capturedCmds.contents[0];
+      globalThis.expect(publishedCmd.commandJson).toEqual("Create");
+    });
+    globalThis.test("returns a Pending outcome with non-empty msgId", async () => {
+      let payload = CommandGeneratorFixtures$ReventlessCore.makeZeroParamPayload("agg-1", "Create");
+      let outcome = await Effect.runPromise(CommandGeneratorFixtures$ReventlessCore.TestGenerator.generateCommand(payload));
+      let msgId;
+      switch (outcome.TAG) {
+        case "Accepted" :
+        case "Rejected" :
+          msgId = "";
+          break;
+        case "Pending" :
+          msgId = outcome.msgId;
+          break;
+      }
+      globalThis.expect(msgId.length > 0).toBe(true);
+    });
+    globalThis.test("meta.service equals AggregateSpec.name", async () => {
+      let payload = CommandGeneratorFixtures$ReventlessCore.makeZeroParamPayload("agg-1", "Create");
+      await Effect.runPromise(CommandGeneratorFixtures$ReventlessCore.TestGenerator.generateCommand(payload));
+      let publishedCmd = CommandGeneratorFixtures$ReventlessCore.capturedCmds.contents[0];
+      globalThis.expect(publishedCmd.meta.service).toBe(CommandGeneratorFixtures$ReventlessCore.CmdGenAggSpec.name);
+    });
+    globalThis.test("meta.msgId equals meta.correlationId", async () => {
+      let payload = CommandGeneratorFixtures$ReventlessCore.makeZeroParamPayload("agg-1", "Create");
+      let outcome = await Effect.runPromise(CommandGeneratorFixtures$ReventlessCore.TestGenerator.generateCommand(payload));
+      let publishedCmd = CommandGeneratorFixtures$ReventlessCore.capturedCmds.contents[0];
+      let msgId;
+      switch (outcome.TAG) {
+        case "Accepted" :
+        case "Rejected" :
+          msgId = "";
+          break;
+        case "Pending" :
+          msgId = outcome.msgId;
+          break;
+      }
+      globalThis.expect([
+        publishedCmd.meta.msgId,
+        publishedCmd.meta.correlationId
+      ]).toEqual([
+        msgId,
+        msgId
+      ]);
+    });
+  });
+  globalThis.describe("multi-param command", () => {
+    globalThis.test("publishJsons called with object commandJson {TAG, param}", async () => {
+      let payload = CommandGeneratorFixtures$ReventlessCore.makeOneParamPayload("agg-1", "CreateWithName", "name", "Widget");
+      await Effect.runPromise(CommandGeneratorFixtures$ReventlessCore.TestGenerator.generateCommand(payload));
+      let publishedCmd = CommandGeneratorFixtures$ReventlessCore.capturedCmds.contents[0];
+      let cmdObj = Stdlib_Option.getOrThrow(Stdlib_JSON.Decode.object(publishedCmd.commandJson), undefined);
+      globalThis.expect(cmdObj["TAG"]).toEqual("CreateWithName");
+      globalThis.expect(cmdObj["name"]).toEqual("Widget");
+    });
+  });
+  globalThis.describe("schema validation failure", () => {
+    globalThis.test("invalid command name throws an error", async () => {
+      let payload = CommandGeneratorFixtures$ReventlessCore.makeZeroParamPayload("agg-1", "NonExistentCommand");
+      let threw = false;
+      try {
+        await Effect.runPromise(CommandGeneratorFixtures$ReventlessCore.TestGenerator.generateCommand(payload));
+      } catch (exn) {
+        threw = true;
+      }
+      globalThis.expect(threw).toBe(true);
+    });
+  });
+  globalThis.describe("StateChangeSlice envelope id derivation", () => {
+    globalThis.test("single @partitionTag: id derived from tagged field when args have no id", async () => {
+      let payload = CommandGeneratorFixtures$ReventlessCore.makeSlicePayload("CreateItem", Object.fromEntries([
+        [
+          "itemId",
+          "item-42"
+        ],
+        [
+          "name",
+          "Widget"
+        ]
+      ]));
+      let outcome = await Effect.runPromise(CommandGeneratorFixtures$ReventlessCore.singleTagSliceGen(payload));
+      let publishedCmd = CommandGeneratorFixtures$ReventlessCore.capturedCmds.contents[0];
+      globalThis.expect(publishedCmd.id).toBe("item-42");
+      let msgId;
+      switch (outcome.TAG) {
+        case "Accepted" :
+        case "Rejected" :
+          msgId = "";
+          break;
+        case "Pending" :
+          msgId = outcome.msgId;
+          break;
+      }
+      globalThis.expect(msgId.length > 0).toBe(true);
+    });
+    globalThis.test("composite @compositePartitionTag: id is joined partition-key value", async () => {
+      let payload = CommandGeneratorFixtures$ReventlessCore.makeSlicePayload("DeployVersion", Object.fromEntries([
+        [
+          "environment",
+          "prod"
+        ],
+        [
+          "service",
+          "checkout"
+        ],
+        [
+          "version",
+          "1.2.3"
+        ]
+      ]));
+      await Effect.runPromise(CommandGeneratorFixtures$ReventlessCore.compositeTagSliceGen(payload));
+      let publishedCmd = CommandGeneratorFixtures$ReventlessCore.capturedCmds.contents[0];
+      globalThis.expect(publishedCmd.id).toBe("prod-checkout");
+    });
+    globalThis.test("explicit id in args wins over derivation (regression check)", async () => {
+      let payload = CommandGeneratorFixtures$ReventlessCore.makeSlicePayload("CreateItem", Object.fromEntries([
+        [
+          "id",
+          "explicit-id"
+        ],
+        [
+          "itemId",
+          "item-99"
+        ],
+        [
+          "name",
+          "Gadget"
+        ]
+      ]));
+      await Effect.runPromise(CommandGeneratorFixtures$ReventlessCore.singleTagSliceGen(payload));
+      let publishedCmd = CommandGeneratorFixtures$ReventlessCore.capturedCmds.contents[0];
+      globalThis.expect(publishedCmd.id).toBe("explicit-id");
+    });
+  });
+  globalThis.describe("Aggregate envelope id (regression)", () => {
+    globalThis.test("explicit id in args is preserved unchanged", async () => {
+      let payload = CommandGeneratorFixtures$ReventlessCore.makeZeroParamPayload("agg-7", "Create");
+      await Effect.runPromise(CommandGeneratorFixtures$ReventlessCore.TestGenerator.generateCommand(payload));
+      let publishedCmd = CommandGeneratorFixtures$ReventlessCore.capturedCmds.contents[0];
+      globalThis.expect(publishedCmd.id).toBe("agg-7");
+    });
+  });
+});
+
+/*  Not a pure module */

package/tests/commandgenerator/CommandGeneratorFixtures.res

@@ -0,0 +1,139 @@
+S.enableJson()
+
+// ─────────────────────────────────────────────────────────────
+// Aggregate spec for CommandGenerator tests
+// ─────────────────────────────────────────────────────────────
+
+module CmdGenAggSpec = {
+  module Id = Reventless.Id.StringPure
+  let name = "TestCmdGenAgg"
+
+  // Zero-param variant (serializes as plain string)
+  // Multi-param variant (serializes as {TAG, name} object)
+  @schema
+  type command =
+    | Create
+    | CreateWithName({name: string})
+    | Invalid  // used for schema validation tests
+
+  @schema
+  type event =
+    | Created
+    | CreatedWithName({name: string})
+
+  @schema
+  type error = | InvalidCommand
+
+  let moduleUrl: string = %raw(`import.meta.url`)
+}
+
+// ─────────────────────────────────────────────────────────────
+// Behavior
+// ─────────────────────────────────────────────────────────────
+
+module CmdGenBehavior = {
+  module Spec = CmdGenAggSpec
+  type state = unit
+
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  let initialState = ()
+
+  let evolve = (_state: state, _event: CmdGenAggSpec.event): state => ()
+
+  let decide = (_state: state, command: CmdGenAggSpec.command): result<array<CmdGenAggSpec.event>, CmdGenAggSpec.error> =>
+    switch command {
+    | Create => Ok([CmdGenAggSpec.Created])
+    | CreateWithName({name}) => Ok([CmdGenAggSpec.CreatedWithName({name: name})])
+    | Invalid => Ok([])
+    }
+}
+
+// ─────────────────────────────────────────────────────────────
+// Mock publishJsons — captures published commands
+// ─────────────────────────────────────────────────────────────
+
+let capturedCmds: ref<array<Message.commandJson>> = ref([])
+
+module MockPublishSpec: CommandGenerator_Callback.Spec = {
+  let publishJsons: CommandGenerator.publishJsons = async cmds => {
+    capturedCmds := capturedCmds.contents->Array.concat(cmds)
+  }
+  let publishJsonsAndWait: option<CommandTopic.publishJsonsAndWait> = None
+}
+
+// ─────────────────────────────────────────────────────────────
+// CommandGenerator handler under test
+// ─────────────────────────────────────────────────────────────
+
+module TestGenerator = CommandGenerator_Callback.Make(MockPublishSpec, CmdGenAggSpec)
+
+// ─────────────────────────────────────────────────────────────
+// DCB StateChangeSlice command schemas (for envelope-id derivation)
+// ─────────────────────────────────────────────────────────────
+
+@schema
+type singleTagCommand =
+  CreateItem({itemId: @s.matches(Reventless.DcbTag.string) string, name: string})
+
+@schema
+type compositeTagCommand =
+  | DeployVersion({
+      environment: @s.matches(Reventless.DcbTag.compositePartitionMember(~position=0, ~sep="-"))
+      string,
+      service: @s.matches(Reventless.DcbTag.compositePartitionMember(~position=1)) string,
+      version: string,
+    })
+
+let singleTagSliceGen = CommandGenerator_Callback.makeGenerateCommand(
+  ~publishJsons=MockPublishSpec.publishJsons,
+  ~serviceName="SingleTagSlice",
+  ~commandSchema=singleTagCommandSchema->S.castToUnknown,
+  ~componentKind=CommandGenerator_Callback.StateChangeSlice,
+  ~stripIdFromParams=false,
+)
+
+let compositeTagSliceGen = CommandGenerator_Callback.makeGenerateCommand(
+  ~publishJsons=MockPublishSpec.publishJsons,
+  ~serviceName="CompositeTagSlice",
+  ~commandSchema=compositeTagCommandSchema->S.castToUnknown,
+  ~componentKind=CommandGenerator_Callback.StateChangeSlice,
+  ~stripIdFromParams=false,
+)
+
+// Build a payload for a StateChangeSlice command — args must NOT include `id`.
+let makeSlicePayload = (~command, ~args: dict<JSON.t>): CommandGenerator.payload =>
+  Obj.magic({
+    "command": command,
+    "arguments": Obj.magic(args),
+    "meta": {"ip": ["127.0.0.1"], "user": "test-user", "info": ""},
+  })
+
+// ─────────────────────────────────────────────────────────────
+// Payload builders
+// ─────────────────────────────────────────────────────────────
+
+// Build a payload for a zero-param command
+let makeZeroParamPayload = (~id, ~command): CommandGenerator.payload =>
+  Obj.magic({
+    "command": command,
+    "arguments": {"id": id},
+    "meta": {"ip": ["127.0.0.1"], "user": "test-user", "info": ""},
+  })
+
+// Build a payload for a single extra-param command
+let makeOneParamPayload = (~id, ~command, ~paramName, ~paramValue): CommandGenerator.payload =>
+  Obj.magic({
+    "command": command,
+    "arguments": Obj.magic(
+      Dict.fromArray([
+        ("id", JSON.Encode.string(id)),
+        (paramName, JSON.Encode.string(paramValue)),
+      ]),
+    ),
+    "meta": {"ip": ["127.0.0.1"], "user": "test-user", "info": ""},
+  })
+
+let reset = () => {
+  capturedCmds := []
+}

package/tests/commandgenerator/CommandGeneratorFixtures.res.mjs

@@ -0,0 +1,197 @@
+// 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 DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as CommandGenerator_Callback$ReventlessCore from "../../src/components/CommandGenerator/CommandGenerator_Callback.res.mjs";
+
+S.enableJson();
+
+let name = "TestCmdGenAgg";
+
+let commandSchema = S.union([
+  S.literal("Create"),
+  S.schema(s => ({
+    TAG: "CreateWithName",
+    name: s.m(S.string)
+  })),
+  S.literal("Invalid")
+]);
+
+let eventSchema = S.union([
+  S.literal("Created"),
+  S.schema(s => ({
+    TAG: "CreatedWithName",
+    name: s.m(S.string)
+  }))
+]);
+
+let errorSchema = S.literal("InvalidCommand");
+
+let moduleUrl = import.meta.url;
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let CmdGenAggSpec = {
+  Id: undefined,
+  name: name,
+  commandSchema: commandSchema,
+  eventSchema: eventSchema,
+  errorSchema: errorSchema,
+  moduleUrl: moduleUrl,
+  commandAuthorization: commandAuthorization
+};
+
+let moduleUrl$1 = import.meta.url;
+
+function evolve(_state, _event) {
+  
+}
+
+function decide(_state, command) {
+  if (typeof command !== "object") {
+    if (command === "Create") {
+      return {
+        TAG: "Ok",
+        _0: ["Created"]
+      };
+    } else {
+      return {
+        TAG: "Ok",
+        _0: []
+      };
+    }
+  } else {
+    return {
+      TAG: "Ok",
+      _0: [{
+          TAG: "CreatedWithName",
+          name: command.name
+        }]
+    };
+  }
+}
+
+let CmdGenBehavior = {
+  Spec: undefined,
+  moduleUrl: moduleUrl$1,
+  initialState: undefined,
+  evolve: evolve,
+  decide: decide
+};
+
+let capturedCmds = {
+  contents: []
+};
+
+async function publishJsons(cmds) {
+  capturedCmds.contents = capturedCmds.contents.concat(cmds);
+}
+
+let MockPublishSpec = {
+  publishJsons: publishJsons,
+  publishJsonsAndWait: undefined
+};
+
+let TestGenerator = CommandGenerator_Callback$ReventlessCore.Make(MockPublishSpec)({
+  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
+});
+
+let singleTagCommandSchema = S.schema(s => ({
+  TAG: "CreateItem",
+  itemId: s.m(DcbTag$Reventless.string),
+  name: s.m(S.string)
+}));
+
+let compositeTagCommandSchema = S.schema(s => ({
+  TAG: "DeployVersion",
+  environment: s.m(DcbTag$Reventless.compositePartitionMember(0, "-")),
+  service: s.m(DcbTag$Reventless.compositePartitionMember(1, undefined)),
+  version: s.m(S.string)
+}));
+
+let singleTagSliceGen = CommandGenerator_Callback$ReventlessCore.makeGenerateCommand(publishJsons, undefined, "SingleTagSlice", singleTagCommandSchema, "StateChangeSlice", false);
+
+let compositeTagSliceGen = CommandGenerator_Callback$ReventlessCore.makeGenerateCommand(publishJsons, undefined, "CompositeTagSlice", compositeTagCommandSchema, "StateChangeSlice", false);
+
+function makeSlicePayload(command, args) {
+  return {
+    command: command,
+    arguments: args,
+    meta: {
+      ip: ["127.0.0.1"],
+      user: "test-user",
+      info: ""
+    }
+  };
+}
+
+function makeZeroParamPayload(id, command) {
+  return {
+    command: command,
+    arguments: {
+      id: id
+    },
+    meta: {
+      ip: ["127.0.0.1"],
+      user: "test-user",
+      info: ""
+    }
+  };
+}
+
+function makeOneParamPayload(id, command, paramName, paramValue) {
+  return {
+    command: command,
+    arguments: Object.fromEntries([
+      [
+        "id",
+        id
+      ],
+      [
+        paramName,
+        paramValue
+      ]
+    ]),
+    meta: {
+      ip: ["127.0.0.1"],
+      user: "test-user",
+      info: ""
+    }
+  };
+}
+
+function reset() {
+  capturedCmds.contents = [];
+}
+
+export {
+  CmdGenAggSpec,
+  CmdGenBehavior,
+  capturedCmds,
+  MockPublishSpec,
+  TestGenerator,
+  singleTagCommandSchema,
+  compositeTagCommandSchema,
+  singleTagSliceGen,
+  compositeTagSliceGen,
+  makeSlicePayload,
+  makeZeroParamPayload,
+  makeOneParamPayload,
+  reset,
+}
+/*  Not a pure module */