fix: follow input mapping chain

Author: Buckwich

lib/zeebe/util/feelUtility.js

@@ -24,7 +24,6 @@ export function parseVariables(variables) {
 
   const variablesToResolve = [];
   const analysisResults = [];
-  const inputMappingTargets = {};
 
   // Step 1 - Parse all variables and populate all that don't have references
   // to other variables
@@ -40,20 +39,13 @@ export function parseVariables(variables) {
 
       variablesToResolve.push({ variable, expression, unresolved });
 
-      // Track input mapping targets per origin
-      if (isInputExpression && variable.scope === origin) {
-        if (!inputMappingTargets[origin.id]) {
-          inputMappingTargets[origin.id] = new Set();
-        }
-        inputMappingTargets[origin.id].add(variable.name);
-      }
-
       // Collect analysis for input requirement extraction
       if (isInputExpression && analysis && analysis.inputs.length > 0) {
         analysisResults.push({
           origin,
           targetName: variable.name,
-          inputs: analysis.inputs
+          inputs: analysis.inputs,
+          isLocalMapping: variable.scope === origin
         });
       }
     });
@@ -63,7 +55,7 @@ export function parseVariables(variables) {
   const resolvedVariables = resolveReferences(variablesToResolve, variables);
 
   // Step 3 - Build input requirements from collected analyses
-  const inputRequirements = buildInputRequirements(analysisResults, inputMappingTargets);
+  const inputRequirements = buildInputRequirements(analysisResults);
 
   return { resolvedVariables, inputRequirements };
 }
@@ -490,20 +482,32 @@ export function getElementNamesToRemove(moddleElement, inputOutput) {
 /**
  * Build input requirement variables from pre-collected analysis results.
  *
- * @param {Array<{ origin: Object, targetName: String, inputs: Array }>} analysisResults
- * @param {Object<string, Set<string>>} inputMappingTargets - map of origin id to input mapping target names
+ * @param {Array<{ origin: Object, targetName: String, inputs: Array, isLocalMapping: boolean }>} analysisResults
  * @returns {Array<ProcessVariable>} input requirements
  */
-function buildInputRequirements(analysisResults, inputMappingTargets = {}) {
+function buildInputRequirements(analysisResults) {
   const inputRequirements = {};
+  const inputMappingTargetsCache = {};
 
-  for (const { origin, targetName, inputs } of analysisResults) {
-    const localTargets = inputMappingTargets[origin.id];
+  for (const { origin, targetName, inputs, isLocalMapping } of analysisResults) {
+
+    if (!inputMappingTargetsCache[origin.id]) {
+      inputMappingTargetsCache[origin.id] = getInputMappingTargetNames(origin);
+    }
+    const orderedTargets = inputMappingTargetsCache[origin.id];
+
+    let availableLocalTargets;
+    if (isLocalMapping) {
+      const targetIndex = orderedTargets.indexOf(targetName);
+      availableLocalTargets = new Set(orderedTargets.slice(0, targetIndex));
+    } else {
+      availableLocalTargets = new Set(orderedTargets);
+    }
 
     for (const inputVar of inputs) {
 
       // Skip variables that are provided by input mappings on the same element
-      if (localTargets && localTargets.has(inputVar.name)) {
+      if (availableLocalTargets.has(inputVar.name)) {
         continue;
       }
 
@@ -534,4 +538,16 @@ function buildInputRequirements(analysisResults, inputMappingTargets = {}) {
   return Object.values(inputRequirements);
 }
 
+/**
+ * Get ordered input mapping target names for an element.
+ *
+ * @param {djs.model.Base} origin
+ * @returns {Array<String>}
+ */
+function getInputMappingTargetNames(origin) {
+  const ioMapping = getExtensionElementsList(origin, 'zeebe:IoMapping')[0];
+  if (!ioMapping || !ioMapping.inputParameters) return [];
+  return ioMapping.inputParameters.map(p => p.target);
+}
+
 

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

@@ -15,6 +15,32 @@
         <zeebe:script expression="=x + y" resultVariable="scriptResult2" />
       </bpmn:extensionElements>
     </bpmn:scriptTask>
+    <bpmn:scriptTask id="chainedInputMappings" name="Chained input mappings">
+      <bpmn:extensionElements>
+        <zeebe:ioMapping>
+          <zeebe:input source="=processVar3" target="localC" />
+          <zeebe:input source="=localC + 1" target="localD" />
+        </zeebe:ioMapping>
+        <zeebe:script expression="=localC + localD" resultVariable="chainedResult" />
+      </bpmn:extensionElements>
+    </bpmn:scriptTask>
+    <bpmn:scriptTask id="shadowingTask" name="Shadowing a to a">
+      <bpmn:extensionElements>
+        <zeebe:ioMapping>
+          <zeebe:input source="=a" target="a" />
+        </zeebe:ioMapping>
+        <zeebe:script expression="=a" resultVariable="shadowResult" />
+      </bpmn:extensionElements>
+    </bpmn:scriptTask>
+    <bpmn:scriptTask id="shadowingChainedTask" name="Shadowing then chaining">
+      <bpmn:extensionElements>
+        <zeebe:ioMapping>
+          <zeebe:input source="=a" target="a" />
+          <zeebe:input source="=a + 1" target="b" />
+        </zeebe:ioMapping>
+        <zeebe:script expression="=a + b" resultVariable="shadowChainResult" />
+      </bpmn:extensionElements>
+    </bpmn:scriptTask>
   </bpmn:process>
   <bpmndi:BPMNDiagram id="BPMNDiagram_1">
     <bpmndi:BPMNPlane id="BPMNPlane_1" bpmnElement="Process_1">
@@ -24,6 +50,15 @@
       <bpmndi:BPMNShape id="Shape_2" bpmnElement="scriptWithoutInputs">
         <dc:Bounds x="300" y="80" width="100" height="80" />
       </bpmndi:BPMNShape>
+      <bpmndi:BPMNShape id="Shape_3" bpmnElement="chainedInputMappings">
+        <dc:Bounds x="450" y="80" width="100" height="80" />
+      </bpmndi:BPMNShape>
+      <bpmndi:BPMNShape id="Shape_4" bpmnElement="shadowingTask">
+        <dc:Bounds x="600" y="80" width="100" height="80" />
+      </bpmndi:BPMNShape>
+      <bpmndi:BPMNShape id="Shape_5" bpmnElement="shadowingChainedTask">
+        <dc:Bounds x="750" y="80" width="100" height="80" />
+      </bpmndi:BPMNShape>
     </bpmndi:BPMNPlane>
   </bpmndi:BPMNDiagram>
 </bpmn:definitions>

test/spec/zeebe/Mappings.spec.js

@@ -790,9 +790,7 @@ describe('ZeebeVariableResolver - Variable Mappings', function() {
       const withUsedBy = variables.filter(v => v.usedBy && v.usedBy.length > 0);
       const names = withUsedBy.map(v => v.name);
 
-      // then - input requirements should come from input mapping expressions only;
-      // localA and localB are provided by the input mappings, so the script's
-      // references to them should NOT produce input requirements
+      // then
       expect(names).to.include('processVar1');
       expect(names).to.include('processVar2');
       expect(names).to.not.include('localA');
@@ -807,11 +805,56 @@ describe('ZeebeVariableResolver - Variable Mappings', function() {
       const withUsedBy = variables.filter(v => v.usedBy && v.usedBy.length > 0);
       const names = withUsedBy.map(v => v.name);
 
-      // then - the second script task has no input mappings, so its script variables should be extracted
+      // then
       expect(names).to.include('x');
       expect(names).to.include('y');
     }));
 
+
+    it('should not require locally provided variable when chained input mapping references earlier target', inject(async function(variableResolver) {
+
+      // when
+      const variables = (await variableResolver.getVariables())['Process_1'];
+      const chainedReqs = variables.filter(v =>
+        v.usedBy && v.usedBy.length > 0 && v.origin[0].id === 'chainedInputMappings'
+      );
+      const names = chainedReqs.map(v => v.name);
+
+      // then
+      expect(names).to.include('processVar3');
+      expect(names).to.not.include('localC');
+      expect(names).to.not.include('localD');
+    }));
+
+
+    it('should keep shadowed variable as input requirement when mapping a to a', inject(async function(variableResolver) {
+
+      // when
+      const variables = (await variableResolver.getVariables())['Process_1'];
+      const shadowReqs = variables.filter(v =>
+        v.usedBy && v.usedBy.length > 0 && v.origin[0].id === 'shadowingTask'
+      );
+      const names = shadowReqs.map(v => v.name);
+
+      // then
+      expect(names).to.include('a');
+    }));
+
+
+    it('should handle shadowing with chaining correctly', 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 === 'shadowingChainedTask'
+      );
+      const names = reqs.map(v => v.name);
+
+      // then
+      expect(names).to.include('a');
+      expect(names).to.not.include('b');
+    }));
+
   });
 
 
@@ -978,14 +1021,12 @@ describe('ZeebeVariableResolver - Variable Mappings', function() {
 
       it('should only return process variables as input requirements, not locally mapped ones', inject(async function(variableResolver, elementRegistry) {
 
-        // given
-        const task = elementRegistry.get('scriptWithInputs');
-
         // when
-        const requirements = await variableResolver.getInputRequirementsForElement(task);
+        const requirements = await variableResolver.getInputRequirementsForElement(
+          elementRegistry.get('scriptWithInputs')
+        );
 
-        // then - only processVar1 and processVar2 (from input mapping sources) should
-        // be requirements, not localA and localB (input mapping targets used in the script)
+        // then
         const names = requirements.map(v => v.name);
         expect(names).to.include('processVar1');
         expect(names).to.include('processVar2');
@@ -997,11 +1038,10 @@ describe('ZeebeVariableResolver - Variable Mappings', function() {
 
       it('should return all script variables for task without input mappings', inject(async function(variableResolver, elementRegistry) {
 
-        // given
-        const task = elementRegistry.get('scriptWithoutInputs');
-
         // when
-        const requirements = await variableResolver.getInputRequirementsForElement(task);
+        const requirements = await variableResolver.getInputRequirementsForElement(
+          elementRegistry.get('scriptWithoutInputs')
+        );
 
         // then
         const names = requirements.map(v => v.name);
@@ -1010,6 +1050,51 @@ describe('ZeebeVariableResolver - Variable Mappings', function() {
         expect(requirements).to.have.length(2);
       }));
 
+
+      it('should handle chained input mappings respecting order', inject(async function(variableResolver, elementRegistry) {
+
+        // when
+        const requirements = await variableResolver.getInputRequirementsForElement(
+          elementRegistry.get('chainedInputMappings')
+        );
+
+        // then
+        const names = requirements.map(v => v.name);
+        expect(names).to.include('processVar3');
+        expect(names).to.not.include('localC');
+        expect(names).to.not.include('localD');
+        expect(requirements).to.have.length(1);
+      }));
+
+
+      it('should keep shadowed variable as requirement when mapping a to a', inject(async function(variableResolver, elementRegistry) {
+
+        // when
+        const requirements = await variableResolver.getInputRequirementsForElement(
+          elementRegistry.get('shadowingTask')
+        );
+
+        // then
+        const names = requirements.map(v => v.name);
+        expect(names).to.include('a');
+        expect(requirements).to.have.length(1);
+      }));
+
+
+      it('should handle shadowing with chained mappings', inject(async function(variableResolver, elementRegistry) {
+
+        // when
+        const requirements = await variableResolver.getInputRequirementsForElement(
+          elementRegistry.get('shadowingChainedTask')
+        );
+
+        // then
+        const names = requirements.map(v => v.name);
+        expect(names).to.include('a');
+        expect(names).to.not.include('b');
+        expect(requirements).to.have.length(1);
+      }));
+
     });