@reventlessdev/reventless-gwt 1.0.0-alpha.207 → 1.0.0-alpha.209

package/tests/FlowAggregateGwtTest.res

@@ -7,7 +7,6 @@
 //     command on `o2` does not see `o1`'s prior events.
 //   - The `Error` branch flows through `thenError` like the slice form.
 
-
 open Flow_GWT
 
 // -- Aggregate: CatalogProduct (one event family, no error) -----------------
@@ -16,12 +15,10 @@ module CatalogProductAggregate = {
   let name = "CatalogProduct"
 
   @schema
-  type command =
-    | SyncNewProduct({productId: string, name: string})
+  type command = SyncNewProduct({productId: string, name: string})
 
   @schema
-  type event =
-    | CatalogProductSynced({productId: string, name: string})
+  type event = CatalogProductSynced({productId: string, name: string})
 
   @schema
   type error = AlreadySynced

package/tests/FlowCrossPluginGwtTest.res

@@ -15,7 +15,6 @@
 // order fans out into one demand command per product across the boundary.
 // See `docs/plans/done/gwt-flow-and-extension-test-kinds.md` Phase 3.
 
-
 open Flow_GWT
 
 module EPM = ReventlessInfra.ExtensionPointMapping
@@ -40,7 +39,11 @@ module AddProductSlice = {
 
   @schema
   type event =
-    ProductAdded({productId: @s.matches(Reventless.DcbTag.string) string, name: string, price: float})
+    | ProductAdded({
+        productId: @s.matches(Reventless.DcbTag.string) string,
+        name: string,
+        price: float,
+      })
 }
 
 module AddProductBehavior = {
@@ -91,7 +94,10 @@ module ProductsEpMapping = {
     (_id, event: ProductDelegate.event, _meta, _q) =>
       switch event {
       | ProductAdded({productId, name, price}) => [
-          EPM.PublishEvent(productId, ProductsEpSpec.ProductBecameAvailable({productId, name, price})),
+          EPM.PublishEvent(
+            productId,
+            ProductsEpSpec.ProductBecameAvailable({productId, name, price}),
+          ),
         ]
       },
   )
@@ -127,9 +133,10 @@ module OrdersEpMapping = {
     (_id, event: OrderDelegate.event, _meta, _q) =>
       switch event {
       | OrderPlaced({orderId, productIds}) =>
-        productIds->Array.map(pid =>
-          EPM.PublishEvent(pid, OrdersEpSpec.ItemOrdered({productId: pid, orderId}))
-        )
+        productIds->Array.map(pid => EPM.PublishEvent(
+          pid,
+          OrdersEpSpec.ItemOrdered({productId: pid, orderId}),
+        ))
       },
   )
 }
@@ -164,7 +171,8 @@ module RecordDemandBehavior = {
     }
   let decide = (_state, command: RecordDemandSlice.command) =>
     switch command {
-    | RecordDemand({productId, orderId}) => Ok([RecordDemandSlice.DemandRecorded({productId, orderId})])
+    | RecordDemand({productId, orderId}) =>
+      Ok([RecordDemandSlice.DemandRecorded({productId, orderId})])
     }
 }
 
@@ -194,11 +202,19 @@ module SyncProductSlice = {
   type consumedEvent = ProductSynced({productId: @s.matches(Reventless.DcbTag.string) string})
   @schema
   type command =
-    SyncProduct({productId: @s.matches(Reventless.DcbTag.string) string, name: string, price: float})
+    | SyncProduct({
+        productId: @s.matches(Reventless.DcbTag.string) string,
+        name: string,
+        price: float,
+      })
   @schema type error = NoError
   @schema
   type event =
-    ProductSynced({productId: @s.matches(Reventless.DcbTag.string) string, name: string, price: float})
+    | ProductSynced({
+        productId: @s.matches(Reventless.DcbTag.string) string,
+        name: string,
+        price: float,
+      })
   let moduleUrl = ""
   let commandAuthorization = (_: command): Reventless.Authorization.permission => AllowAuthenticated
   type lifecycleState = unit
@@ -242,20 +258,20 @@ module PlaceOrderSlice = {
     | ProductSynced({productId: @s.matches(Reventless.DcbTag.string) string})
   @schema
   type command =
-    PlaceOrder({
-      orderId: @s.matches(Reventless.DcbTag.string) string,
-      productIds: array<@s.matches(Reventless.DcbTag.stringForKey(~key="productId")) string>,
-    })
+    | PlaceOrder({
+        orderId: @s.matches(Reventless.DcbTag.string) string,
+        productIds: array<@s.matches(Reventless.DcbTag.stringForKey(~key="productId")) string>,
+      })
   @schema
   type error =
     | OrderAlreadyPlaced
     | ProductsNotAvailable({missing: array<string>})
   @schema
   type event =
-    OrderPlaced({
-      orderId: @s.matches(Reventless.DcbTag.string) string,
-      productIds: array<@s.matches(Reventless.DcbTag.stringForKey(~key="productId")) string>,
-    })
+    | OrderPlaced({
+        orderId: @s.matches(Reventless.DcbTag.string) string,
+        productIds: array<@s.matches(Reventless.DcbTag.stringForKey(~key="productId")) string>,
+      })
 }
 
 module PlaceOrderBehavior = {
@@ -265,7 +281,10 @@ module PlaceOrderBehavior = {
   let evolve = (state, event: PlaceOrderSlice.consumedEvent) =>
     switch event {
     | OrderPlaced({orderId}) => {...state, placed: state.placed->Array.concat([orderId])}
-    | ProductSynced({productId}) => {...state, available: state.available->Array.concat([productId])}
+    | ProductSynced({productId}) => {
+        ...state,
+        available: state.available->Array.concat([productId]),
+      }
     }
   let decide = (state, command: PlaceOrderSlice.command) =>
     switch command {
@@ -301,8 +320,12 @@ module Demand = CommandStep(RecordDemandSlice, RecordDemandBehavior)
 describe("Cross-plugin flow", () => {
   test("Tier 2 — a product added in Catalog becomes orderable in Ordering via sync", () =>
     start
-    ->AddProduct.whenCommand(AddProductSlice.AddProduct({productId: "p1", name: "Book", price: 9.99}))
-    ->AddProduct.thenEvent(AddProductSlice.ProductAdded({productId: "p1", name: "Book", price: 9.99}))
+    ->AddProduct.whenCommand(
+      AddProductSlice.AddProduct({productId: "p1", name: "Book", price: 9.99}),
+    )
+    ->AddProduct.thenEvent(
+      AddProductSlice.ProductAdded({productId: "p1", name: "Book", price: 9.99}),
+    )
     ->ProductsEp.whenPublishedThrough
     ->ProductsEp.thenPublicEvent(
       ProductsEpSpec.ProductBecameAvailable({productId: "p1", name: "Book", price: 9.99}),
@@ -323,25 +346,27 @@ describe("Cross-plugin flow", () => {
     ->Place.thenError(ProductsNotAvailable({missing: ["p1"]}))
   )
 
-  test("Tier 3 — a batch order fans out to one demand command per product across the boundary", () =>
-    start
-    ->Sync.givenEvents([
-      SyncProductSlice.ProductSynced({productId: "p1", name: "Book", price: 9.99}),
-      SyncProductSlice.ProductSynced({productId: "p2", name: "Pen", price: 1.5}),
-    ])
-    ->Place.whenCommand(PlaceOrderSlice.PlaceOrder({orderId: "o1", productIds: ["p1", "p2"]}))
-    ->Place.thenEvent(PlaceOrderSlice.OrderPlaced({orderId: "o1", productIds: ["p1", "p2"]}))
-    ->OrdersEp.whenPublishedThrough
-    ->OrdersEp.thenPublicEvents([
-      OrdersEpSpec.ItemOrdered({productId: "p1", orderId: "o1"}),
-      OrdersEpSpec.ItemOrdered({productId: "p2", orderId: "o1"}),
-    ])
-    ->OrdersExt.whenExtensionReacts
-    ->OrdersExt.thenIssuesCommands([
-      RecordDemandSlice.RecordDemand({productId: "p1", orderId: "o1"}),
-      RecordDemandSlice.RecordDemand({productId: "p2", orderId: "o1"}),
-    ])
-    ->Demand.whenCommand(RecordDemandSlice.RecordDemand({productId: "p1", orderId: "o1"}))
-    ->Demand.thenEvent(RecordDemandSlice.DemandRecorded({productId: "p1", orderId: "o1"}))
+  test(
+    "Tier 3 — a batch order fans out to one demand command per product across the boundary",
+    () =>
+      start
+      ->Sync.givenEvents([
+        SyncProductSlice.ProductSynced({productId: "p1", name: "Book", price: 9.99}),
+        SyncProductSlice.ProductSynced({productId: "p2", name: "Pen", price: 1.5}),
+      ])
+      ->Place.whenCommand(PlaceOrderSlice.PlaceOrder({orderId: "o1", productIds: ["p1", "p2"]}))
+      ->Place.thenEvent(PlaceOrderSlice.OrderPlaced({orderId: "o1", productIds: ["p1", "p2"]}))
+      ->OrdersEp.whenPublishedThrough
+      ->OrdersEp.thenPublicEvents([
+        OrdersEpSpec.ItemOrdered({productId: "p1", orderId: "o1"}),
+        OrdersEpSpec.ItemOrdered({productId: "p2", orderId: "o1"}),
+      ])
+      ->OrdersExt.whenExtensionReacts
+      ->OrdersExt.thenIssuesCommands([
+        RecordDemandSlice.RecordDemand({productId: "p1", orderId: "o1"}),
+        RecordDemandSlice.RecordDemand({productId: "p2", orderId: "o1"}),
+      ])
+      ->Demand.whenCommand(RecordDemandSlice.RecordDemand({productId: "p1", orderId: "o1"}))
+      ->Demand.thenEvent(RecordDemandSlice.DemandRecorded({productId: "p1", orderId: "o1"})),
   )
 })

package/tests/FlowGwtTest.res

@@ -8,7 +8,6 @@
 // filters the log by its command's tags.
 // See `docs/plans/done/gwt-flow-and-extension-test-kinds.md` Phase 2.
 
-
 open Flow_GWT
 
 // -- Slices ------------------------------------------------------------------

package/tests/InboundTranslationGwtTest.res

@@ -23,12 +23,15 @@ module PaymentWebhookSlice = {
 
 describe("PaymentWebhook InboundTranslationSlice", () => {
   test("completed status emits ConfirmPayment", () =>
-    whenInput({paymentId: "p1", orderId: "o1", status: "completed"})
-    ->thenCommand("o1", ConfirmPayment({orderId: "o1", paymentId: "p1"}))
+    whenInput({paymentId: "p1", orderId: "o1", status: "completed"})->thenCommand(
+      "o1",
+      ConfirmPayment({orderId: "o1", paymentId: "p1"}),
+    )
   )
 
   test("unknown status surfaces translate error", () =>
-    whenInput({paymentId: "p1", orderId: "o1", status: "garbage"})
-    ->thenTranslateError("Unknown payment status: garbage")
+    whenInput({paymentId: "p1", orderId: "o1", status: "garbage"})->thenTranslateError(
+      "Unknown payment status: garbage",
+    )
   )
 })

package/tests/LocalHostIntegration.res

@@ -34,7 +34,10 @@ test("loadGraph cold-loads structures from the real plugins", async () => {
   deepEqual(g.structures->Array.map(((n, _)) => n), ["Catalog", "Ordering"])
 
   let catalog = structureFor(g, "Catalog")->Option.getOrThrow
-  let category = catalog.aggregates->Array.find((a: Reventless.Plugin.writableDef) => a.name == "Category")->Option.getOrThrow
+  let category =
+    catalog.aggregates
+    ->Array.find((a: Reventless.Plugin.writableDef) => a.name == "Category")
+    ->Option.getOrThrow
   ok(category.producedEventTypes->Array.includes("Catalog.Added"))
 
   // An aggregate's declared errors ride the structure beside its events: what the
@@ -45,7 +48,10 @@ test("loadGraph cold-loads structures from the real plugins", async () => {
   )
 
   let ordering = structureFor(g, "Ordering")->Option.getOrThrow
-  let order = ordering.aggregates->Array.find((a: Reventless.Plugin.writableDef) => a.name == "Order")->Option.getOrThrow
+  let order =
+    ordering.aggregates
+    ->Array.find((a: Reventless.Plugin.writableDef) => a.name == "Order")
+    ->Option.getOrThrow
   ok(order.producedEventTypes->Array.includes("Ordering.Placed"))
 
   // extensionPoints (producer side): Catalog owns Catalog.Products, fed by the
@@ -53,20 +59,31 @@ test("loadGraph cold-loads structures from the real plugins", async () => {
   // subset of the producer's producedEventTypes, the link the event graph draws.
   let catalogEps = catalog.extensionPoints->Option.getOr([])
   let productsEp =
-    catalogEps->Array.find((e: Reventless.Plugin.extensionPointDef) => e.name == "Catalog.Products")->Option.getOrThrow
-  ok(productsEp.delegateNames->Array.includes("Product"), ~message=productsEp.delegateNames->Array.join(","))
+    catalogEps
+    ->Array.find((e: Reventless.Plugin.extensionPointDef) => e.name == "Catalog.Products")
+    ->Option.getOrThrow
+  ok(
+    productsEp.delegateNames->Array.includes("Product"),
+    ~message=productsEp.delegateNames->Array.join(","),
+  )
   ok(
     productsEp.sourceEventTypes->Array.includes("Catalog.Added"),
     ~message=productsEp.sourceEventTypes->Array.join(","),
   )
-  let product = catalog.aggregates->Array.find((a: Reventless.Plugin.writableDef) => a.name == "Product")->Option.getOrThrow
+  let product =
+    catalog.aggregates
+    ->Array.find((a: Reventless.Plugin.writableDef) => a.name == "Product")
+    ->Option.getOrThrow
   ok(productsEp.sourceEventTypes->Array.every(e => product.producedEventTypes->Array.includes(e)))
 })
 
-test("loadGraph is cold — a second call in the same process succeeds (cache-busting works)", async () => {
-  let plugins = LocalHost.discover(~packageDirs=[catalogDir])
-  let g1 = await LocalHost.loadGraph(~platformModulePath=platformPath, ~plugins)
-  let g2 = await LocalHost.loadGraph(~platformModulePath=platformPath, ~plugins)
-  equal(g1.structures->Array.length, 1)
-  equal(g2.structures->Array.length, 1)
-})
+test(
+  "loadGraph is cold — a second call in the same process succeeds (cache-busting works)",
+  async () => {
+    let plugins = LocalHost.discover(~packageDirs=[catalogDir])
+    let g1 = await LocalHost.loadGraph(~platformModulePath=platformPath, ~plugins)
+    let g2 = await LocalHost.loadGraph(~platformModulePath=platformPath, ~plugins)
+    equal(g1.structures->Array.length, 1)
+    equal(g2.structures->Array.length, 1)
+  },
+)

package/tests/LocalHostTest.res

@@ -14,9 +14,9 @@ describe("LocalHost.packageNameToPluginName", () => {
   testPromise("PascalCases scoped / dashed / underscored package names", async () => {
     expect(LocalHost.packageNameToPluginName("@scope/my-catalog"))->toBe("MyCatalog")
     expect(LocalHost.packageNameToPluginName("online-shop"))->toBe("OnlineShop")
-    expect(
-      LocalHost.packageNameToPluginName("online-shop-aggregates-catalog"),
-    )->toBe("OnlineShopAggregatesCatalog")
+    expect(LocalHost.packageNameToPluginName("online-shop-aggregates-catalog"))->toBe(
+      "OnlineShopAggregatesCatalog",
+    )
   })
 })
 
@@ -31,10 +31,14 @@ describe("LocalHost name derivation + discovery", () => {
       let a = NodePath.join([root, "a"])
       let aSrc = NodePath.join([a, "src"])
       let _ = await NodeFs.Promises.mkdir(aSrc, {recursive: true})
-      let _ =
-        await NodeFs.Promises.writeFile(NodePath.join([a, "package.json"]), `{"name":"@x/a-pkg"}`)
-      let _ =
-        await NodeFs.Promises.writeFile(NodePath.join([aSrc, "plugin.json"]), `{"name":"Catalog"}`)
+      let _ = await NodeFs.Promises.writeFile(
+        NodePath.join([a, "package.json"]),
+        `{"name":"@x/a-pkg"}`,
+      )
+      let _ = await NodeFs.Promises.writeFile(
+        NodePath.join([aSrc, "plugin.json"]),
+        `{"name":"Catalog"}`,
+      )
       let _ = await NodeFs.Promises.writeFile(NodePath.join([aSrc, "Plugin.res.mjs"]), "")
 
       // b: no plugin.json → name falls back to PascalCase(package.json name).
@@ -55,7 +59,10 @@ describe("LocalHost name derivation + discovery", () => {
       expect(LocalHost.derivePluginName(~pluginSrcDir=bSrc))->toBe("MyOrdering")
 
       let refs = LocalHost.discover(~packageDirs=[a, b, c])
-      expect(refs->Array.map((r: LocalHost.pluginRef) => r.name))->toEqual(["Catalog", "MyOrdering"])
+      expect(refs->Array.map((r: LocalHost.pluginRef) => r.name))->toEqual([
+        "Catalog",
+        "MyOrdering",
+      ])
       let first: LocalHost.pluginRef = refs->Array.getUnsafe(0)
       expect(first.modulePath->String.endsWith("Plugin.res.mjs"))->toBe(true)
       expect(first.packageDir)->toBe(a)

package/tests/MappingGwtTest.res

@@ -6,7 +6,6 @@
 // target-decide pipeline end-to-end against the unified `GwtSource`/`GwtTarget`
 // module types.
 
-
 // ---------------------------------------------------------------------------
 // Shared Aggregate specs + behaviours used by the Aggr→* cases below.
 // ---------------------------------------------------------------------------
@@ -98,9 +97,7 @@ module NotificationSlice = {
 
   @schema
   type consumedEvent =
-    | NotificationSent({
-        notificationId: @s.matches(Reventless.DcbTag.string) string,
-      })
+    NotificationSent({notificationId: @s.matches(Reventless.DcbTag.string) string})
 
   let evolve = (_state, event) =>
     switch event {
@@ -140,8 +137,7 @@ module InventorySlice = {
   let initialState = {reserved: false}
 
   @schema
-  type consumedEvent =
-    | StockReserved({itemId: @s.matches(Reventless.DcbTag.string) string})
+  type consumedEvent = StockReserved({itemId: @s.matches(Reventless.DcbTag.string) string})
 
   let evolve = (_state, event) =>
     switch event {
@@ -149,21 +145,13 @@ module InventorySlice = {
     }
 
   @schema
-  type command =
-    | ReserveStock({
-        itemId: @s.matches(Reventless.DcbTag.string) string,
-        quantity: int,
-      })
+  type command = ReserveStock({itemId: @s.matches(Reventless.DcbTag.string) string, quantity: int})
 
   @schema
   type error = OutOfStock
 
   @schema
-  type event =
-    | StockReserved({
-        itemId: @s.matches(Reventless.DcbTag.string) string,
-        quantity: int,
-      })
+  type event = StockReserved({itemId: @s.matches(Reventless.DcbTag.string) string, quantity: int})
 
   let decide = (state, command) =>
     switch command {
@@ -337,10 +325,7 @@ DcbToDcbGwt.describe("Inventory → Notification (DCB → DCB)", () => {
   DcbToDcbGwt.test("existing NotificationSent causes target decide to reject", () =>
     DcbToDcbGwt.givenSourceEvents([])
     ->DcbToDcbGwt.andTargetEvents([
-      (
-        "reserved-i7",
-        [NotificationSlice.NotificationSent({notificationId: "reserved-i7"})],
-      ),
+      ("reserved-i7", [NotificationSlice.NotificationSent({notificationId: "reserved-i7"})]),
     ])
     ->DcbToDcbGwt.whenSourceCmd("i7", ReserveStock({itemId: "i7", quantity: 2}))
     ->DcbToDcbGwt.thenTargetError(NotificationAlreadySent)

package/tests/OutboundTranslationGwtTest.res

@@ -44,10 +44,13 @@ describe("SendTrackingEmail OutboundTranslationSlice", () => {
   test("retrying translate succeeds on the third attempt → 2 retries recorded", () => {
     let calls = ref(0)
     givenTodo("o1", {orderId: "o1", email: "x@y"})
-    ->whenTranslateRetrying(~maxRetries=3, (_id, _item) => {
-      calls := calls.contents + 1
-      Promise.resolve(calls.contents < 3 ? Error("smtp down") : Ok(None))
-    })
+    ->whenTranslateRetrying(
+      ~maxRetries=3,
+      (_id, _item) => {
+        calls := calls.contents + 1
+        Promise.resolve(calls.contents < 3 ? Error("smtp down") : Ok(None))
+      },
+    )
     ->thenRetryRecorded(2)
   })
 

package/tests/QueryGwtTest.res

@@ -2,7 +2,6 @@
 // to prove the unified DSL works for either consumer type. Stage 6 of
 // `docs/plans/done/reventless-gwt.md`.
 
-
 // ---------------------------------------------------------------------------
 // Case 1 — ReadModel: Categories.
 // ---------------------------------------------------------------------------
@@ -51,9 +50,7 @@ CategoriesQuery.describe("Categories ReadModel queries", () => {
 
   CategoriesQuery.test("missing index produces QueryRowsMismatch", () => {
     let outcome =
-      CategoriesQuery.givenStore([
-        ("c1", {categoryId: "c1", name: "Electronics", archived: false}),
-      ])
+      CategoriesQuery.givenStore([("c1", {categoryId: "c1", name: "Electronics", archived: false})])
       ->CategoriesQuery.whenQuery({by: "name", value: "Electronics", index: "byArchived"})
       ->CategoriesQuery.thenRows([])
     switch outcome {
@@ -82,11 +79,14 @@ CategoriesQuery.describe("Categories ReadModel queries", () => {
 
   CategoriesQuery.test("limit truncates results and thenRowCount verifies", () =>
     CategoriesQuery.givenStore(
-      Array.fromInitializer(~length=10, i => {
-        let id = "c" ++ i->Int.toString
-        let state: CategoriesReadModel.state = {categoryId: id, name: "Books", archived: false}
-        (id, state)
-      }),
+      Array.fromInitializer(
+        ~length=10,
+        i => {
+          let id = "c" ++ i->Int.toString
+          let state: CategoriesReadModel.state = {categoryId: id, name: "Books", archived: false}
+          (id, state)
+        },
+      ),
     )
     ->CategoriesQuery.whenQuery({by: "name", value: "Books", index: "byName", limit: 3})
     ->CategoriesQuery.thenRowCount(3)
@@ -145,9 +145,7 @@ OrdersQuery.describe("OrdersView StateViewSlice queries", () => {
       ("ord-2", "cust-b", {orderId: "ord-2", customerId: "cust-b", total: 200}),
     ])
     ->OrdersQuery.whenQueryByCompositeId({id: "ord-1", subId: "cust-a"})
-    ->OrdersQuery.thenRowFromComposite(
-      Some({orderId: "ord-1", customerId: "cust-a", total: 100}),
-    )
+    ->OrdersQuery.thenRowFromComposite(Some({orderId: "ord-1", customerId: "cust-a", total: 100}))
   )
 
   OrdersQuery.test("composite-id lookup with wrong subId returns None", () =>

package/tests/QueryResolverGwtTest.res

@@ -3,7 +3,6 @@
 // productId (and a productIds array) that resolve into a Products read model;
 // the resolver DSL follows those keys across the spec boundary.
 
-
 module RM = Reventless.ReadModel
 
 module ProductRow = {
@@ -61,9 +60,10 @@ R.describe("Cross-spec resolvers (MakeResolver)", () => {
   )
 
   R.test("resolving an unknown foreign key returns no row", () =>
-    R.givenStores([("order2", {OrderRow.orderId: "order2", productId: "px", productIds: []})], [
-      ("p1", book),
-    ])
+    R.givenStores(
+      [("order2", {OrderRow.orderId: "order2", productId: "px", productIds: []})],
+      [("p1", book)],
+    )
     ->R.whenResolve(~field="productId", "order2")
     ->R.thenResolved(None)
   )

package/tests/SideEffect/FakeOrderNotification.res

@@ -17,7 +17,6 @@ let moduleUrl = "test://FakeOrderNotification"
 
 let execute = async (id, _meta, event, _queryEngine) =>
   switch event {
-  | Source.Placed({email}) =>
-    MockEmail.recordSend(~email, ~orderId=Source.Id.toString(id))
+  | Source.Placed({email}) => MockEmail.recordSend(~email, ~orderId=Source.Id.toString(id))
   | Source.Shipped => ()
   }

package/tests/SideEffect/FakeOrderNotificationGwtTest.res

@@ -8,14 +8,9 @@ describe("FakeOrderNotification SideEffect", () => {
   JestGlobals.beforeEach(MockEmail.reset)
 
   test("Placed records a confirmation send", () =>
-    givenEventForId(
-      Source.Id.makeFromString("o1"),
-      Source.Placed({email: "alice@example.com"}),
-    )
+    givenEventForId(Source.Id.makeFromString("o1"), Source.Placed({email: "alice@example.com"}))
     ->whenExecuted(MockEmail.mock)
-    ->thenExternalCalls([
-      MockEmail.SendConfirmation({email: "alice@example.com", orderId: "o1"}),
-    ])
+    ->thenExternalCalls([MockEmail.SendConfirmation({email: "alice@example.com", orderId: "o1"})])
   )
 
   test("Shipped is a no-op", () =>
@@ -25,9 +20,10 @@ describe("FakeOrderNotification SideEffect", () => {
   )
 
   test("Two distinct Placed events record two calls", async () => {
-    let _ =
-      await givenEventForId(Source.Id.makeFromString("o1"), Source.Placed({email: "a@a"}))
-      ->whenExecuted(MockEmail.mock)
+    let _ = await givenEventForId(
+      Source.Id.makeFromString("o1"),
+      Source.Placed({email: "a@a"}),
+    )->whenExecuted(MockEmail.mock)
     await givenEventForId(Source.Id.makeFromString("o2"), Source.Placed({email: "b@b"}))
     ->whenExecuted(MockEmail.mock)
     ->thenExternalCallCount(2)

package/tests/StateChange/WithFixtures_GWT.res

@@ -20,4 +20,3 @@ describe("WithFixtures StateChangeSlice (companion fixtures auto-open)", () => {
     ->thenEvent((electronicsCategoryAdded :> event))
   )
 })
-

package/tests/StateChangeSliceGwtTest.res

@@ -118,10 +118,7 @@ module MissingTagBehavior = {
 
   let evolve = (state: state, _event: Spec.consumedEvent): state => state
 
-  let decide = (
-    _state: state,
-    cmd: Spec.command,
-  ): result<array<Spec.event>, Spec.error> =>
+  let decide = (_state: state, cmd: Spec.command): result<array<Spec.event>, Spec.error> =>
     switch cmd {
     | Do({id}) => Ok([Spec.Done({id: id})])
     }
@@ -130,23 +127,27 @@ module MissingTagBehavior = {
 module MissingTagGwt = Behavior_GWT.Make(MissingTagSlice, MissingTagBehavior)
 
 MissingTagGwt.describe("MissingTag slice implicit check", () => {
-  MissingTagGwt.test("thenEvent surfaces AppendConditionMismatch when command lacks DCB tag", () => {
-    let outcome =
-      MissingTagGwt.givenEvents([])
-      ->MissingTagGwt.whenCmd(Do({id: "x1"}))
-      ->MissingTagGwt.thenEvent(Done({id: "x1"}))
-    switch outcome {
-    | Error(AppendConditionMismatch(_)) => Outcome.pass
-    | Error(other) =>
-      Outcome.fail(
-        Throw({error: "expected AppendConditionMismatch, got: " ++ Outcome.kindName(other), stack: ""}),
-      )
-    | Ok() =>
-      Outcome.fail(
-        Throw({error: "expected AppendConditionMismatch, got pass", stack: ""}),
-      )
-    }
-  })
+  MissingTagGwt.test(
+    "thenEvent surfaces AppendConditionMismatch when command lacks DCB tag",
+    () => {
+      let outcome =
+        MissingTagGwt.givenEvents([])
+        ->MissingTagGwt.whenCmd(Do({id: "x1"}))
+        ->MissingTagGwt.thenEvent(Done({id: "x1"}))
+      switch outcome {
+      | Error(AppendConditionMismatch(_)) => Outcome.pass
+      | Error(other) =>
+        Outcome.fail(
+          Throw({
+            error: "expected AppendConditionMismatch, got: " ++ Outcome.kindName(other),
+            stack: "",
+          }),
+        )
+      | Ok() =>
+        Outcome.fail(Throw({error: "expected AppendConditionMismatch, got pass", stack: ""}))
+      }
+    },
+  )
 
   MissingTagGwt.test(
     "thenAppendsConditionedOnExactly bypasses implicit check (still passes with derived)",

package/tests/StateViewSliceGwtTest.res

@@ -31,15 +31,9 @@ module CategoriesViewProjection = {
 
   let project = ({event}: Reventless.StateViewSlice.consumed<consumedEvent>) =>
     switch event {
-    | CategoryAdded({categoryId, name}) => [
-        Set(categoryId, {categoryId, name, archived: false}),
-      ]
-    | CategoryRenamed({categoryId, name}) => [
-        Update(categoryId, state => {...state, name}),
-      ]
-    | CategoryArchived({categoryId}) => [
-        Update(categoryId, state => {...state, archived: true}),
-      ]
+    | CategoryAdded({categoryId, name}) => [Set(categoryId, {categoryId, name, archived: false})]
+    | CategoryRenamed({categoryId, name}) => [Update(categoryId, state => {...state, name})]
+    | CategoryArchived({categoryId}) => [Update(categoryId, state => {...state, archived: true})]
     }
 }
 
@@ -47,18 +41,12 @@ describe("CategoriesView StateViewSlice", () => {
   test("projects CategoryAdded into a new row", () =>
     givenEvents([])
     ->whenEvent(CategoryAdded({categoryId: "c1", name: "Electronics"}))
-    ->thenStateWithId(
-      "c1",
-      {categoryId: "c1", name: "Electronics", archived: false},
-    )
+    ->thenStateWithId("c1", {categoryId: "c1", name: "Electronics", archived: false})
   )
 
   test("CategoryRenamed updates the name", () =>
     givenEvents([CategoryAdded({categoryId: "c1", name: "Electronics"})])
     ->whenEvent(CategoryRenamed({categoryId: "c1", name: "Consumer Electronics"}))
-    ->thenStateWithId(
-      "c1",
-      {categoryId: "c1", name: "Consumer Electronics", archived: false},
-    )
+    ->thenStateWithId("c1", {categoryId: "c1", name: "Consumer Electronics", archived: false})
   )
 })