adjust for #90 (used variables - scopes)

note: internal usedby gets merged, thats why i added both tasks

Author: Buckwich

lib/base/VariableResolver.js

@@ -287,14 +287,26 @@ export class BaseVariableResolver {
       });
     });
 
-    const reversedVariables = [ ...scopeVariables, ...parentsScopeVariables ].reverse();
+    // (3) include descendant-scoped variables that are used outside their
+    // own scope but still within the current scope (cross-scope leak)
+    const leakedVariables = allVariables.filter(variable => {
+      return variable.scope
+        && variable.scope.id !== bo.id
+        && isElementInScope(variable.scope, bo)
+        && isUsedInScope(variable, bo)
+        && isUsedOutsideOwnScope(variable);
+    });
+
+    const reversedVariables = [ ...leakedVariables, ...scopeVariables, ...parentsScopeVariables ].reverse();
 
     const seenNames = new Set();
 
     return reversedVariables.filter(variable => {
 
+      const provider = variable.provider || [];
+
       // if external variable, keep
-      if (variable.provider.find(extractor => extractor !== this._baseExtractor)) {
+      if (provider.find(extractor => extractor !== this._baseExtractor)) {
         return true;
       }
 
@@ -329,9 +341,8 @@ export class BaseVariableResolver {
     const allVariables = Object.values(allVariablesByRoot).flat();
 
     return allVariables.filter(v =>
-      v.usedBy && v.usedBy.length > 0
-      && !v.scope
-      && v.origin.length === 1 && v.origin[0].id === element.id
+      !v.scope
+      && v.usedBy && v.usedBy.some((a) => a.id === element.id)
     );
   }
 }
@@ -431,4 +442,34 @@ function cloneVariable(variable) {
   }
 
   return newVariable;
+}
+
+function isUsedInScope(variable, scopeElement) {
+  if (!variable.usedBy || !Array.isArray(variable.usedBy)) {
+    return false;
+  }
+
+  return variable.usedBy.some(usedBy => isElementInScope(usedBy, scopeElement));
+}
+
+function isElementInScope(element, scopeElement) {
+  if (!element || !element.id || !scopeElement || !scopeElement.id) {
+    return false;
+  }
+
+  if (element.id === scopeElement.id) {
+    return true;
+  }
+
+  return getParents(element).some(parent => parent.id === scopeElement.id);
+}
+
+function isUsedOutsideOwnScope(variable) {
+  if (!variable.scope || !Array.isArray(variable.usedBy)) {
+    return false;
+  }
+
+  return variable.usedBy.some(usedBy => {
+    return usedBy && usedBy.id && !isElementInScope(usedBy, variable.scope);
+  });
 }

lib/zeebe/util/feelUtility.js

@@ -82,22 +82,83 @@ export function parseVariables(variables) {
 
   // Step 4 - Annotate locally-provided variables with usedBy information
   for (const { variableName, targetName, origin } of localUsages) {
-    const variable = variables.find(v =>
-      v.name === variableName && v.scope === origin
-    );
+    const variable = findNearestScopedVariable(variables, variableName, origin);
 
-    if (variable) {
-      if (!variable.usedBy) {
-        variable.usedBy = [];
+    if (!variable) {
+      continue;
+    }
+
+    // Keep existing behavior for same-origin mappings (`usedBy: [ 'targetVar' ]`)
+    // and use the consuming element for ancestor-scoped variables.
+    const usage = variable.scope === origin ? targetName : origin;
+
+    if (!variable.usedBy) {
+      variable.usedBy = [];
+    }
+
+    if (!hasUsage(variable.usedBy, usage)) {
+      variable.usedBy.push(usage);
+    }
+  }
+
+  // Step 5 - Bridge consumed usages back to uniquely scoped declarations
+  annotateConsumedUsagesToScopedVariables(variables, consumedVariables);
+
+  return { resolvedVariables, consumedVariables };
+}
+
+function annotateConsumedUsagesToScopedVariables(variables, consumedVariables) {
+  for (const consumedVariable of consumedVariables) {
+    const scopedCandidates = variables.filter(v => v.name === consumedVariable.name && v.scope);
+
+    if (scopedCandidates.length !== 1) {
+      continue;
+    }
+
+    const scopedVariable = scopedCandidates[0];
+
+    if (!scopedVariable.usedBy) {
+      scopedVariable.usedBy = [];
+    }
+
+    for (const usage of consumedVariable.usedBy || []) {
+      if (!usage || !usage.id) {
+        continue;
       }
 
-      if (!variable.usedBy.includes(targetName)) {
-        variable.usedBy.push(targetName);
+      if (!hasUsage(scopedVariable.usedBy, usage)) {
+        scopedVariable.usedBy.push(usage);
       }
     }
   }
+}
 
-  return { resolvedVariables, consumedVariables };
+function findNearestScopedVariable(variables, variableName, origin) {
+  const scopes = [ origin, ...getParents(origin) ];
+
+  for (const scope of scopes) {
+    const variable = variables.find(v => v.name === variableName && v.scope === scope);
+
+    if (variable) {
+      return variable;
+    }
+  }
+
+  return null;
+}
+
+function hasUsage(usages, usage) {
+  return usages.some(existing => {
+    if (existing === usage) {
+      return true;
+    }
+
+    if (typeof existing === 'string' && typeof usage === 'string') {
+      return existing === usage;
+    }
+
+    return existing && usage && existing.id && usage.id && existing.id === usage.id;
+  });
 }
 
 /**
@@ -669,21 +730,12 @@ function buildConsumedVariables(analysisResults) {
   const inputMappingTargetsCache = {};
 
   for (const { origin, targetName, inputs, expressionType } of analysisResults) {
-
-    if (!inputMappingTargetsCache[origin.id]) {
-      inputMappingTargetsCache[origin.id] = getInputMappingTargetNames(origin);
-    }
-    const orderedTargets = inputMappingTargetsCache[origin.id];
-
-    // Input mappings are order-sensitive: only earlier targets are available.
-    // Scripts can reference all input mapping targets.
-    let availableLocalTargets;
-    if (expressionType === 'input-mapping') {
-      const targetIndex = orderedTargets.indexOf(targetName);
-      availableLocalTargets = new Set(orderedTargets.slice(0, targetIndex));
-    } else {
-      availableLocalTargets = new Set(orderedTargets);
-    }
+    const availableLocalTargets = getAvailableLocalTargets(
+      origin,
+      expressionType,
+      targetName,
+      inputMappingTargetsCache
+    );
 
     for (const inputVar of inputs) {
 
@@ -735,4 +787,31 @@ function getInputMappingTargetNames(origin) {
   return ioMapping.inputParameters.map(p => p.target);
 }
 
+function getAvailableLocalTargets(origin, expressionType, targetName, inputMappingTargetsCache) {
+  const availableTargets = new Set();
+  const scopes = [ origin, ...getParents(origin) ];
+
+  for (const scope of scopes) {
+    if (!inputMappingTargetsCache[scope.id]) {
+      inputMappingTargetsCache[scope.id] = getInputMappingTargetNames(scope);
+    }
+
+    const orderedTargets = inputMappingTargetsCache[scope.id];
+
+    // Input mappings on the current element are order-sensitive; ancestor
+    // mappings are already established and fully available.
+    if (scope === origin && expressionType === 'input-mapping') {
+      const targetIndex = orderedTargets.indexOf(targetName);
+      const availableOwnTargets = targetIndex === -1 ? orderedTargets : orderedTargets.slice(0, targetIndex);
+
+      availableOwnTargets.forEach(target => availableTargets.add(target));
+      continue;
+    }
+
+    orderedTargets.forEach(target => availableTargets.add(target));
+  }
+
+  return availableTargets;
+}
+
 

test/spec/zeebe/ZeebeVariableResolver.spec.js

@@ -2631,7 +2631,7 @@ describe('ZeebeVariableResolver', function() {
       // then
       expect(variables).to.variableEqual([
         { name: 'taskResult' },
-        { name: 'approved', usedBy: [ 'Task_2' ] }
+        { name: 'approved', usedBy: [ 'Task_1', 'Task_2' ] }
       ]);
     }));
 
@@ -2647,7 +2647,7 @@ describe('ZeebeVariableResolver', function() {
       // then
       expect(variables).to.variableEqual([
         { name: 'taskResult' },
-        { name: 'approved', usedBy: [ 'Task_1' ] }
+        { name: 'approved', usedBy: [ 'Task_1', 'Task_2' ] }
       ]);
     }));