@mmmnt/cli 0.9.0 → 0.10.1

package/dist/moment.mjs

@@ -55439,6 +55439,9 @@ var PolicyDeclaration = {
   $type: "PolicyDeclaration",
   action: "action",
   chainsTo: "chainsTo",
+  conditionAfter: "conditionAfter",
+  conditionField: "conditionField",
+  conditionValue: "conditionValue",
   gateways: "gateways",
   name: "name",
   trigger: "trigger"
@@ -56130,6 +56133,18 @@ var MomentAstReflection = class extends AbstractAstReflection {
         chainsTo: {
           name: PolicyDeclaration.chainsTo
         },
+        conditionAfter: {
+          name: PolicyDeclaration.conditionAfter,
+          optional: true
+        },
+        conditionField: {
+          name: PolicyDeclaration.conditionField,
+          optional: true
+        },
+        conditionValue: {
+          name: PolicyDeclaration.conditionValue,
+          optional: true
+        },
         gateways: {
           name: PolicyDeclaration.gateways,
           defaultValue: [],
@@ -58059,6 +58074,66 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
               "arguments": []
             }
           },
+          {
+            "$type": "Group",
+            "elements": [
+              {
+                "$type": "Keyword",
+                "value": "when"
+              },
+              {
+                "$type": "Assignment",
+                "feature": "conditionField",
+                "operator": "=",
+                "terminal": {
+                  "$type": "RuleCall",
+                  "rule": {
+                    "$ref": "#/rules@50"
+                  },
+                  "arguments": []
+                }
+              },
+              {
+                "$type": "Keyword",
+                "value": "="
+              },
+              {
+                "$type": "Assignment",
+                "feature": "conditionValue",
+                "operator": "=",
+                "terminal": {
+                  "$type": "RuleCall",
+                  "rule": {
+                    "$ref": "#/rules@10"
+                  },
+                  "arguments": []
+                }
+              }
+            ],
+            "cardinality": "?"
+          },
+          {
+            "$type": "Group",
+            "elements": [
+              {
+                "$type": "Keyword",
+                "value": "after"
+              },
+              {
+                "$type": "Assignment",
+                "feature": "conditionAfter",
+                "operator": "=",
+                "terminal": {
+                  "$type": "RuleCall",
+                  "rule": {
+                    "$ref": "#/rules@56"
+                  },
+                  "arguments": []
+                }
+              }
+            ],
+            "cardinality": "?"
+          },
           {
             "$type": "Keyword",
             "value": "action"
@@ -59222,6 +59297,10 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
           {
             "$type": "Keyword",
             "value": "outcome"
+          },
+          {
+            "$type": "Keyword",
+            "value": "after"
           }
         ]
       },
@@ -59777,6 +59856,10 @@ var MomentGrammar = () => loadedMomentGrammar ?? (loadedMomentGrammar = loadGram
           {
             "$type": "Keyword",
             "value": "outcome"
+          },
+          {
+            "$type": "Keyword",
+            "value": "after"
           }
         ]
       },
@@ -61061,6 +61144,76 @@ function validateMultiEvent(ir, options = {}) {
   ];
 }
 
+// ../core/dist/validation/policy-condition.js
+function placedOrder(flow) {
+  return flow.moments.flatMap((m) => [
+    ...m.contextEntries.map((e) => e.nodeName),
+    ...(m.branches ?? []).flatMap((b) => b.entries.map((e) => e.nodeName))
+  ]);
+}
+function someFlowPlacesBefore(flows, cause, trigger) {
+  let triggerPlaced = false;
+  for (const flow of flows) {
+    const order = placedOrder(flow);
+    const firstCause = order.indexOf(cause);
+    const lastTrigger = order.lastIndexOf(trigger);
+    if (lastTrigger >= 0)
+      triggerPlaced = true;
+    if (firstCause >= 0 && lastTrigger > firstCause)
+      return { reached: true, triggerPlaced };
+  }
+  return { reached: false, triggerPlaced };
+}
+function fieldsByEvent(ir) {
+  const events = /* @__PURE__ */ new Map();
+  for (const ctx of ir.contexts)
+    for (const e of ctx.events) {
+      const fields = events.get(e.name) ?? /* @__PURE__ */ new Set();
+      for (const f of e.fields ?? [])
+        fields.add(f.name);
+      events.set(e.name, fields);
+    }
+  return events;
+}
+function v49(p, events) {
+  const c = p.condition;
+  const fields = events.get(p.trigger);
+  if (c?.field === void 0 || fields === void 0 || fields.has(c.field))
+    return [];
+  return [
+    {
+      ruleId: "V49",
+      message: `Policy '${p.name}' reacts when '${c.field}' of '${p.trigger}' is '${c.equals ?? ""}', but '${p.trigger}' has no field '${c.field}'.`
+    }
+  ];
+}
+function v50v51(p, events, flows) {
+  const after = p.condition?.after;
+  if (after === void 0)
+    return [];
+  if (!events.has(after))
+    return [
+      {
+        ruleId: "V50",
+        message: `Policy '${p.name}' reacts after '${after}', which is no declared event.`
+      }
+    ];
+  const { reached, triggerPlaced } = someFlowPlacesBefore(flows, after, p.trigger);
+  if (!triggerPlaced || reached)
+    return [];
+  return [
+    {
+      ruleId: "V51",
+      severity: "warning",
+      message: `Policy '${p.name}' reacts to '${p.trigger}' after '${after}', but no flow places '${after}' before '${p.trigger}'; the condition is never met.`
+    }
+  ];
+}
+function validatePolicyConditions(ir) {
+  const events = fieldsByEvent(ir);
+  return ir.contexts.flatMap((ctx) => ctx.policies.filter((p) => p.condition !== void 0).flatMap((p) => [...v49(p, events), ...v50v51(p, events, ir.flows ?? [])]));
+}
+
 // ../core/dist/validation/palette-conformance.js
 function namesOf2(ir) {
   const contexts = ir.contexts;
@@ -61314,6 +61467,7 @@ function validatePaletteConformance(ir, options = {}) {
     ...v41v42Placements(ir, commands),
     ...v43(ir),
     ...validateMultiEvent(ir, options),
+    ...validatePolicyConditions(ir),
     ...(ir.externals ?? []).flatMap((e) => gatewayFindings(`external '${e.name}'`, e.gateways ?? [], known))
   ];
 }
@@ -61623,6 +61777,12 @@ function transformPolicy(pol, annotations) {
     trigger: pol.trigger,
     action: pol.action,
     chainsTo: pol.chainsTo,
+    ...pol.conditionField !== void 0 || pol.conditionAfter !== void 0 ? {
+      condition: {
+        ...pol.conditionField !== void 0 ? { field: pol.conditionField, equals: pol.conditionValue } : {},
+        ...pol.conditionAfter !== void 0 ? { after: pol.conditionAfter } : {}
+      }
+    } : {},
     ...gatewaysOf(pol.gateways)
   };
 }
@@ -64219,7 +64379,11 @@ function validateCrossFileReferences(ir) {
 }
 
 // ../core/dist/project/project-loader.js
-var isCompletenessRule = (d) => /^V(2[2-9]|3[0-9]|4[0-8])$/.test(d.ruleId ?? "");
+var FIRST_COMPLETENESS_RULE = 22;
+var isCompletenessRule = (d) => {
+  const n = /^V(\d+)$/.exec(d.ruleId ?? "")?.[1];
+  return n !== void 0 && Number(n) >= FIRST_COMPLETENESS_RULE;
+};
 var ProjectLoader = class {
   parser;
   constructor(parser) {
@@ -64850,6 +65014,7 @@ function multiEventPlacements(steps, commandOf) {
 }
 
 // ../derive/dist/engine/simulation-scenario-generator.js
+var BRANCH_KEY = "$branch";
 function resolveNodeKind(nodeName, contextId, contextMap, declaredKind) {
   const ctx = contextMap.get(contextId);
   if (!ctx)
@@ -65118,6 +65283,7 @@ function generateEvents(nodes, flow, contextMap, sessionId, correlationId, baseT
   const eventIds = nodes.map((_, i) => `evt-${String(i + 1).padStart(3, "0")}`);
   const placements2 = placementsOf(nodes, contextMap);
   const commandOfEvent = new Map(placements2.flatMap((p) => p.events.map((k) => [k, p.command])));
+  const conditioned = policyConditionedOccurrences(nodes, flow, contextMap);
   for (let i = 0; i < nodes.length; i++) {
     const node = nodes[i];
     const recordedBy = commandOfEvent.get(i);
@@ -65127,6 +65293,7 @@ function generateEvents(nodes, flow, contextMap, sessionId, correlationId, baseT
     const eventType = resolveEventType(node, effectiveKind);
     const productSource = resolveProductSource(node, effectiveKind, contextMap);
     const payload = buildPayload(node, effectiveKind, contextMap, flow);
+    applyPolicyConditions(payload, i, node, conditioned, contextMap);
     const whenState = placements2.find((p) => p.command === i)?.whenState;
     if (whenState !== void 0)
       payload.whenState = whenState;
@@ -65144,6 +65311,89 @@ function generateEvents(nodes, flow, contextMap, sessionId, correlationId, baseT
   }
   return events;
 }
+function guardedPolicies(contextMap) {
+  const byTrigger = /* @__PURE__ */ new Map();
+  for (const ctx of contextMap.values())
+    for (const policy of ctx.policies) {
+      if (policy.condition?.field === void 0)
+        continue;
+      byTrigger.set(policy.trigger, [...byTrigger.get(policy.trigger) ?? [], policy]);
+    }
+  return byTrigger;
+}
+function policyConditionedOccurrences(nodes, flow, contextMap) {
+  const guarded = guardedPolicies(contextMap);
+  const named = /* @__PURE__ */ new Map();
+  if (guarded.size === 0)
+    return named;
+  nodes.forEach((node, index) => {
+    for (const conn of flow.connections) {
+      if (!isCausationConnectionFor(conn, node))
+        continue;
+      const triggerName = conn.sourceNodeName ?? conn.eventId.replace(/^evt-/, "");
+      const policies = (guarded.get(triggerName) ?? []).filter((p) => p.chainsTo === node.nodeName);
+      if (policies.length === 0)
+        continue;
+      for (let j = index - 1; j >= 0; j--) {
+        if (nodes[j].nodeName !== triggerName)
+          continue;
+        named.set(j, [...named.get(j) ?? [], ...policies]);
+        break;
+      }
+    }
+  });
+  return named;
+}
+function typedValue(type, value) {
+  if (type === "number" && value.trim() !== "" && !Number.isNaN(Number(value)))
+    return Number(value);
+  if (type === "boolean" && (value === "true" || value === "false"))
+    return value === "true";
+  return value;
+}
+function otherThan(value) {
+  if (typeof value === "number")
+    return value + 1;
+  if (typeof value === "boolean")
+    return !value;
+  return `${String(value)}-other`;
+}
+function guardedField(policy, payload) {
+  const field = policy.condition?.field;
+  return field !== void 0 && field in payload ? field : void 0;
+}
+function declaredValue(evt, policy) {
+  const field = policy.condition?.field ?? "";
+  const type = evt.fields.find((f) => f.name === field)?.type ?? "";
+  return typedValue(type, policy.condition?.equals ?? "");
+}
+function moveOffDeclared(payload, guarded, evt, fixed) {
+  for (const policy of guarded) {
+    const field = guardedField(policy, payload);
+    if (field === void 0 || fixed.has(field))
+      continue;
+    const declared = declaredValue(evt, policy);
+    if (payload[field] === declared)
+      payload[field] = otherThan(declared);
+  }
+}
+function applyPolicyConditions(payload, index, node, conditioned, contextMap) {
+  const ctx = contextMap.get(node.contextId);
+  const evt = ctx ? findEvent(ctx, node.nodeName) : void 0;
+  if (!evt)
+    return;
+  const guarded = [...contextMap.values()].flatMap((c) => c.policies.filter((p) => p.trigger === node.nodeName && p.condition?.field !== void 0));
+  const naming = conditioned.get(index) ?? [];
+  const fixed = /* @__PURE__ */ new Set();
+  for (const policy of guarded.filter((p) => naming.includes(p))) {
+    const field = guardedField(policy, payload);
+    if (field === void 0 || fixed.has(field))
+      continue;
+    payload[field] = declaredValue(evt, policy);
+    fixed.add(field);
+  }
+  moveOffDeclared(payload, guarded, evt, fixed);
+}
 function findCausationEvents(node, allNodes, flow, eventIds, currentIndex, recordedBy) {
   const causation = [];
   for (const conn of flow.connections) {
@@ -65220,11 +65470,16 @@ function buildPayload(node, effectiveKind, contextMap, flow) {
     }
   }
   addContractFields(payload, node, flow);
-  if (node.outcome !== void 0) {
-    payload.outcome = node.outcome;
-  }
+  stampBranch(payload, node);
   return payload;
 }
+function stampBranch(payload, node) {
+  if (node.outcome === void 0)
+    return;
+  payload[BRANCH_KEY] = node.outcome;
+  if (!("outcome" in payload))
+    payload.outcome = node.outcome;
+}
 function addContractFields(payload, node, flow) {
   for (const conn of flow.connections) {
     if (conn.connectionType !== "crosses-to")
@@ -65604,7 +65859,8 @@ function generatePolicyDefinitions(ir) {
         contextId: context.id,
         trigger: policy.trigger,
         ...policy.action ? { actionDescription: policy.action } : {},
-        chainsTo: normalizeChainsTo(policy.chainsTo)
+        chainsTo: normalizeChainsTo(policy.chainsTo),
+        ...policy.condition ? { condition: { ...policy.condition } } : {}
       });
     }
   }
@@ -66418,7 +66674,7 @@ function buildBranchPredicates(flow) {
       routes[branch.condition] = branch.condition;
     }
     predicates[moment.id] = {
-      field: "outcome",
+      field: BRANCH_KEY,
       defaultRoute: moment.branches[0].condition,
       routes
     };