feat: provide variables used in feel expressions

Related to camunda/camunda-modeler#5639

Author: Buckwich

lib/base/VariableResolver.js

@@ -24,13 +24,14 @@ import { getParents } from './util/elementsUtil';
  * Base Class that handles additional variable extractors, variable parsing and caching.
  */
 export class BaseVariableResolver {
+
   constructor(eventBus, bpmnjs) {
     this.providers = [];
     this._eventBus = eventBus;
     this._bpmnjs = bpmnjs;
 
     this.rawVariables = new CachedValue(this._generateRawVariables.bind(this));
-    this.parsedVariables = new CachedValue(async () => {
+    this._allParsedVariables = new CachedValue(async () => {
 
       const rawVariables = await this.getRawVariables();
       const context = { variables: rawVariables };
@@ -39,6 +40,17 @@ export class BaseVariableResolver {
 
       return context.variables;
     });
+    this.parsedVariables = new CachedValue(async () => {
+      const allParsed = await this._allParsedVariables.get();
+
+      // Filter out variables with no scope (e.g. consumed variable markers)
+      const filtered = {};
+      for (const key in allParsed) {
+        filtered[key] = allParsed[key].filter(v => v.scope);
+      }
+
+      return filtered;
+    });
 
     eventBus.on([ 'commandStack.changed', 'diagram.clear', 'import.done', 'variables.changed' ], () => {
       this.invalidateCache();
@@ -100,6 +112,7 @@ export class BaseVariableResolver {
    */
   invalidateCache() {
     this.rawVariables.invalidate();
+    this._allParsedVariables.invalidate();
     this.parsedVariables.invalidate();
   }
 
@@ -159,12 +172,26 @@ export class BaseVariableResolver {
       variables.forEach(variable => {
         const existingVariable = mergedVariables.find(v =>
           v.name === variable.name && v.scope === variable.scope
+          && (v.scope || !v.usedBy) && (variable.scope || !variable.usedBy)
         );
 
         if (existingVariable) {
           merge('origin', existingVariable, variable);
           merge('provider', existingVariable, variable);
           mergeEntries(existingVariable, variable);
+
+          // Preserve usedBy from either side during merge
+          if (variable.usedBy) {
+            if (!existingVariable.usedBy) {
+              existingVariable.usedBy = [ ...variable.usedBy ];
+            } else {
+              variable.usedBy.forEach(target => {
+                if (!existingVariable.usedBy.includes(target)) {
+                  existingVariable.usedBy.push(target);
+                }
+              });
+            }
+          }
         } else {
           mergedVariables.push(variable);
         }
@@ -251,7 +278,7 @@ export class BaseVariableResolver {
    *
    * @async
    * @param {ModdleElement} element
-   * @returns {Array<ProcessVariable>} variables
+   * @returns {Promise<Array<ProcessVariable>>} variables
    */
   async getVariablesForElement(element) {
     const bo = getBusinessObject(element);
@@ -261,14 +288,14 @@ export class BaseVariableResolver {
 
     // (1) get variables for given scope
     var scopeVariables = allVariables.filter(function(variable) {
-      return variable.scope.id === bo.id;
+      return variable.scope && variable.scope.id === bo.id;
     });
 
     // (2) get variables for parent scopes
     var parents = getParents(bo);
 
     var parentsScopeVariables = allVariables.filter(function(variable) {
-      return parents.find(function(parent) {
+      return variable.scope && parents.find(function(parent) {
         return parent.id === variable.scope.id;
       });
     });
@@ -299,6 +326,31 @@ export class BaseVariableResolver {
     throw new Error('not implemented VariableResolver#_getScope');
   }
 
+  /**
+   * Returns consumed variables for an element — variables
+   * the element needs as input for its expressions and mappings.
+   *
+   * Uses `getVariables()` instead of `getVariablesForElement()` to
+   * bypass the name-based deduplication that would drop requirement
+   * entries for variables that also exist in ancestor scopes.
+   *
+   * @param {Object} element
+   * @returns {Promise<Array<AvailableVariable>>}
+   */
+  async getConsumedVariablesForElement(element) {
+    const allVariablesByRoot = await this._allParsedVariables.get()
+      .catch(() => {
+        return {};
+      });
+
+    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
+    );
+  }
 }
 
 BaseVariableResolver.$inject = [ 'eventBus', 'bpmnjs' ];

lib/zeebe/VariableResolver.js

@@ -100,9 +100,9 @@ export default class ZeebeVariableResolver extends BaseVariableResolver {
 
     for (const key in rawVariables) {
       const variables = rawVariables[key];
-      const newVariables = parseVariables(variables);
+      const { resolvedVariables, consumedVariables } = parseVariables(variables);
 
-      mappedVariables[key] = [ ...variables, ...newVariables ];
+      mappedVariables[key] = [ ...variables, ...resolvedVariables, ...consumedVariables ];
     }
 
     context.variables = mappedVariables;