fix: allow all inputs in scripts

Author: Buckwich

lib/zeebe/util/feelUtility.js

@@ -35,17 +35,21 @@ export function parseVariables(variables) {
         return;
       }
 
-      const { expression, unresolved, analysis, isInputExpression } = expressionDetails;
+      const {
+        expression,
+        unresolved,
+        requirementAnalyses
+      } = expressionDetails;
 
       variablesToResolve.push({ variable, expression, unresolved });
 
-      // Collect analysis for input requirement extraction
-      if (isInputExpression && analysis && analysis.inputs.length > 0) {
+      // Collect analyses for input requirement extraction
+      for (const { expressionType, inputs } of requirementAnalyses) {
         analysisResults.push({
           origin,
           targetName: variable.name,
-          inputs: analysis.inputs,
-          isLocalMapping: variable.scope === origin
+          inputs,
+          expressionType
         });
       }
     });
@@ -184,73 +188,125 @@ export function getResultContext(expression, variables = {}) {
   return latestVariables;
 }
 
+/**
+ * Find all matching expression sources for a variable on a given origin element.
+ *
+ * Returns candidates ordered by resolution priority (first = highest).
+ * Local variables: script > input-mapping (script result overwrites at runtime).
+ * Global variables: output-mapping > script.
+ *
+ * @param {ProcessVariable} variable
+ * @param {djs.model.Base} origin
+ * @returns {Array<{ type: string, value: string }>}
+ */
+function findExpressions(variable, origin) {
+  const isLocal = variable.scope === origin;
+
+  const candidates = isLocal
+    ? [
+      { type: 'script', value: getScriptExpression(variable, origin) },
+      { type: 'input-mapping', value: getIoInputExpression(variable, origin) },
+    ]
+    : [
+      { type: 'output-mapping', value: getIoOutputExpression(variable, origin) },
+      { type: 'script', value: getScriptExpression(variable, origin) },
+    ];
+
+  return candidates.filter(c => c.value);
+}
+
 /**
  * Given a Variable and a specific origin, return the mapping expression and all
  * unresolved variables used in that expression. Returns undefined if no mapping
  * exists for the given origin.
  *
+ * The primary (highest-priority) expression is used for variable resolution.
+ * All non-output-mapping expressions are analyzed for input requirements,
+ * since a variable may be produced by both a script and an input mapping.
+ *
  * @param {ProcessVariable} variable
  * @param {djs.model.Base} origin
- * @returns {{ expression: String, unresolved: Array<String>, analysis: Object }}}
+ * @returns {{ expression: String, unresolved: Array<String>, requirementAnalyses: Array, expressionType: String }}
  */
 function getExpressionDetails(variable, origin) {
 
-  // if variable scope is !== origin (global), prioritize IoExpression over ScriptExpression
-  // if variable scope is === origin (local), prioritize ScriptExpression over IoExpression
-  const expression = variable.scope !== origin
-    ? getIoExpression(variable, origin) || getScriptExpression(variable, origin)
-    : getScriptExpression(variable, origin) || getIoExpression(variable, origin);
-
-  // Output mappings don't produce input requirements
-  const isInputExpression = variable.scope !== origin
-    ? !getIoExpression(variable, origin)
-    : true;
+  const matches = findExpressions(variable, origin);
 
-  if (!expression) {
+  if (matches.length === 0) {
     return;
   }
 
-  const result = getResultContext(expression);
+  // Primary expression for variable resolution (highest priority)
+  const { value: expression, type: expressionType } = matches[0];
 
+  const result = getResultContext(expression);
   const unresolved = findUnresolvedVariables(result);
 
-  // Analyze the expression to extract input requirements
-  let analysis;
-  try {
-    const analysisResult = feelAnalyzer.analyzeExpression(`=${expression}`);
-    if (analysisResult.valid !== false) {
-      analysis = {
-        inputs: analysisResult.inputs || []
-      };
+  // Analyze each non-output-mapping expression for input requirements
+  const requirementAnalyses = [];
+
+  for (const { type, value } of matches) {
+    if (type === 'output-mapping') {
+      continue;
+    }
+
+    try {
+      const analysisResult = feelAnalyzer.analyzeExpression(`=${value}`);
+
+      if (analysisResult.valid !== false && analysisResult.inputs && analysisResult.inputs.length > 0) {
+        requirementAnalyses.push({
+          expressionType: type,
+          inputs: analysisResult.inputs
+        });
+      }
+    } catch (error) {
+      console.warn(`Failed to analyze expression for variable ${variable.name}:`, error);
     }
-  } catch (error) {
-    console.warn(`Failed to analyze expression for variable ${variable.name}:`, error);
   }
 
-  return { expression, unresolved, analysis, isInputExpression };
+  return { expression, unresolved, requirementAnalyses, expressionType };
+}
+
+/**
+ * Given a variable and origin, return input mapping expression targeting the variable.
+ *
+ * @param {ProcessVariable} variable
+ * @param {djs.model.Base} origin
+ * @returns {string|undefined}
+ */
+function getIoInputExpression(variable, origin) {
+  return getIoExpressionByType(variable, origin, 'input');
 }
 
 /**
- * Given a Variable and a specific origin, return the mapping expression for all
- * input outputs mapping. Returns undefined if no mapping exists for the given origin.
+ * Given a variable and origin, return output mapping expression targeting the variable.
  *
  * @param {ProcessVariable} variable
  * @param {djs.model.Base} origin
- * @returns { expression: String}
+ * @returns {string|undefined}
  */
-function getIoExpression(variable, origin) {
+function getIoOutputExpression(variable, origin) {
+  return getIoExpressionByType(variable, origin, 'output');
+}
+
+/**
+ * Given a variable and origin, return mapping expression by mapping type.
+ *
+ * @param {ProcessVariable} variable
+ * @param {djs.model.Base} origin
+ * @param {'input'|'output'} mappingType
+ * @returns {string|undefined}
+ */
+function getIoExpressionByType(variable, origin, mappingType) {
   const ioMapping = getExtensionElementsList(origin, 'zeebe:IoMapping')[0];
 
   if (!ioMapping) {
     return;
   }
 
-  let mappings;
-  if (origin === variable.scope) {
-    mappings = ioMapping.inputParameters;
-  } else {
-    mappings = ioMapping.outputParameters;
-  }
+  const mappings = mappingType === 'input'
+    ? ioMapping.inputParameters
+    : ioMapping.outputParameters;
 
   if (!mappings) {
     return;
@@ -263,7 +319,6 @@ function getIoExpression(variable, origin) {
   }
 
   return mapping.source.substring(1);
-
 }
 
 /**
@@ -482,22 +537,24 @@ export function getElementNamesToRemove(moddleElement, inputOutput) {
 /**
  * Build input requirement variables from pre-collected analysis results.
  *
- * @param {Array<{ origin: Object, targetName: String, inputs: Array, isLocalMapping: boolean }>} analysisResults
+ * @param {Array<{ origin: Object, targetName: String, inputs: Array, expressionType: String }>} analysisResults
  * @returns {Array<ProcessVariable>} input requirements
  */
 function buildInputRequirements(analysisResults) {
   const inputRequirements = {};
   const inputMappingTargetsCache = {};
 
-  for (const { origin, targetName, inputs, isLocalMapping } of analysisResults) {
+  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 (isLocalMapping) {
+    if (expressionType === 'input-mapping') {
       const targetIndex = orderedTargets.indexOf(targetName);
       availableLocalTargets = new Set(orderedTargets.slice(0, targetIndex));
     } else {

test/fixtures/zeebe/mappings/script-task-with-input-mappings.bpmn

@@ -41,6 +41,15 @@
         <zeebe:script expression="=a + b" resultVariable="shadowChainResult" />
       </bpmn:extensionElements>
     </bpmn:scriptTask>
+    <bpmn:scriptTask id="scriptUsesSecondInput" name="Script uses second input">
+      <bpmn:extensionElements>
+        <zeebe:ioMapping>
+          <zeebe:input source="=def" target="abc" />
+          <zeebe:input source="=1" target="test" />
+        </zeebe:ioMapping>
+        <zeebe:script expression="=test" resultVariable="abc" />
+      </bpmn:extensionElements>
+    </bpmn:scriptTask>
   </bpmn:process>
   <bpmndi:BPMNDiagram id="BPMNDiagram_1">
     <bpmndi:BPMNPlane id="BPMNPlane_1" bpmnElement="Process_1">
@@ -59,6 +68,9 @@
       <bpmndi:BPMNShape id="Shape_5" bpmnElement="shadowingChainedTask">
         <dc:Bounds x="750" y="80" width="100" height="80" />
       </bpmndi:BPMNShape>
+      <bpmndi:BPMNShape id="Shape_6" bpmnElement="scriptUsesSecondInput">
+        <dc:Bounds x="900" y="80" width="100" height="80" />
+      </bpmndi:BPMNShape>
     </bpmndi:BPMNPlane>
   </bpmndi:BPMNDiagram>
 </bpmn:definitions>

test/spec/zeebe/Mappings.spec.js

@@ -855,6 +855,22 @@ describe('ZeebeVariableResolver - Variable Mappings', function() {
       expect(names).to.not.include('b');
     }));
 
+
+    it('should not require second input mapping variable used in script', inject(async function(variableResolver) {
+
+      // when
+      const variables = (await variableResolver.getVariables())['Process_1'];
+      const reqs = variables.filter(v =>
+        v.usedBy && v.usedBy.length > 0 && v.origin[0].id === 'scriptUsesSecondInput'
+      );
+      const names = reqs.map(v => v.name);
+
+      // then
+      expect(names).to.include('def');
+      expect(names).to.not.include('test');
+      expect(reqs).to.have.length(1);
+    }));
+
   });
 
 
@@ -1095,6 +1111,21 @@ describe('ZeebeVariableResolver - Variable Mappings', function() {
         expect(requirements).to.have.length(1);
       }));
 
+
+      it('should allow script to use all input targets regardless of order', inject(async function(variableResolver, elementRegistry) {
+
+        // when
+        const requirements = await variableResolver.getInputRequirementsForElement(
+          elementRegistry.get('scriptUsesSecondInput')
+        );
+
+        // then
+        const names = requirements.map(v => v.name);
+        expect(names).to.include('def');
+        expect(names).to.not.include('test');
+        expect(requirements).to.have.length(1);
+      }));
+
     });