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

package/tests/dcb/DcbScopeInferenceTest.res.mjs

@@ -28,7 +28,7 @@ function ev(eventType, idFields) {
   };
 }
 
-function slice(sliceName, commandOpt, consumedOpt, producedOpt, partitionHint) {
+function slice(sliceName, commandOpt, consumedOpt, producedOpt, partitionHint, chapter) {
   let command = commandOpt !== undefined ? commandOpt : [];
   let consumed = consumedOpt !== undefined ? consumedOpt : [];
   let produced = producedOpt !== undefined ? producedOpt : [];
@@ -37,7 +37,8 @@ function slice(sliceName, commandOpt, consumedOpt, producedOpt, partitionHint) {
     command: command,
     consumed: consumed,
     produced: produced,
-    partitionHint: partitionHint
+    partitionHint: partitionHint,
+    chapter: chapter
   };
 }
 
@@ -84,7 +85,7 @@ let addProduct = slice("AddProduct", [
         isList: false
       }
     ]
-  }], undefined);
+  }], undefined, undefined);
 
 let addCategory = slice("AddCategory", [{
     name: "categoryId",
@@ -104,7 +105,7 @@ let addCategory = slice("AddCategory", [{
         name: "categoryId",
         isList: false
       }]
-  }], undefined);
+  }], undefined, undefined);
 
 let renameCategory = slice("RenameCategory", [{
     name: "categoryId",
@@ -128,7 +129,7 @@ let renameCategory = slice("RenameCategory", [{
         name: "categoryId",
         isList: false
       }]
-  }], undefined);
+  }], undefined, undefined);
 
 let archiveCategory = slice("ArchiveCategory", [{
     name: "categoryId",
@@ -148,7 +149,7 @@ let archiveCategory = slice("ArchiveCategory", [{
         name: "categoryId",
         isList: false
       }]
-  }], undefined);
+  }], undefined, undefined);
 
 let catalog = [
   addProduct,
@@ -242,7 +243,7 @@ globalThis.describe("DcbScopeInference:", () => {
           }
         ]
       }
-    ], "productId");
+    ], "productId", undefined);
     let d = DcbScopeInference$Reventless.infer([recordDemand]);
     globalThis.test("the @partitionTag hint resolves the partition (no ambiguity)", () => {
       globalThis.expect(d.partitionBySlice["RecordProductDemand"]).toEqual("productId");
@@ -295,7 +296,7 @@ globalThis.describe("DcbScopeInference:", () => {
             isList: true
           }
         ]
-      }], undefined);
+      }], undefined, undefined);
     let productEntity = slice("SyncCatalogProduct", [{
         name: "productId",
         isList: false
@@ -308,7 +309,7 @@ globalThis.describe("DcbScopeInference:", () => {
             name: "productId",
             isList: false
           }]
-      }], undefined);
+      }], undefined, undefined);
     let d = DcbScopeInference$Reventless.infer([
       placeOrder,
       productEntity
@@ -342,7 +343,7 @@ globalThis.describe("DcbScopeInference:", () => {
               name: "studentId",
               isList: false
             }]
-        }], undefined);
+        }], undefined, undefined);
       let subscribe_command = [
         {
           name: "courseId",
@@ -403,6 +404,417 @@ globalThis.describe("DcbScopeInference:", () => {
       globalThis.expect(issues.redundancies).toEqual([]);
     });
   });
+  globalThis.describe("partition: identity given back only when subtraction leaves nothing", () => {
+    globalThis.test("AddProduct without a hint stays productId, though its category arms come from a categoryId slice", () => {
+      let d = DcbScopeInference$Reventless.infer(catalog);
+      globalThis.expect(addProduct.partitionHint).toEqual(undefined);
+      globalThis.expect(d.partitionBySlice["AddProduct"]).toEqual("productId");
+    });
+    globalThis.test("a lifecycle arm naming the slice's own id resolves", () => {
+      let changeName = slice("ChangeProductName", [{
+          name: "productId",
+          isList: false
+        }], [{
+          eventType: "ProductAdded",
+          idFields: [{
+              name: "productId",
+              isList: false
+            }]
+        }], [{
+          eventType: "ProductNameChanged",
+          idFields: [{
+              name: "productId",
+              isList: false
+            }]
+        }], undefined, undefined);
+      let d = DcbScopeInference$Reventless.infer(catalog.concat([changeName]));
+      globalThis.expect(d.partitionBySlice["ChangeProductName"]).toEqual("productId");
+      globalThis.expect(d.ambiguities).toEqual([]);
+    });
+    let placeOrder = slice("PlaceOrder", [
+      {
+        name: "orderId",
+        isList: false
+      },
+      {
+        name: "customerId",
+        isList: false
+      }
+    ], undefined, [{
+        eventType: "OrderPlaced",
+        idFields: [
+          {
+            name: "orderId",
+            isList: false
+          },
+          {
+            name: "customerId",
+            isList: false
+          },
+          {
+            name: "productIds",
+            isList: true
+          }
+        ]
+      }], "orderId", undefined);
+    let shipOrder = slice("ShipOrder", [{
+        name: "orderId",
+        isList: false
+      }], [
+      {
+        eventType: "OrderPlaced",
+        idFields: [
+          {
+            name: "orderId",
+            isList: false
+          },
+          {
+            name: "customerId",
+            isList: false
+          },
+          {
+            name: "productIds",
+            isList: true
+          }
+        ]
+      },
+      {
+        eventType: "OrderCancelled",
+        idFields: [
+          {
+            name: "orderId",
+            isList: false
+          },
+          {
+            name: "productIds",
+            isList: true
+          }
+        ]
+      }
+    ], [{
+        eventType: "OrderShipped",
+        idFields: [
+          {
+            name: "orderId",
+            isList: false
+          },
+          {
+            name: "customerId",
+            isList: false
+          }
+        ]
+      }], undefined, undefined);
+    let cancelOrder = slice("CancelOrder", [{
+        name: "orderId",
+        isList: false
+      }], [
+      {
+        eventType: "OrderPlaced",
+        idFields: [
+          {
+            name: "orderId",
+            isList: false
+          },
+          {
+            name: "customerId",
+            isList: false
+          },
+          {
+            name: "productIds",
+            isList: true
+          }
+        ]
+      },
+      {
+        eventType: "OrderShipped",
+        idFields: [
+          {
+            name: "orderId",
+            isList: false
+          },
+          {
+            name: "customerId",
+            isList: false
+          }
+        ]
+      }
+    ], [{
+        eventType: "OrderCancelled",
+        idFields: [
+          {
+            name: "orderId",
+            isList: false
+          },
+          {
+            name: "productIds",
+            isList: true
+          }
+        ]
+      }], undefined, undefined);
+    globalThis.test("the ShipOrder ⇄ CancelOrder cycle resolves both to orderId", () => {
+      let d = DcbScopeInference$Reventless.infer([
+        placeOrder,
+        shipOrder,
+        cancelOrder
+      ]);
+      globalThis.expect(d.partitionBySlice["ShipOrder"]).toEqual("orderId");
+      globalThis.expect(d.partitionBySlice["CancelOrder"]).toEqual("orderId");
+      globalThis.expect(d.ambiguities).toEqual([]);
+    });
+    globalThis.test("seen alone, the same slice names the arms to change", () => {
+      globalThis.expect(DcbScopeInference$Reventless.partitionBlockers(cancelOrder)).toEqual([
+        [
+          "orderId",
+          [
+            "OrderPlaced",
+            "OrderShipped"
+          ]
+        ],
+        [
+          "productId",
+          ["OrderPlaced"]
+        ]
+      ]);
+    });
+    let recordDemand = slice("RecordProductDemand", [
+      {
+        name: "productId",
+        isList: false
+      },
+      {
+        name: "orderId",
+        isList: false
+      }
+    ], [{
+        eventType: "ProductDemandRecorded",
+        idFields: [{
+            name: "orderId",
+            isList: false
+          }]
+      }], [{
+        eventType: "ProductDemandRecorded",
+        idFields: [
+          {
+            name: "productId",
+            isList: false
+          },
+          {
+            name: "orderId",
+            isList: false
+          }
+        ]
+      }], undefined, undefined);
+    globalThis.test("a join without a hint stays ambiguous", () => {
+      let d = DcbScopeInference$Reventless.infer([recordDemand]);
+      globalThis.expect(d.partitionBySlice["RecordProductDemand"]).toEqual(undefined);
+      globalThis.expect(d.ambiguities.map(param => param[0])).toEqual(["RecordProductDemand"]);
+    });
+    globalThis.test("a produced id another slice is partitioned by is not dropped", () => {
+      let d = DcbScopeInference$Reventless.infer(catalog.concat([
+        placeOrder,
+        recordDemand
+      ]));
+      globalThis.expect(d.partitionBySlice["RecordProductDemand"]).toEqual(undefined);
+      globalThis.expect(d.ambiguities.some(param => {
+        if (param[0] === "RecordProductDemand") {
+          return param[1].includes("orderId, productId");
+        } else {
+          return false;
+        }
+      })).toBe(true);
+    });
+    globalThis.test("a boundary that never settles is reported, not guessed", () => {
+      let a = slice("A", undefined, [
+        {
+          eventType: "BHappened",
+          idFields: [{
+              name: "xId",
+              isList: false
+            }]
+        },
+        {
+          eventType: "ZHappened",
+          idFields: [{
+              name: "yId",
+              isList: false
+            }]
+        }
+      ], [{
+          eventType: "AHappened",
+          idFields: [
+            {
+              name: "xId",
+              isList: false
+            },
+            {
+              name: "yId",
+              isList: false
+            }
+          ]
+        }], undefined, undefined);
+      let b = slice("B", undefined, [
+        {
+          eventType: "AHappened",
+          idFields: [{
+              name: "yId",
+              isList: false
+            }]
+        },
+        {
+          eventType: "Z2Happened",
+          idFields: [{
+              name: "xId",
+              isList: false
+            }]
+        }
+      ], [{
+          eventType: "BHappened",
+          idFields: [
+            {
+              name: "xId",
+              isList: false
+            },
+            {
+              name: "yId",
+              isList: false
+            }
+          ]
+        }], undefined, undefined);
+      let d = DcbScopeInference$Reventless.infer([
+        a,
+        b
+      ]);
+      globalThis.expect(d.ambiguities.map(param => param[0])).toEqual([
+        "A",
+        "B"
+      ]);
+      globalThis.expect(d.ambiguities.every(param => param[1].includes("did not settle"))).toBe(true);
+    });
+  });
+  globalThis.describe("partition: the chapter breaks a tie", () => {
+    let placeOrder = chapter => slice("PlaceOrder", [
+      {
+        name: "orderId",
+        isList: false
+      },
+      {
+        name: "customerId",
+        isList: false
+      }
+    ], [{
+        eventType: "OrderPlaced",
+        idFields: [{
+            name: "orderId",
+            isList: false
+          }]
+      }], [{
+        eventType: "OrderPlaced",
+        idFields: [
+          {
+            name: "orderId",
+            isList: false
+          },
+          {
+            name: "customerId",
+            isList: false
+          }
+        ]
+      }], undefined, chapter);
+    let cancelOrder = slice("CancelOrder", undefined, [{
+        eventType: "OrderPlaced",
+        idFields: []
+      }], [{
+        eventType: "OrderCancelled",
+        idFields: [{
+            name: "orderId",
+            isList: false
+          }]
+      }], undefined, "Order");
+    globalThis.test("an order and its customer resolve to the id every Order event carries", () => {
+      let d = DcbScopeInference$Reventless.infer([
+        placeOrder("Order"),
+        cancelOrder
+      ]);
+      globalThis.expect(d.partitionBySlice["PlaceOrder"]).toEqual("orderId");
+      globalThis.expect(d.ambiguities).toEqual([]);
+    });
+    globalThis.test("without a chapter the same slice stays ambiguous", () => {
+      let d = DcbScopeInference$Reventless.infer([
+        placeOrder(undefined),
+        cancelOrder
+      ]);
+      globalThis.expect(d.partitionBySlice["PlaceOrder"]).toEqual(undefined);
+    });
+    globalThis.test("a join whose chapter carries both ids stays ambiguous, and the reason says so", () => {
+      let demand = slice("RecordProductDemand", undefined, undefined, [{
+          eventType: "ProductDemandRecorded",
+          idFields: [
+            {
+              name: "productId",
+              isList: false
+            },
+            {
+              name: "orderId",
+              isList: false
+            }
+          ]
+        }], undefined, "ProductDemand");
+      let d = DcbScopeInference$Reventless.infer([demand]);
+      globalThis.expect(d.partitionBySlice["RecordProductDemand"]).toEqual(undefined);
+      globalThis.expect(d.ambiguities.some(param => param[1].includes("The ProductDemand chapter does not decide"))).toBe(true);
+    });
+    globalThis.test("it never overrides a key the subtraction decided", () => {
+      let newrecord = {...addProduct};
+      newrecord.chapter = "Category";
+      let newrecord$1 = {...addCategory};
+      let d = DcbScopeInference$Reventless.infer([
+        newrecord,
+        (newrecord$1.chapter = "Category", newrecord$1)
+      ]);
+      globalThis.expect(d.partitionBySlice["AddProduct"]).toEqual("productId");
+    });
+  });
+  globalThis.describe("validatePartitionHintsVsInference (@partitionTag ⇄ inference)", () => {
+    let hinted = (s, key) => {
+      let newrecord = {...s};
+      newrecord.partitionHint = key;
+      return newrecord;
+    };
+    globalThis.test("a hint naming a key the slice only references is a contradiction", () => {
+      let issues = DcbValidation$Reventless.validatePartitionHintsVsInference([
+        hinted(addProduct, "categoryId"),
+        addCategory
+      ]);
+      globalThis.expect(issues.contradictions.map(e => e.sliceName)).toEqual(["AddProduct"]);
+      globalThis.expect(issues.redundancies).toEqual([]);
+    });
+    globalThis.test("a hint inference reaches unaided is redundant", () => {
+      let issues = DcbValidation$Reventless.validatePartitionHintsVsInference([
+        hinted(addProduct, "productId"),
+        addCategory
+      ]);
+      globalThis.expect(issues.contradictions).toEqual([]);
+      globalThis.expect(issues.redundancies.map(e => e.sliceName)).toEqual(["AddProduct"]);
+    });
+    globalThis.test("a hint that decides a join is neither", () => {
+      let demand = slice("RecordProductDemand", undefined, undefined, [{
+          eventType: "ProductDemandRecorded",
+          idFields: [
+            {
+              name: "productId",
+              isList: false
+            },
+            {
+              name: "orderId",
+              isList: false
+            }
+          ]
+        }], "productId", undefined);
+      let issues = DcbValidation$Reventless.validatePartitionHintsVsInference([demand]);
+      globalThis.expect(issues.contradictions).toEqual([]);
+      globalThis.expect(issues.redundancies).toEqual([]);
+    });
+  });
   globalThis.describe("ambiguity surfacing", () => {
     let aOwner = slice("A", undefined, undefined, [{
         eventType: "AHappened",
@@ -410,14 +822,14 @@ globalThis.describe("DcbScopeInference:", () => {
             name: "aId",
             isList: false
           }]
-      }], undefined);
+      }], undefined, undefined);
     let bOwner = slice("B", undefined, undefined, [{
         eventType: "BHappened",
         idFields: [{
             name: "bId",
             isList: false
           }]
-      }], undefined);
+      }], undefined, undefined);
     let join = slice("Join", undefined, [
       {
         eventType: "AHappened",
@@ -445,7 +857,7 @@ globalThis.describe("DcbScopeInference:", () => {
             isList: false
           }
         ]
-      }], undefined);
+      }], undefined, undefined);
     let d = DcbScopeInference$Reventless.infer([
       aOwner,
       bOwner,