@reventlessdev/reventless-local 3.0.0-alpha.113

package/tests/components/inboundtranslationslice/InboundTranslationSliceCallbackTest.res

@@ -0,0 +1,241 @@
+// Unit tests for InboundTranslationSlice_Callback — tests receive function directly.
+
+open JestGlobals
+open InboundTranslationSliceFixtures
+
+module PaymentWebhookTranslation = {
+  let translate = PaymentWebhookSpec.translate
+  let moduleUrl = PaymentWebhookSpec.moduleUrl
+}
+module Callback = ReventlessCore.InboundTranslationSlice_Callback.Make(
+  PaymentWebhookSpec,
+  PaymentWebhookTranslation,
+)
+
+describe("InboundTranslationSlice Callback", () => {
+  let _ = beforeEach(() => {
+    Callback.auditLog->Dict.keysToArray->Array.forEach(k => Callback.auditLog->Dict.delete(k))
+  })
+
+  describe("receive", () => {
+    testPromise("valid input with completed status publishes command and returns Ok", async () => {
+      let publishedCommands = ref([])
+      let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
+        publishedCommands := cmds
+      }
+
+      let inputJson =
+        {
+          "paymentId": "pay-123",
+          "orderId": "ord-1",
+          "status": "completed",
+        }->Obj.magic
+
+      let result = await Callback.receive(mockPublish, inputJson)
+
+      switch result {
+      | Ok(targetIds) =>
+        expect(targetIds->Array.length)->toBe(1)
+        expect(targetIds->Array.getUnsafe(0))->toBe("ord-1")
+      | Error(_) => expect(true)->toBe(false)
+      }
+      expect(publishedCommands.contents->Array.length)->toBe(1)
+      let cmd = publishedCommands.contents->Array.getUnsafe(0)
+      expect(cmd.id)->toBe("ord-1")
+
+      // Audit log should have one entry
+      let auditEntries = Callback.auditLog->Dict.toArray
+      expect(auditEntries->Array.length)->toBe(1)
+      let (_, auditRow) = auditEntries->Array.getUnsafe(0)
+      expect(auditRow.status)->toBe(ReventlessCore.InboundTranslationSlice_Callback.Success)
+      expect(auditRow.commandCount)->toBe(Some(1))
+    })
+
+    testPromise("translate returns Error — no command published, audit logged", async () => {
+      let publishedCommands = ref([])
+      let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
+        publishedCommands := cmds
+      }
+
+      let inputJson =
+        {
+          "paymentId": "pay-123",
+          "orderId": "ord-1",
+          "status": "pending",
+        }->Obj.magic
+
+      let result = await Callback.receive(mockPublish, inputJson)
+
+      switch result {
+      | Error(msg) => expect(msg)->toBe("Unknown payment status: pending")
+      | Ok(_) => expect(true)->toBe(false)
+      }
+      expect(publishedCommands.contents->Array.length)->toBe(0)
+
+      let auditEntries = Callback.auditLog->Dict.toArray
+      expect(auditEntries->Array.length)->toBe(1)
+      let (_, auditRow) = auditEntries->Array.getUnsafe(0)
+      expect(auditRow.status)->toBe(ReventlessCore.InboundTranslationSlice_Callback.Failure)
+    })
+
+    testPromise("invalid JSON input returns Error and audit logged", async () => {
+      let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async _cmds => ()
+
+      // Missing required fields
+      let inputJson = {"unexpected": "data"}->Obj.magic
+
+      let result = await Callback.receive(mockPublish, inputJson)
+
+      switch result {
+      | Error(_) => expect(true)->toBe(true)
+      | Ok(_) => expect(true)->toBe(false)
+      }
+
+      let auditEntries = Callback.auditLog->Dict.toArray
+      expect(auditEntries->Array.length)->toBe(1)
+      let (_, auditRow) = auditEntries->Array.getUnsafe(0)
+      expect(auditRow.status)->toBe(ReventlessCore.InboundTranslationSlice_Callback.Failure)
+    })
+
+    testPromise("publishJsons failure returns Error and audit logged", async () => {
+      let failingPublish: ReventlessInfra.CommandTopic.publishJsons = async _cmds => {
+        JsError.throwWithMessage("publish failed")
+      }
+
+      let inputJson =
+        {
+          "paymentId": "pay-123",
+          "orderId": "ord-1",
+          "status": "completed",
+        }->Obj.magic
+
+      let result = await Callback.receive(failingPublish, inputJson)
+
+      switch result {
+      | Error(msg) => expect(msg)->toBe("publish failed")
+      | Ok(_) => expect(true)->toBe(false)
+      }
+
+      let auditEntries = Callback.auditLog->Dict.toArray
+      expect(auditEntries->Array.length)->toBe(1)
+      let (_, auditRow) = auditEntries->Array.getUnsafe(0)
+      expect(auditRow.status)->toBe(ReventlessCore.InboundTranslationSlice_Callback.Failure)
+    })
+  })
+
+  describe("multi-command", () => {
+    testPromise("translate returning multiple pairs publishes all commands", async () => {
+      // Use a spec that returns multiple commands
+      module MultiSpec = {
+        let name = "BatchWebhook"
+        let moduleUrl: string = %raw(`import.meta.url`)
+
+        @schema
+        type externalInput = {orderId: string, items: array<string>}
+
+        @schema
+        type command = ConfirmPayment({
+          orderId: @s.matches(Reventless.DcbTag.string) string,
+          paymentId: string,
+        })
+
+        let targetName = "ConfirmPayment"
+
+        let translate = (input: externalInput) =>
+          Ok(
+            input.items->Array.map(item => (
+              input.orderId,
+              ConfirmPayment({orderId: input.orderId, paymentId: item}),
+            )),
+          )
+
+        let commandAuthorization = (_: command): Reventless.Authorization.permission =>
+          AllowAuthenticated
+      }
+
+      module MultiTranslation = {
+        let translate = MultiSpec.translate
+        let moduleUrl = MultiSpec.moduleUrl
+      }
+      module MultiCallback = ReventlessCore.InboundTranslationSlice_Callback.Make(
+        MultiSpec,
+        MultiTranslation,
+      )
+
+      let publishedCommands = ref([])
+      let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
+        publishedCommands := cmds
+      }
+
+      let inputJson =
+        {
+          "orderId": "ord-1",
+          "items": ["pay-1", "pay-2", "pay-3"],
+        }->Obj.magic
+
+      let result = await MultiCallback.receive(mockPublish, inputJson)
+
+      switch result {
+      | Ok(targetIds) =>
+        expect(targetIds->Array.length)->toBe(3)
+        expect(targetIds->Array.getUnsafe(0))->toBe("ord-1")
+      | Error(_) => expect(true)->toBe(false)
+      }
+      // All 3 commands published in one batch
+      expect(publishedCommands.contents->Array.length)->toBe(3)
+
+      let auditEntries = MultiCallback.auditLog->Dict.toArray
+      expect(auditEntries->Array.length)->toBe(1)
+      let (_, auditRow) = auditEntries->Array.getUnsafe(0)
+      expect(auditRow.status)->toBe(ReventlessCore.InboundTranslationSlice_Callback.Success)
+      expect(auditRow.commandCount)->toBe(Some(3))
+    })
+
+    testPromise("translate returning empty array publishes nothing", async () => {
+      module EmptySpec = {
+        let name = "EmptyWebhook"
+        let moduleUrl: string = %raw(`import.meta.url`)
+
+        @schema
+        type externalInput = {orderId: string}
+
+        @schema
+        type command = ConfirmPayment({
+          orderId: @s.matches(Reventless.DcbTag.string) string,
+          paymentId: string,
+        })
+
+        let targetName = "ConfirmPayment"
+
+        let translate = (_input: externalInput) => Ok([])
+
+        let commandAuthorization = (_: command): Reventless.Authorization.permission =>
+          AllowAuthenticated
+      }
+
+      module EmptyTranslation = {
+        let translate = EmptySpec.translate
+        let moduleUrl = EmptySpec.moduleUrl
+      }
+      module EmptyCallback = ReventlessCore.InboundTranslationSlice_Callback.Make(
+        EmptySpec,
+        EmptyTranslation,
+      )
+
+      let publishedCommands = ref([])
+      let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
+        publishedCommands := cmds
+      }
+
+      let inputJson = {"orderId": "ord-1"}->Obj.magic
+
+      let result = await EmptyCallback.receive(mockPublish, inputJson)
+
+      switch result {
+      | Ok(targetIds) => expect(targetIds->Array.length)->toBe(0)
+      | Error(_) => expect(true)->toBe(false)
+      }
+      expect(publishedCommands.contents->Array.length)->toBe(0)
+    })
+  })
+})

package/tests/components/inboundtranslationslice/InboundTranslationSliceCallbackTest.res.mjs

@@ -0,0 +1,239 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as InboundTranslationSliceFixtures$ReventlessLocal from "./InboundTranslationSliceFixtures.res.mjs";
+import * as InboundTranslationSlice_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/InboundTranslationSlice/InboundTranslationSlice_Callback.res.mjs";
+
+let translate = InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.translate;
+
+let moduleUrl = InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.moduleUrl;
+
+let PaymentWebhookTranslation = {
+  translate: translate,
+  moduleUrl: moduleUrl
+};
+
+let Callback = InboundTranslationSlice_Callback$ReventlessCore.Make({
+  name: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.name,
+  moduleUrl: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.moduleUrl,
+  externalInputSchema: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.externalInputSchema,
+  commandSchema: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.commandSchema,
+  targetName: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.targetName,
+  commandAuthorization: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.commandAuthorization
+})(PaymentWebhookTranslation);
+
+globalThis.describe("InboundTranslationSlice Callback", () => {
+  globalThis.beforeEach(() => {
+    Object.keys(Callback.auditLog).forEach(k => Stdlib_Dict.$$delete(Callback.auditLog, k));
+  });
+  globalThis.describe("receive", () => {
+    globalThis.test("valid input with completed status publishes command and returns Ok", async () => {
+      let publishedCommands = {
+        contents: []
+      };
+      let mockPublish = async cmds => {
+        publishedCommands.contents = cmds;
+      };
+      let inputJson = {
+        paymentId: "pay-123",
+        orderId: "ord-1",
+        status: "completed"
+      };
+      let result = await Callback.receive(mockPublish, inputJson);
+      if (result.TAG === "Ok") {
+        let targetIds = result._0;
+        globalThis.expect(targetIds.length).toBe(1);
+        globalThis.expect(targetIds[0]).toBe("ord-1");
+      } else {
+        globalThis.expect(true).toBe(false);
+      }
+      globalThis.expect(publishedCommands.contents.length).toBe(1);
+      let cmd = publishedCommands.contents[0];
+      globalThis.expect(cmd.id).toBe("ord-1");
+      let auditEntries = Object.entries(Callback.auditLog);
+      globalThis.expect(auditEntries.length).toBe(1);
+      let match = auditEntries[0];
+      let auditRow = match[1];
+      globalThis.expect(auditRow.status).toBe("Success");
+      globalThis.expect(auditRow.commandCount).toBe(1);
+    });
+    globalThis.test("translate returns Error — no command published, audit logged", async () => {
+      let publishedCommands = {
+        contents: []
+      };
+      let mockPublish = async cmds => {
+        publishedCommands.contents = cmds;
+      };
+      let inputJson = {
+        paymentId: "pay-123",
+        orderId: "ord-1",
+        status: "pending"
+      };
+      let result = await Callback.receive(mockPublish, inputJson);
+      if (result.TAG === "Ok") {
+        globalThis.expect(true).toBe(false);
+      } else {
+        globalThis.expect(result._0).toBe("Unknown payment status: pending");
+      }
+      globalThis.expect(publishedCommands.contents.length).toBe(0);
+      let auditEntries = Object.entries(Callback.auditLog);
+      globalThis.expect(auditEntries.length).toBe(1);
+      let match = auditEntries[0];
+      globalThis.expect(match[1].status).toBe("Failure");
+    });
+    globalThis.test("invalid JSON input returns Error and audit logged", async () => {
+      let mockPublish = async _cmds => {};
+      let inputJson = {
+        unexpected: "data"
+      };
+      let result = await Callback.receive(mockPublish, inputJson);
+      if (result.TAG === "Ok") {
+        globalThis.expect(true).toBe(false);
+      } else {
+        globalThis.expect(true).toBe(true);
+      }
+      let auditEntries = Object.entries(Callback.auditLog);
+      globalThis.expect(auditEntries.length).toBe(1);
+      let match = auditEntries[0];
+      globalThis.expect(match[1].status).toBe("Failure");
+    });
+    globalThis.test("publishJsons failure returns Error and audit logged", async () => {
+      let failingPublish = async _cmds => Stdlib_JsError.throwWithMessage("publish failed");
+      let inputJson = {
+        paymentId: "pay-123",
+        orderId: "ord-1",
+        status: "completed"
+      };
+      let result = await Callback.receive(failingPublish, inputJson);
+      if (result.TAG === "Ok") {
+        globalThis.expect(true).toBe(false);
+      } else {
+        globalThis.expect(result._0).toBe("publish failed");
+      }
+      let auditEntries = Object.entries(Callback.auditLog);
+      globalThis.expect(auditEntries.length).toBe(1);
+      let match = auditEntries[0];
+      globalThis.expect(match[1].status).toBe("Failure");
+    });
+  });
+  globalThis.describe("multi-command", () => {
+    globalThis.test("translate returning multiple pairs publishes all commands", async () => {
+      let moduleUrl = import.meta.url;
+      let externalInputSchema = S.schema(s => ({
+        orderId: s.m(S.string),
+        items: s.m(S.array(S.string))
+      }));
+      let commandSchema = S.schema(s => ({
+        TAG: "ConfirmPayment",
+        orderId: s.m(DcbTag$Reventless.string),
+        paymentId: s.m(S.string)
+      }));
+      let translate = input => ({
+        TAG: "Ok",
+        _0: input.items.map(item => [
+          input.orderId,
+          {
+            TAG: "ConfirmPayment",
+            orderId: input.orderId,
+            paymentId: item
+          }
+        ])
+      });
+      let commandAuthorization = param => "AllowAuthenticated";
+      let MultiTranslation = {
+        translate: translate,
+        moduleUrl: moduleUrl
+      };
+      let MultiCallback = InboundTranslationSlice_Callback$ReventlessCore.Make({
+        name: "BatchWebhook",
+        moduleUrl: moduleUrl,
+        externalInputSchema: externalInputSchema,
+        commandSchema: commandSchema,
+        targetName: "ConfirmPayment",
+        commandAuthorization: commandAuthorization
+      })(MultiTranslation);
+      let publishedCommands = {
+        contents: []
+      };
+      let mockPublish = async cmds => {
+        publishedCommands.contents = cmds;
+      };
+      let inputJson = {
+        orderId: "ord-1",
+        items: [
+          "pay-1",
+          "pay-2",
+          "pay-3"
+        ]
+      };
+      let result = await MultiCallback.receive(mockPublish, inputJson);
+      if (result.TAG === "Ok") {
+        let targetIds = result._0;
+        globalThis.expect(targetIds.length).toBe(3);
+        globalThis.expect(targetIds[0]).toBe("ord-1");
+      } else {
+        globalThis.expect(true).toBe(false);
+      }
+      globalThis.expect(publishedCommands.contents.length).toBe(3);
+      let auditEntries = Object.entries(MultiCallback.auditLog);
+      globalThis.expect(auditEntries.length).toBe(1);
+      let match = auditEntries[0];
+      let auditRow = match[1];
+      globalThis.expect(auditRow.status).toBe("Success");
+      globalThis.expect(auditRow.commandCount).toBe(3);
+    });
+    globalThis.test("translate returning empty array publishes nothing", async () => {
+      let moduleUrl = import.meta.url;
+      let externalInputSchema = S.schema(s => ({
+        orderId: s.m(S.string)
+      }));
+      let commandSchema = S.schema(s => ({
+        TAG: "ConfirmPayment",
+        orderId: s.m(DcbTag$Reventless.string),
+        paymentId: s.m(S.string)
+      }));
+      let translate = _input => ({
+        TAG: "Ok",
+        _0: []
+      });
+      let commandAuthorization = param => "AllowAuthenticated";
+      let EmptyTranslation = {
+        translate: translate,
+        moduleUrl: moduleUrl
+      };
+      let EmptyCallback = InboundTranslationSlice_Callback$ReventlessCore.Make({
+        name: "EmptyWebhook",
+        moduleUrl: moduleUrl,
+        externalInputSchema: externalInputSchema,
+        commandSchema: commandSchema,
+        targetName: "ConfirmPayment",
+        commandAuthorization: commandAuthorization
+      })(EmptyTranslation);
+      let publishedCommands = {
+        contents: []
+      };
+      let mockPublish = async cmds => {
+        publishedCommands.contents = cmds;
+      };
+      let inputJson = {
+        orderId: "ord-1"
+      };
+      let result = await EmptyCallback.receive(mockPublish, inputJson);
+      if (result.TAG === "Ok") {
+        globalThis.expect(result._0.length).toBe(0);
+      } else {
+        globalThis.expect(true).toBe(false);
+      }
+      globalThis.expect(publishedCommands.contents.length).toBe(0);
+    });
+  });
+});
+
+export {
+  PaymentWebhookTranslation,
+  Callback,
+}
+/* Callback Not a pure module */

package/tests/components/inboundtranslationslice/InboundTranslationSliceFixtures.res

@@ -0,0 +1,36 @@
+// Test fixtures for InboundTranslationSlice callback tests.
+
+// ─────────────────────────────────────────────────────────────
+// Minimal DcbEventLog spec
+// ─────────────────────────────────────────────────────────────
+
+module OrderEventLog = {
+  let moduleUrl: string = %raw(`import.meta.url`)
+  @schema
+  type event =
+    | PaymentConfirmed({orderId: @s.matches(Reventless.DcbTag.string) string, paymentId: string})
+}
+
+// ─────────────────────────────────────────────────────────────
+// InboundTranslationSlice spec — payment webhook
+// ─────────────────────────────────────────────────────────────
+
+module PaymentWebhookSpec = {
+  let name = "PaymentWebhook"
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  @schema
+  type externalInput = {paymentId: string, orderId: string, status: string}
+
+  @schema
+  type command = ConfirmPayment({orderId: @s.matches(Reventless.DcbTag.string) string, paymentId: string})
+
+  let targetName = "ConfirmPayment"
+
+  let translate = (input: externalInput) =>
+    switch input.status {
+    | "completed" =>
+      Ok([(input.orderId, ConfirmPayment({orderId: input.orderId, paymentId: input.paymentId}))])
+    | status => Error("Unknown payment status: " ++ status)
+    }
+}

package/tests/components/inboundtranslationslice/InboundTranslationSliceFixtures.res.mjs

@@ -0,0 +1,73 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+
+let moduleUrl = import.meta.url;
+
+let eventSchema = S.schema(s => ({
+  TAG: "PaymentConfirmed",
+  orderId: s.m(DcbTag$Reventless.string),
+  paymentId: s.m(S.string)
+}));
+
+let OrderEventLog = {
+  moduleUrl: moduleUrl,
+  eventSchema: eventSchema
+};
+
+let moduleUrl$1 = import.meta.url;
+
+let externalInputSchema = S.schema(s => ({
+  paymentId: s.m(S.string),
+  orderId: s.m(S.string),
+  status: s.m(S.string)
+}));
+
+let commandSchema = S.schema(s => ({
+  TAG: "ConfirmPayment",
+  orderId: s.m(DcbTag$Reventless.string),
+  paymentId: s.m(S.string)
+}));
+
+function translate(input) {
+  let status = input.status;
+  if (status === "completed") {
+    return {
+      TAG: "Ok",
+      _0: [[
+          input.orderId,
+          {
+            TAG: "ConfirmPayment",
+            orderId: input.orderId,
+            paymentId: input.paymentId
+          }
+        ]]
+    };
+  } else {
+    return {
+      TAG: "Error",
+      _0: "Unknown payment status: " + status
+    };
+  }
+}
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let PaymentWebhookSpec = {
+  name: "PaymentWebhook",
+  moduleUrl: moduleUrl$1,
+  externalInputSchema: externalInputSchema,
+  commandSchema: commandSchema,
+  targetName: "ConfirmPayment",
+  translate: translate,
+  commandAuthorization: commandAuthorization
+};
+
+export {
+  OrderEventLog,
+  PaymentWebhookSpec,
+}
+/* moduleUrl Not a pure module */