@reventlessdev/reventless-core 3.0.0-alpha.170 → 3.0.0-alpha.171

package/tests/dcb/DcbScopeInferenceTest.res.mjs

@@ -1,480 +0,0 @@
-// 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 */