@reventlessdev/reventless-local 3.0.0-alpha.285 → 3.0.0-alpha.286

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

@@ -0,0 +1,217 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sury from "sury";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+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 Pulumi from "@pulumi/pulumi";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+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 Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
+import * as Adapter$ReventlessInfra from "@reventlessdev/reventless-infra/src/adapter/Adapter.res.mjs";
+import * as LocalBus$ReventlessLocal from "../../../src/adapter/LocalBus.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 TestFixtures$ReventlessLocal from "../../TestFixtures.res.mjs";
+import * as AutomationSlice_Builder$ReventlessLocal from "../../../src/components/AutomationSlice_Builder.res.mjs";
+import * as AutomationSlice_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/AutomationSlice/AutomationSlice_Callback.res.mjs";
+
+let name = "DeadlineOrderEventTopic";
+
+let eventSchema = Sury.$schema(s => ({
+  TAG: "OrderPlaced",
+  orderId: s.m(Sury.string),
+  within: s.m(Sury.number)
+}));
+
+let OrderSource = {
+  Id: undefined,
+  name: name,
+  eventSchema: eventSchema
+};
+
+let name$1 = "CancelUnshipped";
+
+let moduleUrl = import.meta.url;
+
+let todoItemSchema = Sury.$schema(s => ({
+  orderId: s.m(Sury.string),
+  dueAt: s.m(Sury.number)
+}));
+
+let commandSchema = Sury.$schema(s => ({
+  TAG: "CancelOrder",
+  orderId: s.m(DcbTag$Reventless.string)
+}));
+
+function authorizationOf(param) {
+  return "AllowAuthenticated";
+}
+
+function commandTransition(param) {
+  return "Undeclared";
+}
+
+let traits = [];
+
+let CancelUnshippedSpec = {
+  name: name$1,
+  moduleUrl: moduleUrl,
+  todoItemSchema: todoItemSchema,
+  commandSchema: commandSchema,
+  maxRetries: 2,
+  heartbeatInterval: 60,
+  targetName: "CancelOrder",
+  authorizationOf: authorizationOf,
+  commandTransition: commandTransition,
+  traits: traits
+};
+
+function collect(event, param, ctx) {
+  let match = ctx.recordedAt;
+  if (match === undefined) {
+    return [];
+  }
+  let orderId = event.orderId;
+  return [[
+      orderId,
+      {
+        orderId: orderId,
+        dueAt: match + event.within
+      }
+    ]];
+}
+
+function resolve(_event) {
+  
+}
+
+let FromOrders = AutomationSlice$Reventless.Mapping.Make({
+  Id: Id$Reventless.$$String,
+  name: name,
+  eventSchema: eventSchema
+})(CancelUnshippedSpec)({
+  collect: collect,
+  resolve: resolve
+});
+
+function process(id, item, now) {
+  if (now >= item.dueAt) {
+    return [
+      id,
+      {
+        TAG: "CancelOrder",
+        orderId: item.orderId
+      }
+    ];
+  }
+}
+
+function onExhausted(_id, _item) {
+  
+}
+
+let moduleUrl$1 = import.meta.url;
+
+AutomationSlice$Reventless.Mappings.Make(CancelUnshippedSpec);
+
+let mappings = [FromOrders];
+
+let CancelUnshippedAutomation = {
+  process: process,
+  onExhausted: onExhausted,
+  moduleUrl: moduleUrl$1,
+  mappings: mappings
+};
+
+let orderResource = Adapter$ReventlessInfra.make(Pulumi.output(name), Pulumi.output(name), Pulumi.output(name), Pulumi.output("memory:InMemory"), undefined, undefined, undefined, undefined, undefined, undefined);
+
+let allEventTopics = Object.fromEntries([[
+    name,
+    {
+      resources: [orderResource]
+    }
+  ]]);
+
+let Bus = LocalBus$ReventlessLocal.Make({});
+
+TestRunner$ReventlessLocal.setup();
+
+let AutomationSliceMaker = AutomationSlice_Builder$ReventlessLocal.Make(Bus);
+
+let CancelUnshipped = AutomationSliceMaker.Make(CancelUnshippedSpec)(CancelUnshippedAutomation);
+
+let publishedCommands = {
+  contents: []
+};
+
+let failPublish = {
+  contents: false
+};
+
+async function publishJsons(cmds) {
+  if (failPublish.contents) {
+    return Stdlib_JsError.throwWithMessage("command topic unavailable");
+  } else {
+    publishedCommands.contents = publishedCommands.contents.concat(cmds);
+    return;
+  }
+}
+
+let slice = CancelUnshipped.make(allEventTopics, Pulumi.output(publishJsons), {
+  environment: "local",
+  platformName: "local",
+  pluginName: "TestPlugin",
+  sliceName: name$1
+}, undefined, undefined);
+
+async function placeOrder(orderId, within) {
+  let newrecord = {...TestFixtures$ReventlessLocal.makeTestMeta(name)};
+  newrecord.time = new Date(Date.now()).toISOString();
+  let eventJson = Object.fromEntries([
+    [
+      "id",
+      orderId
+    ],
+    [
+      "meta",
+      Util_Sury$Reventless.toJson(newrecord, Message$Reventless.metaSchema)
+    ],
+    [
+      "event",
+      Util_Sury$Reventless.toJson({
+        TAG: "OrderPlaced",
+        orderId: orderId,
+        within: within
+      }, eventSchema)
+    ]
+  ]);
+  await Bus.publishEvent(name, "test", newrecord, eventJson);
+  await Promise.resolve();
+  await Promise.resolve();
+}
+
+function storedRow(id) {
+  return Stdlib_Option.map(Stdlib_Option.getOr(Stdlib_Option.map(Bus.getQueryDbScan(CancelUnshipped.queryDbName), scan => scan()), []).find(row => Primitive_object.equal(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(row), o => o["id"]), id)), row => Util_Sury$Reventless.fromJson(row, AutomationSlice_Callback$ReventlessCore.todoRowSchema));
+}
+
+export {
+  OrderSource,
+  CancelUnshippedSpec,
+  FromOrders,
+  CancelUnshippedAutomation,
+  orderResource,
+  allEventTopics,
+  Bus,
+  AutomationSliceMaker,
+  CancelUnshipped,
+  publishedCommands,
+  failPublish,
+  publishJsons,
+  slice,
+  placeOrder,
+  storedRow,
+}
+/* eventSchema Not a pure module */

package/tests/components/automationslice/AutomationSweepTest.res

@@ -0,0 +1,107 @@
+// The local platform sweeps pending automation items as AWS does: a deadline,
+// counted from its event's recorded time, passes without another event, a failed command is retried up to maxRetries,
+// and what the sweep moved is written back to the query store.
+
+open JestGlobals
+open AutomationSweepFixtures
+
+module Callback = ReventlessCore.AutomationSlice_Callback
+
+// Only Date is faked, so `process` sees the time a test sets while Effect's own
+// scheduling still runs on real timers.
+type jestObj
+type fakeTimersConfig = {doNotFake: array<string>}
+@module("@jest/globals") external jest: jestObj = "jest"
+@send external useFakeTimers: (jestObj, fakeTimersConfig) => unit = "useFakeTimers"
+@send external useRealTimers: jestObj => unit = "useRealTimers"
+@send external setSystemTime: (jestObj, float) => unit = "setSystemTime"
+
+let setNow = millis => jest->setSystemTime(millis)
+
+let commandIds = () => publishedCommands.contents->Array.map(c => c.id)
+
+describe("the local automation sweep", () => {
+  let _ = beforeAll(() =>
+    jest->useFakeTimers({
+      doNotFake: [
+        "hrtime",
+        "nextTick",
+        "performance",
+        "queueMicrotask",
+        "setImmediate",
+        "clearImmediate",
+        "setInterval",
+        "clearInterval",
+        "setTimeout",
+        "clearTimeout",
+      ],
+    })
+  )
+  let _ = afterAll(() => jest->useRealTimers)
+
+  let _ = beforeAllAsync(async () => {
+    let _ = await slice->ReventlessCore.Component.operations->TestRunner.resolve
+    let _ = await orderResource.name->TestRunner.resolve
+    let _ = await Promise.resolve()
+    let _ = await Promise.resolve()
+  })
+
+  let _ = beforeEach(() => {
+    publishedCommands := []
+    failPublish := false
+    setNow(0.)
+  })
+
+  testPromise("sends a deadline's command once it is due, with no further event", async () => {
+    await placeOrder("o1", ~within=100.)
+    expect(commandIds())->toEqual([])
+
+    await LocalAutomationSweep.sweepOnce()
+    expect(commandIds())->toEqual([])
+
+    setNow(100.)
+    await LocalAutomationSweep.sweepOnce()
+    expect(commandIds())->toEqual(["o1"])
+  })
+
+  testPromise("writes what it moved back to the query store", async () => {
+    await placeOrder("o2", ~within=100.)
+    expect(storedRow("o2")->Option.map(row => row.status))->toEqual(Some(Callback.Pending))
+
+    setNow(100.)
+    await LocalAutomationSweep.sweepOnce()
+    expect(storedRow("o2")->Option.map(row => row.status))->toEqual(Some(Callback.Processing))
+  })
+
+  testPromise("retries a failed command up to maxRetries, then abandons it", async () => {
+    setNow(100.)
+    failPublish := true
+    await placeOrder("o3", ~within=0.)
+    expect(storedRow("o3")->Option.map(row => (row.status, row.retryCount)))->toEqual(
+      Some((Callback.Failed, 1)),
+    )
+
+    await LocalAutomationSweep.sweepOnce()
+    expect(storedRow("o3")->Option.map(row => (row.status, row.retryCount)))->toEqual(
+      Some((Callback.Abandoned, 2)),
+    )
+
+    failPublish := false
+    await LocalAutomationSweep.sweepOnce()
+    expect(commandIds()->Array.includes("o3"))->toBe(false)
+  })
+
+  testSync("waits five minutes by default, as on AWS", () => {
+    expect(LocalAutomationSweep.intervalSeconds())->toBe(300)
+  })
+
+  testSync("waits REVENTLESS_LOCAL_SWEEP_SECONDS when it is a positive number", () => {
+    let key = "REVENTLESS_LOCAL_SWEEP_SECONDS"
+    NodeProcess.env->Dict.set(key, "15")
+    let shortened = LocalAutomationSweep.intervalSeconds()
+    NodeProcess.env->Dict.set(key, "soon")
+    let malformed = LocalAutomationSweep.intervalSeconds()
+    NodeProcess.env->Dict.delete(key)
+    expect((shortened, malformed))->toEqual((15, 300))
+  })
+})

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

@@ -0,0 +1,116 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Globals from "@jest/globals";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+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 LocalAutomationSweep$ReventlessLocal from "../../../src/components/LocalAutomationSweep.res.mjs";
+import * as AutomationSweepFixtures$ReventlessLocal from "./AutomationSweepFixtures.res.mjs";
+
+function setNow(millis) {
+  Globals.jest.setSystemTime(millis);
+}
+
+function commandIds() {
+  return AutomationSweepFixtures$ReventlessLocal.publishedCommands.contents.map(c => c.id);
+}
+
+globalThis.describe("the local automation sweep", () => {
+  globalThis.beforeAll(() => {
+    Globals.jest.useFakeTimers({
+      doNotFake: [
+        "hrtime",
+        "nextTick",
+        "performance",
+        "queueMicrotask",
+        "setImmediate",
+        "clearImmediate",
+        "setInterval",
+        "clearInterval",
+        "setTimeout",
+        "clearTimeout"
+      ]
+    });
+  });
+  globalThis.afterAll(() => {
+    Globals.jest.useRealTimers();
+  });
+  globalThis.beforeAll(async () => {
+    await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(AutomationSweepFixtures$ReventlessLocal.slice));
+    await TestRunner$ReventlessLocal.resolve(AutomationSweepFixtures$ReventlessLocal.orderResource.name);
+    await Promise.resolve();
+    await Promise.resolve();
+  });
+  globalThis.beforeEach(() => {
+    AutomationSweepFixtures$ReventlessLocal.publishedCommands.contents = [];
+    AutomationSweepFixtures$ReventlessLocal.failPublish.contents = false;
+    Globals.jest.setSystemTime(0);
+  });
+  globalThis.test("sends a deadline's command once it is due, with no further event", async () => {
+    await AutomationSweepFixtures$ReventlessLocal.placeOrder("o1", 100);
+    globalThis.expect(commandIds()).toEqual([]);
+    await LocalAutomationSweep$ReventlessLocal.sweepOnce();
+    globalThis.expect(commandIds()).toEqual([]);
+    Globals.jest.setSystemTime(100);
+    await LocalAutomationSweep$ReventlessLocal.sweepOnce();
+    globalThis.expect(commandIds()).toEqual(["o1"]);
+  });
+  globalThis.test("writes what it moved back to the query store", async () => {
+    await AutomationSweepFixtures$ReventlessLocal.placeOrder("o2", 100);
+    globalThis.expect(Stdlib_Option.map(AutomationSweepFixtures$ReventlessLocal.storedRow("o2"), row => row.status)).toEqual("Pending");
+    Globals.jest.setSystemTime(100);
+    await LocalAutomationSweep$ReventlessLocal.sweepOnce();
+    globalThis.expect(Stdlib_Option.map(AutomationSweepFixtures$ReventlessLocal.storedRow("o2"), row => row.status)).toEqual("Processing");
+  });
+  globalThis.test("retries a failed command up to maxRetries, then abandons it", async () => {
+    Globals.jest.setSystemTime(100);
+    AutomationSweepFixtures$ReventlessLocal.failPublish.contents = true;
+    await AutomationSweepFixtures$ReventlessLocal.placeOrder("o3", 0);
+    globalThis.expect(Stdlib_Option.map(AutomationSweepFixtures$ReventlessLocal.storedRow("o3"), row => [
+      row.status,
+      row.retryCount
+    ])).toEqual([
+      "Failed",
+      1
+    ]);
+    await LocalAutomationSweep$ReventlessLocal.sweepOnce();
+    globalThis.expect(Stdlib_Option.map(AutomationSweepFixtures$ReventlessLocal.storedRow("o3"), row => [
+      row.status,
+      row.retryCount
+    ])).toEqual([
+      "Abandoned",
+      2
+    ]);
+    AutomationSweepFixtures$ReventlessLocal.failPublish.contents = false;
+    await LocalAutomationSweep$ReventlessLocal.sweepOnce();
+    globalThis.expect(commandIds().includes("o3")).toBe(false);
+  });
+  globalThis.test("waits five minutes by default, as on AWS", () => {
+    globalThis.expect(LocalAutomationSweep$ReventlessLocal.intervalSeconds()).toBe(300);
+  });
+  globalThis.test("waits REVENTLESS_LOCAL_SWEEP_SECONDS when it is a positive number", () => {
+    let key = "REVENTLESS_LOCAL_SWEEP_SECONDS";
+    process.env[key] = "15";
+    let shortened = LocalAutomationSweep$ReventlessLocal.intervalSeconds();
+    process.env[key] = "soon";
+    let malformed = LocalAutomationSweep$ReventlessLocal.intervalSeconds();
+    Stdlib_Dict.$$delete(process.env, key);
+    globalThis.expect([
+      shortened,
+      malformed
+    ]).toEqual([
+      15,
+      300
+    ]);
+  });
+});
+
+let Callback;
+
+export {
+  Callback,
+  setNow,
+  commandIds,
+}
+/*  Not a pure module */

package/tests/components/automationslice/MixedSourceAutomationSliceFixtures.res

@@ -123,7 +123,7 @@ module FromInventoryDcb = AutomationSlice.Mapping.Make(
 // ─────────────────────────────────────────────────────────────
 
 module AutoFulfillAutomation: AutomationSlice.Automation with module Spec := AutoFulfillSpec = {
-  let process = (id, item: AutoFulfillSpec.todoItem) => Some((
+  let process = (id, item: AutoFulfillSpec.todoItem, ~now as _) => Some((
     id,
     AutoFulfillSpec.MarkFulfilled({orderId: item.orderId, productId: item.productId}),
   ))

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

@@ -151,7 +151,7 @@ let FromInventoryDcb = AutomationSlice$Reventless.Mapping.Make({
   resolve: resolve$1
 });
 
-function process(id, item) {
+function process(id, item, param) {
   return [
     id,
     {

package/tests/components/scheduler/SchedulerTest.res

@@ -21,10 +21,10 @@ describe("Scheduler_Builder.Make:", () => {
             count := count.contents + 1
           },
         )
-        // createSchedule async body has no await — setInterval registered synchronously
+        // createSchedule async body has no await — the timer is set synchronously
         let _ = ops.createSchedule(
           [makeTopicResource("sched-recurring")],
-          {name: "test-recurring", rate: Reventless.Schedule.Minutes(1), payload: "{}"},
+          {name: "test-recurring", time: Every(Minutes(1)), payload: "{}"},
         )
         // Two microtask ticks: publishEvent uses Effect.all(concurrency=unbounded) which forks
         // child fibers via startFork — one tick runs the child fiber (Queue.offer),
@@ -55,11 +55,11 @@ describe("Scheduler_Builder.Make:", () => {
           [makeTopicResource("sched-single")],
           {
             name: "test-single",
-            rate: Reventless.Schedule.Single(2024, 1, 1, 0, 0),
+            time: Once({moment: After(Minutes(1))}),
             payload: "{}",
           },
         )
-        jest->advanceTimersByTime(0)
+        jest->advanceTimersByTime(60 * 1000)
         let _ = await Promise.resolve()
         let _ = await Promise.resolve()
         expect(count.contents)->toBe(1)
@@ -83,7 +83,7 @@ describe("Scheduler_Builder.Make:", () => {
         )
         let _ = ops.createSchedule(
           [makeTopicResource("sched-delete")],
-          {name: "test-delete", rate: Reventless.Schedule.Minutes(2), payload: "{}"},
+          {name: "test-delete", time: Every(Minutes(2)), payload: "{}"},
         )
         let _ = ops.deleteSchedule([], "test-delete")
         jest->advanceTimersByTime(2 * 60 * 1000)

package/tests/components/scheduler/SchedulerTest.res.mjs

@@ -16,9 +16,12 @@ globalThis.describe("Scheduler_Builder.Make:", () => {
       });
       ops.createSchedule([SchedulerFixtures$ReventlessLocal.makeTopicResource("sched-recurring")], {
         name: "test-recurring",
-        rate: {
-          TAG: "Minutes",
-          _0: 1
+        time: {
+          TAG: "Every",
+          _0: {
+            TAG: "Minutes",
+            _0: 1
+          }
         },
         payload: "{}"
       });
@@ -41,17 +44,19 @@ globalThis.describe("Scheduler_Builder.Make:", () => {
       });
       ops.createSchedule([SchedulerFixtures$ReventlessLocal.makeTopicResource("sched-single")], {
         name: "test-single",
-        rate: {
-          TAG: "Single",
-          _0: 2024,
-          _1: 1,
-          _2: 1,
-          _3: 0,
-          _4: 0
+        time: {
+          TAG: "Once",
+          moment: {
+            TAG: "After",
+            _0: {
+              TAG: "Minutes",
+              _0: 1
+            }
+          }
         },
         payload: "{}"
       });
-      Globals.jest.advanceTimersByTime(0);
+      Globals.jest.advanceTimersByTime(60000);
       await Promise.resolve();
       await Promise.resolve();
       globalThis.expect(count.contents).toBe(1);
@@ -70,9 +75,12 @@ globalThis.describe("Scheduler_Builder.Make:", () => {
       });
       ops.createSchedule([SchedulerFixtures$ReventlessLocal.makeTopicResource("sched-delete")], {
         name: "test-delete",
-        rate: {
-          TAG: "Minutes",
-          _0: 2
+        time: {
+          TAG: "Every",
+          _0: {
+            TAG: "Minutes",
+            _0: 2
+          }
         },
         payload: "{}"
       });