@reventlessdev/reventless-local 3.0.0-alpha.113

package/tests/components/automationslice/AutomationSliceSelfDeadlockFixtures.res.mjs

@@ -0,0 +1,453 @@
+// 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 AutomationSlice$Reventless from "@reventlessdev/reventless-spec/src/components/AutomationSlice.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 AutomationSlice_Builder$ReventlessLocal from "../../../src/components/AutomationSlice_Builder.res.mjs";
+import * as StateChangeSlice_Builder$ReventlessLocal from "../../../src/components/StateChangeSlice_Builder.res.mjs";
+
+let name = "Place";
+
+let moduleUrl = import.meta.url;
+
+let eventSchema = S.schema(s => ({
+  TAG: "Placed",
+  orderId: s.m(DcbTag$Reventless.string)
+}));
+
+let consumedEventSchema = S.literal("Placed");
+
+let commandSchema = S.schema(s => ({
+  TAG: "Place",
+  orderId: s.m(DcbTag$Reventless.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
+        }]
+    };
+  }
+}
+
+let PlaceBehavior = {
+  Spec: undefined,
+  moduleUrl: moduleUrl$1,
+  initialState: false,
+  evolve: evolve,
+  decide: decide
+};
+
+let name$1 = "Ship";
+
+let moduleUrl$2 = import.meta.url;
+
+let eventSchema$1 = S.schema(s => ({
+  TAG: "Shipped",
+  orderId: s.m(DcbTag$Reventless.string)
+}));
+
+let consumedEventSchema$1 = S.union([
+  S.schema(s => ({
+    TAG: "Placed",
+    orderId: s.m(S.string)
+  })),
+  S.literal("Shipped")
+]);
+
+let commandSchema$1 = S.schema(s => ({
+  TAG: "Ship",
+  orderId: s.m(DcbTag$Reventless.string)
+}));
+
+let errorSchema$1 = S.literal("NotPlaced");
+
+function commandAuthorization$1(param) {
+  return "AllowAuthenticated";
+}
+
+let ShipSpec = {
+  name: name$1,
+  Id: undefined,
+  moduleUrl: moduleUrl$2,
+  eventSchema: eventSchema$1,
+  consumedEventSchema: consumedEventSchema$1,
+  errorSchema: errorSchema$1,
+  commandSchema: commandSchema$1,
+  commandAuthorization: commandAuthorization$1,
+  readConsistency: "EscalateOnRetry"
+};
+
+let moduleUrl$3 = import.meta.url;
+
+let initialState = {
+  placed: false,
+  shipped: false
+};
+
+function evolve$1(state, event) {
+  if (typeof event !== "object") {
+    return {
+      placed: state.placed,
+      shipped: true
+    };
+  } else {
+    return {
+      placed: true,
+      shipped: state.shipped
+    };
+  }
+}
+
+function decide$1(state, command) {
+  if (state.placed) {
+    if (state.shipped) {
+      return {
+        TAG: "Ok",
+        _0: []
+      };
+    } else {
+      return {
+        TAG: "Ok",
+        _0: [{
+            TAG: "Shipped",
+            orderId: command.orderId
+          }]
+      };
+    }
+  } else {
+    return {
+      TAG: "Error",
+      _0: "NotPlaced"
+    };
+  }
+}
+
+let ShipBehavior = {
+  Spec: undefined,
+  moduleUrl: moduleUrl$3,
+  initialState: initialState,
+  evolve: evolve$1,
+  decide: decide$1
+};
+
+let name$2 = "TestLogDcbEventLog";
+
+let eventSchema$2 = S.union([
+  S.schema(s => ({
+    TAG: "Placed",
+    orderId: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "Shipped",
+    orderId: s.m(S.string)
+  }))
+]);
+
+let DcbSource = {
+  Id: undefined,
+  name: name$2,
+  eventSchema: eventSchema$2
+};
+
+let name$3 = "AutoShip";
+
+let moduleUrl$4 = import.meta.url;
+
+let todoItemSchema = S.schema(s => ({
+  orderId: s.m(S.string)
+}));
+
+let commandSchema$2 = S.schema(s => ({
+  TAG: "Ship",
+  orderId: s.m(DcbTag$Reventless.string)
+}));
+
+function commandAuthorization$2(param) {
+  return "AllowAuthenticated";
+}
+
+let AutoShipSpec = {
+  name: name$3,
+  moduleUrl: moduleUrl$4,
+  todoItemSchema: todoItemSchema,
+  commandSchema: commandSchema$2,
+  maxRetries: 3,
+  heartbeatInterval: 60,
+  targetName: "Ship",
+  commandAuthorization: commandAuthorization$2
+};
+
+function collect(event, _ctx) {
+  if (event.TAG !== "Placed") {
+    return [];
+  }
+  let orderId = event.orderId;
+  return [[
+      orderId,
+      {
+        orderId: orderId
+      }
+    ]];
+}
+
+function resolve(event) {
+  if (event.TAG === "Placed") {
+    return;
+  } else {
+    return event.orderId;
+  }
+}
+
+let FromDcb = AutomationSlice$Reventless.Mapping.Make({
+  Id: Id$Reventless.$$String,
+  name: name$2,
+  eventSchema: eventSchema$2
+})(AutoShipSpec)({
+  collect: collect,
+  resolve: resolve
+});
+
+function process(id, _item) {
+  return [
+    id,
+    {
+      TAG: "Ship",
+      orderId: id
+    }
+  ];
+}
+
+let moduleUrl$5 = import.meta.url;
+
+AutomationSlice$Reventless.Mappings.Make(AutoShipSpec);
+
+let mappings = [FromDcb];
+
+let AutoShipAutomation = {
+  process: process,
+  moduleUrl: moduleUrl$5,
+  mappings: mappings
+};
+
+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);
+
+let ShipMaker = StateChangeSlice_Builder$ReventlessLocal.Make({
+  name: name$1,
+  moduleUrl: moduleUrl$2,
+  Id: Id$Reventless.$$String,
+  consumedEventSchema: consumedEventSchema$1,
+  errorSchema: errorSchema$1,
+  eventSchema: eventSchema$1,
+  commandSchema: commandSchema$1,
+  commandAuthorization: commandAuthorization$1,
+  readConsistency: "EscalateOnRetry"
+})({
+  initialState: initialState,
+  evolve: evolve$1,
+  decide: decide$1,
+  moduleUrl: moduleUrl$3
+});
+
+let _shipSlice = ShipMaker.make(dcbEventLog, publishJsonsOutput, undefined, undefined, undefined);
+
+let dcbTopicOutputs = Component$ReventlessInfra.outputs(dcbEventLog).eventTopic;
+
+let allEventTopics = Object.fromEntries([[
+    name$2,
+    dcbTopicOutputs
+  ]]);
+
+let testContext = {
+  environment: "test",
+  platformName: "local",
+  pluginName: "TestPlugin",
+  sliceName: name$3
+};
+
+let AutomationSliceMaker = AutomationSlice_Builder$ReventlessLocal.Make(Bus);
+
+let AutoShip = AutomationSliceMaker.Make(AutoShipSpec)(AutoShipAutomation);
+
+let autoShipSlice = AutoShip.make(allEventTopics, publishJsonsOutput, testContext, undefined);
+
+function placeCmdJson(orderId) {
+  return {
+    id: orderId,
+    meta: TestFixtures$ReventlessLocal.testMeta,
+    commandJson: S.reverseConvertToJsonOrThrow({
+      TAG: "Place",
+      orderId: orderId
+    }, commandSchema)
+  };
+}
+
+async function withTimeout(p, ms) {
+  let timeout = new Promise((resolve, param) => {
+    setTimeout(() => resolve({
+      TAG: "Error",
+      _0: "timed out"
+    }), ms);
+  });
+  let work = p.then(v => ({
+    TAG: "Ok",
+    _0: v
+  }));
+  return await Promise.race([
+    work,
+    timeout
+  ]);
+}
+
+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);
+}
+
+export {
+  PlaceSpec,
+  PlaceBehavior,
+  ShipSpec,
+  ShipBehavior,
+  DcbSource,
+  AutoShipSpec,
+  FromDcb,
+  AutoShipAutomation,
+  Bus,
+  DcbLogMaker,
+  dcbEventLog,
+  publishJsons,
+  publishJsonsOutput,
+  PlaceMaker,
+  _placeSlice,
+  ShipMaker,
+  _shipSlice,
+  dcbTopicOutputs,
+  allEventTopics,
+  testContext,
+  AutomationSliceMaker,
+  AutoShip,
+  autoShipSlice,
+  placeCmdJson,
+  withTimeout,
+  readEventTypes,
+}
+/* moduleUrl Not a pure module */

package/tests/components/automationslice/AutomationSliceSelfDeadlockTest.res

@@ -0,0 +1,47 @@
+// Regression test for the AutomationSlice self-deadlock fix.
+// See AutomationSliceSelfDeadlockFixtures.res for the wiring rationale.
+//
+// Without the fix, `publishJsons([Place])` never returns: phase 2 publishes a
+// Ship command on the originating subscriber fiber, Ship appends Shipped, and
+// the bus blocks waiting for that same fiber to dequeue Shipped. The wall-clock
+// timeout below catches that.
+
+open JestGlobals
+open AutomationSliceSelfDeadlockFixtures
+
+describe("AutomationSlice self-deadlock regression:", () => {
+  let _ = beforeAllAsync(async () => {
+    let _ = await dcbEventLog->DcbLogMaker.operations->TestRunner.resolve
+    let _ = await autoShipSlice->ReventlessCore.Component.operations->TestRunner.resolve
+    // LocalEventCollectorChannel.connect registers the bus subscription
+    // inside a fire-and-forget Effect.runPromise; flush a couple of microtasks
+    // so the AutoShip subscription is in place before we publish.
+    let _ = await Promise.resolve()
+    let _ = await Promise.resolve()
+    let resource = dcbTopicOutputs.resources->Array.getUnsafe(0)
+    let _ = await resource.name->TestRunner.resolve
+  })
+
+  testPromise("Place → Placed → AutoShip → Ship → Shipped completes", async () => {
+    // The originating publish must return inside the timeout. With phase 2
+    // awaited inline (the pre-fix shape), this hangs until Jest times out.
+    let outcome = await withTimeout(publishJsons([placeCmdJson("order-1")]), ~ms=1500)
+    expect(
+      switch outcome {
+      | Ok(_) => "ok"
+      | Error(msg) => msg
+      },
+    )->toBe("ok")
+
+    // Drain microtasks so the detached phase 2 chain has a chance to publish
+    // Ship and the Ship slice can append Shipped.
+    let _ = await Promise.resolve()
+    let _ = await Promise.resolve()
+    let _ = await Promise.resolve()
+    let _ = await Promise.resolve()
+
+    let eventTypes = await readEventTypes("order-1")
+    expect(eventTypes->Array.includes("Placed"))->toBe(true)
+    expect(eventTypes->Array.includes("Shipped"))->toBe(true)
+  })
+})

package/tests/components/automationslice/AutomationSliceSelfDeadlockTest.res.mjs

@@ -0,0 +1,31 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../../src/test/TestRunner.res.mjs";
+import * as AutomationSliceSelfDeadlockFixtures$ReventlessLocal from "./AutomationSliceSelfDeadlockFixtures.res.mjs";
+
+globalThis.describe("AutomationSlice self-deadlock regression:", () => {
+  globalThis.beforeAll(async () => {
+    await TestRunner$ReventlessLocal.resolve(AutomationSliceSelfDeadlockFixtures$ReventlessLocal.DcbLogMaker.operations(AutomationSliceSelfDeadlockFixtures$ReventlessLocal.dcbEventLog));
+    await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(AutomationSliceSelfDeadlockFixtures$ReventlessLocal.autoShipSlice));
+    await Promise.resolve();
+    await Promise.resolve();
+    let resource = AutomationSliceSelfDeadlockFixtures$ReventlessLocal.dcbTopicOutputs.resources[0];
+    await TestRunner$ReventlessLocal.resolve(resource.name);
+  });
+  globalThis.test("Place → Placed → AutoShip → Ship → Shipped completes", async () => {
+    let outcome = await AutomationSliceSelfDeadlockFixtures$ReventlessLocal.withTimeout(AutomationSliceSelfDeadlockFixtures$ReventlessLocal.publishJsons([AutomationSliceSelfDeadlockFixtures$ReventlessLocal.placeCmdJson("order-1")]), 1500);
+    let tmp;
+    tmp = outcome.TAG === "Ok" ? "ok" : outcome._0;
+    globalThis.expect(tmp).toBe("ok");
+    await Promise.resolve();
+    await Promise.resolve();
+    await Promise.resolve();
+    await Promise.resolve();
+    let eventTypes = await AutomationSliceSelfDeadlockFixtures$ReventlessLocal.readEventTypes("order-1");
+    globalThis.expect(eventTypes.includes("Placed")).toBe(true);
+    globalThis.expect(eventTypes.includes("Shipped")).toBe(true);
+  });
+});
+
+/*  Not a pure module */