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

package/tests/dcb/DcbStateChangeSliceTest.res.mjs

@@ -201,7 +201,7 @@ globalThis.beforeEach(() => {
 globalThis.describe("StateChangeSlice_Callback:", () => {
   globalThis.describe("handleCommands - happy path", () => {
     globalThis.test("CreateItem on empty log succeeds", async () => {
-      let results = await Effect.runPromise(TestHandler.handleCommands(undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem("ref-1", {
+      let results = await Effect.runPromise(TestHandler.handleCommands(undefined, undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem("ref-1", {
           TAG: "CreateItem",
           itemId: "item-1",
           name: "Test"
@@ -220,7 +220,7 @@ globalThis.describe("StateChangeSlice_Callback:", () => {
       ]);
     });
     globalThis.test("stored event carries only its entity tags (no framework provenance tag)", async () => {
-      await Effect.runPromise(TestHandler.handleCommands(undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem("ref-1", {
+      await Effect.runPromise(TestHandler.handleCommands(undefined, undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem("ref-1", {
           TAG: "CreateItem",
           itemId: "item-1",
           name: "Test"
@@ -234,7 +234,7 @@ globalThis.describe("StateChangeSlice_Callback:", () => {
   });
   globalThis.describe("handleCommands - decide returns Ok([])", () => {
     globalThis.test("NoOp returns Ok without storing events", async () => {
-      let results = await Effect.runPromise(TestHandler.handleCommands(undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem("ref-noop", "NoOp")])));
+      let results = await Effect.runPromise(TestHandler.handleCommands(undefined, undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem("ref-noop", "NoOp")])));
       globalThis.expect([
         results,
         mock.getEvents().length
@@ -249,12 +249,12 @@ globalThis.describe("StateChangeSlice_Callback:", () => {
   });
   globalThis.describe("handleCommands - decide returns Error", () => {
     globalThis.test("CreateItem when item exists returns Ok (business-rule violations ACK, not NACK)", async () => {
-      await Effect.runPromise(TestHandler.handleCommands(undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem("ref-1", {
+      await Effect.runPromise(TestHandler.handleCommands(undefined, undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem("ref-1", {
           TAG: "CreateItem",
           itemId: "item-1",
           name: "Test"
         })])));
-      let results = await Effect.runPromise(TestHandler.handleCommands(undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem("ref-2", {
+      let results = await Effect.runPromise(TestHandler.handleCommands(undefined, undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem("ref-2", {
           TAG: "CreateItem",
           itemId: "item-1",
           name: "Duplicate"
@@ -268,7 +268,7 @@ globalThis.describe("StateChangeSlice_Callback:", () => {
   globalThis.describe("handleCommands - retry on conflict", () => {
     globalThis.test("retries and succeeds after 1 append failure", async () => {
       mock.failNextAppends.contents = 1;
-      let results = await Effect.runPromise(TestHandler.handleCommands(undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem("ref-1", {
+      let results = await Effect.runPromise(TestHandler.handleCommands(undefined, undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem("ref-1", {
           TAG: "CreateItem",
           itemId: "item-1",
           name: "Test"
@@ -286,7 +286,7 @@ globalThis.describe("StateChangeSlice_Callback:", () => {
     });
     globalThis.test("returns Error after retries exhausted (4 failures)", async () => {
       mock.failNextAppends.contents = 4;
-      let results = await Effect.runPromise(TestHandler.handleCommands(undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem("ref-1", {
+      let results = await Effect.runPromise(TestHandler.handleCommands(undefined, undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem("ref-1", {
           TAG: "CreateItem",
           itemId: "item-1",
           name: "Test"
@@ -305,7 +305,7 @@ globalThis.describe("StateChangeSlice_Callback:", () => {
   });
   globalThis.describe("handleCommands - read consistency (eventual-first, strong-on-retry)", () => {
     globalThis.test("a conflict-free command reads eventually-consistent (no strong read)", async () => {
-      await Effect.runPromise(TestHandler.handleCommands(undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem("ref-1", {
+      await Effect.runPromise(TestHandler.handleCommands(undefined, undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem("ref-1", {
           TAG: "CreateItem",
           itemId: "item-1",
           name: "Test"
@@ -314,7 +314,7 @@ globalThis.describe("StateChangeSlice_Callback:", () => {
     });
     globalThis.test("escalates to strong consistency on retry after a conflict", async () => {
       mock.failNextAppends.contents = 1;
-      await Effect.runPromise(TestHandler.handleCommands(undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem("ref-1", {
+      await Effect.runPromise(TestHandler.handleCommands(undefined, undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem("ref-1", {
           TAG: "CreateItem",
           itemId: "item-1",
           name: "Test"
@@ -326,7 +326,7 @@ globalThis.describe("StateChangeSlice_Callback:", () => {
     });
     globalThis.test("every retry after the first is strong (2 failures)", async () => {
       mock.failNextAppends.contents = 2;
-      await Effect.runPromise(TestHandler.handleCommands(undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem("ref-1", {
+      await Effect.runPromise(TestHandler.handleCommands(undefined, undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem("ref-1", {
           TAG: "CreateItem",
           itemId: "item-1",
           name: "Test"
@@ -340,7 +340,7 @@ globalThis.describe("StateChangeSlice_Callback:", () => {
   });
   globalThis.describe("handleCommands - read consistency (per-slice override)", () => {
     globalThis.test("AlwaysStrong reads strong on the first attempt", async () => {
-      await Effect.runPromise(StrongHandler.handleCommands(undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem("ref-1", {
+      await Effect.runPromise(StrongHandler.handleCommands(undefined, undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem("ref-1", {
           TAG: "CreateItem",
           itemId: "item-1",
           name: "Test"
@@ -349,7 +349,7 @@ globalThis.describe("StateChangeSlice_Callback:", () => {
     });
     globalThis.test("AlwaysStrong stays strong across retries (2 failures)", async () => {
       mock.failNextAppends.contents = 2;
-      await Effect.runPromise(StrongHandler.handleCommands(undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem("ref-1", {
+      await Effect.runPromise(StrongHandler.handleCommands(undefined, undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem("ref-1", {
           TAG: "CreateItem",
           itemId: "item-1",
           name: "Test"
@@ -362,7 +362,7 @@ globalThis.describe("StateChangeSlice_Callback:", () => {
     });
     globalThis.test("AlwaysEventual never reads strong, even on retry (2 failures)", async () => {
       mock.failNextAppends.contents = 2;
-      await Effect.runPromise(EventualHandler.handleCommands(undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem("ref-1", {
+      await Effect.runPromise(EventualHandler.handleCommands(undefined, undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem("ref-1", {
           TAG: "CreateItem",
           itemId: "item-1",
           name: "Test"
@@ -376,12 +376,12 @@ globalThis.describe("StateChangeSlice_Callback:", () => {
   });
   globalThis.describe("handleCommands - conditional append", () => {
     globalThis.test("RenameItem after CreateItem uses headPosition in condition", async () => {
-      await Effect.runPromise(TestHandler.handleCommands(undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem("ref-1", {
+      await Effect.runPromise(TestHandler.handleCommands(undefined, undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem("ref-1", {
           TAG: "CreateItem",
           itemId: "item-1",
           name: "Test"
         })])));
-      let results = await Effect.runPromise(TestHandler.handleCommands(undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem("ref-2", {
+      let results = await Effect.runPromise(TestHandler.handleCommands(undefined, undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem("ref-2", {
           TAG: "RenameItem",
           itemId: "item-1",
           newName: "Updated"
@@ -400,7 +400,7 @@ globalThis.describe("StateChangeSlice_Callback:", () => {
   });
   globalThis.describe("handleCommands - batch", () => {
     globalThis.test("multiple successful commands", async () => {
-      let results = await Effect.runPromise(TestHandler.handleCommands(undefined, undefined, testDcbEventLog, Stream.fromIterable([
+      let results = await Effect.runPromise(TestHandler.handleCommands(undefined, undefined, undefined, testDcbEventLog, Stream.fromIterable([
         makeTopicItem("ref-1", {
           TAG: "CreateItem",
           itemId: "item-1",
@@ -424,12 +424,12 @@ globalThis.describe("StateChangeSlice_Callback:", () => {
       ]);
     });
     globalThis.test("mixed: new item succeeds, duplicate item ACKs as Ok (business-rule violation)", async () => {
-      await Effect.runPromise(TestHandler.handleCommands(undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem("ref-0", {
+      await Effect.runPromise(TestHandler.handleCommands(undefined, undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem("ref-0", {
           TAG: "CreateItem",
           itemId: "item-1",
           name: "Existing"
         })])));
-      let results = await Effect.runPromise(TestHandler.handleCommands(undefined, undefined, testDcbEventLog, Stream.fromIterable([
+      let results = await Effect.runPromise(TestHandler.handleCommands(undefined, undefined, undefined, testDcbEventLog, Stream.fromIterable([
         makeTopicItem("ref-1", {
           TAG: "CreateItem",
           itemId: "item-2",
@@ -453,13 +453,13 @@ globalThis.describe("StateChangeSlice_Callback:", () => {
       ]);
     });
     globalThis.test("empty batch returns empty array", async () => {
-      let results = await Effect.runPromise(TestHandler.handleCommands(undefined, undefined, testDcbEventLog, Stream.fromIterable([])));
+      let results = await Effect.runPromise(TestHandler.handleCommands(undefined, undefined, undefined, testDcbEventLog, Stream.fromIterable([])));
       globalThis.expect(results).toEqual([]);
     });
   });
   globalThis.describe("handleCommands - projection cache", () => {
     globalThis.test("a third same-entity command reads only the delta", async () => {
-      let run = (reference, command) => Effect.runPromise(TestHandler.handleCommands(undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem(reference, command)])));
+      let run = (reference, command) => Effect.runPromise(TestHandler.handleCommands(undefined, undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem(reference, command)])));
       await run("ref-1", {
         TAG: "CreateItem",
         itemId: "item-1",
@@ -493,7 +493,7 @@ globalThis.describe("StateChangeSlice_Callback:", () => {
       ]);
     });
     globalThis.test("a different entity does not hit another entity's cache (full read)", async () => {
-      let run = (reference, command) => Effect.runPromise(TestHandler.handleCommands(undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem(reference, command)])));
+      let run = (reference, command) => Effect.runPromise(TestHandler.handleCommands(undefined, undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem(reference, command)])));
       await run("ref-1", {
         TAG: "CreateItem",
         itemId: "item-1",
@@ -510,7 +510,7 @@ globalThis.describe("StateChangeSlice_Callback:", () => {
       ]);
     });
     globalThis.test("conflict re-seeds the cache so the retry reads the delta", async () => {
-      let run = (reference, command) => Effect.runPromise(TestHandler.handleCommands(undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem(reference, command)])));
+      let run = (reference, command) => Effect.runPromise(TestHandler.handleCommands(undefined, undefined, undefined, testDcbEventLog, Stream.fromIterable([makeTopicItem(reference, command)])));
       await run("ref-1", {
         TAG: "CreateItem",
         itemId: "item-1",

package/tests/dcb/DcbTagTest.res

@@ -534,107 +534,120 @@ describe("DcbTag:", () => {
     )
   })
 
-  describe("derivePartitionTag", () => {
-    let u = S.castToUnknown
+  describe("deriveBoundaryPartition", () => {
+    let slice = (name, eventSchema): Reventless.DcbTag.sliceSchemas => {
+      name,
+      commandSchema: S.unknown,
+      consumedEventSchema: S.unknown,
+      eventSchema: eventSchema->S.castToUnknown,
+    }
+    let thrownMessage = f =>
+      try {
+        let _ = f()
+        None
+      } catch {
+      | JsExn(err) => JsExn.message(err)
+      }
 
     testSync(
       "returns Composite for schema with >= 2 composite fields",
-      () => {
-        let result = Reventless.DcbTag.derivePartitionTag([
-          ("Sync", "test.res", DcbFixtures.compositeEventSchema->u),
-        ])
-        switch result {
+      () =>
+        switch Reventless.DcbTag.deriveBoundaryPartition([
+          slice("Sync", DcbFixtures.compositeEventSchema),
+        ]).partitionTag {
         | Composite(spec) =>
-          expect(spec.keys)->toEqual(["environment", "platformName", "pluginName"])->ignore
+          expect(spec.keys)->toEqual(["environment", "platformName", "pluginName"])
           expect(spec.seps)->toEqual(["/", "/"])
-        | Simple(_) => fail("Expected Composite")
-        }
-      },
+        | _ => fail("Expected Composite")
+        },
     )
 
     testSync(
       "returns Composite with custom separators",
-      () => {
-        let result = Reventless.DcbTag.derivePartitionTag([
-          ("Config", "test.res", DcbFixtures.compositeEventCustomSepSchema->u),
-        ])
-        switch result {
+      () =>
+        switch Reventless.DcbTag.deriveBoundaryPartition([
+          slice("Config", DcbFixtures.compositeEventCustomSepSchema),
+        ]).partitionTag {
         | Composite(spec) =>
-          expect(spec.keys)->toEqual(["tenantId", "region", "service"])->ignore
+          expect(spec.keys)->toEqual(["tenantId", "region", "service"])
           expect(spec.seps)->toEqual([":", "/"])
-        | Simple(_) => fail("Expected Composite")
-        }
-      },
+        | _ => fail("Expected Composite")
+        },
     )
 
     testSync(
-      "returns Simple for schema with only @partitionTag",
+      "files each event type under its own slice's key — two entities, two annotated keys",
       () => {
-        let result = Reventless.DcbTag.derivePartitionTag([
-          ("Order", "test.res", DcbFixtures.simplePartitionEventSchema->u),
+        let bp = Reventless.DcbTag.deriveBoundaryPartition([
+          slice("PlaceOrder", DcbFixtures.simplePartitionEventSchema),
+          slice("LinkAddress", DcbFixtures.addressLinkedEventSchema),
         ])
-        switch result {
-        | Simple(pt) => expect(pt.key)->toBe("orderId")
-        | Composite(_) => fail("Expected Simple")
+        switch bp.partitionTag {
+        | ByEventType(keys) =>
+          expect(keys->Dict.get("OrderPlaced"))->toEqual(Some("orderId"))
+          expect(keys->Dict.get("AddressLinked"))->toEqual(Some("customerId"))
+        | _ => fail("Expected ByEventType")
         }
+        expect(bp->Reventless.DcbTag.slicePartitionTag("LinkAddress"))->toEqual(
+          Some(Reventless.DcbTag.Simple({key: "customerId"})),
+        )
       },
     )
 
     testSync(
-      "returns Simple for schema with single tagged field",
+      "a single tagged field is the partition",
+      () =>
+        expect(
+          Reventless.DcbTag.deriveBoundaryPartition([
+            slice("Item", DcbFixtures.singleTagCommandSchema),
+          ]).partitionBySlice->Dict.get("Item"),
+        )->toEqual(Some("itemId")),
+    )
+
+    testSync(
+      "an unannotated multi-id slice throws naming it, though a sibling is annotated",
       () => {
-        let result = Reventless.DcbTag.derivePartitionTag([
-          ("Item", "test.res", DcbFixtures.singleTagCommandSchema->u),
-        ])
-        switch result {
-        | Simple(pt) => expect(pt.key)->toBe("itemId")
-        | Composite(_) => fail("Expected Simple")
-        }
+        let message =
+          thrownMessage(
+            () =>
+              Reventless.DcbTag.deriveBoundaryPartition([
+                slice("PlaceOrder", DcbFixtures.simplePartitionEventSchema),
+                slice("LinkCustomerAddress", DcbFixtures.unannotatedLinkEventSchema),
+              ]),
+          )->Option.getOr("")
+        expect(message->String.includes("LinkCustomerAddress"))->toBe(true)
+        expect(message->String.includes("@partitionTag"))->toBe(true)
       },
     )
 
     testSync(
       "throws on mixed composite and simple partition strategy",
-      () => {
-        let threw = ref(false)
-        try {
-          let _ = Reventless.DcbTag.derivePartitionTag([
-            ("Mixed", "test.res", DcbFixtures.mixedStrategyEventSchema->u),
-          ])
-        } catch {
-        | JsExn(err) =>
-          threw := true
-          expect(
-            JsExn.message(err)
-            ->Option.getOr("")
-            ->String.includes("mixes @compositePartitionTag and @partitionTag"),
+      () =>
+        expect(
+          thrownMessage(
+            () =>
+              Reventless.DcbTag.deriveBoundaryPartition([
+                slice("Mixed", DcbFixtures.mixedStrategyEventSchema),
+              ]),
           )
-          ->toBe(true)
-          ->ignore
-        }
-        expect(threw.contents)->toBe(true)
-      },
+          ->Option.getOr("")
+          ->String.includes("mixes @compositePartitionTag and @partitionTag"),
+        )->toBe(true),
     )
 
     testSync(
       "throws on single composite field (< 2)",
-      () => {
-        let threw = ref(false)
-        try {
-          let _ = Reventless.DcbTag.derivePartitionTag([
-            ("Single", "test.res", DcbFixtures.singleCompositeEventSchema->u),
-          ])
-        } catch {
-        | JsExn(err) =>
-          threw := true
-          expect(
-            JsExn.message(err)->Option.getOr("")->String.includes("at least 2 annotated fields"),
+      () =>
+        expect(
+          thrownMessage(
+            () =>
+              Reventless.DcbTag.deriveBoundaryPartition([
+                slice("Single", DcbFixtures.singleCompositeEventSchema),
+              ]),
           )
-          ->toBe(true)
-          ->ignore
-        }
-        expect(threw.contents)->toBe(true)
-      },
+          ->Option.getOr("")
+          ->String.includes("at least 2 annotated fields"),
+        )->toBe(true),
     )
   })
 

package/tests/dcb/DcbTagTest.res.mjs

@@ -418,106 +418,105 @@ globalThis.describe("DcbTag:", () => {
       globalThis.expect(DcbTag$Reventless.getCompositePartitionKeyValue(tags, spec)).toBe("1/2/3");
     });
   });
-  globalThis.describe("derivePartitionTag", () => {
+  globalThis.describe("deriveBoundaryPartition", () => {
+    let slice = (name, eventSchema) => ({
+      name: name,
+      commandSchema: Sury.unknown,
+      consumedEventSchema: Sury.unknown,
+      eventSchema: eventSchema
+    });
+    let thrownMessage = f => {
+      try {
+        f();
+        return;
+      } catch (raw_err) {
+        let err = Primitive_exceptions.internalToException(raw_err);
+        if (err.RE_EXN_ID === "JsExn") {
+          return Stdlib_JsExn.message(err._1);
+        }
+        throw err;
+      }
+    };
     globalThis.test("returns Composite for schema with >= 2 composite fields", () => {
-      let result = DcbTag$Reventless.derivePartitionTag([[
-          "Sync",
-          "test.res",
-          DcbFixtures$ReventlessCore.compositeEventSchema
-        ]]);
-      if (result.TAG === "Simple") {
-        return JestGlobals.fail("Expected Composite");
+      let spec = DcbTag$Reventless.deriveBoundaryPartition([slice("Sync", DcbFixtures$ReventlessCore.compositeEventSchema)]).partitionTag;
+      switch (spec.TAG) {
+        case "Composite" :
+          let spec$1 = spec._0;
+          globalThis.expect(spec$1.keys).toEqual([
+            "environment",
+            "platformName",
+            "pluginName"
+          ]);
+          globalThis.expect(spec$1.seps).toEqual([
+            "/",
+            "/"
+          ]);
+          return;
+        case "Simple" :
+        case "ByEventType" :
+          return JestGlobals.fail("Expected Composite");
       }
-      let spec = result._0;
-      globalThis.expect(spec.keys).toEqual([
-        "environment",
-        "platformName",
-        "pluginName"
-      ]);
-      globalThis.expect(spec.seps).toEqual([
-        "/",
-        "/"
-      ]);
     });
     globalThis.test("returns Composite with custom separators", () => {
-      let result = DcbTag$Reventless.derivePartitionTag([[
-          "Config",
-          "test.res",
-          DcbFixtures$ReventlessCore.compositeEventCustomSepSchema
-        ]]);
-      if (result.TAG === "Simple") {
-        return JestGlobals.fail("Expected Composite");
+      let spec = DcbTag$Reventless.deriveBoundaryPartition([slice("Config", DcbFixtures$ReventlessCore.compositeEventCustomSepSchema)]).partitionTag;
+      switch (spec.TAG) {
+        case "Composite" :
+          let spec$1 = spec._0;
+          globalThis.expect(spec$1.keys).toEqual([
+            "tenantId",
+            "region",
+            "service"
+          ]);
+          globalThis.expect(spec$1.seps).toEqual([
+            ":",
+            "/"
+          ]);
+          return;
+        case "Simple" :
+        case "ByEventType" :
+          return JestGlobals.fail("Expected Composite");
       }
-      let spec = result._0;
-      globalThis.expect(spec.keys).toEqual([
-        "tenantId",
-        "region",
-        "service"
-      ]);
-      globalThis.expect(spec.seps).toEqual([
-        ":",
-        "/"
-      ]);
     });
-    globalThis.test("returns Simple for schema with only @partitionTag", () => {
-      let result = DcbTag$Reventless.derivePartitionTag([[
-          "Order",
-          "test.res",
-          DcbFixtures$ReventlessCore.simplePartitionEventSchema
-        ]]);
-      if (result.TAG !== "Simple") {
-        return JestGlobals.fail("Expected Simple");
-      }
-      globalThis.expect(result._0.key).toBe("orderId");
-    });
-    globalThis.test("returns Simple for schema with single tagged field", () => {
-      let result = DcbTag$Reventless.derivePartitionTag([[
-          "Item",
-          "test.res",
-          DcbFixtures$ReventlessCore.singleTagCommandSchema
-        ]]);
-      if (result.TAG !== "Simple") {
-        return JestGlobals.fail("Expected Simple");
+    globalThis.test("files each event type under its own slice's key — two entities, two annotated keys", () => {
+      let bp = DcbTag$Reventless.deriveBoundaryPartition([
+        slice("PlaceOrder", DcbFixtures$ReventlessCore.simplePartitionEventSchema),
+        slice("LinkAddress", DcbFixtures$ReventlessCore.addressLinkedEventSchema)
+      ]);
+      let keys = bp.partitionTag;
+      switch (keys.TAG) {
+        case "Simple" :
+        case "Composite" :
+          JestGlobals.fail("Expected ByEventType");
+          break;
+        case "ByEventType" :
+          let keys$1 = keys._0;
+          globalThis.expect(keys$1["OrderPlaced"]).toEqual("orderId");
+          globalThis.expect(keys$1["AddressLinked"]).toEqual("customerId");
+          break;
       }
-      globalThis.expect(result._0.key).toBe("itemId");
+      globalThis.expect(DcbTag$Reventless.slicePartitionTag(bp, "LinkAddress")).toEqual({
+        TAG: "Simple",
+        _0: {
+          key: "customerId"
+        }
+      });
+    });
+    globalThis.test("a single tagged field is the partition", () => {
+      globalThis.expect(DcbTag$Reventless.deriveBoundaryPartition([slice("Item", DcbFixtures$ReventlessCore.singleTagCommandSchema)]).partitionBySlice["Item"]).toEqual("itemId");
+    });
+    globalThis.test("an unannotated multi-id slice throws naming it, though a sibling is annotated", () => {
+      let message = Stdlib_Option.getOr(thrownMessage(() => DcbTag$Reventless.deriveBoundaryPartition([
+        slice("PlaceOrder", DcbFixtures$ReventlessCore.simplePartitionEventSchema),
+        slice("LinkCustomerAddress", DcbFixtures$ReventlessCore.unannotatedLinkEventSchema)
+      ])), "");
+      globalThis.expect(message.includes("LinkCustomerAddress")).toBe(true);
+      globalThis.expect(message.includes("@partitionTag")).toBe(true);
     });
     globalThis.test("throws on mixed composite and simple partition strategy", () => {
-      let threw = false;
-      try {
-        DcbTag$Reventless.derivePartitionTag([[
-            "Mixed",
-            "test.res",
-            DcbFixtures$ReventlessCore.mixedStrategyEventSchema
-          ]]);
-      } catch (raw_err) {
-        let err = Primitive_exceptions.internalToException(raw_err);
-        if (err.RE_EXN_ID === "JsExn") {
-          threw = true;
-          globalThis.expect(Stdlib_Option.getOr(Stdlib_JsExn.message(err._1), "").includes("mixes @compositePartitionTag and @partitionTag")).toBe(true);
-        } else {
-          throw err;
-        }
-      }
-      globalThis.expect(threw).toBe(true);
+      globalThis.expect(Stdlib_Option.getOr(thrownMessage(() => DcbTag$Reventless.deriveBoundaryPartition([slice("Mixed", DcbFixtures$ReventlessCore.mixedStrategyEventSchema)])), "").includes("mixes @compositePartitionTag and @partitionTag")).toBe(true);
     });
     globalThis.test("throws on single composite field (< 2)", () => {
-      let threw = false;
-      try {
-        DcbTag$Reventless.derivePartitionTag([[
-            "Single",
-            "test.res",
-            DcbFixtures$ReventlessCore.singleCompositeEventSchema
-          ]]);
-      } catch (raw_err) {
-        let err = Primitive_exceptions.internalToException(raw_err);
-        if (err.RE_EXN_ID === "JsExn") {
-          threw = true;
-          globalThis.expect(Stdlib_Option.getOr(Stdlib_JsExn.message(err._1), "").includes("at least 2 annotated fields")).toBe(true);
-        } else {
-          throw err;
-        }
-      }
-      globalThis.expect(threw).toBe(true);
+      globalThis.expect(Stdlib_Option.getOr(thrownMessage(() => DcbTag$Reventless.deriveBoundaryPartition([slice("Single", DcbFixtures$ReventlessCore.singleCompositeEventSchema)])), "").includes("at least 2 annotated fields")).toBe(true);
     });
   });
   globalThis.describe("isCompositePartitionMember", () => {

package/tests/plugin/PluginStructureAccessTest.res

@@ -32,6 +32,7 @@ module PsGatedCommandsSlice: ReventlessInfra.StateChangeSlice.T = {
     ~publishJsons as _,
     ~tagKeysByEventType as _=?,
     ~crossPartitionTagKeys as _=?,
+    ~partitionTag as _=?,
     ~runtime as _=?,
     ~opts as _=?,
   ): component => Obj.magic(0)

package/tests/plugin/PluginStructureAccessTest.res.mjs

@@ -15,7 +15,7 @@ let Behavior = {
   moduleUrl: PsGatedCommands$ReventlessCore.moduleUrl
 };
 
-function make(param, param$1, param$2, param$3, param$4, param$5) {
+function make(param, param$1, param$2, param$3, param$4, param$5, param$6) {
   return 0;
 }