@reventlessdev/reventless-spec 3.0.0-alpha.134 → 3.0.0-alpha.136

package/src/components/DcbScopeInference.res.mjs

@@ -1,5 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
 import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
@@ -50,79 +51,214 @@ function foreignConsumedKeys(s) {
   }));
 }
 
-function partitionBlockers(s) {
-  let foreign = foreignConsumedKeys(s);
-  let ownProduced = new Set();
-  s.produced.forEach(e => {
-    ownProduced.add(e.eventType);
-  });
-  return producedKeys(s).filter(k => foreign.includes(k)).map(k => [
-    k,
-    s.consumed.filter(e => {
-      if (ownProduced.has(e.eventType)) {
-        return false;
-      } else {
-        return e.idFields.map(tagKeyOf).includes(k);
-      }
-    }).map(e => e.eventType)
-  ]);
+function sameAssignment(a, b) {
+  let entries = d => Object.entries(d).toSorted((param, param$1) => Primitive_string.compare(param[0], param$1[0]));
+  return Primitive_object.equal(entries(a), entries(b));
 }
 
-function crossPartitionForSlice(s) {
-  let foreign = foreignConsumedKeys(s);
-  let scalar = commandScalarKeys(s);
-  let h = s.partitionHint;
-  let partition;
-  let exit = 0;
-  if (h !== undefined && producedKeys(s).includes(h)) {
-    partition = h;
-  } else {
-    exit = 1;
-  }
-  if (exit === 1) {
-    let match = producedKeys(s).filter(k => !foreign.includes(k));
-    partition = match.length !== 1 ? undefined : match[0];
-  }
-  return foreign.filter(k => {
-    if (Primitive_object.notequal(k, partition)) {
-      return scalar.includes(k);
+function resolvePartitions(slices) {
+  let producersByEventType = {};
+  slices.forEach(s => {
+    s.produced.forEach(e => {
+      let prev = Stdlib_Option.getOr(producersByEventType[e.eventType], []);
+      if (!prev.some(p => p.sliceName === s.sliceName)) {
+        producersByEventType[e.eventType] = prev.concat([s]);
+        return;
+      }
+    });
+  });
+  let chapterKeys = {};
+  slices.forEach(s => Stdlib_Option.forEach(s.chapter, chapter => {
+    let events = s.produced.filter(e => e.idFields.length !== 0);
+    events.forEach(e => {
+      let keys = e.idFields.map(tagKeyOf);
+      let prev = chapterKeys[chapter];
+      let shared = prev !== undefined ? prev.filter(k => keys.includes(k)) : dedupSorted(keys);
+      chapterKeys[chapter] = shared;
+    });
+  }));
+  let chapterKeysOf = s => Stdlib_Option.flatMap(s.chapter, c => chapterKeys[c]);
+  let byChapter = (s, candidates) => {
+    let keys = chapterKeysOf(s);
+    if (keys === undefined) {
+      return candidates;
+    }
+    let match = candidates.filter(k => keys.includes(k));
+    if (match.length !== 1) {
+      return candidates;
+    } else {
+      return [match[0]];
+    }
+  };
+  let foreignArms = s => {
+    let own = new Set();
+    s.produced.forEach(e => {
+      own.add(e.eventType);
+    });
+    return s.consumed.filter(e => !own.has(e.eventType));
+  };
+  let armIsIdentity = (e, k, known) => {
+    let producers = producersByEventType[e.eventType];
+    if (producers !== undefined && producers.length !== 0) {
+      return producers.every(p => {
+        let pk = known[p.sliceName];
+        if (pk !== undefined) {
+          return pk === k;
+        } else {
+          return producedKeys(p).includes(k);
+        }
+      });
     } else {
       return false;
     }
+  };
+  let blockersOf = (s, known) => Stdlib_Array.filterMap(producedKeys(s), k => {
+    let arms = foreignArms(s).filter(e => {
+      if (e.idFields.map(tagKeyOf).includes(k)) {
+        return !armIsIdentity(e, k, known);
+      } else {
+        return false;
+      }
+    }).map(e => e.eventType);
+    if (arms.length !== 0) {
+      return [
+        k,
+        arms
+      ];
+    }
   });
-}
-
-function infer(slices) {
+  let seedOf = s => {
+    let produced = producedKeys(s);
+    let match = s.partitionHint;
+    if (match !== undefined && produced.includes(match)) {
+      return match;
+    }
+    if (produced.length !== 1) {
+      return;
+    } else {
+      return produced[0];
+    }
+  };
+  let subtracted = s => {
+    let foreign = foreignConsumedKeys(s);
+    return producedKeys(s).filter(k => !foreign.includes(k));
+  };
+  let candidatesOf = (s, known) => {
+    let k = seedOf(s);
+    if (k !== undefined) {
+      return [k];
+    }
+    let remaining = subtracted(s);
+    if (remaining.length !== 0) {
+      return byChapter(s, remaining);
+    }
+    let blocked = blockersOf(s, known).map(param => param[0]);
+    return byChapter(s, producedKeys(s).filter(k => !blocked.includes(k)));
+  };
+  let pass = known => {
+    let next = {};
+    slices.forEach(s => {
+      let match = candidatesOf(s, known);
+      if (match.length !== 1) {
+        return;
+      }
+      let k = match[0];
+      next[s.sliceName] = k;
+    });
+    return next;
+  };
+  let settle = (_known, _remaining) => {
+    while (true) {
+      let remaining = _remaining;
+      let known = _known;
+      let next = pass(known);
+      if (sameAssignment(next, known)) {
+        return [
+          next,
+          true
+        ];
+      }
+      if (remaining === 0) {
+        return [
+          next,
+          false
+        ];
+      }
+      _remaining = remaining - 1 | 0;
+      _known = next;
+      continue;
+    };
+  };
+  let match = settle({}, slices.length + 1 | 0);
+  let converged = match[1];
+  let settled = match[0];
+  let previous = pass(settled);
   let partitionBySlice = {};
+  let candidatesBySlice = {};
+  let blockersBySlice = {};
   let ambiguities = [];
   slices.forEach(s => {
-    let produced = producedKeys(s);
-    let h = s.partitionHint;
-    if (h !== undefined && produced.includes(h)) {
-      partitionBySlice[s.sliceName] = h;
+    let candidates = candidatesOf(s, settled);
+    candidatesBySlice[s.sliceName] = candidates;
+    if (!converged && Primitive_object.notequal(settled[s.sliceName], previous[s.sliceName])) {
+      ambiguities.push([
+        s.sliceName,
+        `partition inference did not settle — the slices it reads from keep changing each other's partition. Add an explicit @partitionTag`
+      ]);
       return;
     }
-    let foreign = foreignConsumedKeys(s);
-    let many = produced.filter(k => !foreign.includes(k));
-    let len = many.length;
+    let len = candidates.length;
     if (len !== 1) {
       if (len !== 0) {
+        let match = s.chapter;
+        let match$1 = chapterKeysOf(s);
+        let chapterNote = match !== undefined && match$1 !== undefined ? ` The ` + match + ` chapter does not decide: the ids every event in it carries are [` + match$1.join(", ") + `].` : "";
         ambiguities.push([
           s.sliceName,
-          `multiple candidate partition keys (` + many.join(", ") + `) — add an explicit @partitionTag`
+          `multiple candidate partition keys (` + candidates.join(", ") + `) — add an explicit @partitionTag.` + chapterNote
         ]);
         return;
       }
-      let blame = partitionBlockers(s).map(param => param[1].join("/") + ` declares ` + param[0]).join("; ");
+      let blockers = blockersOf(s, settled);
+      blockersBySlice[s.sliceName] = blockers;
+      let blame = blockers.map(param => param[1].join("/") + ` declares ` + param[0]).join("; ");
       ambiguities.push([
         s.sliceName,
         `no own partition key — every produced *Id is read from a foreign producer (` + blame + `). If that field is this slice's own partition, remove it from the consumed arm; if the slice really is a pure join, add an explicit @partitionTag`
       ]);
       return;
     }
-    let single = many[0];
-    partitionBySlice[s.sliceName] = single;
+    let k = candidates[0];
+    partitionBySlice[s.sliceName] = k;
   });
+  return {
+    partitionBySlice: partitionBySlice,
+    candidatesBySlice: candidatesBySlice,
+    blockersBySlice: blockersBySlice,
+    ambiguities: ambiguities
+  };
+}
+
+function partitionBlockers(s) {
+  return Stdlib_Option.getOr(resolvePartitions([s]).blockersBySlice[s.sliceName], []);
+}
+
+function crossPartitionForSlice(s) {
+  let foreign = foreignConsumedKeys(s);
+  let scalar = commandScalarKeys(s);
+  let partition = resolvePartitions([s]).partitionBySlice[s.sliceName];
+  return foreign.filter(k => {
+    if (Primitive_object.notequal(k, partition)) {
+      return scalar.includes(k);
+    } else {
+      return false;
+    }
+  });
+}
+
+function infer(slices) {
+  let match = resolvePartitions(slices);
+  let partitionBySlice = match.partitionBySlice;
   let ownerByKey = {};
   let ownedPartitionKeys = new Set();
   slices.forEach(s => {
@@ -178,7 +314,7 @@ function infer(slices) {
     ownerByKey: ownerByKey,
     crossPartitionTagKeys: crossPartitionTagKeys,
     tagKeysByEventType: tagKeysByEventType,
-    ambiguities: ambiguities
+    ambiguities: match.ambiguities
   };
 }
 
@@ -190,6 +326,8 @@ export {
   consumedKeys,
   commandScalarKeys,
   foreignConsumedKeys,
+  sameAssignment,
+  resolvePartitions,
   partitionBlockers,
   crossPartitionForSlice,
   infer,