@reventlessdev/reventless-core 3.0.0-alpha.259 → 3.0.0-alpha.261

package/tests/commandgenerator/OwnerStampingTest.res

@@ -1,6 +1,5 @@
 open JestGlobals
 
-
 // Driven through `makeGenerateCommand` rather than by calling `stampOwnerFields`
 // directly. The unit under test is not really the stamp — it is the claim that
 // the stamp is reached on the path a command actually takes, which is the half a
@@ -16,7 +15,10 @@ type command =
     })
   | // The control variant: same union, no owner. Whatever the caller sends here
   // must survive untouched, or the stamp is reaching across constructors.
-  ImportProducts({batchId: @s.matches(Reventless.DcbTag.string) string, source: string})
+  ImportProducts({
+      batchId: @s.matches(Reventless.DcbTag.string) string,
+      source: string,
+    })
 
 let published: ref<array<Message.commandJson>> = ref([])
 
@@ -86,30 +88,27 @@ describe("@owner stamping on the command path:", () => {
   // The decisive case. An implementation that fills only the absent field passes
   // every other test in this file and hands one customer another's orders.
   testPromise("a FORGED owner field is overwritten, not respected", async () => {
-    let _ =
-      await generate(
-        placeOrder(~customerId="cust-B", ~identity=cognito(~userId="cust-A", ~groups=["User"])),
-      )->Effect.runPromise
+    let _ = await generate(
+      placeOrder(~customerId="cust-B", ~identity=cognito(~userId="cust-A", ~groups=["User"])),
+    )->Effect.runPromise
     expect(lastPublished()->fieldOf("customerId"))->toEqual(Some(str("cust-A")))
   })
 
   testPromise("non-owner fields of the same command are untouched", async () => {
-    let _ =
-      await generate(
-        placeOrder(~customerId="cust-B", ~identity=cognito(~userId="cust-A", ~groups=["User"])),
-      )->Effect.runPromise
+    let _ = await generate(
+      placeOrder(~customerId="cust-B", ~identity=cognito(~userId="cust-A", ~groups=["User"])),
+    )->Effect.runPromise
     expect(lastPublished()->fieldOf("note"))->toEqual(Some(str("gift wrap")))
   })
 
   testPromise("a command in the same union with no owner field is left alone", async () => {
-    let _ =
-      await generate(
-        payload(
-          ~command="ImportProducts",
-          ~args=Dict.fromArray([("batchId", str("b-1")), ("source", str("acme"))]),
-          ~identity=cognito(~userId="cust-A", ~groups=["User"]),
-        ),
-      )->Effect.runPromise
+    let _ = await generate(
+      payload(
+        ~command="ImportProducts",
+        ~args=Dict.fromArray([("batchId", str("b-1")), ("source", str("acme"))]),
+        ~identity=cognito(~userId="cust-A", ~groups=["User"]),
+      ),
+    )->Effect.runPromise
     expect((lastPublished()->fieldOf("source"), lastPublished()->fieldOf("customerId")))->toEqual((
       Some(str("acme")),
       None,
@@ -119,21 +118,25 @@ describe("@owner stamping on the command path:", () => {
   describe("exempt callers keep the value they sent:", () => {
     // Acting on another principal's behalf must stay possible for those who may
     // — otherwise an operator can never correct or back-fill anything.
-    testPromise("an elevated caller's chosen customerId survives", async () => {
-      let _ =
-        await generate(
+    testPromise(
+      "an elevated caller's chosen customerId survives",
+      async () => {
+        let _ = await generate(
           placeOrder(~customerId="cust-B", ~identity=cognito(~userId="ops-1", ~groups=["Admin"])),
         )->Effect.runPromise
-      expect(lastPublished()->fieldOf("customerId"))->toEqual(Some(str("cust-B")))
-    })
+        expect(lastPublished()->fieldOf("customerId"))->toEqual(Some(str("cust-B")))
+      },
+    )
 
     // The IAM shape carries no userId at all. Stamping it would write
     // `undefined`; refusing it would break internal traffic. It is exempt.
-    testPromise("an IAM system caller's chosen customerId survives", async () => {
-      let _ =
-        await generate(placeOrder(~customerId="cust-B", ~identity=iam))->Effect.runPromise
-      expect(lastPublished()->fieldOf("customerId"))->toEqual(Some(str("cust-B")))
-    })
+    testPromise(
+      "an IAM system caller's chosen customerId survives",
+      async () => {
+        let _ = await generate(placeOrder(~customerId="cust-B", ~identity=iam))->Effect.runPromise
+        expect(lastPublished()->fieldOf("customerId"))->toEqual(Some(str("cust-B")))
+      },
+    )
   })
 
   describe("a caller that cannot be identified is refused:", () => {
@@ -143,45 +146,56 @@ describe("@owner stamping on the command path:", () => {
       | exception _ => true
       }
 
-    testPromise("an anonymous caller cannot place an owned command", async () =>
-      expect(
-        await refused(placeOrder(~customerId="cust-B", ~identity=Reventless.Identity.anonymous)),
-      )->toBe(true)
+    testPromise(
+      "an anonymous caller cannot place an owned command",
+      async () =>
+        expect(
+          await refused(placeOrder(~customerId="cust-B", ~identity=Reventless.Identity.anonymous)),
+        )->toBe(true),
     )
 
     // The refusal describes the caller's own request, so a transport is allowed
     // to report it. Unmarked it arrives as "Unexpected error", which tells a
     // caller who needs to authenticate nothing at all.
-    testPromise("the refusal is marked as the caller's fault", async () => {
-      let failure = switch await generate(
-        placeOrder(~customerId="cust-B", ~identity=Reventless.Identity.anonymous),
-      )->Effect.runPromise {
-      | _ => None
-      | exception e => Some(e)
-      }
-      expect(failure->Option.mapOr(false, Plugin_ResolverError.isCallerFault))->toBe(true)
-    })
+    testPromise(
+      "the refusal is marked as the caller's fault",
+      async () => {
+        let failure = switch await generate(
+          placeOrder(~customerId="cust-B", ~identity=Reventless.Identity.anonymous),
+        )->Effect.runPromise {
+        | _ => None
+        | exception e => Some(e)
+        }
+        expect(failure->Option.mapOr(false, Plugin_ResolverError.isCallerFault))->toBe(true)
+      },
+    )
 
-    testPromise("nothing is published when the caller is refused", async () => {
-      let _ = await refused(
-        placeOrder(~customerId="cust-B", ~identity=Reventless.Identity.anonymous),
-      )
-      expect(published.contents->Array.length)->toBe(0)
-    })
+    testPromise(
+      "nothing is published when the caller is refused",
+      async () => {
+        let _ = await refused(
+          placeOrder(~customerId="cust-B", ~identity=Reventless.Identity.anonymous),
+        )
+        expect(published.contents->Array.length)->toBe(0)
+      },
+    )
 
     // The refusal is scoped to commands that actually record an owner. An
     // anonymous caller invoking an unowned command has nothing to prove, and
     // refusing it here would silently narrow `AllowAnonymous`.
-    testPromise("an anonymous caller may still issue an unowned command", async () => {
-      let _ = await generate(
-        payload(
-          ~command="ImportProducts",
-          ~args=Dict.fromArray([("batchId", str("b-1")), ("source", str("acme"))]),
-          ~identity=Reventless.Identity.anonymous,
-        ),
-      )->Effect.runPromise
-      expect(lastPublished()->fieldOf("source"))->toEqual(Some(str("acme")))
-    })
+    testPromise(
+      "an anonymous caller may still issue an unowned command",
+      async () => {
+        let _ = await generate(
+          payload(
+            ~command="ImportProducts",
+            ~args=Dict.fromArray([("batchId", str("b-1")), ("source", str("acme"))]),
+            ~identity=Reventless.Identity.anonymous,
+          ),
+        )->Effect.runPromise
+        expect(lastPublished()->fieldOf("source"))->toEqual(Some(str("acme")))
+      },
+    )
   })
 })
 
@@ -207,10 +221,9 @@ describe("the schema a generator is built with must answer for its commands:", (
   )
 
   testPromise("a permissive schema silently stamps nothing — the defect, pinned", async () => {
-    let _ =
-      await permissive(
-        placeOrder(~customerId="cust-B", ~identity=cognito(~userId="cust-A", ~groups=["User"])),
-      )->Effect.runPromise
+    let _ = await permissive(
+      placeOrder(~customerId="cust-B", ~identity=cognito(~userId="cust-A", ~groups=["User"])),
+    )->Effect.runPromise
     // Not the behaviour we want anywhere — recorded so that a change making the
     // permissive path stamp correctly is a deliberate one, and so the contrast
     // with the case below cannot be read as incidental.
@@ -218,10 +231,9 @@ describe("the schema a generator is built with must answer for its commands:", (
   })
 
   testPromise("the real schema stamps, from the same payload and caller", async () => {
-    let _ =
-      await generate(
-        placeOrder(~customerId="cust-B", ~identity=cognito(~userId="cust-A", ~groups=["User"])),
-      )->Effect.runPromise
+    let _ = await generate(
+      placeOrder(~customerId="cust-B", ~identity=cognito(~userId="cust-A", ~groups=["User"])),
+    )->Effect.runPromise
     expect(lastPublished()->fieldOf("customerId"))->toEqual(Some(str("cust-A")))
   })
 
@@ -229,15 +241,18 @@ describe("the schema a generator is built with must answer for its commands:", (
   // maps now satisfy by construction: every command a spec exposes resolves to
   // its own owner fields through the schema that command will be dispatched
   // with. Reading `[]` here is exactly the state that stamps nothing.
-  testPromise("every command of a spec resolves its owner fields through that spec's schema", async () => {
-    let schema = commandSchema->S.castToUnknown
-    expect(Reventless.Owner.variantFieldNames(schema, ~variant="PlaceOrder"))->toEqual([
-      "customerId",
-    ])
-    expect(Reventless.Owner.variantFieldNames(schema, ~variant="ImportProducts"))->toEqual([])
-    // The substitution, asked the same question.
-    expect(
-      Reventless.Owner.variantFieldNames(S.json->S.castToUnknown, ~variant="PlaceOrder"),
-    )->toEqual([])
-  })
+  testPromise(
+    "every command of a spec resolves its owner fields through that spec's schema",
+    async () => {
+      let schema = commandSchema->S.castToUnknown
+      expect(Reventless.Owner.variantFieldNames(schema, ~variant="PlaceOrder"))->toEqual([
+        "customerId",
+      ])
+      expect(Reventless.Owner.variantFieldNames(schema, ~variant="ImportProducts"))->toEqual([])
+      // The substitution, asked the same question.
+      expect(
+        Reventless.Owner.variantFieldNames(S.json->S.castToUnknown, ~variant="PlaceOrder"),
+      )->toEqual([])
+    },
+  )
 })

package/tests/commandtopic/CommandOutcomeHookTest.res

@@ -47,8 +47,10 @@ let sliceItem = (reference, command): CommandTopic.topicItem<
 }
 
 let runSlice = (reference, command) =>
-  SliceHandler.handleCommands(dcbEventLog, Stream.fromIterable([sliceItem(reference, command)]))
-  ->Effect.runPromise
+  SliceHandler.handleCommands(
+    dcbEventLog,
+    Stream.fromIterable([sliceItem(reference, command)]),
+  )->Effect.runPromise
 
 let runAgg = (~aggId="agg-1", reference, command) =>
   Stream.fromIterable([AggregateFixtures.makeTopicItem(~aggId, reference, command)])
@@ -78,9 +80,7 @@ let seen = () =>
   )
 
 let record = () =>
-  CommandTopic_Helpers.registerCommandOutcome(r =>
-    observed := observed.contents->Array.concat([r])
-  )
+  CommandTopic_Helpers.registerCommandOutcome(r => observed := observed.contents->Array.concat([r]))
 
 let _ = beforeEach(() => {
   AggregateFixtures.mock.reset()
@@ -94,166 +94,209 @@ let _ = beforeEach(() => {
 
 describe("CommandTopic command-outcome hook:", () => {
   describe("aggregate", () => {
-    testPromise("observes an accepted command with no side-channel installed", async () => {
-      record()
-      let results = await runAgg("ref-1", AggregateFixtures.AggSpec.Create({name: "Widget"}))
-
-      expect(results)->toEqual([Ok("ref-1")])
-      expect(seen())->toEqual([("TestAggregate", "ref-1", "accepted", "", 1)])
-    })
-
-    testPromise("carries the entity id of an accepted command", async () => {
-      record()
-      let _ = await runAgg(~aggId="agg-7", "ref-1", AggregateFixtures.AggSpec.Create({name: "W"}))
-
-      let entityId = switch (observed.contents->Array.getUnsafe(0)).outcome {
-      | OutcomeAccepted({entityId}) => entityId
-      | OutcomeRejected(_) => None
-      }
-      expect(entityId)->toEqual(Some("agg-7"))
-    })
-
-    testPromise("reports a decide rejection as domain, with the declared error code", async () => {
-      // Seed before registering, so only the second (rejected) Create is observed.
-      let _ = await runAgg("ref-seed", AggregateFixtures.AggSpec.Create({name: "Widget"}))
-      record()
-      let results = await runAgg("ref-1", AggregateFixtures.AggSpec.Create({name: "Widget"}))
-
-      expect(results)->toEqual([Ok("ref-1")])
-      expect(seen())->toEqual([
-        ("TestAggregate", "ref-1", "rejected/domain", "AlreadyExists", 0),
-      ])
-    })
-
-    testPromise("reports a failed append as infrastructure, not a domain rejection", async () => {
-      record()
-      AggregateFixtures.mock.failNextAppend := true
-      let _ = await runAgg("ref-1", AggregateFixtures.AggSpec.Create({name: "Widget"}))
-
-      // `decide` said Ok here — the store is what failed, and the hook has to say so.
-      expect(seen())->toEqual([
-        ("TestAggregate", "ref-1", "rejected/infrastructure", "AppendFailed", 0),
-      ])
-    })
-
-    testPromise("observes every command of a mixed batch", async () => {
-      let _ = await runAgg("ref-seed", AggregateFixtures.AggSpec.Create({name: "Widget"}))
-      record()
-      let _ =
-        await Stream.fromIterable([
-          AggregateFixtures.makeTopicItem("ref-1", AggregateFixtures.AggSpec.Rename({newName: "A"})),
+    testPromise(
+      "observes an accepted command with no side-channel installed",
+      async () => {
+        record()
+        let results = await runAgg("ref-1", AggregateFixtures.AggSpec.Create({name: "Widget"}))
+
+        expect(results)->toEqual([Ok("ref-1")])
+        expect(seen())->toEqual([("TestAggregate", "ref-1", "accepted", "", 1)])
+      },
+    )
+
+    testPromise(
+      "carries the entity id of an accepted command",
+      async () => {
+        record()
+        let _ = await runAgg(~aggId="agg-7", "ref-1", AggregateFixtures.AggSpec.Create({name: "W"}))
+
+        let entityId = switch (observed.contents->Array.getUnsafe(0)).outcome {
+        | OutcomeAccepted({entityId}) => entityId
+        | OutcomeRejected(_) => None
+        }
+        expect(entityId)->toEqual(Some("agg-7"))
+      },
+    )
+
+    testPromise(
+      "reports a decide rejection as domain, with the declared error code",
+      async () => {
+        // Seed before registering, so only the second (rejected) Create is observed.
+        let _ = await runAgg("ref-seed", AggregateFixtures.AggSpec.Create({name: "Widget"}))
+        record()
+        let results = await runAgg("ref-1", AggregateFixtures.AggSpec.Create({name: "Widget"}))
+
+        expect(results)->toEqual([Ok("ref-1")])
+        expect(seen())->toEqual([("TestAggregate", "ref-1", "rejected/domain", "AlreadyExists", 0)])
+      },
+    )
+
+    testPromise(
+      "reports a failed append as infrastructure, not a domain rejection",
+      async () => {
+        record()
+        AggregateFixtures.mock.failNextAppend := true
+        let _ = await runAgg("ref-1", AggregateFixtures.AggSpec.Create({name: "Widget"}))
+
+        // `decide` said Ok here — the store is what failed, and the hook has to say so.
+        expect(seen())->toEqual([
+          ("TestAggregate", "ref-1", "rejected/infrastructure", "AppendFailed", 0),
+        ])
+      },
+    )
+
+    testPromise(
+      "observes every command of a mixed batch",
+      async () => {
+        let _ = await runAgg("ref-seed", AggregateFixtures.AggSpec.Create({name: "Widget"}))
+        record()
+        let _ = await Stream.fromIterable([
+          AggregateFixtures.makeTopicItem(
+            "ref-1",
+            AggregateFixtures.AggSpec.Rename({newName: "A"}),
+          ),
           AggregateFixtures.makeTopicItem("ref-2", AggregateFixtures.AggSpec.Create({name: "B"})),
-          AggregateFixtures.makeTopicItem("ref-3", AggregateFixtures.AggSpec.Rename({newName: "C"})),
+          AggregateFixtures.makeTopicItem(
+            "ref-3",
+            AggregateFixtures.AggSpec.Rename({newName: "C"}),
+          ),
         ])
         ->AggregateFixtures.TestHandler.handleCommands
         ->Effect.runPromise
 
-      expect(seen())->toEqual([
-        ("TestAggregate", "ref-1", "accepted", "", 2),
-        ("TestAggregate", "ref-2", "rejected/domain", "AlreadyExists", 0),
-        ("TestAggregate", "ref-3", "accepted", "", 2),
-      ])
-    })
+        expect(seen())->toEqual([
+          ("TestAggregate", "ref-1", "accepted", "", 2),
+          ("TestAggregate", "ref-2", "rejected/domain", "AlreadyExists", 0),
+          ("TestAggregate", "ref-3", "accepted", "", 2),
+        ])
+      },
+    )
   })
 
   describe("state-change slice", () => {
-    testPromise("observes an accepted command with no side-channel installed", async () => {
-      record()
-      let _ = await runSlice(
-        "ref-1",
-        DcbFixtures.TestCommandSpec.CreateItem({itemId: "item-1", name: "Test"}),
-      )
-
-      expect(seen())->toEqual([
-        ("TestStateChangeSlice", DcbFixtures.testMeta.msgId, "accepted", "", 1),
-      ])
-    })
-
-    testPromise("reports a decide rejection as domain, with the declared error code", async () => {
-      let _ = await runSlice(
-        "ref-seed",
-        DcbFixtures.TestCommandSpec.CreateItem({itemId: "item-1", name: "Test"}),
-      )
-      record()
-      let _ = await runSlice(
-        "ref-1",
-        DcbFixtures.TestCommandSpec.CreateItem({itemId: "item-1", name: "Again"}),
-      )
-
-      expect(seen())->toEqual([
-        (
-          "TestStateChangeSlice",
-          DcbFixtures.testMeta.msgId,
-          "rejected/domain",
-          "ItemAlreadyExists",
-          0,
-        ),
-      ])
-    })
-
-    testPromise("reports exhausted append conflicts as infrastructure", async () => {
-      record()
-      // One more failure than the retry loop can absorb.
-      dcbMock.failNextAppends := 4
-      let _ = await runSlice(
-        "ref-1",
-        DcbFixtures.TestCommandSpec.CreateItem({itemId: "item-1", name: "Test"}),
-      )
-
-      expect(seen())->toEqual([
-        ("TestStateChangeSlice", DcbFixtures.testMeta.msgId, "rejected/infrastructure", "Conflict", 0),
-      ])
-    })
+    testPromise(
+      "observes an accepted command with no side-channel installed",
+      async () => {
+        record()
+        let _ = await runSlice(
+          "ref-1",
+          DcbFixtures.TestCommandSpec.CreateItem({itemId: "item-1", name: "Test"}),
+        )
+
+        expect(seen())->toEqual([
+          ("TestStateChangeSlice", DcbFixtures.testMeta.msgId, "accepted", "", 1),
+        ])
+      },
+    )
+
+    testPromise(
+      "reports a decide rejection as domain, with the declared error code",
+      async () => {
+        let _ = await runSlice(
+          "ref-seed",
+          DcbFixtures.TestCommandSpec.CreateItem({itemId: "item-1", name: "Test"}),
+        )
+        record()
+        let _ = await runSlice(
+          "ref-1",
+          DcbFixtures.TestCommandSpec.CreateItem({itemId: "item-1", name: "Again"}),
+        )
+
+        expect(seen())->toEqual([
+          (
+            "TestStateChangeSlice",
+            DcbFixtures.testMeta.msgId,
+            "rejected/domain",
+            "ItemAlreadyExists",
+            0,
+          ),
+        ])
+      },
+    )
+
+    testPromise(
+      "reports exhausted append conflicts as infrastructure",
+      async () => {
+        record()
+        // One more failure than the retry loop can absorb.
+        dcbMock.failNextAppends := 4
+        let _ = await runSlice(
+          "ref-1",
+          DcbFixtures.TestCommandSpec.CreateItem({itemId: "item-1", name: "Test"}),
+        )
+
+        expect(seen())->toEqual([
+          (
+            "TestStateChangeSlice",
+            DcbFixtures.testMeta.msgId,
+            "rejected/infrastructure",
+            "Conflict",
+            0,
+          ),
+        ])
+      },
+    )
   })
 
   describe("registration", () => {
-    testPromise("with nothing registered nothing is observed and the command is unaffected", async () => {
-      let results = await runAgg("ref-1", AggregateFixtures.AggSpec.Create({name: "Widget"}))
-
-      expect(results)->toEqual([Ok("ref-1")])
-      expect(AggregateFixtures.mock.getAll()->Array.length)->toBe(1)
-      expect(observed.contents->Array.length)->toBe(0)
-    })
-
-    testPromise("clearCommandOutcome stops observation", async () => {
-      record()
-      CommandTopic_Helpers.clearCommandOutcome()
-      let _ = await runAgg("ref-1", AggregateFixtures.AggSpec.Create({name: "Widget"}))
-
-      expect(observed.contents->Array.length)->toBe(0)
-    })
-
-    testPromise("an out-of-tree extension can register it from onColdStart", async () => {
-      // The hook needs no registration path of its own: it has the shape the cold-start
-      // seam already reaches, so an extension picks it up alongside the other four.
-      module Accountant: RuntimeExtension.Extension = {
-        let moduleUrl = "file:///pkg/accountant.res.mjs"
-        let companionModuleUrls = []
-        let onColdStart = (~runtimeKind as _, ~component as _, ~plugin as _, ~platform as _) =>
-          record()
-      }
-      RuntimeExtension.use(module(Accountant: RuntimeExtension.Extension))
-      RuntimeExtension.notifyColdStart(
-        ~runtimeKind=ComponentType.Aggregate,
-        ~component="AllAggregates",
-        ~plugin=Some("Catalog"),
-        ~platform=Some("Shop"),
-      )
-
-      let _ = await runAgg("ref-1", AggregateFixtures.AggSpec.Create({name: "Widget"}))
-
-      expect(seen())->toEqual([("TestAggregate", "ref-1", "accepted", "", 1)])
-    })
-
-    testPromise("a throwing hook is swallowed and the command still succeeds", async () => {
-      CommandTopic_Helpers.registerCommandOutcome(_ =>
-        JsError.throwWithMessage("hook exploded")
-      )
-      let results = await runAgg("ref-1", AggregateFixtures.AggSpec.Create({name: "Widget"}))
-
-      // The outcome the hook observes has already happened — an observer must not undo it.
-      expect(results)->toEqual([Ok("ref-1")])
-      expect(AggregateFixtures.mock.getAll()->Array.length)->toBe(1)
-    })
+    testPromise(
+      "with nothing registered nothing is observed and the command is unaffected",
+      async () => {
+        let results = await runAgg("ref-1", AggregateFixtures.AggSpec.Create({name: "Widget"}))
+
+        expect(results)->toEqual([Ok("ref-1")])
+        expect(AggregateFixtures.mock.getAll()->Array.length)->toBe(1)
+        expect(observed.contents->Array.length)->toBe(0)
+      },
+    )
+
+    testPromise(
+      "clearCommandOutcome stops observation",
+      async () => {
+        record()
+        CommandTopic_Helpers.clearCommandOutcome()
+        let _ = await runAgg("ref-1", AggregateFixtures.AggSpec.Create({name: "Widget"}))
+
+        expect(observed.contents->Array.length)->toBe(0)
+      },
+    )
+
+    testPromise(
+      "an out-of-tree extension can register it from onColdStart",
+      async () => {
+        // The hook needs no registration path of its own: it has the shape the cold-start
+        // seam already reaches, so an extension picks it up alongside the other four.
+        module Accountant: RuntimeExtension.Extension = {
+          let moduleUrl = "file:///pkg/accountant.res.mjs"
+          let companionModuleUrls = []
+          let onColdStart = (~runtimeKind as _, ~component as _, ~plugin as _, ~platform as _) =>
+            record()
+        }
+        RuntimeExtension.use(module(Accountant: RuntimeExtension.Extension))
+        RuntimeExtension.notifyColdStart(
+          ~runtimeKind=ComponentType.Aggregate,
+          ~component="AllAggregates",
+          ~plugin=Some("Catalog"),
+          ~platform=Some("Shop"),
+        )
+
+        let _ = await runAgg("ref-1", AggregateFixtures.AggSpec.Create({name: "Widget"}))
+
+        expect(seen())->toEqual([("TestAggregate", "ref-1", "accepted", "", 1)])
+      },
+    )
+
+    testPromise(
+      "a throwing hook is swallowed and the command still succeeds",
+      async () => {
+        CommandTopic_Helpers.registerCommandOutcome(_ => JsError.throwWithMessage("hook exploded"))
+        let results = await runAgg("ref-1", AggregateFixtures.AggSpec.Create({name: "Widget"}))
+
+        // The outcome the hook observes has already happened — an observer must not undo it.
+        expect(results)->toEqual([Ok("ref-1")])
+        expect(AggregateFixtures.mock.getAll()->Array.length)->toBe(1)
+      },
+    )
   })
 })

package/tests/commandtopic/CommandTopicCallbackFixtures.res

@@ -1,4 +1,3 @@
-
 // ─────────────────────────────────────────────────────────────
 // Command spec for CommandTopic_Callback tests
 // ─────────────────────────────────────────────────────────────
@@ -43,9 +42,11 @@ module TestOps: CommandTopic_Callback.Ops with module Spec = TestSpec = {
       }
       capturedItems :=
         capturedItems.contents->Array.concat(
-          items->Array.map((item: ReventlessInfra.CommandTopic.topicItem<
-            Message.command'<TestSpec.Id.t, TestSpec.command>,
-          >) => {
+          items->Array.map((
+            item: ReventlessInfra.CommandTopic.topicItem<
+              Message.command'<TestSpec.Id.t, TestSpec.command>,
+            >,
+          ) => {
             reference: item.reference,
             command: item.command.command,
           }),