@reventlessdev/reventless-local 3.0.0-alpha.167 → 3.0.0-alpha.169

package/tests/components/outboundtranslationslice/OutboundTranslationSlicePlatformFixtures.res

@@ -0,0 +1,215 @@
+// Platform-level fixtures for OutboundTranslationSlice.
+//
+// The sibling callback test calls phase1/phase2 directly and passes even when
+// the component is never reached by an event — it cannot observe wiring. This
+// fixture builds the real thing: a DcbEventLog, a StateChangeSlice that appends
+// to it, and an OutboundTranslationSlice subscribed to that log's event topic.
+// A command published through `publishJsons` is the only input; the assertions
+// read the TODO QueryDb and the recorded external calls.
+//
+// Wiring summary:
+//   DcbEventLog "TestLog" — publishes events to TestLogDcbEventLogEventTopic
+//   StateChangeSlice "Place" — Place command → Placed event
+//   OutboundTranslationSlice "SendConfirm" — Placed event → external call
+
+open TestFixtures
+open Reventless
+
+// ─────────────────────────────────────────────────────────────
+// Place StateChangeSlice
+// ─────────────────────────────────────────────────────────────
+
+module PlaceSpec = {
+  let name = "Place"
+  module Id = Reventless.Id.String
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  @schema
+  type event = Placed({
+    orderId: @s.matches(Reventless.DcbTag.string) string,
+    customerId: string,
+  })
+
+  @schema
+  type consumedEvent = Placed
+
+  @schema
+  type command = Place({
+    orderId: @s.matches(Reventless.DcbTag.string) string,
+    customerId: string,
+  })
+
+  @schema
+  type error = AlreadyPlaced
+
+  let commandSchema = commandSchema
+}
+
+module PlaceBehavior = {
+  module Spec = PlaceSpec
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  type state = bool
+  let initialState = false
+  let evolve = (_state: state, _event: Spec.consumedEvent) => true
+  let decide = (state: state, command: Spec.command): result<array<Spec.event>, Spec.error> =>
+    if state {
+      Error(AlreadyPlaced)
+    } else {
+      switch command {
+      | Place({orderId, customerId}) => Ok([Spec.Placed({orderId, customerId})])
+      }
+    }
+}
+
+// ─────────────────────────────────────────────────────────────
+// OutboundTranslationSlice — consumes Placed, fire-and-forget
+//
+// `consumedEvent` deliberately declares a strict subset of the appended event's
+// fields (no customerId beyond the two it needs is added, but the stored event
+// carries fields this slice ignores) — the same shape the hybrid example uses.
+// ─────────────────────────────────────────────────────────────
+
+module SendConfirmSpec = {
+  let name = "SendConfirm"
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  @schema
+  type consumedEvent = Placed({orderId: string})
+
+  @schema
+  type outboundItem = {orderId: string}
+
+  @schema
+  type inboundCommand = unit
+
+  let maxRetries = 3
+  let heartbeatInterval = 60
+  let targetName = None
+  let externalSystem = Some("EmailService")
+}
+
+// Two separate records so a failure says which phase stalled: `collectCalls`
+// empty means the event never reached phase 1 at all, while `collectCalls`
+// populated with `externalCalls` empty isolates the fault to phase 2.
+let collectCalls: array<string> = []
+let externalCalls: array<string> = []
+
+module SendConfirmTranslation: OutboundTranslationSlice.Translation
+  with module Spec := SendConfirmSpec = {
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  let collect = (event: SendConfirmSpec.consumedEvent) =>
+    switch event {
+    | Placed({orderId}) =>
+      collectCalls->Array.push(orderId)
+      [(orderId, ({orderId: orderId}: SendConfirmSpec.outboundItem))]
+    }
+
+  let translate = async (_id, item: SendConfirmSpec.outboundItem) => {
+    externalCalls->Array.push(item.orderId)
+    Ok(None)
+  }
+}
+
+// ─────────────────────────────────────────────────────────────
+// Bus + Pulumi mock setup
+// ─────────────────────────────────────────────────────────────
+
+module Bus = LocalBus.Make()
+let _ = TestRunner.setup()
+
+module DcbLogMaker = DcbEventLog_Builder.Make(Bus)
+let dcbEventLog = DcbLogMaker.make(
+  ~name="TestLog",
+  ~partitionTag=Reventless.DcbTag.Simple({key: "orderId"}),
+)
+
+// ─────────────────────────────────────────────────────────────
+// publishJsons routes by TAG through the global handler registry.
+// (Same shape AutomationSliceSelfDeadlockFixtures uses — substitutes for a real
+// CommandTopic without the runtime wiring overhead.)
+// ─────────────────────────────────────────────────────────────
+
+let publishJsons: ReventlessInfra.CommandTopic.publishJsons = async cmdJsons => {
+  let _ =
+    await cmdJsons
+    ->Array.map(async cmdJson => {
+      let typeName = switch cmdJson.commandJson {
+      | JSON.Object(dict) =>
+        dict
+        ->Dict.get("TAG")
+        ->Option.flatMap(j =>
+          switch j {
+          | JSON.String(s) => Some(s)
+          | _ => None
+          }
+        )
+        ->Option.getOr("")
+      | _ => ""
+      }
+      let fullBody = JSON.Encode.object(
+        Dict.fromArray([
+          ("id", JSON.Encode.string(cmdJson.id)),
+          ("meta", cmdJson.meta->S.reverseConvertToJsonOrThrow(Reventless.Message.metaSchema)),
+          ("command", cmdJson.commandJson),
+        ]),
+      )
+      let handlers = ReventlessCore.CommandTopic.getHandlers(typeName)
+      let _ =
+        await handlers
+        ->Array.map(async entry => {
+          let item: ReventlessInfra.CommandTopic.topicItem<JSON.t> = {
+            reference: cmdJson.id,
+            command: fullBody,
+          }
+          let _ = await entry.handler(Stream.fromIterable([item]))->Effect.runPromise
+        })
+        ->Promise.all
+    })
+    ->Promise.all
+}
+
+let publishJsonsOutput = publishJsons->Pulumi.Output.make
+
+// ─────────────────────────────────────────────────────────────
+// Wire the StateChangeSlice + the OutboundTranslationSlice
+// ─────────────────────────────────────────────────────────────
+
+module PlaceMaker = StateChangeSlice_Builder.Make(PlaceSpec, PlaceBehavior)
+let _placeSlice = PlaceMaker.make(~dcbEventLog, ~publishJsons=publishJsonsOutput)
+
+let dcbTopicOutputs: ReventlessInfra.EventTopic.outputs = (
+  dcbEventLog->ReventlessInfra.Component.outputs
+).eventTopic
+
+module OutboundMaker = OutboundTranslationSlice_Builder.Make(Bus)
+module SendConfirm = OutboundMaker.Make(SendConfirmSpec, SendConfirmTranslation)
+let sendConfirmSlice = SendConfirm.make(~dcbEventLog, ~publishJsons=publishJsonsOutput)
+
+// ─────────────────────────────────────────────────────────────
+// Test helpers
+// ─────────────────────────────────────────────────────────────
+
+let placeCmdJson = (orderId: string): Reventless.Message.commandJson => {
+  id: orderId,
+  meta: testMeta,
+  commandJson: PlaceSpec.Place({orderId, customerId: "cust-" ++ orderId})
+    ->S.reverseConvertToJsonOrThrow(PlaceSpec.commandSchema),
+}
+
+let readEventTypes = async (orderId: string) => {
+  let logOps = await dcbEventLog->DcbLogMaker.operations->TestRunner.resolve
+  let result = await logOps.read(
+    ~query=[{tags: [{Reventless.DcbTag.key: "orderId", value: orderId}]}],
+  )
+  result.events->Array.map(e => e.eventType)
+}
+
+// Drains pending microtasks so detached work (phase 2, QueryDb sync) settles.
+let flush = async () => {
+  let _ = await Promise.resolve()
+  let _ = await Promise.resolve()
+  let _ = await Promise.resolve()
+  let _ = await Promise.resolve()
+}

package/tests/components/outboundtranslationslice/OutboundTranslationSlicePlatformFixtures.res.mjs

@@ -0,0 +1,273 @@
+// 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 Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as Pulumi from "@pulumi/pulumi";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Message$Reventless from "@reventlessdev/reventless-spec/src/types/Message.res.mjs";
+import * as LocalBus$ReventlessLocal from "../../../src/adapter/LocalBus.res.mjs";
+import * as Component$ReventlessInfra from "@reventlessdev/reventless-infra/src/components/Component.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../../src/test/TestRunner.res.mjs";
+import * as CommandTopic$ReventlessCore from "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic.res.mjs";
+import * as TestFixtures$ReventlessLocal from "../../TestFixtures.res.mjs";
+import * as DcbEventLog_Builder$ReventlessLocal from "../../../src/components/DcbEventLog_Builder.res.mjs";
+import * as StateChangeSlice_Builder$ReventlessLocal from "../../../src/components/StateChangeSlice_Builder.res.mjs";
+import * as OutboundTranslationSlice_Builder$ReventlessLocal from "../../../src/components/OutboundTranslationSlice_Builder.res.mjs";
+
+let name = "Place";
+
+let moduleUrl = import.meta.url;
+
+let eventSchema = S.schema(s => ({
+  TAG: "Placed",
+  orderId: s.m(DcbTag$Reventless.string),
+  customerId: s.m(S.string)
+}));
+
+let consumedEventSchema = S.literal("Placed");
+
+let commandSchema = S.schema(s => ({
+  TAG: "Place",
+  orderId: s.m(DcbTag$Reventless.string),
+  customerId: s.m(S.string)
+}));
+
+let errorSchema = S.literal("AlreadyPlaced");
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let PlaceSpec = {
+  name: name,
+  Id: undefined,
+  moduleUrl: moduleUrl,
+  eventSchema: eventSchema,
+  consumedEventSchema: consumedEventSchema,
+  errorSchema: errorSchema,
+  commandSchema: commandSchema,
+  commandAuthorization: commandAuthorization,
+  readConsistency: "EscalateOnRetry"
+};
+
+let moduleUrl$1 = import.meta.url;
+
+function evolve(_state, _event) {
+  return true;
+}
+
+function decide(state, command) {
+  if (state) {
+    return {
+      TAG: "Error",
+      _0: "AlreadyPlaced"
+    };
+  } else {
+    return {
+      TAG: "Ok",
+      _0: [{
+          TAG: "Placed",
+          orderId: command.orderId,
+          customerId: command.customerId
+        }]
+    };
+  }
+}
+
+let PlaceBehavior = {
+  Spec: undefined,
+  moduleUrl: moduleUrl$1,
+  initialState: false,
+  evolve: evolve,
+  decide: decide
+};
+
+let moduleUrl$2 = import.meta.url;
+
+let consumedEventSchema$1 = S.schema(s => ({
+  TAG: "Placed",
+  orderId: s.m(S.string)
+}));
+
+let outboundItemSchema = S.schema(s => ({
+  orderId: s.m(S.string)
+}));
+
+let SendConfirmSpec_externalSystem = "EmailService";
+
+let SendConfirmSpec = {
+  name: "SendConfirm",
+  moduleUrl: moduleUrl$2,
+  consumedEventSchema: consumedEventSchema$1,
+  outboundItemSchema: outboundItemSchema,
+  inboundCommandSchema: S.unit,
+  maxRetries: 3,
+  heartbeatInterval: 60,
+  targetName: undefined,
+  externalSystem: SendConfirmSpec_externalSystem
+};
+
+let collectCalls = [];
+
+let externalCalls = [];
+
+let moduleUrl$3 = import.meta.url;
+
+function collect(event) {
+  let orderId = event.orderId;
+  collectCalls.push(orderId);
+  return [[
+      orderId,
+      {
+        orderId: orderId
+      }
+    ]];
+}
+
+async function translate(_id, item) {
+  externalCalls.push(item.orderId);
+  return {
+    TAG: "Ok",
+    _0: undefined
+  };
+}
+
+let SendConfirmTranslation = {
+  collect: collect,
+  translate: translate,
+  moduleUrl: moduleUrl$3
+};
+
+let Bus = LocalBus$ReventlessLocal.Make({});
+
+TestRunner$ReventlessLocal.setup();
+
+let DcbLogMaker = DcbEventLog_Builder$ReventlessLocal.Make(Bus);
+
+let dcbEventLog = DcbLogMaker.make("TestLog", undefined, {
+  TAG: "Simple",
+  _0: {
+    key: "orderId"
+  }
+}, undefined);
+
+async function publishJsons(cmdJsons) {
+  await Promise.all(cmdJsons.map(async cmdJson => {
+    let dict = cmdJson.commandJson;
+    let typeName;
+    typeName = typeof dict === "object" && dict !== null && !Array.isArray(dict) ? Stdlib_Option.getOr(Stdlib_Option.flatMap(dict["TAG"], j => {
+        if (typeof j === "string") {
+          return j;
+        }
+      }), "") : "";
+    let fullBody = Object.fromEntries([
+      [
+        "id",
+        cmdJson.id
+      ],
+      [
+        "meta",
+        S.reverseConvertToJsonOrThrow(cmdJson.meta, Message$Reventless.metaSchema)
+      ],
+      [
+        "command",
+        cmdJson.commandJson
+      ]
+    ]);
+    let handlers = CommandTopic$ReventlessCore.getHandlers(typeName);
+    await Promise.all(handlers.map(async entry => {
+      let item_reference = cmdJson.id;
+      let item = {
+        command: fullBody,
+        reference: item_reference
+      };
+      await Effect.runPromise(entry.handler(Stream.fromIterable([item])));
+    }));
+  }));
+}
+
+let publishJsonsOutput = Pulumi.output(publishJsons);
+
+let PlaceMaker = StateChangeSlice_Builder$ReventlessLocal.Make({
+  name: name,
+  moduleUrl: moduleUrl,
+  Id: Id$Reventless.$$String,
+  consumedEventSchema: consumedEventSchema,
+  errorSchema: errorSchema,
+  eventSchema: eventSchema,
+  commandSchema: commandSchema,
+  commandAuthorization: commandAuthorization,
+  readConsistency: "EscalateOnRetry"
+})({
+  initialState: false,
+  evolve: evolve,
+  decide: decide,
+  moduleUrl: moduleUrl$1
+});
+
+let _placeSlice = PlaceMaker.make(dcbEventLog, publishJsonsOutput, undefined, undefined, undefined, undefined);
+
+let dcbTopicOutputs = Component$ReventlessInfra.outputs(dcbEventLog).eventTopic;
+
+let OutboundMaker = OutboundTranslationSlice_Builder$ReventlessLocal.Make(Bus);
+
+let SendConfirm = OutboundMaker.Make(SendConfirmSpec)(SendConfirmTranslation);
+
+let sendConfirmSlice = SendConfirm.make(dcbEventLog, publishJsonsOutput, undefined, undefined);
+
+function placeCmdJson(orderId) {
+  return {
+    id: orderId,
+    meta: TestFixtures$ReventlessLocal.testMeta,
+    commandJson: S.reverseConvertToJsonOrThrow({
+      TAG: "Place",
+      orderId: orderId,
+      customerId: "cust-" + orderId
+    }, commandSchema)
+  };
+}
+
+async function readEventTypes(orderId) {
+  let logOps = await TestRunner$ReventlessLocal.resolve(DcbLogMaker.operations(dcbEventLog));
+  let result = await logOps.read([{
+      tags: [{
+          key: "orderId",
+          value: orderId
+        }]
+    }], undefined);
+  return result.events.map(e => e.eventType);
+}
+
+async function flush() {
+  await Promise.resolve();
+  await Promise.resolve();
+  await Promise.resolve();
+  await Promise.resolve();
+}
+
+export {
+  PlaceSpec,
+  PlaceBehavior,
+  SendConfirmSpec,
+  collectCalls,
+  externalCalls,
+  SendConfirmTranslation,
+  Bus,
+  DcbLogMaker,
+  dcbEventLog,
+  publishJsons,
+  publishJsonsOutput,
+  PlaceMaker,
+  _placeSlice,
+  dcbTopicOutputs,
+  OutboundMaker,
+  SendConfirm,
+  sendConfirmSlice,
+  placeCmdJson,
+  readEventTypes,
+  flush,
+}
+/* moduleUrl Not a pure module */

package/tests/components/outboundtranslationslice/OutboundTranslationSlicePlatformTest.res

@@ -0,0 +1,38 @@
+// Platform-level regression test for OutboundTranslationSlice wiring.
+//
+// The callback test next door exercises phase1/phase2 directly and stays green
+// while the component never receives an event. This one publishes a command
+// through the real chain — StateChangeSlice → DcbEventLog → event topic →
+// EventCollector → phase 1 → phase 2 — and asserts the external call lands.
+
+open JestGlobals
+open OutboundTranslationSlicePlatformFixtures
+
+describe("OutboundTranslationSlice platform wiring:", () => {
+  let _ = beforeAllAsync(async () => {
+    let _ = await dcbEventLog->DcbLogMaker.operations->TestRunner.resolve
+    let _ = await sendConfirmSlice->SendConfirm.operations->TestRunner.resolve
+    // LocalEventCollectorChannel.connect registers the bus subscription inside a
+    // fire-and-forget Effect.runPromise; flush so it is in place before publishing.
+    let _ = await flush()
+    let resource = dcbTopicOutputs.resources->Array.getUnsafe(0)
+    let _ = await resource.name->TestRunner.resolve
+  })
+
+  testPromise("Place → Placed reaches phase 1 collect", async () => {
+    let _ = await publishJsons([placeCmdJson("order-1")])
+    let _ = await flush()
+
+    let eventTypes = await readEventTypes("order-1")
+    expect(eventTypes->Array.includes("Placed"))->toBe(true)
+
+    expect(collectCalls->Array.includes("order-1"))->toBe(true)
+  })
+
+  testPromise("phase 2 translates the collected item without the heartbeat", async () => {
+    let _ = await publishJsons([placeCmdJson("order-2")])
+    let _ = await flush()
+
+    expect(externalCalls->Array.includes("order-2"))->toBe(true)
+  })
+})

package/tests/components/outboundtranslationslice/OutboundTranslationSlicePlatformTest.res.mjs

@@ -0,0 +1,28 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as TestRunner$ReventlessLocal from "../../../src/test/TestRunner.res.mjs";
+import * as OutboundTranslationSlicePlatformFixtures$ReventlessLocal from "./OutboundTranslationSlicePlatformFixtures.res.mjs";
+
+globalThis.describe("OutboundTranslationSlice platform wiring:", () => {
+  globalThis.beforeAll(async () => {
+    await TestRunner$ReventlessLocal.resolve(OutboundTranslationSlicePlatformFixtures$ReventlessLocal.DcbLogMaker.operations(OutboundTranslationSlicePlatformFixtures$ReventlessLocal.dcbEventLog));
+    await TestRunner$ReventlessLocal.resolve(OutboundTranslationSlicePlatformFixtures$ReventlessLocal.SendConfirm.operations(OutboundTranslationSlicePlatformFixtures$ReventlessLocal.sendConfirmSlice));
+    await OutboundTranslationSlicePlatformFixtures$ReventlessLocal.flush();
+    let resource = OutboundTranslationSlicePlatformFixtures$ReventlessLocal.dcbTopicOutputs.resources[0];
+    await TestRunner$ReventlessLocal.resolve(resource.name);
+  });
+  globalThis.test("Place → Placed reaches phase 1 collect", async () => {
+    await OutboundTranslationSlicePlatformFixtures$ReventlessLocal.publishJsons([OutboundTranslationSlicePlatformFixtures$ReventlessLocal.placeCmdJson("order-1")]);
+    await OutboundTranslationSlicePlatformFixtures$ReventlessLocal.flush();
+    let eventTypes = await OutboundTranslationSlicePlatformFixtures$ReventlessLocal.readEventTypes("order-1");
+    globalThis.expect(eventTypes.includes("Placed")).toBe(true);
+    globalThis.expect(OutboundTranslationSlicePlatformFixtures$ReventlessLocal.collectCalls.includes("order-1")).toBe(true);
+  });
+  globalThis.test("phase 2 translates the collected item without the heartbeat", async () => {
+    await OutboundTranslationSlicePlatformFixtures$ReventlessLocal.publishJsons([OutboundTranslationSlicePlatformFixtures$ReventlessLocal.placeCmdJson("order-2")]);
+    await OutboundTranslationSlicePlatformFixtures$ReventlessLocal.flush();
+    globalThis.expect(OutboundTranslationSlicePlatformFixtures$ReventlessLocal.externalCalls.includes("order-2")).toBe(true);
+  });
+});
+
+/*  Not a pure module */

package/tests/components/stateviewslice/StateViewSliceFixtures.res

@@ -42,7 +42,7 @@ module ItemsViewProjection = {
 
   let moduleUrl: string = %raw(`import.meta.url`)
 
-  let project = (event: consumedEvent) =>
+  let project = ({event}: Reventless.StateViewSlice.consumed<consumedEvent>) =>
     switch event {
     | ItemAdded({id, name}) => [Set(id, {id, name})]
     | ItemRenamed({id, name}) => [Update(id, s => {...s, name})]

package/tests/components/stateviewslice/StateViewSliceFixtures.res.mjs

@@ -74,7 +74,8 @@ let ItemsViewSpec = {
 
 let moduleUrl$1 = import.meta.url;
 
-function project(event) {
+function project(param) {
+  let event = param.event;
   switch (event.TAG) {
     case "ItemAdded" :
       let id = event.id;

package/tests/components/stateviewslice/StateViewSliceSubIdFixtures.res

@@ -44,7 +44,7 @@ module ScoresViewProjection = {
 
   let moduleUrl: string = %raw(`import.meta.url`)
 
-  let project = (event: consumedEvent) =>
+  let project = ({event}: Reventless.StateViewSlice.consumed<consumedEvent>) =>
     switch event {
     | ScoreRecorded({id, category, date, score}) =>
       [Set(id, {id, category, date, score})]

package/tests/components/stateviewslice/StateViewSliceSubIdFixtures.res.mjs

@@ -79,7 +79,8 @@ let ScoresViewSpec = {
 
 let moduleUrl$1 = import.meta.url;
 
-function project(event) {
+function project(param) {
+  let event = param.event;
   if (event.TAG !== "ScoreRecorded") {
     return [{
         TAG: "Delete",