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

package/tests/dcb/DcbScopeInferenceTest.res

@@ -6,7 +6,13 @@ module DSI = Reventless.DcbScopeInference
 let scal = (name): DSI.idField => {name, isList: false}
 let arr = (name): DSI.idField => {name, isList: true}
 let ev = (eventType, idFields): DSI.eventShape => {eventType, idFields}
-let slice = (sliceName, ~command=[], ~consumed=[], ~produced=[], ~partitionHint=?): DSI.sliceShape => {
+let slice = (
+  sliceName,
+  ~command=[],
+  ~consumed=[],
+  ~produced=[],
+  ~partitionHint=?,
+): DSI.sliceShape => {
   sliceName,
   command,
   consumed,
@@ -19,7 +25,11 @@ let slice = (sliceName, ~command=[], ~consumed=[], ~produced=[], ~partitionHint=
 let addProduct = slice(
   "AddProduct",
   ~command=[scal("productId"), scal("categoryId")],
-  ~consumed=[ev("ProductAdded", [scal("productId")]), ev("CategoryAdded", [scal("categoryId")]), ev("CategoryArchived", [scal("categoryId")])],
+  ~consumed=[
+    ev("ProductAdded", [scal("productId")]),
+    ev("CategoryAdded", [scal("categoryId")]),
+    ev("CategoryArchived", [scal("categoryId")]),
+  ],
   ~produced=[ev("ProductAdded", [scal("productId"), scal("categoryId")])],
 )
 let addCategory = slice(
@@ -44,47 +54,57 @@ let catalog = [addProduct, addCategory, renameCategory, archiveCategory]
 
 describe("DcbScopeInference:", () => {
   describe("tagKeyOf", () => {
-    testSync("scalar *Id uses the field name", () =>
-      expect(DSI.tagKeyOf(scal("categoryId")))->toBe("categoryId")
+    testSync(
+      "scalar *Id uses the field name",
+      () => expect(DSI.tagKeyOf(scal("categoryId")))->toBe("categoryId"),
     )
-    testSync("plural *Ids strips the trailing s", () =>
-      expect(DSI.tagKeyOf(arr("productIds")))->toBe("productId")
+    testSync(
+      "plural *Ids strips the trailing s",
+      () => expect(DSI.tagKeyOf(arr("productIds")))->toBe("productId"),
     )
   })
 
   describe("hybrid catalog (no annotations)", () => {
     let d = DSI.infer(catalog)
 
-    testSync("derives categoryId as the only cross-partition key — without any @crossPartition", () =>
-      expect(d.crossPartitionTagKeys)->toEqual(["categoryId"])
+    testSync(
+      "derives categoryId as the only cross-partition key — without any @crossPartition",
+      () => expect(d.crossPartitionTagKeys)->toEqual(["categoryId"]),
     )
 
-    testSync("AddProduct partition = productId (foreign categoryId eliminated)", () =>
-      expect(d.partitionBySlice->Dict.get("AddProduct"))->toEqual(Some("productId"))
+    testSync(
+      "AddProduct partition = productId (foreign categoryId eliminated)",
+      () => expect(d.partitionBySlice->Dict.get("AddProduct"))->toEqual(Some("productId")),
     )
 
-    testSync("Category slices partition = categoryId", () => {
-      expect(d.partitionBySlice->Dict.get("AddCategory"))->toEqual(Some("categoryId"))
-      expect(d.partitionBySlice->Dict.get("RenameCategory"))->toEqual(Some("categoryId"))
-      expect(d.partitionBySlice->Dict.get("ArchiveCategory"))->toEqual(Some("categoryId"))
-    })
-
-    testSync("ProductAdded indexes productId only — categoryId is payload (no sibling leak)", () =>
-      expect(d.tagKeysByEventType->Dict.get("ProductAdded"))->toEqual(Some(["productId"]))
+    testSync(
+      "Category slices partition = categoryId",
+      () => {
+        expect(d.partitionBySlice->Dict.get("AddCategory"))->toEqual(Some("categoryId"))
+        expect(d.partitionBySlice->Dict.get("RenameCategory"))->toEqual(Some("categoryId"))
+        expect(d.partitionBySlice->Dict.get("ArchiveCategory"))->toEqual(Some("categoryId"))
+      },
     )
 
-    testSync("CategoryAdded indexes its own categoryId", () =>
-      expect(d.tagKeysByEventType->Dict.get("CategoryAdded"))->toEqual(Some(["categoryId"]))
+    testSync(
+      "ProductAdded indexes productId only — categoryId is payload (no sibling leak)",
+      () => expect(d.tagKeysByEventType->Dict.get("ProductAdded"))->toEqual(Some(["productId"])),
     )
 
-    testSync("no ambiguities for a well-formed boundary", () =>
-      expect(d.ambiguities)->toEqual([])
+    testSync(
+      "CategoryAdded indexes its own categoryId",
+      () => expect(d.tagKeysByEventType->Dict.get("CategoryAdded"))->toEqual(Some(["categoryId"])),
     )
 
-    testSync("ownerByKey points categoryId at a Category slice, productId at Product", () => {
-      expect(d.ownerByKey->Dict.get("productId"))->toEqual(Some("AddProduct"))
-      expect(d.ownerByKey->Dict.get("categoryId")->Option.isSome)->toBe(true)
-    })
+    testSync("no ambiguities for a well-formed boundary", () => expect(d.ambiguities)->toEqual([]))
+
+    testSync(
+      "ownerByKey points categoryId at a Category slice, productId at Product",
+      () => {
+        expect(d.ownerByKey->Dict.get("productId"))->toEqual(Some("AddProduct"))
+        expect(d.ownerByKey->Dict.get("categoryId")->Option.isSome)->toBe(true)
+      },
+    )
   })
 
   describe("own composite read + @partitionTag hint (RecordProductDemand shape)", () => {
@@ -94,22 +114,34 @@ describe("DcbScopeInference:", () => {
     let recordDemand = slice(
       "RecordProductDemand",
       ~partitionHint="productId",
-      ~consumed=[ev("ProductDemandRecorded", [scal("orderId")]), ev("ProductDemandRevoked", [scal("orderId")])],
-      ~produced=[ev("ProductDemandRecorded", [scal("productId"), scal("orderId")]), ev("ProductDemandRevoked", [scal("productId"), scal("orderId")])],
+      ~consumed=[
+        ev("ProductDemandRecorded", [scal("orderId")]),
+        ev("ProductDemandRevoked", [scal("orderId")]),
+      ],
+      ~produced=[
+        ev("ProductDemandRecorded", [scal("productId"), scal("orderId")]),
+        ev("ProductDemandRevoked", [scal("productId"), scal("orderId")]),
+      ],
     )
     let d = DSI.infer([recordDemand])
 
-    testSync("the @partitionTag hint resolves the partition (no ambiguity)", () => {
-      expect(d.partitionBySlice->Dict.get("RecordProductDemand"))->toEqual(Some("productId"))
-      expect(d.ambiguities)->toEqual([])
-    })
-    testSync("orderId stays indexed — it is an own-stream read key, not a foreign ref", () =>
-      expect(d.tagKeysByEventType->Dict.get("ProductDemandRecorded"))->toEqual(
-        Some(["orderId", "productId"]),
-      )
+    testSync(
+      "the @partitionTag hint resolves the partition (no ambiguity)",
+      () => {
+        expect(d.partitionBySlice->Dict.get("RecordProductDemand"))->toEqual(Some("productId"))
+        expect(d.ambiguities)->toEqual([])
+      },
     )
-    testSync("orderId is not cross-partition (no Order entity owns it in this boundary)", () =>
-      expect(d.crossPartitionTagKeys)->toEqual([])
+    testSync(
+      "orderId stays indexed — it is an own-stream read key, not a foreign ref",
+      () =>
+        expect(d.tagKeysByEventType->Dict.get("ProductDemandRecorded"))->toEqual(
+          Some(["orderId", "productId"]),
+        ),
+    )
+    testSync(
+      "orderId is not cross-partition (no Order entity owns it in this boundary)",
+      () => expect(d.crossPartitionTagKeys)->toEqual([]),
     )
   })
 
@@ -122,7 +154,10 @@ describe("DcbScopeInference:", () => {
     let placeOrder = slice(
       "PlaceOrder",
       ~command=[scal("orderId"), arr("productIds")],
-      ~consumed=[ev("OrderPlaced", [scal("orderId")]), ev("CatalogProductSynced", [scal("productId")])],
+      ~consumed=[
+        ev("OrderPlaced", [scal("orderId")]),
+        ev("CatalogProductSynced", [scal("productId")]),
+      ],
       ~produced=[ev("OrderPlaced", [scal("orderId"), arr("productIds")])],
     )
     let productEntity = slice(
@@ -133,14 +168,17 @@ describe("DcbScopeInference:", () => {
     )
     let d = DSI.infer([placeOrder, productEntity])
 
-    testSync("an array-only foreign read is NOT cross-partition (auto-fans, partition-scoped)", () =>
-      expect(d.crossPartitionTagKeys)->toEqual([])
+    testSync(
+      "an array-only foreign read is NOT cross-partition (auto-fans, partition-scoped)",
+      () => expect(d.crossPartitionTagKeys)->toEqual([]),
     )
-    testSync("PlaceOrder partition = orderId", () =>
-      expect(d.partitionBySlice->Dict.get("PlaceOrder"))->toEqual(Some("orderId"))
+    testSync(
+      "PlaceOrder partition = orderId",
+      () => expect(d.partitionBySlice->Dict.get("PlaceOrder"))->toEqual(Some("orderId")),
     )
-    testSync("OrderPlaced indexes orderId only (productIds is a foreign payload ref)", () =>
-      expect(d.tagKeysByEventType->Dict.get("OrderPlaced"))->toEqual(Some(["orderId"]))
+    testSync(
+      "OrderPlaced indexes orderId only (productIds is a foreign payload ref)",
+      () => expect(d.tagKeysByEventType->Dict.get("OrderPlaced"))->toEqual(Some(["orderId"])),
     )
   })
 
@@ -151,71 +189,86 @@ describe("DcbScopeInference:", () => {
   describe("schema adapter ⇄ inference parity", () => {
     let shapes = Reventless.DcbTag.eventShapesOfSchema(DcbFixtures.subscriptionEventSchema)
 
-    testSync("eventShapesOfSchema extracts *Id fields by name (tag flags ignored)", () => {
-      expect(shapes->Array.length)->toBe(1)
-      let arm = shapes->Array.getUnsafe(0)
-      expect(arm.eventType)->toBe("StudentSubscribed")
-      let names = arm.idFields->Array.map(f => f.name)->Array.toSorted(String.compare)
-      expect(names)->toEqual(["courseId", "studentId"])
-    })
-
-    testSync("inference reproduces extractCrossPartitionTagKeys ⇒ [\"studentId\"]", () => {
-      // A Student entity owns studentId; Subscribe (built from the real fixture
-      // schema) reads it from the foreign StudentRegistered event.
-      let studentEntity = slice(
-        "RegisterStudent",
-        ~produced=[ev("StudentRegistered", [scal("studentId")])],
-      )
-      let subscribe: DSI.sliceShape = {
-        sliceName: "SubscribeStudent",
-        // The real command carries studentId as a SCALAR — so the foreign read is
-        // fanned cross-partition (a scalar reference, unlike PlaceOrder's array).
-        command: [scal("courseId"), scal("studentId")],
-        consumed: [ev("StudentRegistered", [scal("studentId")])],
-        produced: shapes, // StudentSubscribed({courseId, studentId}) from the schema adapter
-        partitionHint: None,
-      }
-      let d = DSI.infer([studentEntity, subscribe])
-      expect(d.crossPartitionTagKeys)->toEqual(
-        Reventless.DcbTag.extractCrossPartitionTagKeys(DcbFixtures.subscriptionEventSchema),
-      )
-      expect(d.partitionBySlice->Dict.get("SubscribeStudent"))->toEqual(Some("courseId"))
-    })
+    testSync(
+      "eventShapesOfSchema extracts *Id fields by name (tag flags ignored)",
+      () => {
+        expect(shapes->Array.length)->toBe(1)
+        let arm = shapes->Array.getUnsafe(0)
+        expect(arm.eventType)->toBe("StudentSubscribed")
+        let names = arm.idFields->Array.map(f => f.name)->Array.toSorted(String.compare)
+        expect(names)->toEqual(["courseId", "studentId"])
+      },
+    )
+
+    testSync(
+      "inference reproduces extractCrossPartitionTagKeys ⇒ [\"studentId\"]",
+      () => {
+        // A Student entity owns studentId; Subscribe (built from the real fixture
+        // schema) reads it from the foreign StudentRegistered event.
+        let studentEntity = slice(
+          "RegisterStudent",
+          ~produced=[ev("StudentRegistered", [scal("studentId")])],
+        )
+        let subscribe: DSI.sliceShape = {
+          sliceName: "SubscribeStudent",
+          // The real command carries studentId as a SCALAR — so the foreign read is
+          // fanned cross-partition (a scalar reference, unlike PlaceOrder's array).
+          command: [scal("courseId"), scal("studentId")],
+          consumed: [ev("StudentRegistered", [scal("studentId")])],
+          produced: shapes, // StudentSubscribed({courseId, studentId}) from the schema adapter
+          partitionHint: None,
+        }
+        let d = DSI.infer([studentEntity, subscribe])
+        expect(d.crossPartitionTagKeys)->toEqual(
+          Reventless.DcbTag.extractCrossPartitionTagKeys(DcbFixtures.subscriptionEventSchema),
+        )
+        expect(d.partitionBySlice->Dict.get("SubscribeStudent"))->toEqual(Some("courseId"))
+      },
+    )
   })
 
   describe("validateScopeVsInference (annotation ⇄ inference)", () => {
     let d = DSI.infer(catalog)
 
-    testSync("flags @crossPartition on a slice's OWN partition as a contradiction", () => {
-      // AddCategory's partition is categoryId; marking it @crossPartition is wrong.
-      let issues = Reventless.DcbValidation.validateScopeVsInference(
-        ~annotations=[("AddCategory", ["categoryId"])],
-        ~inferred=d,
-      )
-      expect(issues.contradictions->Array.length)->toBe(1)
-      expect((issues.contradictions->Array.getUnsafe(0)).sliceName)->toBe("AddCategory")
-      expect(issues.redundancies)->toEqual([])
-    })
-
-    testSync("flags @crossPartition that inference already derives as redundant", () => {
-      // AddProduct really does read categoryId cross-partition — the annotation is
-      // just no longer needed.
-      let issues = Reventless.DcbValidation.validateScopeVsInference(
-        ~annotations=[("AddProduct", ["categoryId"])],
-        ~inferred=d,
-      )
-      expect(issues.contradictions)->toEqual([])
-      expect(issues.redundancies->Array.length)->toBe(1)
-    })
-
-    testSync("no annotations ⇒ no issues (the migrated catalog)", () => {
-      let issues = Reventless.DcbValidation.validateScopeVsInference(
-        ~annotations=catalog->Array.map(s => (s.sliceName, [])),
-        ~inferred=d,
-      )
-      expect(issues.contradictions)->toEqual([])
-      expect(issues.redundancies)->toEqual([])
-    })
+    testSync(
+      "flags @crossPartition on a slice's OWN partition as a contradiction",
+      () => {
+        // AddCategory's partition is categoryId; marking it @crossPartition is wrong.
+        let issues = Reventless.DcbValidation.validateScopeVsInference(
+          ~annotations=[("AddCategory", ["categoryId"])],
+          ~inferred=d,
+        )
+        expect(issues.contradictions->Array.length)->toBe(1)
+        expect((issues.contradictions->Array.getUnsafe(0)).sliceName)->toBe("AddCategory")
+        expect(issues.redundancies)->toEqual([])
+      },
+    )
+
+    testSync(
+      "flags @crossPartition that inference already derives as redundant",
+      () => {
+        // AddProduct really does read categoryId cross-partition — the annotation is
+        // just no longer needed.
+        let issues = Reventless.DcbValidation.validateScopeVsInference(
+          ~annotations=[("AddProduct", ["categoryId"])],
+          ~inferred=d,
+        )
+        expect(issues.contradictions)->toEqual([])
+        expect(issues.redundancies->Array.length)->toBe(1)
+      },
+    )
+
+    testSync(
+      "no annotations ⇒ no issues (the migrated catalog)",
+      () => {
+        let issues = Reventless.DcbValidation.validateScopeVsInference(
+          ~annotations=catalog->Array.map(s => (s.sliceName, [])),
+          ~inferred=d,
+        )
+        expect(issues.contradictions)->toEqual([])
+        expect(issues.redundancies)->toEqual([])
+      },
+    )
   })
 
   describe("ambiguity surfacing", () => {
@@ -229,14 +282,20 @@ describe("DcbScopeInference:", () => {
     )
     let d = DSI.infer([aOwner, bOwner, join])
 
-    testSync("a pure-join slice with no own key is reported ambiguous", () => {
-      let names = d.ambiguities->Array.map(((n, _)) => n)
-      expect(names->Array.includes("Join"))->toBe(true)
-    })
-    testSync("the well-formed owners are not ambiguous", () => {
-      let names = d.ambiguities->Array.map(((n, _)) => n)
-      expect(names->Array.includes("A"))->toBe(false)
-      expect(names->Array.includes("B"))->toBe(false)
-    })
+    testSync(
+      "a pure-join slice with no own key is reported ambiguous",
+      () => {
+        let names = d.ambiguities->Array.map(((n, _)) => n)
+        expect(names->Array.includes("Join"))->toBe(true)
+      },
+    )
+    testSync(
+      "the well-formed owners are not ambiguous",
+      () => {
+        let names = d.ambiguities->Array.map(((n, _)) => n)
+        expect(names->Array.includes("A"))->toBe(false)
+        expect(names->Array.includes("B"))->toBe(false)
+      },
+    )
   })
 })