@reventlessdev/reventless-core 3.0.0-alpha.274 → 3.0.0-alpha.276

package/CHANGELOG.md

@@ -3,6 +3,20 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.276 (2026-09-25)
+
+### Bug Fixes
+
+* **spec:** a chapter that carries both keys backs neither ([cbd823e](https://github.com/ReventlessDev/reventless-core/commit/cbd823e4f87ddd5810debd929bb536b2003d0e4c))
+
+
+# 3.0.0-alpha.275 (2026-09-25)
+
+### Bug Fixes
+
+* **spec,core:** a partition tag its chapter backs overrides inference ([4244a4a](https://github.com/ReventlessDev/reventless-core/commit/4244a4af9e7aad4378d9b6276ddeb44878e125b2))
+
+
 # 3.0.0-alpha.274 (2026-09-24)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.274",
+  "version": "3.0.0-alpha.276",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -30,20 +30,20 @@
     "uuid": "^13.0.0",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.34",
     "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.15",
-    "@reventlessdev/rescript-hash-object": "1.2.0-alpha.15",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.11",
     "@reventlessdev/rescript-node": "2.0.0-alpha.15",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.11",
+    "@reventlessdev/rescript-hash-object": "1.2.0-alpha.15",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.22",
     "@reventlessdev/rescript-ssh2": "2.0.0-alpha.15",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.1",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.174",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.146",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.176",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.148",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.38"
   },
   "devDependencies": {
     "rescript": "12.3.1",
     "sury-ppx": "11.0.0",
-    "@reventlessdev/reventless-ppx": "1.0.0-alpha.92"
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.94"
   },
   "peerDependencies": {
     "rescript": "^12.3.1"

package/src/components/Dcb/Dcb_Builder.res

@@ -237,11 +237,14 @@ module Make = (
 
       // A `@partitionTag` inference contradicts would steer storage, fence and read
       // scope to a key the slice only references, so it stops the build. One that
-      // inference agrees with is noise, and says so.
+      // inference agrees with is noise, and says so. One its chapter backs against
+      // inference is the author deciding what inference cannot see, and is kept.
       let hintIssues = Reventless.DcbValidation.validatePartitionHintsVsInference(
         ~shapes=inferenceShapes,
       )
-      hintIssues.redundancies->Array.forEach(e =>
+      hintIssues.redundancies
+      ->Array.concat(hintIssues.overrides)
+      ->Array.forEach(e =>
         log.info(~comp="Dcb_Builder", `DCB partition (${e.sliceName}): ${e.message}`)
       )
       if hintIssues.contradictions->Array.length > 0 {

package/src/components/Dcb/Dcb_Builder.res.mjs

@@ -178,7 +178,7 @@ function Make(DcbEventLogStorage) {
       }));
       let inferenceShapes = sliceSchemas.map(DcbTag$Reventless.sliceShape);
       let hintIssues = DcbValidation$Reventless.validatePartitionHintsVsInference(inferenceShapes);
-      hintIssues.redundancies.forEach(e => log.info("Dcb_Builder", undefined, `DCB partition (` + e.sliceName + `): ` + e.message));
+      hintIssues.redundancies.concat(hintIssues.overrides).forEach(e => log.info("Dcb_Builder", undefined, `DCB partition (` + e.sliceName + `): ` + e.message));
       if (hintIssues.contradictions.length !== 0) {
         let detail = hintIssues.contradictions.map(e => e.sliceName + `: ` + e.message).join(" | ");
         log.error("Dcb_Builder", undefined, `DCB partition contradiction (` + name + `): ` + detail);

package/tests/dcb/DcbScopeInferenceTest.res

@@ -503,6 +503,105 @@ describe("DcbScopeInference:", () => {
         expect(issues.redundancies)->toEqual([])
       },
     )
+
+    // `ShipOrder` records the carrier's booking, which nothing else in the boundary
+    // writes or reads. Rule 1 subtracts `orderId` (read off `OrderPlaced`) and is
+    // left with the booking: `AddProduct`'s shape exactly, with the other answer.
+    let placeOrder = slice(
+      "PlaceOrder",
+      ~chapter="Order",
+      ~produced=[ev("OrderPlaced", [scal("orderId")])],
+    )
+    let shipOrder = slice(
+      "ShipOrder",
+      ~chapter="Order",
+      ~partitionHint="orderId",
+      ~command=[scal("orderId"), scal("carrierBookingId")],
+      ~consumed=[ev("OrderPlaced", [scal("orderId")]), ev("OrderShipped", [scal("orderId")])],
+      ~produced=[ev("OrderShipped", [scal("orderId"), scal("carrierBookingId")])],
+    )
+
+    testSync(
+      "a hint its chapter backs overrides inference instead of contradicting it",
+      () => {
+        let issues = check([placeOrder, shipOrder])
+        expect(issues.contradictions)->toEqual([])
+        expect(issues.redundancies)->toEqual([])
+        expect(issues.overrides->names)->toEqual(["ShipOrder"])
+        // and the hint is what the boundary is partitioned by
+        expect(
+          DSI.resolvePartitions([placeOrder, shipOrder]).partitionBySlice->Dict.get("ShipOrder"),
+        )->toEqual(Some("orderId"))
+      },
+    )
+
+    testSync(
+      "without a chapter the same hint is still a contradiction",
+      () => {
+        let noChapter = (s: DSI.sliceShape) => {...s, chapter: ?None}
+        let issues = check([noChapter(placeOrder), noChapter(shipOrder)])
+        expect(issues.contradictions->names)->toEqual(["ShipOrder"])
+        expect(issues.overrides)->toEqual([])
+      },
+    )
+
+    // Every producer is present, so the arms it reads by `categoryId` all come from
+    // category slices: only the chapter can refuse the hint.
+    let categories = [
+      {...addCategory, chapter: "Category"},
+      {...renameCategory, chapter: "Category"},
+      {...archiveCategory, chapter: "Category"},
+    ]
+
+    testSync(
+      "a hint its chapter disagrees with is still a contradiction",
+      () => {
+        // `RenameProduct` writes only `productId`, so `Product/` is about products.
+        let renameProduct = slice(
+          "RenameProduct",
+          ~chapter="Product",
+          ~consumed=[ev("ProductAdded", [scal("productId")])],
+          ~produced=[ev("ProductRenamed", [scal("productId")])],
+        )
+        let inProduct = {...hinted(addProduct, "categoryId"), chapter: "Product"}
+        let issues = check([inProduct, renameProduct, ...categories])
+        expect(issues.contradictions->names)->toEqual(["AddProduct"])
+        expect(issues.overrides)->toEqual([])
+      },
+    )
+
+    testSync(
+      "a chapter that carries both keys everywhere backs neither",
+      () => {
+        // One slice, one event with both ids: the chapter cannot say which one it is about.
+        let inProduct = {...hinted(addProduct, "categoryId"), chapter: "Product"}
+        let issues = check([inProduct, ...categories])
+        expect(issues.contradictions->names)->toEqual(["AddProduct"])
+        expect(issues.overrides)->toEqual([])
+      },
+    )
+
+    testSync(
+      "a chapter-backed hint read off another entity's events is still a contradiction",
+      () => {
+        // `WarehouseAssigned` carries the order but belongs to the warehouse.
+        let assign = slice(
+          "AssignWarehouse",
+          ~chapter="Warehouse",
+          ~partitionHint="warehouseId",
+          ~produced=[ev("WarehouseAssigned", [scal("warehouseId"), scal("orderId")])],
+        )
+        let ship = {
+          ...shipOrder,
+          consumed: shipOrder.consumed->Array.concat([
+            ev("WarehouseAssigned", [scal("warehouseId"), scal("orderId")]),
+          ]),
+        }
+        let issues = check([placeOrder, ship, assign])
+        expect(issues.overrides->names)->toEqual([])
+        expect(issues.contradictions->names)->toEqual(["ShipOrder"])
+      },
+    )
   })
 
   describe("ambiguity surfacing", () => {

package/tests/dcb/DcbScopeInferenceTest.res.mjs

@@ -1,5 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Belt_Array from "@rescript/runtime/lib/es6/Belt_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
@@ -814,6 +815,156 @@ globalThis.describe("DcbScopeInference:", () => {
       globalThis.expect(issues.contradictions).toEqual([]);
       globalThis.expect(issues.redundancies).toEqual([]);
     });
+    let placeOrder = slice("PlaceOrder", undefined, undefined, [{
+        eventType: "OrderPlaced",
+        idFields: [{
+            name: "orderId",
+            isList: false
+          }]
+      }], undefined, "Order");
+    let shipOrder = slice("ShipOrder", [
+      {
+        name: "orderId",
+        isList: false
+      },
+      {
+        name: "carrierBookingId",
+        isList: false
+      }
+    ], [
+      {
+        eventType: "OrderPlaced",
+        idFields: [{
+            name: "orderId",
+            isList: false
+          }]
+      },
+      {
+        eventType: "OrderShipped",
+        idFields: [{
+            name: "orderId",
+            isList: false
+          }]
+      }
+    ], [{
+        eventType: "OrderShipped",
+        idFields: [
+          {
+            name: "orderId",
+            isList: false
+          },
+          {
+            name: "carrierBookingId",
+            isList: false
+          }
+        ]
+      }], "orderId", "Order");
+    globalThis.test("a hint its chapter backs overrides inference instead of contradicting it", () => {
+      let issues = DcbValidation$Reventless.validatePartitionHintsVsInference([
+        placeOrder,
+        shipOrder
+      ]);
+      globalThis.expect(issues.contradictions).toEqual([]);
+      globalThis.expect(issues.redundancies).toEqual([]);
+      globalThis.expect(issues.overrides.map(e => e.sliceName)).toEqual(["ShipOrder"]);
+      globalThis.expect(DcbScopeInference$Reventless.resolvePartitions([
+          placeOrder,
+          shipOrder
+        ]).partitionBySlice["ShipOrder"]).toEqual("orderId");
+    });
+    globalThis.test("without a chapter the same hint is still a contradiction", () => {
+      let noChapter = s => {
+        let newrecord = {...s};
+        newrecord.chapter = undefined;
+        return newrecord;
+      };
+      let issues = DcbValidation$Reventless.validatePartitionHintsVsInference([
+        noChapter(placeOrder),
+        noChapter(shipOrder)
+      ]);
+      globalThis.expect(issues.contradictions.map(e => e.sliceName)).toEqual(["ShipOrder"]);
+      globalThis.expect(issues.overrides).toEqual([]);
+    });
+    let newrecord = {...addCategory};
+    let newrecord$1 = {...renameCategory};
+    let newrecord$2 = {...archiveCategory};
+    let categories = [
+      (newrecord.chapter = "Category", newrecord),
+      (newrecord$1.chapter = "Category", newrecord$1),
+      (newrecord$2.chapter = "Category", newrecord$2)
+    ];
+    globalThis.test("a hint its chapter disagrees with is still a contradiction", () => {
+      let renameProduct = slice("RenameProduct", undefined, [{
+          eventType: "ProductAdded",
+          idFields: [{
+              name: "productId",
+              isList: false
+            }]
+        }], [{
+          eventType: "ProductRenamed",
+          idFields: [{
+              name: "productId",
+              isList: false
+            }]
+        }], undefined, "Product");
+      let newrecord = {...hinted(addProduct, "categoryId")};
+      newrecord.chapter = "Product";
+      let issues = DcbValidation$Reventless.validatePartitionHintsVsInference(Belt_Array.concatMany([
+        [
+          newrecord,
+          renameProduct
+        ],
+        categories
+      ]));
+      globalThis.expect(issues.contradictions.map(e => e.sliceName)).toEqual(["AddProduct"]);
+      globalThis.expect(issues.overrides).toEqual([]);
+    });
+    globalThis.test("a chapter that carries both keys everywhere backs neither", () => {
+      let newrecord = {...hinted(addProduct, "categoryId")};
+      newrecord.chapter = "Product";
+      let issues = DcbValidation$Reventless.validatePartitionHintsVsInference(Belt_Array.concatMany([
+        [newrecord],
+        categories
+      ]));
+      globalThis.expect(issues.contradictions.map(e => e.sliceName)).toEqual(["AddProduct"]);
+      globalThis.expect(issues.overrides).toEqual([]);
+    });
+    globalThis.test("a chapter-backed hint read off another entity's events is still a contradiction", () => {
+      let assign = slice("AssignWarehouse", undefined, undefined, [{
+          eventType: "WarehouseAssigned",
+          idFields: [
+            {
+              name: "warehouseId",
+              isList: false
+            },
+            {
+              name: "orderId",
+              isList: false
+            }
+          ]
+        }], "warehouseId", "Warehouse");
+      let newrecord = {...shipOrder};
+      newrecord.consumed = shipOrder.consumed.concat([{
+          eventType: "WarehouseAssigned",
+          idFields: [
+            {
+              name: "warehouseId",
+              isList: false
+            },
+            {
+              name: "orderId",
+              isList: false
+            }
+          ]
+        }]);
+      let issues = DcbValidation$Reventless.validatePartitionHintsVsInference([
+        placeOrder,
+        newrecord,
+        assign
+      ]);
+      globalThis.expect(issues.overrides.map(e => e.sliceName)).toEqual([]);
+      globalThis.expect(issues.contradictions.map(e => e.sliceName)).toEqual(["ShipOrder"]);
+    });
   });
   globalThis.describe("ambiguity surfacing", () => {
     let aOwner = slice("A", undefined, undefined, [{