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

package/tests/commandgenerator/CommandGeneratorFixtures.res

@@ -107,6 +107,7 @@ let singleTagSliceGen = CommandGenerator_Callback.makeGenerateCommand(
   ~commandSchema=singleTagCommandSchema->S.castToUnknown,
   ~componentKind=CommandGenerator_Callback.StateChangeSlice,
   ~stripIdFromParams=false,
+  ~partitionTag=Simple({key: "itemId"}),
 )
 
 let compositeTagSliceGen = CommandGenerator_Callback.makeGenerateCommand(
@@ -115,6 +116,7 @@ let compositeTagSliceGen = CommandGenerator_Callback.makeGenerateCommand(
   ~commandSchema=compositeTagCommandSchema->S.castToUnknown,
   ~componentKind=CommandGenerator_Callback.StateChangeSlice,
   ~stripIdFromParams=false,
+  ~partitionTag=Composite({keys: ["environment", "service"], seps: ["-"]}),
 )
 
 // Build a payload for a StateChangeSlice command — args must NOT include `id`.

package/tests/commandgenerator/CommandGeneratorFixtures.res.mjs

@@ -139,11 +139,25 @@ let optionalFieldCommandSchema = Sury.$schema(s => ({
   note: s.m(Sury.$option(Sury.string))
 }));
 
-let optionalFieldSliceGen = CommandGenerator_Callback$ReventlessCore.makeGenerateCommand(publishJsons, undefined, "OptionalFieldSlice", optionalFieldCommandSchema, "StateChangeSlice", false);
+let optionalFieldSliceGen = CommandGenerator_Callback$ReventlessCore.makeGenerateCommand(publishJsons, undefined, "OptionalFieldSlice", optionalFieldCommandSchema, "StateChangeSlice", false, undefined);
 
-let singleTagSliceGen = CommandGenerator_Callback$ReventlessCore.makeGenerateCommand(publishJsons, undefined, "SingleTagSlice", singleTagCommandSchema, "StateChangeSlice", false);
+let singleTagSliceGen = CommandGenerator_Callback$ReventlessCore.makeGenerateCommand(publishJsons, undefined, "SingleTagSlice", singleTagCommandSchema, "StateChangeSlice", false, {
+  TAG: "Simple",
+  _0: {
+    key: "itemId"
+  }
+});
 
-let compositeTagSliceGen = CommandGenerator_Callback$ReventlessCore.makeGenerateCommand(publishJsons, undefined, "CompositeTagSlice", compositeTagCommandSchema, "StateChangeSlice", false);
+let compositeTagSliceGen = CommandGenerator_Callback$ReventlessCore.makeGenerateCommand(publishJsons, undefined, "CompositeTagSlice", compositeTagCommandSchema, "StateChangeSlice", false, {
+  TAG: "Composite",
+  _0: {
+    keys: [
+      "environment",
+      "service"
+    ],
+    seps: ["-"]
+  }
+});
 
 function makeSlicePayload(command, args) {
   return {

package/tests/commandgenerator/OwnerStampingTest.res.mjs

@@ -32,7 +32,7 @@ let published = {
 
 let generate = CommandGenerator_Callback$ReventlessCore.makeGenerateCommand(async cmds => {
   published.contents = published.contents.concat(cmds);
-}, undefined, "Ordering", commandSchema, "StateChangeSlice", false);
+}, undefined, "Ordering", commandSchema, "StateChangeSlice", false, undefined);
 
 function cognito(userId, groups) {
   return {
@@ -193,7 +193,7 @@ globalThis.describe("@owner stamping on the command path:", () => {
 globalThis.describe("the schema a generator is built with must answer for its commands:", () => {
   let permissive = CommandGenerator_Callback$ReventlessCore.makeGenerateCommand(async cmds => {
     published.contents = published.contents.concat(cmds);
-  }, undefined, "Ordering", Sury.json, "StateChangeSlice", false);
+  }, undefined, "Ordering", Sury.json, "StateChangeSlice", false, undefined);
   globalThis.test("a permissive schema silently stamps nothing — the defect, pinned", async () => {
     await Effect.runPromise(permissive(placeOrder("cust-B", cognito("cust-A", ["User"]))));
     globalThis.expect(fieldOf(published.contents[published.contents.length - 1 | 0], "customerId")).toEqual("cust-B");

package/tests/commandtopic/CommandOutcomeHookTest.res.mjs

@@ -82,7 +82,7 @@ function sliceItem(reference, command) {
 }
 
 function runSlice(reference, command) {
-  return Effect.runPromise(SliceHandler.handleCommands(undefined, undefined, dcbEventLog, Stream.fromIterable([sliceItem(reference, command)])));
+  return Effect.runPromise(SliceHandler.handleCommands(undefined, undefined, undefined, dcbEventLog, Stream.fromIterable([sliceItem(reference, command)])));
 }
 
 function runAgg(aggIdOpt, reference, command) {

package/tests/dcb/DcbFixtures.res

@@ -375,7 +375,7 @@ type compositeMultiVariant =
       count: int,
     })
 
-// Schema with @partitionTag (simple) for derivePartitionTagV2 fallback test
+// Schema with @partitionTag (simple)
 @schema
 type simplePartitionEvent =
   | OrderPlaced({
@@ -383,6 +383,23 @@ type simplePartitionEvent =
       customerId: @s.matches(Reventless.DcbTag.string) string,
     })
 
+// A second entity in the same boundary, annotated on its own key. The partition
+// key is declared after the reference, so a positional default would pick the wrong one.
+@schema
+type addressLinkedEvent =
+  | AddressLinked({
+      addressId: @s.matches(Reventless.DcbTag.string) string,
+      customerId: @s.matches(Reventless.DcbTag.partition) string,
+    })
+
+// Two ids, no annotation and nothing read: inference cannot choose.
+@schema
+type unannotatedLinkEvent =
+  | CustomerAddressLinked({
+      customerId: @s.matches(Reventless.DcbTag.string) string,
+      addressId: @s.matches(Reventless.DcbTag.string) string,
+    })
+
 // Schema that mixes composite and simple partition (should throw)
 @schema
 type mixedStrategyEvent =

package/tests/dcb/DcbFixtures.res.mjs

@@ -473,6 +473,18 @@ let simplePartitionEventSchema = Sury.$schema(s => ({
   customerId: s.m(DcbTag$Reventless.string)
 }));
 
+let addressLinkedEventSchema = Sury.$schema(s => ({
+  TAG: "AddressLinked",
+  addressId: s.m(DcbTag$Reventless.string),
+  customerId: s.m(DcbTag$Reventless.partition)
+}));
+
+let unannotatedLinkEventSchema = Sury.$schema(s => ({
+  TAG: "CustomerAddressLinked",
+  customerId: s.m(DcbTag$Reventless.string),
+  addressId: s.m(DcbTag$Reventless.string)
+}));
+
 let mixedStrategyEventSchema = Sury.$schema(s => ({
   TAG: "BadEvent",
   env: s.m(DcbTag$Reventless.compositePartitionMember(0, undefined)),
@@ -532,6 +544,8 @@ export {
   compositeEventCustomSepSchema,
   compositeMultiVariantSchema,
   simplePartitionEventSchema,
+  addressLinkedEventSchema,
+  unannotatedLinkEventSchema,
   mixedStrategyEventSchema,
   singleCompositeEventSchema,
   subscriptionEventSchema,

package/tests/dcb/DcbScopeInferenceTest.res

@@ -12,12 +12,14 @@ let slice = (
   ~consumed=[],
   ~produced=[],
   ~partitionHint=?,
+  ~chapter=?,
 ): DSI.sliceShape => {
   sliceName,
   command,
   consumed,
   produced,
   partitionHint,
+  ?chapter,
 }
 
 // The online-shop-hybrid catalog boundary, transcribed structurally (NO tag
@@ -271,6 +273,238 @@ describe("DcbScopeInference:", () => {
     )
   })
 
+  describe("partition: identity given back only when subtraction leaves nothing", () => {
+    let partitionOf = (d: DSI.derived, name) => d.partitionBySlice->Dict.get(name)
+
+    testSync(
+      "AddProduct without a hint stays productId, though its category arms come from a categoryId slice",
+      () => {
+        let d = DSI.infer(catalog)
+        expect(addProduct.partitionHint)->toEqual(None)
+        expect(d->partitionOf("AddProduct"))->toEqual(Some("productId"))
+      },
+    )
+
+    testSync(
+      "a lifecycle arm naming the slice's own id resolves",
+      () => {
+        let changeName = slice(
+          "ChangeProductName",
+          ~command=[scal("productId")],
+          ~consumed=[ev("ProductAdded", [scal("productId")])],
+          ~produced=[ev("ProductNameChanged", [scal("productId")])],
+        )
+        let d = DSI.infer(catalog->Array.concat([changeName]))
+        expect(d->partitionOf("ChangeProductName"))->toEqual(Some("productId"))
+        expect(d.ambiguities)->toEqual([])
+      },
+    )
+
+    // Every arm a slice reads from the other also names that slice's ids, so
+    // subtraction leaves both with nothing and each depends on the other.
+    let placeOrder = slice(
+      "PlaceOrder",
+      ~partitionHint="orderId",
+      ~command=[scal("orderId"), scal("customerId")],
+      ~produced=[ev("OrderPlaced", [scal("orderId"), scal("customerId"), arr("productIds")])],
+    )
+    let shipOrder = slice(
+      "ShipOrder",
+      ~command=[scal("orderId")],
+      ~consumed=[
+        ev("OrderPlaced", [scal("orderId"), scal("customerId"), arr("productIds")]),
+        ev("OrderCancelled", [scal("orderId"), arr("productIds")]),
+      ],
+      ~produced=[ev("OrderShipped", [scal("orderId"), scal("customerId")])],
+    )
+    let cancelOrder = slice(
+      "CancelOrder",
+      ~command=[scal("orderId")],
+      ~consumed=[
+        ev("OrderPlaced", [scal("orderId"), scal("customerId"), arr("productIds")]),
+        ev("OrderShipped", [scal("orderId"), scal("customerId")]),
+      ],
+      ~produced=[ev("OrderCancelled", [scal("orderId"), arr("productIds")])],
+    )
+
+    testSync(
+      "the ShipOrder ⇄ CancelOrder cycle resolves both to orderId",
+      () => {
+        let d = DSI.infer([placeOrder, shipOrder, cancelOrder])
+        expect(d->partitionOf("ShipOrder"))->toEqual(Some("orderId"))
+        expect(d->partitionOf("CancelOrder"))->toEqual(Some("orderId"))
+        expect(d.ambiguities)->toEqual([])
+      },
+    )
+
+    testSync(
+      "seen alone, the same slice names the arms to change",
+      () =>
+        expect(DSI.partitionBlockers(cancelOrder))->toEqual([
+          ("orderId", ["OrderPlaced", "OrderShipped"]),
+          ("productId", ["OrderPlaced"]),
+        ]),
+    )
+
+    let recordDemand = slice(
+      "RecordProductDemand",
+      ~command=[scal("productId"), scal("orderId")],
+      ~consumed=[ev("ProductDemandRecorded", [scal("orderId")])],
+      ~produced=[ev("ProductDemandRecorded", [scal("productId"), scal("orderId")])],
+    )
+
+    testSync(
+      "a join without a hint stays ambiguous",
+      () => {
+        let d = DSI.infer([recordDemand])
+        expect(d->partitionOf("RecordProductDemand"))->toEqual(None)
+        expect(d.ambiguities->Array.map(((n, _)) => n))->toEqual(["RecordProductDemand"])
+      },
+    )
+
+    testSync(
+      "a produced id another slice is partitioned by is not dropped",
+      () => {
+        // Were productId dropped for belonging to AddProduct, the join would
+        // silently resolve to orderId.
+        let d = DSI.infer(catalog->Array.concat([placeOrder, recordDemand]))
+        expect(d->partitionOf("RecordProductDemand"))->toEqual(None)
+        expect(
+          d.ambiguities->Array.some(
+            ((n, reason)) =>
+              n == "RecordProductDemand" && reason->String.includes("orderId, productId"),
+          ),
+        )->toBe(true)
+      },
+    )
+
+    testSync(
+      "a boundary that never settles is reported, not guessed",
+      () => {
+        // A resolves only while B is unresolved, and B only while A is: each
+        // pass flips both. Z* arms have no producer, so they always block.
+        let a = slice(
+          "A",
+          ~consumed=[ev("BHappened", [scal("xId")]), ev("ZHappened", [scal("yId")])],
+          ~produced=[ev("AHappened", [scal("xId"), scal("yId")])],
+        )
+        let b = slice(
+          "B",
+          ~consumed=[ev("AHappened", [scal("yId")]), ev("Z2Happened", [scal("xId")])],
+          ~produced=[ev("BHappened", [scal("xId"), scal("yId")])],
+        )
+        let d = DSI.infer([a, b])
+        expect(d.ambiguities->Array.map(((n, _)) => n))->toEqual(["A", "B"])
+        expect(
+          d.ambiguities->Array.every(((_, reason)) => reason->String.includes("did not settle")),
+        )->toBe(true)
+      },
+    )
+  })
+
+  describe("partition: the chapter breaks a tie", () => {
+    let placeOrder = (~chapter=?) =>
+      slice(
+        "PlaceOrder",
+        ~command=[scal("orderId"), scal("customerId")],
+        ~consumed=[ev("OrderPlaced", [scal("orderId")])],
+        ~produced=[ev("OrderPlaced", [scal("orderId"), scal("customerId")])],
+        ~chapter?,
+      )
+    let cancelOrder = slice(
+      "CancelOrder",
+      ~chapter="Order",
+      ~consumed=[ev("OrderPlaced", [])],
+      ~produced=[ev("OrderCancelled", [scal("orderId")])],
+    )
+    let partitionOf = (d: DSI.derived, name) => d.partitionBySlice->Dict.get(name)
+
+    testSync(
+      "an order and its customer resolve to the id every Order event carries",
+      () => {
+        let d = DSI.infer([placeOrder(~chapter="Order"), cancelOrder])
+        expect(d->partitionOf("PlaceOrder"))->toEqual(Some("orderId"))
+        expect(d.ambiguities)->toEqual([])
+      },
+    )
+
+    testSync(
+      "without a chapter the same slice stays ambiguous",
+      () => {
+        let d = DSI.infer([placeOrder(), cancelOrder])
+        expect(d->partitionOf("PlaceOrder"))->toEqual(None)
+      },
+    )
+
+    testSync(
+      "a join whose chapter carries both ids stays ambiguous, and the reason says so",
+      () => {
+        let demand = slice(
+          "RecordProductDemand",
+          ~chapter="ProductDemand",
+          ~produced=[ev("ProductDemandRecorded", [scal("productId"), scal("orderId")])],
+        )
+        let d = DSI.infer([demand])
+        expect(d->partitionOf("RecordProductDemand"))->toEqual(None)
+        expect(
+          d.ambiguities->Array.some(
+            ((_, reason)) => reason->String.includes("The ProductDemand chapter does not decide"),
+          ),
+        )->toBe(true)
+      },
+    )
+
+    testSync(
+      "it never overrides a key the subtraction decided",
+      () => {
+        // AddProduct filed under a chapter keyed by categoryId still resolves to
+        // productId: the tie-breaker only sees slices left with several keys.
+        let misfiled = {...addProduct, chapter: "Category"}
+        let d = DSI.infer([misfiled, {...addCategory, chapter: "Category"}])
+        expect(d->partitionOf("AddProduct"))->toEqual(Some("productId"))
+      },
+    )
+  })
+
+  describe("validatePartitionHintsVsInference (@partitionTag ⇄ inference)", () => {
+    let hinted = (s: DSI.sliceShape, key) => {...s, partitionHint: Some(key)}
+    let check = shapes => Reventless.DcbValidation.validatePartitionHintsVsInference(~shapes)
+    let names = (issues: array<Reventless.DcbValidation.validationError>) =>
+      issues->Array.map(e => e.sliceName)
+
+    testSync(
+      "a hint naming a key the slice only references is a contradiction",
+      () => {
+        let issues = check([hinted(addProduct, "categoryId"), addCategory])
+        expect(issues.contradictions->names)->toEqual(["AddProduct"])
+        expect(issues.redundancies)->toEqual([])
+      },
+    )
+
+    testSync(
+      "a hint inference reaches unaided is redundant",
+      () => {
+        let issues = check([hinted(addProduct, "productId"), addCategory])
+        expect(issues.contradictions)->toEqual([])
+        expect(issues.redundancies->names)->toEqual(["AddProduct"])
+      },
+    )
+
+    testSync(
+      "a hint that decides a join is neither",
+      () => {
+        let demand = slice(
+          "RecordProductDemand",
+          ~partitionHint="productId",
+          ~produced=[ev("ProductDemandRecorded", [scal("productId"), scal("orderId")])],
+        )
+        let issues = check([demand])
+        expect(issues.contradictions)->toEqual([])
+        expect(issues.redundancies)->toEqual([])
+      },
+    )
+  })
+
   describe("ambiguity surfacing", () => {
     // A pure join: produces an event carrying two foreign keys, owns neither.
     let aOwner = slice("A", ~produced=[ev("AHappened", [scal("aId")])])