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

package/tests/components/automationslice/AutomationSliceCallbackTest.res

@@ -5,10 +5,7 @@
 open JestGlobals
 open AutomationSliceFixtures
 
-module Callback = ReventlessCore.AutomationSlice_Callback.Make(
-  ShipOrderSpec,
-  ShipOrderAutomation,
-)
+module Callback = ReventlessCore.AutomationSlice_Callback.Make(ShipOrderSpec, ShipOrderAutomation)
 
 module SkipCallback = ReventlessCore.AutomationSlice_Callback.Make(
   SkipProcessSpec,
@@ -28,155 +25,182 @@ describe("AutomationSlice Callback (mixed-source)", () => {
   })
 
   describe("Phase 1 — collect", () => {
-    testPromise("OrderPlaced JSON creates a pending TODO item", async () => {
-      let json = encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))
-      Callback.phase1([json], testContext)
-      let items = Callback.todoItems
-      expect(items->Dict.toArray->Array.length)->toBe(1)
-      let row = items->Dict.get("ord-1")->Option.getOrThrow
-      expect(row.status)->toBe(Pending)
-      expect(row.retryCount)->toBe(0)
-    })
-
-    testPromise("duplicate OrderPlaced is idempotent", async () => {
-      let j1 = encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))
-      let j2 = encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "456 Oak Ave"}))
-      Callback.phase1([j1], testContext)
-      Callback.phase1([j2], testContext)
-      expect(Callback.todoItems->Dict.toArray->Array.length)->toBe(1)
-    })
-
-    testPromise("multiple OrderPlaced events create multiple TODO items", async () => {
-      let j1 = encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))
-      let j2 = encodeShipOrderEvent(OrderPlaced({orderId: "ord-2", address: "456 Oak Ave"}))
-      Callback.phase1([j1, j2], testContext)
-      expect(Callback.todoItems->Dict.toArray->Array.length)->toBe(2)
-    })
-
-    testPromise("ShipmentCreated does not create a TODO item", async () => {
-      let json = encodeShipOrderEvent(ShipmentCreated({orderId: "ord-1"}))
-      Callback.phase1([json], testContext)
-      expect(Callback.todoItems->Dict.toArray->Array.length)->toBe(0)
-    })
+    testPromise(
+      "OrderPlaced JSON creates a pending TODO item",
+      async () => {
+        let json = encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))
+        Callback.phase1([json], testContext)
+        let items = Callback.todoItems
+        expect(items->Dict.toArray->Array.length)->toBe(1)
+        let row = items->Dict.get("ord-1")->Option.getOrThrow
+        expect(row.status)->toBe(Pending)
+        expect(row.retryCount)->toBe(0)
+      },
+    )
+
+    testPromise(
+      "duplicate OrderPlaced is idempotent",
+      async () => {
+        let j1 = encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))
+        let j2 = encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "456 Oak Ave"}))
+        Callback.phase1([j1], testContext)
+        Callback.phase1([j2], testContext)
+        expect(Callback.todoItems->Dict.toArray->Array.length)->toBe(1)
+      },
+    )
+
+    testPromise(
+      "multiple OrderPlaced events create multiple TODO items",
+      async () => {
+        let j1 = encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))
+        let j2 = encodeShipOrderEvent(OrderPlaced({orderId: "ord-2", address: "456 Oak Ave"}))
+        Callback.phase1([j1, j2], testContext)
+        expect(Callback.todoItems->Dict.toArray->Array.length)->toBe(2)
+      },
+    )
+
+    testPromise(
+      "ShipmentCreated does not create a TODO item",
+      async () => {
+        let json = encodeShipOrderEvent(ShipmentCreated({orderId: "ord-1"}))
+        Callback.phase1([json], testContext)
+        expect(Callback.todoItems->Dict.toArray->Array.length)->toBe(0)
+      },
+    )
   })
 
   describe("Phase 1 — resolve", () => {
-    testPromise("ShipmentCreated marks pending TODO item as completed", async () => {
-      Callback.phase1(
-        [encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))],
-        testContext,
-      )
-      Callback.phase1(
-        [encodeShipOrderEvent(ShipmentCreated({orderId: "ord-1"}))],
-        testContext,
-      )
-      let row = Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow
-      expect(row.status)->toBe(Completed)
-    })
-
-    testPromise("ShipmentCreated for unknown id is a no-op", async () => {
-      Callback.phase1(
-        [encodeShipOrderEvent(ShipmentCreated({orderId: "unknown"}))],
-        testContext,
-      )
-      expect(Callback.todoItems->Dict.toArray->Array.length)->toBe(0)
-    })
+    testPromise(
+      "ShipmentCreated marks pending TODO item as completed",
+      async () => {
+        Callback.phase1(
+          [encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))],
+          testContext,
+        )
+        Callback.phase1([encodeShipOrderEvent(ShipmentCreated({orderId: "ord-1"}))], testContext)
+        let row = Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow
+        expect(row.status)->toBe(Completed)
+      },
+    )
+
+    testPromise(
+      "ShipmentCreated for unknown id is a no-op",
+      async () => {
+        Callback.phase1([encodeShipOrderEvent(ShipmentCreated({orderId: "unknown"}))], testContext)
+        expect(Callback.todoItems->Dict.toArray->Array.length)->toBe(0)
+      },
+    )
   })
 
   describe("Phase 2 — process", () => {
-    testPromise("pending items produce commands via publishJsons", async () => {
-      Callback.phase1(
-        [encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))],
-        testContext,
-      )
-      let publishedCommands = ref([])
-      let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
-        publishedCommands := cmds
-      }
-      await Callback.phase2(mockPublish)
-
-      expect(publishedCommands.contents->Array.length)->toBe(1)
-      let cmd = publishedCommands.contents->Array.getUnsafe(0)
-      expect(cmd.id)->toBe("ord-1")
-
-      let row = Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow
-      expect(row.status)->toBe(Processing)
-    })
-
-    testPromise("completed items are not processed", async () => {
-      Callback.phase1(
-        [encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))],
-        testContext,
-      )
-      Callback.phase1(
-        [encodeShipOrderEvent(ShipmentCreated({orderId: "ord-1"}))],
-        testContext,
-      )
-      let publishedCommands = ref([])
-      let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
-        publishedCommands := cmds
-      }
-      await Callback.phase2(mockPublish)
-      expect(publishedCommands.contents->Array.length)->toBe(0)
-    })
-
-    testPromise("items where process returns None are skipped", async () => {
-      let json = encodeSkipProcessEvent(OrderPlaced({orderId: "ord-1"}))
-      SkipCallback.phase1([json], testContext)
-      let publishedCommands = ref([])
-      let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
-        publishedCommands := cmds
-      }
-      await SkipCallback.phase2(mockPublish)
-      expect(publishedCommands.contents->Array.length)->toBe(0)
-      let row = SkipCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow
-      expect(row.status)->toBe(Pending)
-    })
-
-    testPromise("empty TODO list produces no commands", async () => {
-      let publishedCommands = ref([])
-      let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
-        publishedCommands := cmds
-      }
-      await Callback.phase2(mockPublish)
-      expect(publishedCommands.contents->Array.length)->toBe(0)
-    })
-
-    testPromise("publishJsons failure marks items as Failed", async () => {
-      Callback.phase1(
-        [encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))],
-        testContext,
-      )
-      let failingPublish: ReventlessInfra.CommandTopic.publishJsons = async _cmds => {
-        JsError.throwWithMessage("publish failed")
-      }
-      await Callback.phase2(failingPublish)
-      let row = Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow
-      expect(row.status)->toBe(Failed)
-      expect(row.retryCount)->toBe(1)
-    })
-
-    testPromise("failed items with retryCount < maxRetries are retried", async () => {
-      Callback.phase1(
-        [encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))],
-        testContext,
-      )
-      let failingPublish: ReventlessInfra.CommandTopic.publishJsons = async _cmds => {
-        JsError.throwWithMessage("publish failed")
-      }
-      await Callback.phase2(failingPublish)
-      let row1 = Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow
-      expect(row1.retryCount)->toBe(1)
-
-      let publishedCommands = ref([])
-      let successPublish: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
-        publishedCommands := cmds
-      }
-      await Callback.phase2(successPublish)
-      expect(publishedCommands.contents->Array.length)->toBe(1)
-      let row2 = Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow
-      expect(row2.status)->toBe(Processing)
-    })
+    testPromise(
+      "pending items produce commands via publishJsons",
+      async () => {
+        Callback.phase1(
+          [encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))],
+          testContext,
+        )
+        let publishedCommands = ref([])
+        let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
+          publishedCommands := cmds
+        }
+        await Callback.phase2(mockPublish)
+
+        expect(publishedCommands.contents->Array.length)->toBe(1)
+        let cmd = publishedCommands.contents->Array.getUnsafe(0)
+        expect(cmd.id)->toBe("ord-1")
+
+        let row = Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow
+        expect(row.status)->toBe(Processing)
+      },
+    )
+
+    testPromise(
+      "completed items are not processed",
+      async () => {
+        Callback.phase1(
+          [encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))],
+          testContext,
+        )
+        Callback.phase1([encodeShipOrderEvent(ShipmentCreated({orderId: "ord-1"}))], testContext)
+        let publishedCommands = ref([])
+        let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
+          publishedCommands := cmds
+        }
+        await Callback.phase2(mockPublish)
+        expect(publishedCommands.contents->Array.length)->toBe(0)
+      },
+    )
+
+    testPromise(
+      "items where process returns None are skipped",
+      async () => {
+        let json = encodeSkipProcessEvent(OrderPlaced({orderId: "ord-1"}))
+        SkipCallback.phase1([json], testContext)
+        let publishedCommands = ref([])
+        let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
+          publishedCommands := cmds
+        }
+        await SkipCallback.phase2(mockPublish)
+        expect(publishedCommands.contents->Array.length)->toBe(0)
+        let row = SkipCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow
+        expect(row.status)->toBe(Pending)
+      },
+    )
+
+    testPromise(
+      "empty TODO list produces no commands",
+      async () => {
+        let publishedCommands = ref([])
+        let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
+          publishedCommands := cmds
+        }
+        await Callback.phase2(mockPublish)
+        expect(publishedCommands.contents->Array.length)->toBe(0)
+      },
+    )
+
+    testPromise(
+      "publishJsons failure marks items as Failed",
+      async () => {
+        Callback.phase1(
+          [encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))],
+          testContext,
+        )
+        let failingPublish: ReventlessInfra.CommandTopic.publishJsons = async _cmds => {
+          JsError.throwWithMessage("publish failed")
+        }
+        await Callback.phase2(failingPublish)
+        let row = Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow
+        expect(row.status)->toBe(Failed)
+        expect(row.retryCount)->toBe(1)
+      },
+    )
+
+    testPromise(
+      "failed items with retryCount < maxRetries are retried",
+      async () => {
+        Callback.phase1(
+          [encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))],
+          testContext,
+        )
+        let failingPublish: ReventlessInfra.CommandTopic.publishJsons = async _cmds => {
+          JsError.throwWithMessage("publish failed")
+        }
+        await Callback.phase2(failingPublish)
+        let row1 = Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow
+        expect(row1.retryCount)->toBe(1)
+
+        let publishedCommands = ref([])
+        let successPublish: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
+          publishedCommands := cmds
+        }
+        await Callback.phase2(successPublish)
+        expect(publishedCommands.contents->Array.length)->toBe(1)
+        let row2 = Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow
+        expect(row2.status)->toBe(Processing)
+      },
+    )
   })
 
   // A row used to leave the retry budget by falling out of phase2's filter, so
@@ -194,83 +218,96 @@ describe("AutomationSlice Callback (mixed-source)", () => {
 
     let statusOf = id => (Callback.todoItems->Dict.get(id)->Option.getOrThrow).status
 
-    testPromise("the attempt that spends the budget writes Abandoned, not Failed", async () => {
-      collectOne()
-      // ShipOrderSpec.maxRetries is 3: attempts at retryCount 0, 1 and 2 leave the
-      // row retriable, and the third failure is the one that ends it.
-      await Callback.phase2(failingPublish)
-      expect(statusOf("ord-1"))->toBe(Failed)
-      await Callback.phase2(failingPublish)
-      expect(statusOf("ord-1"))->toBe(Failed)
-      await Callback.phase2(failingPublish)
-      expect(statusOf("ord-1"))->toBe(Abandoned)
-      expect((Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow).retryCount)->toBe(3)
-    })
-
-    testPromise("an abandoned row is not picked up again", async () => {
-      collectOne()
-      await Callback.phase2(failingPublish)
-      await Callback.phase2(failingPublish)
-      await Callback.phase2(failingPublish)
-      expect(statusOf("ord-1"))->toBe(Abandoned)
-
-      // A pass that would have succeeded: the row must still not be attempted,
-      // which is what makes the status a decision rather than a label.
-      let published = ref([])
-      await Callback.phase2(async cmds => published := cmds)
-      expect(published.contents->Array.length)->toBe(0)
-      expect(statusOf("ord-1"))->toBe(Abandoned)
-      expect((Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow).retryCount)->toBe(3)
-    })
-
-    testPromise("a row left stranded at the ceiling is normalised on the next pass", async () => {
-      collectOne()
-      // What an older build wrote, and what a Spec that lowered maxRetries leaves
-      // behind: Failed at the ceiling, which no pass would ever pick up or mark.
-      let row = Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow
-      Callback.todoItems->Dict.set("ord-1", {...row, status: Failed, retryCount: 3})
-
-      let published = ref([])
-      await Callback.phase2(async cmds => published := cmds)
-      expect(published.contents->Array.length)->toBe(0)
-      expect(statusOf("ord-1"))->toBe(Abandoned)
-    })
-
-    testPromise("the row carries the ceiling its count is racing", async () => {
-      collectOne()
-      expect((Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow).maxRetries)
-      ->toEqual(Some(ShipOrderSpec.maxRetries))
-    })
+    testPromise(
+      "the attempt that spends the budget writes Abandoned, not Failed",
+      async () => {
+        collectOne()
+        // ShipOrderSpec.maxRetries is 3: attempts at retryCount 0, 1 and 2 leave the
+        // row retriable, and the third failure is the one that ends it.
+        await Callback.phase2(failingPublish)
+        expect(statusOf("ord-1"))->toBe(Failed)
+        await Callback.phase2(failingPublish)
+        expect(statusOf("ord-1"))->toBe(Failed)
+        await Callback.phase2(failingPublish)
+        expect(statusOf("ord-1"))->toBe(Abandoned)
+        expect((Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow).retryCount)->toBe(3)
+      },
+    )
+
+    testPromise(
+      "an abandoned row is not picked up again",
+      async () => {
+        collectOne()
+        await Callback.phase2(failingPublish)
+        await Callback.phase2(failingPublish)
+        await Callback.phase2(failingPublish)
+        expect(statusOf("ord-1"))->toBe(Abandoned)
+
+        // A pass that would have succeeded: the row must still not be attempted,
+        // which is what makes the status a decision rather than a label.
+        let published = ref([])
+        await Callback.phase2(async cmds => published := cmds)
+        expect(published.contents->Array.length)->toBe(0)
+        expect(statusOf("ord-1"))->toBe(Abandoned)
+        expect((Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow).retryCount)->toBe(3)
+      },
+    )
+
+    testPromise(
+      "a row left stranded at the ceiling is normalised on the next pass",
+      async () => {
+        collectOne()
+        // What an older build wrote, and what a Spec that lowered maxRetries leaves
+        // behind: Failed at the ceiling, which no pass would ever pick up or mark.
+        let row = Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow
+        Callback.todoItems->Dict.set("ord-1", {...row, status: Failed, retryCount: 3})
+
+        let published = ref([])
+        await Callback.phase2(async cmds => published := cmds)
+        expect(published.contents->Array.length)->toBe(0)
+        expect(statusOf("ord-1"))->toBe(Abandoned)
+      },
+    )
+
+    testPromise(
+      "the row carries the ceiling its count is racing",
+      async () => {
+        collectOne()
+        expect((Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow).maxRetries)->toEqual(
+          Some(ShipOrderSpec.maxRetries),
+        )
+      },
+    )
   })
 
   describe("full lifecycle", () => {
-    testPromise("collect → process → resolve completes the TODO item", async () => {
-      Callback.phase1(
-        [encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))],
-        testContext,
-      )
-      expect((Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow).status)->toBe(Pending)
-
-      let publishedCommands = ref([])
-      let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
-        publishedCommands := cmds
-      }
-      await Callback.phase2(mockPublish)
-      expect(publishedCommands.contents->Array.length)->toBe(1)
-      expect((Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow).status)->toBe(Processing)
-
-      Callback.phase1(
-        [encodeShipOrderEvent(ShipmentCreated({orderId: "ord-1"}))],
-        testContext,
-      )
-      expect((Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow).status)->toBe(Completed)
-
-      let publishedCommands2 = ref([])
-      let mockPublish2: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
-        publishedCommands2 := cmds
-      }
-      await Callback.phase2(mockPublish2)
-      expect(publishedCommands2.contents->Array.length)->toBe(0)
-    })
+    testPromise(
+      "collect → process → resolve completes the TODO item",
+      async () => {
+        Callback.phase1(
+          [encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))],
+          testContext,
+        )
+        expect((Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow).status)->toBe(Pending)
+
+        let publishedCommands = ref([])
+        let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
+          publishedCommands := cmds
+        }
+        await Callback.phase2(mockPublish)
+        expect(publishedCommands.contents->Array.length)->toBe(1)
+        expect((Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow).status)->toBe(Processing)
+
+        Callback.phase1([encodeShipOrderEvent(ShipmentCreated({orderId: "ord-1"}))], testContext)
+        expect((Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow).status)->toBe(Completed)
+
+        let publishedCommands2 = ref([])
+        let mockPublish2: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
+          publishedCommands2 := cmds
+        }
+        await Callback.phase2(mockPublish2)
+        expect(publishedCommands2.contents->Array.length)->toBe(0)
+      },
+    )
   })
 })

package/tests/components/automationslice/AutomationSliceFixtures.res

@@ -106,8 +106,10 @@ module SkipProcessMapping = Reventless.AutomationSlice.Mapping.Make(
 
 module ShipOrderAutomation: Reventless.AutomationSlice.Automation
   with module Spec := ShipOrderSpec = {
-  let process = (id, _item: ShipOrderSpec.todoItem) =>
-    Some((id, ShipOrderSpec.CreateShipment({orderId: id})))
+  let process = (id, _item: ShipOrderSpec.todoItem) => Some((
+    id,
+    ShipOrderSpec.CreateShipment({orderId: id}),
+  ))
   let onExhausted = (_id, _item: ShipOrderSpec.todoItem) => None
   let moduleUrl: string = %raw(`import.meta.url`)
   module M = Reventless.AutomationSlice.Mappings.Make(ShipOrderSpec)

package/tests/components/automationslice/AutomationSliceSelfDeadlockFixtures.res

@@ -156,8 +156,7 @@ module FromDcb = AutomationSlice.Mapping.Make(
 )
 
 module AutoShipAutomation: AutomationSlice.Automation with module Spec := AutoShipSpec = {
-  let process = (id, _item: AutoShipSpec.todoItem) =>
-    Some((id, AutoShipSpec.Ship({orderId: id})))
+  let process = (id, _item: AutoShipSpec.todoItem) => Some((id, AutoShipSpec.Ship({orderId: id})))
   let onExhausted = (_id, _item: AutoShipSpec.todoItem) => None
   let moduleUrl: string = %raw(`import.meta.url`)
   module M = AutomationSlice.Mappings.Make(AutoShipSpec)
@@ -189,42 +188,40 @@ let dcbEventLog = DcbLogMaker.make(
 // ─────────────────────────────────────────────────────────────
 
 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->Reventless.Util_Sury.toJson(Reventless.Message.metaSchema)),
-          ("command", cmdJson.commandJson),
-        ]),
+  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
+        }
       )
-      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
+      ->Option.getOr("")
+    | _ => ""
+    }
+    let fullBody = JSON.Encode.object(
+      Dict.fromArray([
+        ("id", JSON.Encode.string(cmdJson.id)),
+        ("meta", cmdJson.meta->Reventless.Util_Sury.toJson(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
@@ -239,7 +236,9 @@ let _placeSlice = PlaceMaker.make(~dcbEventLog, ~publishJsons=publishJsonsOutput
 module ShipMaker = StateChangeSlice_Builder.Make(ShipSpec, ShipBehavior)
 let _shipSlice = ShipMaker.make(~dcbEventLog, ~publishJsons=publishJsonsOutput)
 
-let dcbTopicOutputs: ReventlessInfra.EventTopic.outputs = (dcbEventLog->ReventlessInfra.Component.outputs).eventTopic
+let dcbTopicOutputs: ReventlessInfra.EventTopic.outputs = (
+  dcbEventLog->ReventlessInfra.Component.outputs
+).eventTopic
 let allEventTopics: ReventlessInfra.EventTopic.allOutputs = Dict.fromArray([
   (DcbSource.name, dcbTopicOutputs),
 ])
@@ -266,8 +265,9 @@ let autoShipSlice = AutoShip.make(
 let placeCmdJson = (orderId: string): Reventless.Message.commandJson => {
   id: orderId,
   meta: testMeta,
-  commandJson: PlaceSpec.Place({orderId: orderId})
-    ->Reventless.Util_Sury.toJson(PlaceSpec.commandSchema),
+  commandJson: PlaceSpec.Place({orderId: orderId})->Reventless.Util_Sury.toJson(
+    PlaceSpec.commandSchema,
+  ),
 }
 
 // Promise-based timeout used to fail fast if the chain self-deadlocks.