@reventlessdev/reventless-core 3.0.0-alpha.260 → 3.0.0-alpha.262

package/tests/admin/Platform_Admin_StructureTest.res

@@ -44,8 +44,7 @@ describe("the Plugins read model declares its lifecycle", () => {
   })
 
   testSync("is served on the encoded def under the new key", () => {
-    let json =
-      rm->Platform_ComponentDefinitionsApi.encodeQueryableDef->JSON.stringify
+    let json = rm->Platform_ComponentDefinitionsApi.encodeQueryableDef->JSON.stringify
     expect(json->String.includes(`"lifecycleField":"status"`))->toEqual(true)
   })
 
@@ -137,11 +136,7 @@ describe("the Plugin command defs carry every argument the SDL requires", () =>
       Platform_Admin_Structure.pluginCommands
       ->Array.filter(c => c.apiExposed != Some(false))
       ->Array.map(c => c.mutationField),
-    )->toEqual([
-      "Platform_Plugin_Activate",
-      "Platform_Plugin_Deactivate",
-      "Platform_Plugin_Retire",
-    ])
+    )->toEqual(["Platform_Plugin_Activate", "Platform_Plugin_Deactivate", "Platform_Plugin_Retire"])
   )
 
   // The `@noApi` protocol variants come back from the same walk. They belong on
@@ -179,16 +174,20 @@ describe("the internal commands declare the edges they move rows along", () => {
   }
 
   testSync("the only edge into Disconnected is declared", () =>
-    expect((commandNamed("Disconnect").allowedStates, commandNamed("Disconnect").targetState))
-    ->toEqual((Some(["Connected"]), Some("Disconnected")))
+    expect((
+      commandNamed("Disconnect").allowedStates,
+      commandNamed("Disconnect").targetState,
+    ))->toEqual((Some(["Connected"]), Some("Disconnected")))
   )
 
   // The creating form's claim: a target and no from-set. `Connect` brings the
   // version's row into being, so there is no state it runs from — and an empty
   // `allowedStates` would say the opposite, that it is legal in none.
   testSync("the handshake declares a target and no from-set", () =>
-    expect((commandNamed("Connect").allowedStates, commandNamed("Connect").targetState))
-    ->toEqual((None, Some("Connected")))
+    expect((commandNamed("Connect").allowedStates, commandNamed("Connect").targetState))->toEqual((
+      None,
+      Some("Connected"),
+    ))
   )
 
   testSync("and no state is left unreachable", () =>
@@ -207,14 +206,23 @@ describe("the internal commands declare the edges they move rows along", () => {
 // was open to everyone and the server refused anyone outside `Admin`. The
 // mismatch is invisible until a non-admin clicks the page.
 describe("the Plugins view publishes the rule the server enforces", () => {
-  testSync("the spec declares the group", () =>
+  // 🚨 **This is also the only check `Reventless.AdminGroup.name` can carry.** A
+  // PPX annotation takes a literal, so `@@reventless.authorize(AllowGroups(
+  // ["Admin"]))` above cannot reference the constant — the constant's job is to
+  // make everything *else* agree with the annotation, and nothing in the compiler
+  // spans that gap. The actual side here comes from the expanded annotation and
+  // the expected side from the constant, so the two are compared rather than
+  // restated. Writing the literal on both sides would pass while they diverged.
+  testSync("the spec declares the group, and it is the one the constant names", () =>
     expect(PluginsReadModelSpec.authorization)->toEqual(
-      Reventless.Authorization.AllowGroups(["Admin"]),
+      Reventless.Authorization.AllowGroups([Reventless.AdminGroup.name]),
     )
   )
 
   testSync("and the published access keys are derived from it", () =>
-    expect(Platform_Admin_Structure.pluginReadModel.requiredAccess)->toEqual(Some(["Admin"]))
+    expect(Platform_Admin_Structure.pluginReadModel.requiredAccess)->toEqual(
+      Some([Reventless.AdminGroup.name]),
+    )
   )
 
   // The API entry reads the same binding rather than restating it, so the two

package/tests/admin/Platform_Admin_StructureTest.res.mjs

@@ -3,6 +3,7 @@
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as AdminGroup$Reventless from "@reventlessdev/reventless-spec/src/types/AdminGroup.res.mjs";
 import * as Plugin_Structure$ReventlessCore from "../../src/plugin/component/Plugin_Structure.res.mjs";
 import * as PluginBaseFragment$ReventlessCore from "../../src/plugin/api/PluginBaseFragment.res.mjs";
 import * as PluginsReadModelSpec$ReventlessCore from "../../src/plugin/lifecycle/PluginsReadModelSpec.res.mjs";
@@ -154,14 +155,14 @@ globalThis.describe("the internal commands declare the edges they move rows alon
 });
 
 globalThis.describe("the Plugins view publishes the rule the server enforces", () => {
-  globalThis.test("the spec declares the group", () => {
+  globalThis.test("the spec declares the group, and it is the one the constant names", () => {
     globalThis.expect(PluginsReadModelSpec$ReventlessCore.authorization).toEqual({
       TAG: "AllowGroups",
-      _0: ["Admin"]
+      _0: [AdminGroup$Reventless.name]
     });
   });
   globalThis.test("and the published access keys are derived from it", () => {
-    globalThis.expect(Platform_Admin_Structure$ReventlessCore.pluginReadModel.requiredAccess).toEqual(["Admin"]);
+    globalThis.expect(Platform_Admin_Structure$ReventlessCore.pluginReadModel.requiredAccess).toEqual([AdminGroup$Reventless.name]);
   });
   globalThis.test("the query entry carries the spec's rule and no hand-written pair", () => {
     let entry = PluginBaseFragment$ReventlessCore.queryEntries[0];

package/tests/admin/Platform_BakedManifestTest.res

@@ -91,8 +91,7 @@ let structure: pluginStructure = {
 
 let structures = [("Ordering@1.0.0", structure)]
 
-let bake = selections =>
-  Platform_BakedManifest.curate(~structures, ~selections)
+let bake = selections => Platform_BakedManifest.curate(~structures, ~selections)
 
 // Every case below varies one include-list and means "everything" by the rest,
 // which is exactly what an omitted labelled argument says.
@@ -112,7 +111,10 @@ let names = (entry: JSON.t, field: string) =>
   ->Option.flatMap(JSON.Decode.array)
   ->Option.getOr([])
   ->Array.filterMap(v =>
-    v->JSON.Decode.object->Option.flatMap(d => d->Dict.get("name"))->Option.flatMap(JSON.Decode.string)
+    v
+    ->JSON.Decode.object
+    ->Option.flatMap(d => d->Dict.get("name"))
+    ->Option.flatMap(JSON.Decode.string)
   )
 
 let firstEntry = (r: result<JSON.t, Platform_BakedManifest.error>) =>
@@ -146,15 +148,13 @@ describe("curate", () => {
   // from, so an Internal view a kept command points at has to survive the bake.
   testSync("carries an Internal view referenced by an included command", () => {
     let entry =
-      bake([sel(~plugin="Ordering", ~views=["Orders"], ~commands=["PlaceOrder"])])
-      ->firstEntry
+      bake([sel(~plugin="Ordering", ~views=["Orders"], ~commands=["PlaceOrder"])])->firstEntry
     expect(entry->names("internalQueryables"))->toEqual(["AvailableProducts"])
   })
 
   testSync("omits an Internal view no included command references", () => {
     let entry =
-      bake([sel(~plugin="Ordering", ~views=["Orders"], ~commands=["ImportOrders"])])
-      ->firstEntry
+      bake([sel(~plugin="Ordering", ~views=["Orders"], ~commands=["ImportOrders"])])->firstEntry
     expect(entry->names("internalQueryables"))->toEqual([])
   })
 
@@ -193,9 +193,9 @@ describe("curate", () => {
   )
 
   testSync("accepts a kind this plugin generates no page for", () =>
-    expect(
-      bake([sel(~plugin="Ordering", ~derived=["scheduler"])])->firstEntry->derivedOf,
-    )->toEqual(Some(["scheduler"]))
+    expect(bake([sel(~plugin="Ordering", ~derived=["scheduler"])])->firstEntry->derivedOf)->toEqual(
+      Some(["scheduler"]),
+    )
   )
 
   testSync("an Internal view is never selectable as a view", () =>
@@ -228,27 +228,26 @@ describe("curate", () => {
   })
 
   testSync("one entry per selection, in declaration order", () => {
-    let json =
-      Platform_BakedManifest.curate(
-        ~structures=[("Ordering@1.0.0", structure), ("Catalog@1.0.0", structure)],
-        ~selections=[
-          sel(~plugin="Catalog", ~views=[], ~commands=[]),
-          sel(~plugin="Ordering", ~views=[], ~commands=[]),
-        ],
-      )
-    let ids =
-      switch json {
-      | Ok(j) =>
-        j
-        ->entries
-        ->Array.filterMap(e =>
+    let json = Platform_BakedManifest.curate(
+      ~structures=[("Ordering@1.0.0", structure), ("Catalog@1.0.0", structure)],
+      ~selections=[
+        sel(~plugin="Catalog", ~views=[], ~commands=[]),
+        sel(~plugin="Ordering", ~views=[], ~commands=[]),
+      ],
+    )
+    let ids = switch json {
+    | Ok(j) =>
+      j
+      ->entries
+      ->Array.filterMap(
+        e =>
           e
           ->JSON.Decode.object
           ->Option.flatMap(d => d->Dict.get("pluginId"))
-          ->Option.flatMap(JSON.Decode.string)
-        )
-      | Error(_) => []
-      }
+          ->Option.flatMap(JSON.Decode.string),
+      )
+    | Error(_) => []
+    }
     expect(ids)->toEqual(["Catalog", "Ordering"])
   })
 
@@ -258,8 +257,7 @@ describe("curate", () => {
   // makes this hold — the assertion guards that property, not a second code path.
   testSync("a curated entry carries the owner field the served entry carries", () => {
     let entry =
-      bake([sel(~plugin="Ordering", ~views=["Orders"], ~commands=["PlaceOrder"])])
-      ->firstEntry
+      bake([sel(~plugin="Ordering", ~views=["Orders"], ~commands=["PlaceOrder"])])->firstEntry
     let ownerOf = (key, name) =>
       entry
       ->JSON.Decode.object
@@ -267,9 +265,7 @@ describe("curate", () => {
       ->Option.flatMap(JSON.Decode.array)
       ->Option.getOr([])
       ->Array.filterMap(JSON.Decode.object)
-      ->Array.find(d =>
-        d->Dict.get("name")->Option.flatMap(JSON.Decode.string) == Some(name)
-      )
+      ->Array.find(d => d->Dict.get("name")->Option.flatMap(JSON.Decode.string) == Some(name))
       ->Option.flatMap(d => d->Dict.get("ownerField"))
       ->Option.flatMap(JSON.Decode.string)
     let commandOwner =
@@ -279,8 +275,8 @@ describe("curate", () => {
       ->Option.flatMap(JSON.Decode.array)
       ->Option.getOr([])
       ->Array.filterMap(JSON.Decode.object)
-      ->Array.flatMap(w =>
-        w->Dict.get("commands")->Option.flatMap(JSON.Decode.array)->Option.getOr([])
+      ->Array.flatMap(
+        w => w->Dict.get("commands")->Option.flatMap(JSON.Decode.array)->Option.getOr([]),
       )
       ->Array.filterMap(JSON.Decode.object)
       ->Array.get(0)

package/tests/admin/Platform_ComponentDefinitionsApiTest.res

@@ -11,9 +11,7 @@ let cmd: commandDef = {
   level: Collection,
   aggregateIdField: None,
   mutationField: "AddProduct",
-  references: [
-    {fieldName: "categoryId", entity: "Category", plugin: Some("Catalog")},
-  ],
+  references: [{fieldName: "categoryId", entity: "Category", plugin: Some("Catalog")}],
   allowedStates: None,
   targetState: None,
   apiExposed: Some(true),
@@ -276,10 +274,10 @@ describe("visibility filtering (deployed AutoUI hides Internal)", () => {
     idField: Some("productId"),
     idFieldSource: Some("sole"),
     requiredAccess: None,
-      ownerField: None,
-      retiredField: None,
-      retiredValues: None,
-      namedWhenRetired: None,
+    ownerField: None,
+    retiredField: None,
+    retiredValues: None,
+    namedWhenRetired: None,
   }
   // A distinct name per source array: the complement has to be fed by both, and
   // reusing one def would hide a version that only walks `readModels`.
@@ -293,8 +291,10 @@ describe("visibility filtering (deployed AutoUI hides Internal)", () => {
     readModels: [qbl, internalQbl],
     stateViewSlices: [internalSlice],
   }
-  let mixedEntry =
-    Platform_ComponentDefinitionsApi.encodePluginStructureEntry(~pluginId="Ordering", mixed)
+  let mixedEntry = Platform_ComponentDefinitionsApi.encodePluginStructureEntry(
+    ~pluginId="Ordering",
+    mixed,
+  )
 
   // Names under one key of the encoded entry. `String.includes` over the whole
   // JSON can no longer answer this: an Internal view is legitimately present
@@ -308,7 +308,10 @@ describe("visibility filtering (deployed AutoUI hides Internal)", () => {
     ->Option.flatMap(JSON.Decode.array)
     ->Option.getOr([])
     ->Array.filterMap(c =>
-      c->JSON.Decode.object->Option.flatMap(o => o->Dict.get("name"))->Option.flatMap(JSON.Decode.string)
+      c
+      ->JSON.Decode.object
+      ->Option.flatMap(o => o->Dict.get("name"))
+      ->Option.flatMap(JSON.Decode.string)
     )
 
   testSync("excludes an Internal queryableDef from the encoded read-side", () => {
@@ -358,7 +361,7 @@ describe("allowedStates + lifecycleField populated", () => {
     allowedStatesSource: "declared",
     apiExposed: Some(true),
     requiredAccess: None,
-      ownerField: None,
+    ownerField: None,
   }
 
   let qblWithStatus: queryableDef = {
@@ -377,10 +380,10 @@ describe("allowedStates + lifecycleField populated", () => {
     idField: None,
     idFieldSource: None,
     requiredAccess: None,
-      ownerField: None,
-      retiredField: None,
-      retiredValues: None,
-      namedWhenRetired: None,
+    ownerField: None,
+    retiredField: None,
+    retiredValues: None,
+    namedWhenRetired: None,
   }
 
   let wblWithStates: writableDef = {

package/tests/admin/Platform_PluginStructuresApiTest.res

@@ -84,7 +84,10 @@ let namesOf = (key): array<string> =>
   ->Option.flatMap(JSON.Decode.array)
   ->Option.getOr([])
   ->Array.filterMap(v =>
-    v->JSON.Decode.object->Option.flatMap(o => o->Dict.get("name"))->Option.flatMap(JSON.Decode.string)
+    v
+    ->JSON.Decode.object
+    ->Option.flatMap(o => o->Dict.get("name"))
+    ->Option.flatMap(JSON.Decode.string)
   )
 
 describe("Platform_PluginStructures entry", () => {
@@ -130,8 +133,7 @@ describe("Platform_PluginStructures entry", () => {
     expect(
       json->String.includes(
         "\"extensionPoints\":[{\"name\":\"Catalog.Products\",\"delegateNames\":[\"onAdded\"],\"sourceEventTypes\":[\"Catalog.ProductAdded\"],\"commandTypes\":null," ++
-          "\"publishedEvents\":[{\"name\":\"Catalog.Products.ProductBecameAvailable\",\"fromEventTypes\":[\"Catalog.ProductAdded\"]}]," ++
-          "\"acceptedCommands\":[{\"name\":\"Catalog.Products.Reserve\",\"toCommandTypes\":[\"Catalog.ReserveStock\"]}]}]",
+        "\"publishedEvents\":[{\"name\":\"Catalog.Products.ProductBecameAvailable\",\"fromEventTypes\":[\"Catalog.ProductAdded\"]}]," ++ "\"acceptedCommands\":[{\"name\":\"Catalog.Products.Reserve\",\"toCommandTypes\":[\"Catalog.ReserveStock\"]}]}]",
       ),
     )->toEqual(true)
   )

package/tests/admin/Platform_UIFragmentsApiTest.res

@@ -57,7 +57,9 @@ describe("encodeUIFragmentEntry", () => {
 
   testSync("encodes remoteEntryUrl", () =>
     expect(
-      json->String.includes("\"remoteEntryUrl\":\"https://cdn.example.com/catalog@1.0/remoteEntry.js\""),
+      json->String.includes(
+        "\"remoteEntryUrl\":\"https://cdn.example.com/catalog@1.0/remoteEntry.js\"",
+      ),
     )->toEqual(true)
   )
 
@@ -80,8 +82,9 @@ describe("encodeUIFragmentEntry", () => {
 
 describe("Platform_UIFragmentsApi.sdl", () => {
   testSync("query field declares the list type", () =>
-    expect(Platform_UIFragmentsApi.sdlQueryField->String.includes("[Platform_UIFragmentEntry!]!"))
-    ->toEqual(true)
+    expect(
+      Platform_UIFragmentsApi.sdlQueryField->String.includes("[Platform_UIFragmentEntry!]!"),
+    )->toEqual(true)
   )
 
   testSync("sdlTypes includes Platform_UIFragmentEntry", () => {

package/tests/aggregate/AggregateCacheTest.res

@@ -12,7 +12,6 @@
 
 open JestGlobals
 
-
 module AggSpec = {
   module Id = Reventless.Id.StringPure
   let name = "CacheTestAggregate"
@@ -29,7 +28,7 @@ module AggSpec = {
     | CheckpointTaken({count: int})
 
   @schema
-  type error = | Never
+  type error = Never
 
   let moduleUrl: string = %raw(`import.meta.url`)
 }
@@ -103,7 +102,7 @@ let makeMockEL = (): mockEL => {
       Error(EventLog.Conflict)
     } else {
       storedRef := storedRef.contents->Array.concat(newEvents)
-      Ok(())
+      Ok()
     }
   }
 
@@ -155,11 +154,11 @@ module TestOps = {
       ) => promise<result<unit, EventLog.appendError>>,
       replay: string => promise<array<AggSpec.event>>,
       replayStream: (string, ~fromSeq: int=?) => Stream.t<AggSpec.event, string, unit>,
-      appendStream: (int, string, Stream.t<AggSpec.event, string, unit>) => Effect.t<
-        unit,
+      appendStream: (
+        int,
         string,
-        unit,
-      >,
+        Stream.t<AggSpec.event, string, unit>,
+      ) => Effect.t<unit, string, unit>,
       latestSnapshot: string => promise<result<option<EventLog.snapshot>, string>>,
       writeSnapshot: (string, EventLog.snapshot) => promise<result<unit, string>>,
     }
@@ -223,14 +222,13 @@ describe("Aggregate_Callback — replay cache:", () => {
     let _ = await run(AggSpec.Checkpoint)
     expect(mock.replayCallCount.contents)->toBe(2)
     // Both checkpoints observed the same state — cached fold ≡ replayed fold.
-    let checkpoints =
-      mock.getAll()
-      ->Array.filterMap(e =>
+    let checkpoints = mock.getAll()->Array.filterMap(
+      e =>
         switch e.event {
         | CheckpointTaken({count}) => Some(count)
         | _ => None
-        }
-      )
+        },
+    )
     expect(checkpoints)->toEqual([3, 3])
   })
 

package/tests/aggregate/AggregateCallbackTest.res

@@ -8,77 +8,106 @@ let _ = beforeEach(() => {
 
 describe("Aggregate_Callback.handleCommands:", () => {
   describe("single command — new aggregate", () => {
-    testPromise("Create returns Ok(reference) and stores 1 event", async () => {
-      let results = await Stream.fromIterable([
-        makeTopicItem("ref-1", AggSpec.Create({name: "Widget"})),
-      ])->TestHandler.handleCommands->Effect.runPromise
-      expect((results, mock.getAll()->Array.length))->toEqual(([Ok("ref-1")], 1))
-    })
+    testPromise(
+      "Create returns Ok(reference) and stores 1 event",
+      async () => {
+        let results = await Stream.fromIterable([
+          makeTopicItem("ref-1", AggSpec.Create({name: "Widget"})),
+        ])
+        ->TestHandler.handleCommands
+        ->Effect.runPromise
+        expect((results, mock.getAll()->Array.length))->toEqual(([Ok("ref-1")], 1))
+      },
+    )
   })
 
   describe("command on existing aggregate", () => {
-    testPromise("Rename after Create replays history and appends new event", async () => {
-      let _ =
-        await Stream.fromIterable([
+    testPromise(
+      "Rename after Create replays history and appends new event",
+      async () => {
+        let _ = await Stream.fromIterable([
           makeTopicItem("ref-1", AggSpec.Create({name: "Widget"})),
-        ])->TestHandler.handleCommands->Effect.runPromise
-      let results =
-        await Stream.fromIterable([
+        ])
+        ->TestHandler.handleCommands
+        ->Effect.runPromise
+        let results = await Stream.fromIterable([
           makeTopicItem("ref-2", AggSpec.Rename({newName: "Gadget"})),
-        ])->TestHandler.handleCommands->Effect.runPromise
-      expect((results, mock.getAll()->Array.length))->toEqual(([Ok("ref-2")], 2))
-    })
+        ])
+        ->TestHandler.handleCommands
+        ->Effect.runPromise
+        expect((results, mock.getAll()->Array.length))->toEqual(([Ok("ref-2")], 2))
+      },
+    )
   })
 
   describe("behavior returns no events", () => {
-    testPromise("Rename on new aggregate returns Ok with no event stored", async () => {
-      // Rename on empty history: Behavior.decide(NotCreated, Rename) returns Error(NotFound)
-      let results =
-        await Stream.fromIterable([
+    testPromise(
+      "Rename on new aggregate returns Ok with no event stored",
+      async () => {
+        // Rename on empty history: Behavior.decide(NotCreated, Rename) returns Error(NotFound)
+        let results = await Stream.fromIterable([
           makeTopicItem("ref-1", AggSpec.Rename({newName: "Gadget"})),
-        ])->TestHandler.handleCommands->Effect.runPromise
-      expect((results, mock.getAll()->Array.length))->toEqual(([Ok("ref-1")], 0))
-    })
+        ])
+        ->TestHandler.handleCommands
+        ->Effect.runPromise
+        expect((results, mock.getAll()->Array.length))->toEqual(([Ok("ref-1")], 0))
+      },
+    )
   })
 
   describe("append failure", () => {
-    testPromise("eventLog.append fails → reference returned Error", async () => {
-      mock.failNextAppend := true
-      let results =
-        await Stream.fromIterable([
+    testPromise(
+      "eventLog.append fails → reference returned Error",
+      async () => {
+        mock.failNextAppend := true
+        let results = await Stream.fromIterable([
           makeTopicItem("ref-1", AggSpec.Create({name: "Widget"})),
-        ])->TestHandler.handleCommands->Effect.runPromise
-      expect(results)->toEqual([Error("ref-1")])
-    })
+        ])
+        ->TestHandler.handleCommands
+        ->Effect.runPromise
+        expect(results)->toEqual([Error("ref-1")])
+      },
+    )
   })
 
   describe("multiple commands for same aggregate ID", () => {
-    testPromise("Create then Rename in one batch accumulate state correctly", async () => {
-      let results =
-        await Stream.fromIterable([
+    testPromise(
+      "Create then Rename in one batch accumulate state correctly",
+      async () => {
+        let results = await Stream.fromIterable([
           makeTopicItem(~aggId="agg-1", "ref-1", AggSpec.Create({name: "Widget"})),
           makeTopicItem(~aggId="agg-1", "ref-2", AggSpec.Rename({newName: "Gadget"})),
-        ])->TestHandler.handleCommands->Effect.runPromise
-      // Both commands for same ID processed sequentially
-      expect((results, mock.getAll()->Array.length))->toEqual(([Ok("ref-1"), Ok("ref-2")], 2))
-    })
+        ])
+        ->TestHandler.handleCommands
+        ->Effect.runPromise
+        // Both commands for same ID processed sequentially
+        expect((results, mock.getAll()->Array.length))->toEqual(([Ok("ref-1"), Ok("ref-2")], 2))
+      },
+    )
   })
 
   describe("commands for different aggregate IDs", () => {
-    testPromise("each ID processed independently", async () => {
-      let results =
-        await Stream.fromIterable([
+    testPromise(
+      "each ID processed independently",
+      async () => {
+        let results = await Stream.fromIterable([
           makeTopicItem(~aggId="agg-a", "ref-a", AggSpec.Create({name: "Alpha"})),
           makeTopicItem(~aggId="agg-b", "ref-b", AggSpec.Create({name: "Beta"})),
-        ])->TestHandler.handleCommands->Effect.runPromise
-      expect((results->Array.length, mock.getAll()->Array.length))->toEqual((2, 2))
-    })
+        ])
+        ->TestHandler.handleCommands
+        ->Effect.runPromise
+        expect((results->Array.length, mock.getAll()->Array.length))->toEqual((2, 2))
+      },
+    )
   })
 
   describe("empty batch", () => {
-    testPromise("returns empty array", async () => {
-      let results = await Stream.fromIterable([])->TestHandler.handleCommands->Effect.runPromise
-      expect(results)->toEqual([])
-    })
+    testPromise(
+      "returns empty array",
+      async () => {
+        let results = await Stream.fromIterable([])->TestHandler.handleCommands->Effect.runPromise
+        expect(results)->toEqual([])
+      },
+    )
   })
 })

package/tests/aggregate/AggregateCausationTest.res

@@ -15,37 +15,36 @@ let _ = beforeEach(() => {
 
 describe("Aggregate_Callback causation propagation:", () => {
   testPromise("event.meta.causationId = command.meta.msgId", async () => {
-    let _ =
-      await Stream.fromIterable([
-        makeTopicItem("ref-1", AggSpec.Create({name: "Widget"})),
-      ])->TestHandler.handleCommands->Effect.runPromise
+    let _ = await Stream.fromIterable([makeTopicItem("ref-1", AggSpec.Create({name: "Widget"}))])
+    ->TestHandler.handleCommands
+    ->Effect.runPromise
     let stored = mock.getAll()->Array.getUnsafe(0)
     expect(stored.meta.causationId)->toEqual(Some(testMeta.msgId))
   })
 
-  testPromise("event.meta.correlationId = command.meta.correlationId (chain root stable)", async () => {
-    let _ =
-      await Stream.fromIterable([
-        makeTopicItem("ref-1", AggSpec.Create({name: "Widget"})),
-      ])->TestHandler.handleCommands->Effect.runPromise
-    let stored = mock.getAll()->Array.getUnsafe(0)
-    expect(stored.meta.correlationId)->toBe(testMeta.correlationId)
-  })
+  testPromise(
+    "event.meta.correlationId = command.meta.correlationId (chain root stable)",
+    async () => {
+      let _ = await Stream.fromIterable([makeTopicItem("ref-1", AggSpec.Create({name: "Widget"}))])
+      ->TestHandler.handleCommands
+      ->Effect.runPromise
+      let stored = mock.getAll()->Array.getUnsafe(0)
+      expect(stored.meta.correlationId)->toBe(testMeta.correlationId)
+    },
+  )
 
   testPromise("event has a fresh msgId distinct from the command's msgId", async () => {
-    let _ =
-      await Stream.fromIterable([
-        makeTopicItem("ref-1", AggSpec.Create({name: "Widget"})),
-      ])->TestHandler.handleCommands->Effect.runPromise
+    let _ = await Stream.fromIterable([makeTopicItem("ref-1", AggSpec.Create({name: "Widget"}))])
+    ->TestHandler.handleCommands
+    ->Effect.runPromise
     let stored = mock.getAll()->Array.getUnsafe(0)
     expect(stored.meta.msgId == testMeta.msgId)->toBe(false)
   })
 
   testPromise("event inherits ip / user / service from the command's meta", async () => {
-    let _ =
-      await Stream.fromIterable([
-        makeTopicItem("ref-1", AggSpec.Create({name: "Widget"})),
-      ])->TestHandler.handleCommands->Effect.runPromise
+    let _ = await Stream.fromIterable([makeTopicItem("ref-1", AggSpec.Create({name: "Widget"}))])
+    ->TestHandler.handleCommands
+    ->Effect.runPromise
     let stored = mock.getAll()->Array.getUnsafe(0)
     expect(stored.meta.service)->toBe(testMeta.service)
   })