@reventlessdev/reventless-core 3.0.0-alpha.180 → 3.0.0-alpha.181

package/tests/dcb/DcbScopeInferenceTest.res.mjs

@@ -0,0 +1,480 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+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";
+import * as DcbValidation$Reventless from "@reventlessdev/reventless-spec/src/components/DcbValidation.res.mjs";
+import * as DcbFixtures$ReventlessCore from "./DcbFixtures.res.mjs";
+import * as DcbScopeInference$Reventless from "@reventlessdev/reventless-spec/src/components/DcbScopeInference.res.mjs";
+
+function scal(name) {
+  return {
+    name: name,
+    isList: false
+  };
+}
+
+function arr(name) {
+  return {
+    name: name,
+    isList: true
+  };
+}
+
+function ev(eventType, idFields) {
+  return {
+    eventType: eventType,
+    idFields: idFields
+  };
+}
+
+function slice(sliceName, commandOpt, consumedOpt, producedOpt, partitionHint) {
+  let command = commandOpt !== undefined ? commandOpt : [];
+  let consumed = consumedOpt !== undefined ? consumedOpt : [];
+  let produced = producedOpt !== undefined ? producedOpt : [];
+  return {
+    sliceName: sliceName,
+    command: command,
+    consumed: consumed,
+    produced: produced,
+    partitionHint: partitionHint
+  };
+}
+
+let addProduct = slice("AddProduct", [
+  {
+    name: "productId",
+    isList: false
+  },
+  {
+    name: "categoryId",
+    isList: false
+  }
+], [
+  {
+    eventType: "ProductAdded",
+    idFields: [{
+        name: "productId",
+        isList: false
+      }]
+  },
+  {
+    eventType: "CategoryAdded",
+    idFields: [{
+        name: "categoryId",
+        isList: false
+      }]
+  },
+  {
+    eventType: "CategoryArchived",
+    idFields: [{
+        name: "categoryId",
+        isList: false
+      }]
+  }
+], [{
+    eventType: "ProductAdded",
+    idFields: [
+      {
+        name: "productId",
+        isList: false
+      },
+      {
+        name: "categoryId",
+        isList: false
+      }
+    ]
+  }], undefined);
+
+let addCategory = slice("AddCategory", [{
+    name: "categoryId",
+    isList: false
+  }], [
+  {
+    eventType: "CategoryAdded",
+    idFields: []
+  },
+  {
+    eventType: "CategoryArchived",
+    idFields: []
+  }
+], [{
+    eventType: "CategoryAdded",
+    idFields: [{
+        name: "categoryId",
+        isList: false
+      }]
+  }], undefined);
+
+let renameCategory = slice("RenameCategory", [{
+    name: "categoryId",
+    isList: false
+  }], [
+  {
+    eventType: "CategoryAdded",
+    idFields: []
+  },
+  {
+    eventType: "CategoryRenamed",
+    idFields: []
+  },
+  {
+    eventType: "CategoryArchived",
+    idFields: []
+  }
+], [{
+    eventType: "CategoryRenamed",
+    idFields: [{
+        name: "categoryId",
+        isList: false
+      }]
+  }], undefined);
+
+let archiveCategory = slice("ArchiveCategory", [{
+    name: "categoryId",
+    isList: false
+  }], [
+  {
+    eventType: "CategoryAdded",
+    idFields: []
+  },
+  {
+    eventType: "CategoryArchived",
+    idFields: []
+  }
+], [{
+    eventType: "CategoryArchived",
+    idFields: [{
+        name: "categoryId",
+        isList: false
+      }]
+  }], undefined);
+
+let catalog = [
+  addProduct,
+  addCategory,
+  renameCategory,
+  archiveCategory
+];
+
+globalThis.describe("DcbScopeInference:", () => {
+  globalThis.describe("tagKeyOf", () => {
+    globalThis.test("scalar *Id uses the field name", () => {
+      globalThis.expect(DcbScopeInference$Reventless.tagKeyOf({
+        name: "categoryId",
+        isList: false
+      })).toBe("categoryId");
+    });
+    globalThis.test("plural *Ids strips the trailing s", () => {
+      globalThis.expect(DcbScopeInference$Reventless.tagKeyOf({
+        name: "productIds",
+        isList: true
+      })).toBe("productId");
+    });
+  });
+  globalThis.describe("hybrid catalog (no annotations)", () => {
+    let d = DcbScopeInference$Reventless.infer(catalog);
+    globalThis.test("derives categoryId as the only cross-partition key — without any @crossPartition", () => {
+      globalThis.expect(d.crossPartitionTagKeys).toEqual(["categoryId"]);
+    });
+    globalThis.test("AddProduct partition = productId (foreign categoryId eliminated)", () => {
+      globalThis.expect(d.partitionBySlice["AddProduct"]).toEqual("productId");
+    });
+    globalThis.test("Category slices partition = categoryId", () => {
+      globalThis.expect(d.partitionBySlice["AddCategory"]).toEqual("categoryId");
+      globalThis.expect(d.partitionBySlice["RenameCategory"]).toEqual("categoryId");
+      globalThis.expect(d.partitionBySlice["ArchiveCategory"]).toEqual("categoryId");
+    });
+    globalThis.test("ProductAdded indexes productId only — categoryId is payload (no sibling leak)", () => {
+      globalThis.expect(d.tagKeysByEventType["ProductAdded"]).toEqual(["productId"]);
+    });
+    globalThis.test("CategoryAdded indexes its own categoryId", () => {
+      globalThis.expect(d.tagKeysByEventType["CategoryAdded"]).toEqual(["categoryId"]);
+    });
+    globalThis.test("no ambiguities for a well-formed boundary", () => {
+      globalThis.expect(d.ambiguities).toEqual([]);
+    });
+    globalThis.test("ownerByKey points categoryId at a Category slice, productId at Product", () => {
+      globalThis.expect(d.ownerByKey["productId"]).toEqual("AddProduct");
+      globalThis.expect(Stdlib_Option.isSome(d.ownerByKey["categoryId"])).toBe(true);
+    });
+  });
+  globalThis.describe("own composite read + @partitionTag hint (RecordProductDemand shape)", () => {
+    let recordDemand = slice("RecordProductDemand", undefined, [
+      {
+        eventType: "ProductDemandRecorded",
+        idFields: [{
+            name: "orderId",
+            isList: false
+          }]
+      },
+      {
+        eventType: "ProductDemandRevoked",
+        idFields: [{
+            name: "orderId",
+            isList: false
+          }]
+      }
+    ], [
+      {
+        eventType: "ProductDemandRecorded",
+        idFields: [
+          {
+            name: "productId",
+            isList: false
+          },
+          {
+            name: "orderId",
+            isList: false
+          }
+        ]
+      },
+      {
+        eventType: "ProductDemandRevoked",
+        idFields: [
+          {
+            name: "productId",
+            isList: false
+          },
+          {
+            name: "orderId",
+            isList: false
+          }
+        ]
+      }
+    ], "productId");
+    let d = DcbScopeInference$Reventless.infer([recordDemand]);
+    globalThis.test("the @partitionTag hint resolves the partition (no ambiguity)", () => {
+      globalThis.expect(d.partitionBySlice["RecordProductDemand"]).toEqual("productId");
+      globalThis.expect(d.ambiguities).toEqual([]);
+    });
+    globalThis.test("orderId stays indexed — it is an own-stream read key, not a foreign ref", () => {
+      globalThis.expect(d.tagKeysByEventType["ProductDemandRecorded"]).toEqual([
+        "orderId",
+        "productId"
+      ]);
+    });
+    globalThis.test("orderId is not cross-partition (no Order entity owns it in this boundary)", () => {
+      globalThis.expect(d.crossPartitionTagKeys).toEqual([]);
+    });
+  });
+  globalThis.describe("array foreign reference (productIds) stays partition-scoped", () => {
+    let placeOrder = slice("PlaceOrder", [
+      {
+        name: "orderId",
+        isList: false
+      },
+      {
+        name: "productIds",
+        isList: true
+      }
+    ], [
+      {
+        eventType: "OrderPlaced",
+        idFields: [{
+            name: "orderId",
+            isList: false
+          }]
+      },
+      {
+        eventType: "CatalogProductSynced",
+        idFields: [{
+            name: "productId",
+            isList: false
+          }]
+      }
+    ], [{
+        eventType: "OrderPlaced",
+        idFields: [
+          {
+            name: "orderId",
+            isList: false
+          },
+          {
+            name: "productIds",
+            isList: true
+          }
+        ]
+      }], undefined);
+    let productEntity = slice("SyncCatalogProduct", [{
+        name: "productId",
+        isList: false
+      }], [{
+        eventType: "CatalogProductSynced",
+        idFields: []
+      }], [{
+        eventType: "CatalogProductSynced",
+        idFields: [{
+            name: "productId",
+            isList: false
+          }]
+      }], undefined);
+    let d = DcbScopeInference$Reventless.infer([
+      placeOrder,
+      productEntity
+    ]);
+    globalThis.test("an array-only foreign read is NOT cross-partition (auto-fans, partition-scoped)", () => {
+      globalThis.expect(d.crossPartitionTagKeys).toEqual([]);
+    });
+    globalThis.test("PlaceOrder partition = orderId", () => {
+      globalThis.expect(d.partitionBySlice["PlaceOrder"]).toEqual("orderId");
+    });
+    globalThis.test("OrderPlaced indexes orderId only (productIds is a foreign payload ref)", () => {
+      globalThis.expect(d.tagKeysByEventType["OrderPlaced"]).toEqual(["orderId"]);
+    });
+  });
+  globalThis.describe("schema adapter ⇄ inference parity", () => {
+    let shapes = DcbTag$Reventless.eventShapesOfSchema(DcbFixtures$ReventlessCore.subscriptionEventSchema);
+    globalThis.test("eventShapesOfSchema extracts *Id fields by name (tag flags ignored)", () => {
+      globalThis.expect(shapes.length).toBe(1);
+      let arm = shapes[0];
+      globalThis.expect(arm.eventType).toBe("StudentSubscribed");
+      let names = arm.idFields.map(f => f.name).toSorted(Primitive_string.compare);
+      globalThis.expect(names).toEqual([
+        "courseId",
+        "studentId"
+      ]);
+    });
+    globalThis.test("inference reproduces extractCrossPartitionTagKeys ⇒ [\"studentId\"]", () => {
+      let studentEntity = slice("RegisterStudent", undefined, undefined, [{
+          eventType: "StudentRegistered",
+          idFields: [{
+              name: "studentId",
+              isList: false
+            }]
+        }], undefined);
+      let subscribe_command = [
+        {
+          name: "courseId",
+          isList: false
+        },
+        {
+          name: "studentId",
+          isList: false
+        }
+      ];
+      let subscribe_consumed = [{
+          eventType: "StudentRegistered",
+          idFields: [{
+              name: "studentId",
+              isList: false
+            }]
+        }];
+      let subscribe = {
+        sliceName: "SubscribeStudent",
+        command: subscribe_command,
+        consumed: subscribe_consumed,
+        produced: shapes,
+        partitionHint: undefined
+      };
+      let d = DcbScopeInference$Reventless.infer([
+        studentEntity,
+        subscribe
+      ]);
+      globalThis.expect(d.crossPartitionTagKeys).toEqual(DcbTag$Reventless.extractCrossPartitionTagKeys(DcbFixtures$ReventlessCore.subscriptionEventSchema));
+      globalThis.expect(d.partitionBySlice["SubscribeStudent"]).toEqual("courseId");
+    });
+  });
+  globalThis.describe("validateScopeVsInference (annotation ⇄ inference)", () => {
+    let d = DcbScopeInference$Reventless.infer(catalog);
+    globalThis.test("flags @crossPartition on a slice's OWN partition as a contradiction", () => {
+      let issues = DcbValidation$Reventless.validateScopeVsInference([[
+          "AddCategory",
+          ["categoryId"]
+        ]], d);
+      globalThis.expect(issues.contradictions.length).toBe(1);
+      globalThis.expect(issues.contradictions[0].sliceName).toBe("AddCategory");
+      globalThis.expect(issues.redundancies).toEqual([]);
+    });
+    globalThis.test("flags @crossPartition that inference already derives as redundant", () => {
+      let issues = DcbValidation$Reventless.validateScopeVsInference([[
+          "AddProduct",
+          ["categoryId"]
+        ]], d);
+      globalThis.expect(issues.contradictions).toEqual([]);
+      globalThis.expect(issues.redundancies.length).toBe(1);
+    });
+    globalThis.test("no annotations ⇒ no issues (the migrated catalog)", () => {
+      let issues = DcbValidation$Reventless.validateScopeVsInference(catalog.map(s => [
+        s.sliceName,
+        []
+      ]), d);
+      globalThis.expect(issues.contradictions).toEqual([]);
+      globalThis.expect(issues.redundancies).toEqual([]);
+    });
+  });
+  globalThis.describe("ambiguity surfacing", () => {
+    let aOwner = slice("A", undefined, undefined, [{
+        eventType: "AHappened",
+        idFields: [{
+            name: "aId",
+            isList: false
+          }]
+      }], undefined);
+    let bOwner = slice("B", undefined, undefined, [{
+        eventType: "BHappened",
+        idFields: [{
+            name: "bId",
+            isList: false
+          }]
+      }], undefined);
+    let join = slice("Join", undefined, [
+      {
+        eventType: "AHappened",
+        idFields: [{
+            name: "aId",
+            isList: false
+          }]
+      },
+      {
+        eventType: "BHappened",
+        idFields: [{
+            name: "bId",
+            isList: false
+          }]
+      }
+    ], [{
+        eventType: "Joined",
+        idFields: [
+          {
+            name: "aId",
+            isList: false
+          },
+          {
+            name: "bId",
+            isList: false
+          }
+        ]
+      }], undefined);
+    let d = DcbScopeInference$Reventless.infer([
+      aOwner,
+      bOwner,
+      join
+    ]);
+    globalThis.test("a pure-join slice with no own key is reported ambiguous", () => {
+      let names = d.ambiguities.map(param => param[0]);
+      globalThis.expect(names.includes("Join")).toBe(true);
+    });
+    globalThis.test("the well-formed owners are not ambiguous", () => {
+      let names = d.ambiguities.map(param => param[0]);
+      globalThis.expect(names.includes("A")).toBe(false);
+      globalThis.expect(names.includes("B")).toBe(false);
+    });
+  });
+});
+
+let DSI;
+
+export {
+  DSI,
+  scal,
+  arr,
+  ev,
+  slice,
+  addProduct,
+  addCategory,
+  renameCategory,
+  archiveCategory,
+  catalog,
+}
+/* addProduct Not a pure module */