@reventlessdev/reventless-local 3.0.0-alpha.249 → 3.0.0-alpha.250

package/tests/components/automationslice/MixedSourceAutomationSliceFixtures.res

@@ -14,8 +14,7 @@ module OrderAggregateSource = {
   module Id = Id.String
   let name = "OrderAggregateEventTopic"
   @schema
-  type event =
-    | OrderShipped({orderId: string, productId: string})
+  type event = OrderShipped({orderId: string, productId: string})
 }
 
 // ─────────────────────────────────────────────────────────────
@@ -47,10 +46,11 @@ module AutoFulfillSpec = {
   }
 
   @schema
-  type command = MarkFulfilled({
-    orderId: @s.matches(DcbTag.string) string,
-    productId: @s.matches(DcbTag.string) string,
-  })
+  type command =
+    | MarkFulfilled({
+        orderId: @s.matches(DcbTag.string) string,
+        productId: @s.matches(DcbTag.string) string,
+      })
 
   let maxRetries = 3
   let heartbeatInterval = 60
@@ -122,10 +122,11 @@ module FromInventoryDcb = AutomationSlice.Mapping.Make(
 // Mappings collection
 // ─────────────────────────────────────────────────────────────
 
-module AutoFulfillAutomation: AutomationSlice.Automation
-  with module Spec := AutoFulfillSpec = {
-  let process = (id, item: AutoFulfillSpec.todoItem) =>
-    Some((id, AutoFulfillSpec.MarkFulfilled({orderId: item.orderId, productId: item.productId})))
+module AutoFulfillAutomation: AutomationSlice.Automation with module Spec := AutoFulfillSpec = {
+  let process = (id, item: AutoFulfillSpec.todoItem) => Some((
+    id,
+    AutoFulfillSpec.MarkFulfilled({orderId: item.orderId, productId: item.productId}),
+  ))
   let onExhausted = (_id, _item: AutoFulfillSpec.todoItem) => None
   let moduleUrl: string = %raw(`import.meta.url`)
   module M = AutomationSlice.Mappings.Make(AutoFulfillSpec)
@@ -168,10 +169,7 @@ let _ = TestRunner.setup()
 // ─────────────────────────────────────────────────────────────
 
 module AutomationSliceMaker = AutomationSlice_Builder.Make(Bus)
-module AutoFulfill = AutomationSliceMaker.Make(
-  AutoFulfillSpec,
-  AutoFulfillAutomation,
-)
+module AutoFulfill = AutomationSliceMaker.Make(AutoFulfillSpec, AutoFulfillAutomation)
 
 // Mirrors the context that `Plugin_Builder` constructs for local deployments
 // (environment from `LocalPluginSpec.environment`, platformName "local").

package/tests/components/automationslice/MixedSourceAutomationSliceTest.res

@@ -25,10 +25,7 @@ describe("MixedSource AutomationSlice", () => {
 
   testPromise("Aggregate-source event creates a TODO and produces a command", async () => {
     publishedCommands := []
-    let _ = await publishAggregateEvent(
-      "env-a1",
-      OrderShipped({orderId: "o1", productId: "p1"}),
-    )
+    let _ = await publishAggregateEvent("env-a1", OrderShipped({orderId: "o1", productId: "p1"}))
 
     // Trigger phase2 manually since we don't have a heartbeat in this test.
     let ops = await slice->ReventlessCore.Component.operations->TestRunner.resolve
@@ -52,10 +49,7 @@ describe("MixedSource AutomationSlice", () => {
 
   testPromise("DCB-source StockReserved creates a TODO and produces a command", async () => {
     publishedCommands := []
-    let _ = await publishDcbEvent(
-      "env-d1",
-      StockReserved({orderId: "o2", productId: "p2"}),
-    )
+    let _ = await publishDcbEvent("env-d1", StockReserved({orderId: "o2", productId: "p2"}))
 
     let ops = await slice->ReventlessCore.Component.operations->TestRunner.resolve
     await ops.processPending()
@@ -70,14 +64,8 @@ describe("MixedSource AutomationSlice", () => {
     // Reserve fires phase1+phase2 (inline) — produces 1 command, item becomes
     // Processing. StockReleased then resolves the item to Completed —
     // subsequent processPending calls produce no further commands for it.
-    let _ = await publishDcbEvent(
-      "env-d2",
-      StockReserved({orderId: "o3", productId: "p3"}),
-    )
-    let _ = await publishDcbEvent(
-      "env-d3",
-      StockReleased({orderId: "o3", productId: "p3"}),
-    )
+    let _ = await publishDcbEvent("env-d2", StockReserved({orderId: "o3", productId: "p3"}))
+    let _ = await publishDcbEvent("env-d3", StockReleased({orderId: "o3", productId: "p3"}))
 
     expect(publishedCommands.contents->Array.length)->toBe(1)
 
@@ -91,14 +79,8 @@ describe("MixedSource AutomationSlice", () => {
 
   testPromise("both sources can drive items into the same TODO list independently", async () => {
     publishedCommands := []
-    let _ = await publishAggregateEvent(
-      "env-a2",
-      OrderShipped({orderId: "o4", productId: "p4"}),
-    )
-    let _ = await publishDcbEvent(
-      "env-d4",
-      StockReserved({orderId: "o5", productId: "p5"}),
-    )
+    let _ = await publishAggregateEvent("env-a2", OrderShipped({orderId: "o4", productId: "p4"}))
+    let _ = await publishDcbEvent("env-d4", StockReserved({orderId: "o5", productId: "p5"}))
 
     let ops = await slice->ReventlessCore.Component.operations->TestRunner.resolve
     await ops.processPending()
@@ -112,14 +94,8 @@ describe("MixedSource AutomationSlice", () => {
   testPromise("first-writer-wins idempotency across mappings sharing an ID", async () => {
     publishedCommands := []
     // Both sources produce the same composite ID — second arrival is ignored.
-    let _ = await publishAggregateEvent(
-      "env-a3",
-      OrderShipped({orderId: "o6", productId: "p6"}),
-    )
-    let _ = await publishDcbEvent(
-      "env-d5",
-      StockReserved({orderId: "o6", productId: "p6"}),
-    )
+    let _ = await publishAggregateEvent("env-a3", OrderShipped({orderId: "o6", productId: "p6"}))
+    let _ = await publishDcbEvent("env-d5", StockReserved({orderId: "o6", productId: "p6"}))
 
     let ops = await slice->ReventlessCore.Component.operations->TestRunner.resolve
     await ops.processPending()

package/tests/components/commandgenerator/CommandGeneratorFixtures.res

@@ -1,7 +1,6 @@
 // Fixtures for CommandGenerator integration tests.
 // Verifies that makeHandler builds a resolver that publishes the correct commandJson.
 
-
 // Activate Pulumi mock mode (must be called before any Component.make)
 let _ = TestRunner.setup()
 
@@ -14,13 +13,13 @@ module CGSpec = {
   let name = "TestCGAggregate"
 
   @schema
-  type command = | CreateCGItem({name: string})
+  type command = CreateCGItem({name: string})
 
   @schema
-  type event = | CGItemCreated({name: string})
+  type event = CGItemCreated({name: string})
 
   @schema
-  type error = | CGAlreadyExists
+  type error = CGAlreadyExists
 
   let moduleUrl: string = %raw(`import.meta.url`)
 }
@@ -42,7 +41,10 @@ module CGBehavior = {
     | CGItemCreated({name}) => {name: name}
     }
 
-  let decide = (_state: state, command: CGSpec.command): result<array<CGSpec.event>, CGSpec.error> =>
+  let decide = (_state: state, command: CGSpec.command): result<
+    array<CGSpec.event>,
+    CGSpec.error,
+  > =>
     switch command {
     | CreateCGItem({name}) => Ok([CGSpec.CGItemCreated({name: name})])
     }

package/tests/components/commandgenerator/CommandGeneratorTest.res

@@ -8,36 +8,45 @@ describe("CommandGenerator_Builder.Make:", () => {
   let _ = beforeEach(() => resetMocks())
 
   describe("makeHandler:", () => {
-    testPromise("CreateCGItem payload publishes correct commandJson", async () => {
-      // Resolve the handler from the Output wrapper
-      let handler = await CGMaker.makeHandler(~publishJsons=mockPublish, ~publishJsonsAndWait=None)->TestRunner.resolve
-
-      // Build payload: arguments must include id AND the command fields (name).
-      // generateCommand stringifies arguments, slices off id (index 0), uses the rest as params.
-      let payload: ReventlessCore.CommandGenerator.payload = {
-        command: "CreateCGItem",
-        arguments: {"id": "item-1", "name": "widget"}->Obj.magic,
-        meta: {ip: ["127.0.0.1"], user: "testuser", info: ""},
-        identity: Reventless.Identity.anonymous,
-      }
-
-      // Call handler — generateCommand is async (awaits publishJsons internally)
-      let _ = await handler(payload, ())->Effect.runPromise
-
-      expect(capturedCmds.contents->Array.length)->toBe(1)
-
-      let cmd = capturedCmds.contents->Array.getUnsafe(0)
-      expect(cmd.id)->toBe("item-1")
-
-      // commandJson should decode to CreateCGItem({name: "widget"})
-      let decoded = cmd.commandJson->Reventless.Util_Sury.fromJson(CGSpec.commandSchema)
-      expect(decoded)->toEqual(CGSpec.CreateCGItem({name: "widget"}))
-    })
-
-    testPromise("make creates a CommandGenerator component without throwing", async () => {
-      let cg = CGMaker.make(~name="test-cg")
-      let _ = cg
-      expect(true)->toBe(true)
-    })
+    testPromise(
+      "CreateCGItem payload publishes correct commandJson",
+      async () => {
+        // Resolve the handler from the Output wrapper
+        let handler = await CGMaker.makeHandler(
+          ~publishJsons=mockPublish,
+          ~publishJsonsAndWait=None,
+        )->TestRunner.resolve
+
+        // Build payload: arguments must include id AND the command fields (name).
+        // generateCommand stringifies arguments, slices off id (index 0), uses the rest as params.
+        let payload: ReventlessCore.CommandGenerator.payload = {
+          command: "CreateCGItem",
+          arguments: {"id": "item-1", "name": "widget"}->Obj.magic,
+          meta: {ip: ["127.0.0.1"], user: "testuser", info: ""},
+          identity: Reventless.Identity.anonymous,
+        }
+
+        // Call handler — generateCommand is async (awaits publishJsons internally)
+        let _ = await handler(payload, ())->Effect.runPromise
+
+        expect(capturedCmds.contents->Array.length)->toBe(1)
+
+        let cmd = capturedCmds.contents->Array.getUnsafe(0)
+        expect(cmd.id)->toBe("item-1")
+
+        // commandJson should decode to CreateCGItem({name: "widget"})
+        let decoded = cmd.commandJson->Reventless.Util_Sury.fromJson(CGSpec.commandSchema)
+        expect(decoded)->toEqual(CGSpec.CreateCGItem({name: "widget"}))
+      },
+    )
+
+    testPromise(
+      "make creates a CommandGenerator component without throwing",
+      async () => {
+        let cg = CGMaker.make(~name="test-cg")
+        let _ = cg
+        expect(true)->toBe(true)
+      },
+    )
   })
 })

package/tests/components/commandtopic/CommandTopicFixtures.res

@@ -5,13 +5,13 @@ module ItemSpec = {
   let name = "TestCommandTopicItem"
 
   @schema
-  type command = | CreateItem({name: string}) | DeleteItem({id: string})
+  type command = CreateItem({name: string}) | DeleteItem({id: string})
 
   @schema
-  type event = | ItemCreated({name: string})
+  type event = ItemCreated({name: string})
 
   @schema
-  type error = | AlreadyExists
+  type error = AlreadyExists
 
   let moduleUrl: string = %raw(`import.meta.url`)
 }
@@ -34,4 +34,3 @@ module CommandTopicMaker = ReventlessCore.CommandTopic_Builder.Make(
 )
 
 let cmdTopic = CommandTopicMaker.make(~name="TestCommandTopic")
-

package/tests/components/commandtopic/CommandTopicStreamFixtures.res

@@ -7,13 +7,13 @@ module ItemSpec = {
   let name = "StreamCmdItem"
 
   @schema
-  type command = | CreateItem({name: string}) | DeleteItem({id: string})
+  type command = CreateItem({name: string}) | DeleteItem({id: string})
 
   @schema
-  type event = | ItemCreated({name: string})
+  type event = ItemCreated({name: string})
 
   @schema
-  type error = | AlreadyExists
+  type error = AlreadyExists
 
   let moduleUrl: string = %raw(`import.meta.url`)
 }
@@ -37,7 +37,9 @@ let _ = StreamBus.registerCommandHandler("StreamCmdTopicCmdTopic", async (body,
 })
 
 let makeJson = (id): Reventless.Message.commandJson => {
-  Reventless.Message.id: id,
+  Reventless.Message.id,
   meta: testMeta,
-  commandJson: ItemSpec.CreateItem({name: id})->ReventlessCore.Message.encode(ItemSpec.commandSchema),
+  commandJson: ItemSpec.CreateItem({name: id})->ReventlessCore.Message.encode(
+    ItemSpec.commandSchema,
+  ),
 }

package/tests/components/commandtopic/CommandTopicTest.res

@@ -11,14 +11,17 @@ describe("CommandTopic (in-memory)", () => {
 
   testPromise("publishJsons succeeds without throwing", async () => {
     let ops = await cmdTopic->ReventlessCore.Component.operations->TestRunner.resolve
-    let commandJson = ItemSpec.CreateItem({name: "Widget"})->ReventlessCore.Message.encode(ItemSpec.commandSchema)
+    let commandJson =
+      ItemSpec.CreateItem({name: "Widget"})->ReventlessCore.Message.encode(ItemSpec.commandSchema)
     let didThrow = ref(false)
     try {
-      await ops.publishJsons([{
-        Reventless.Message.id: "item-1",
-        meta: testMeta,
-        commandJson,
-      }])
+      await ops.publishJsons([
+        {
+          Reventless.Message.id: "item-1",
+          meta: testMeta,
+          commandJson,
+        },
+      ])
     } catch {
     | _ => didThrow := true
     }
@@ -41,15 +44,21 @@ describe("CommandTopic (in-memory)", () => {
     // Verify the bus receives the command on the expected channel.
     // Channel name = make name ++ ComponentType.toName(CommandTopic) = "TestCommandTopic" ++ "CmdTopic"
     let received: ref<bool> = ref(false)
-    Bus.registerCommandHandler("TestCommandTopicCmdTopic", async (_json, _ctx) => {
-      received := true
-    })
-    let commandJson = ItemSpec.DeleteItem({id: "item-99"})->ReventlessCore.Message.encode(ItemSpec.commandSchema)
-    await ops.publishJsons([{
-      Reventless.Message.id: "item-99",
-      meta: testMeta,
-      commandJson,
-    }])
+    Bus.registerCommandHandler(
+      "TestCommandTopicCmdTopic",
+      async (_json, _ctx) => {
+        received := true
+      },
+    )
+    let commandJson =
+      ItemSpec.DeleteItem({id: "item-99"})->ReventlessCore.Message.encode(ItemSpec.commandSchema)
+    await ops.publishJsons([
+      {
+        Reventless.Message.id: "item-99",
+        meta: testMeta,
+        commandJson,
+      },
+    ])
     expect(received.contents)->toBe(true)
   })
 })

package/tests/components/counter/CounterFixtures.res

@@ -23,14 +23,12 @@ module CounterMaker = Counter_Builder.Make(Bus)
 
 let counterEvents: ref<array<JSON.t>> = ref([])
 
-let counter = CounterMaker.make(
-  ~name="TestCounter",
-  ~jsonEventsHandler=stream =>
-    stream
-    ->Stream.runCollect
-    ->Effect.map(chunk => {
-      counterEvents := counterEvents.contents->Array.concat(chunk)
-    }),
+let counter = CounterMaker.make(~name="TestCounter", ~jsonEventsHandler=stream =>
+  stream
+  ->Stream.runCollect
+  ->Effect.map(chunk => {
+    counterEvents := counterEvents.contents->Array.concat(chunk)
+  })
 )
 
 // ─────────────────────────────────────────────────────────────

package/tests/components/dcb/DcbCrossPartitionFixtures.res

@@ -69,7 +69,10 @@ module AddProductBehavior = {
   let evolve = (state: state, event: Spec.consumedEvent): state =>
     switch event {
     | ProductAdded(_) => {...state, exists: true}
-    | CategoryAdded({categoryId}) => {...state, liveCats: Array.concat(state.liveCats, [categoryId])}
+    | CategoryAdded({categoryId}) => {
+        ...state,
+        liveCats: Array.concat(state.liveCats, [categoryId]),
+      }
     }
 
   let decide = (state: state, command: Spec.command): result<array<Spec.event>, Spec.error> =>
@@ -148,7 +151,10 @@ let publishJsonsOutput = publishJsons->Pulumi.Output.make
 let _addProductSlice = AddProductMaker.make(
   ~dcbEventLog=eventLog,
   ~publishJsons=publishJsonsOutput,
-  ~tagKeysByEventType=Dict.fromArray([("ProductAdded", ["productId"]), ("CategoryAdded", ["categoryId"])]),
+  ~tagKeysByEventType=Dict.fromArray([
+    ("ProductAdded", ["productId"]),
+    ("CategoryAdded", ["categoryId"]),
+  ]),
   ~crossPartitionTagKeys=["categoryId"],
 )
 

package/tests/components/dcb/DcbCrossPartitionReadTest.res

@@ -44,25 +44,32 @@ describe("DCB inferred cross-partition read (sibling exclusion)", () => {
       await dispatch(addProductJson("p3", "cat3", "Blocks"), "p3")
 
       // Queryable by its own partition key…
-      let byProduct = await ops.read(~query=[{tags: [{Reventless.DcbTag.key: "productId", value: "p3"}]}])
+      let byProduct = await ops.read(
+        ~query=[{tags: [{Reventless.DcbTag.key: "productId", value: "p3"}]}],
+      )
       expect(byProduct.events->Array.some(e => e.eventType == "ProductAdded"))->toBe(true)
 
       // …but the categoryId index returns only the category's own event, never p3.
-      let byCategory = await ops.read(~query=[{tags: [{Reventless.DcbTag.key: "categoryId", value: "cat3"}]}])
+      let byCategory = await ops.read(
+        ~query=[{tags: [{Reventless.DcbTag.key: "categoryId", value: "cat3"}]}],
+      )
       expect(byCategory.events->Array.some(e => e.eventType == "ProductAdded"))->toBe(false)
       expect(byCategory.events->Array.some(e => e.eventType == "CategoryAdded"))->toBe(true)
     },
   )
 
-  testPromise("re-adding the same product is still rejected (its own read is partition-scoped)", async () => {
-    let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
-    let _ = await ops.append([
-      encodeEvent(CategoryAdded({categoryId: "cat2", name: "Books"})),
-      encodeEvent(ProductAdded({productId: "p9", categoryId: "cat2", name: "Novel"})),
-    ])
-    capturedEventCount := 0 // count only events produced by the command below
-    // p9 already exists — its own productId clause returns its ProductAdded.
-    await dispatch(addProductJson("p9", "cat2", "Novel"), "p9")
-    expect(capturedEventCount.contents)->toBe(0)
-  })
+  testPromise(
+    "re-adding the same product is still rejected (its own read is partition-scoped)",
+    async () => {
+      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+      let _ = await ops.append([
+        encodeEvent(CategoryAdded({categoryId: "cat2", name: "Books"})),
+        encodeEvent(ProductAdded({productId: "p9", categoryId: "cat2", name: "Novel"})),
+      ])
+      capturedEventCount := 0 // count only events produced by the command below
+      // p9 already exists — its own productId clause returns its ProductAdded.
+      await dispatch(addProductJson("p9", "cat2", "Novel"), "p9")
+      expect(capturedEventCount.contents)->toBe(0)
+    },
+  )
 })

package/tests/components/dcb/DcbEventLogAppendStreamTest.res

@@ -25,10 +25,11 @@ describe("DcbEventLog.appendStream (in-memory adapter)", () => {
 
   testPromise("appendStream writes all events from stream", async () => {
     let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
-    let stream = [
-      encodeEvent(DcbFixtures.ItemEventLog.ItemAdded({id: "as-w1", name: "Widget1"})),
-      encodeEvent(DcbFixtures.ItemEventLog.ItemAdded({id: "as-w1", name: "Widget2"})),
-    ]->Stream.fromIterable
+    let stream =
+      [
+        encodeEvent(DcbFixtures.ItemEventLog.ItemAdded({id: "as-w1", name: "Widget1"})),
+        encodeEvent(DcbFixtures.ItemEventLog.ItemAdded({id: "as-w1", name: "Widget2"})),
+      ]->Stream.fromIterable
     let result = await ops.appendStream(stream)->Effect.runPromise
     let isOk = switch result {
     | Ok(_) => true
@@ -52,10 +53,12 @@ describe("DcbEventLog.appendStream (in-memory adapter)", () => {
 
   testPromise("readStream → appendStream pipeline copies events", async () => {
     let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
-    let _ = await ops.append([encodeEvent(DcbFixtures.ItemEventLog.ItemAdded({id: "as-src", name: "Source"}))])
+    let _ = await ops.append([
+      encodeEvent(DcbFixtures.ItemEventLog.ItemAdded({id: "as-src", name: "Source"})),
+    ])
     // readStream returns rawSequencedEvent; extract bare rawEvent for appendStream
-    let srcStream =
-      ops.readStream(~query=tagQuery("as-src"))->Stream.map(se => {
+    let srcStream = ops.readStream(~query=tagQuery("as-src"))->Stream.map(
+      se => {
         let rawEvent: ReventlessInfra.DcbEventLog.rawEvent = {
           eventType: se.eventType,
           data: se.data,
@@ -63,7 +66,8 @@ describe("DcbEventLog.appendStream (in-memory adapter)", () => {
           meta: se.meta,
         }
         rawEvent
-      })
+      },
+    )
     let _ = await ops.appendStream(srcStream)->Effect.runPromise
     let dst = await ops.read(~query=tagQuery("as-src"))
     // 1 original + 1 copy = 2 events for the same tag