feat: prefill context input with needed feel variables

Closes camunda/camunda-modeler#5640

Author: Buckwich

lib/ElementConfig.js

@@ -4,6 +4,14 @@ import { isAny } from 'bpmn-js/lib/util/ModelUtil';
 
 import { isString, omit } from 'min-dash';
 
+import {
+  DEFAULT_INPUT_CONFIG,
+  computeDefaultInput,
+  computeMergedInput
+} from './utils/prefill';
+
+export { DEFAULT_INPUT_CONFIG };
+
 export const DEFAULT_CONFIG = {
   input: {},
   output: {}
@@ -28,8 +36,6 @@ export class ElementConfig extends EventEmitter {
       ...config
     };
 
-    this._selectedElement = null;
-    this._variablesForElements = new Map();
   }
 
   setConfig(newConfig) {
@@ -43,9 +49,7 @@ export class ElementConfig extends EventEmitter {
   }
 
   setInputConfigForElement(element, newConfig) {
-    if (!isAny(element, SUPPORTED_ELEMENT_TYPES)) {
-      throw new Error(`Unsupported element type: ${element.type}`);
-    }
+    this._assertSupportedElement(element);
 
     this._config = {
       ...this._config,
@@ -59,9 +63,7 @@ export class ElementConfig extends EventEmitter {
   }
 
   resetInputConfigForElement(element) {
-    if (!isAny(element, SUPPORTED_ELEMENT_TYPES)) {
-      throw new Error(`Unsupported element type: ${element.type}`);
-    }
+    this._assertSupportedElement(element);
 
     this._config = {
       ...this._config,
@@ -72,9 +74,7 @@ export class ElementConfig extends EventEmitter {
   }
 
   setOutputConfigForElement(element, newConfig) {
-    if (!isAny(element, SUPPORTED_ELEMENT_TYPES)) {
-      throw new Error(`Unsupported element type: ${element.type}`);
-    }
+    this._assertSupportedElement(element);
 
     this._config = {
       ...this._config,
@@ -88,9 +88,7 @@ export class ElementConfig extends EventEmitter {
   }
 
   resetOutputConfigForElement(element) {
-    if (!isAny(element, SUPPORTED_ELEMENT_TYPES)) {
-      throw new Error(`Unsupported element type: ${element.type}`);
-    }
+    this._assertSupportedElement(element);
 
     this._config = {
       ...this._config,
@@ -101,25 +99,55 @@ export class ElementConfig extends EventEmitter {
   }
 
   getInputConfigForElement(element) {
-    if (!isAny(element, SUPPORTED_ELEMENT_TYPES)) {
-      throw new Error(`Unsupported element type: ${element.type}`);
-    }
+    this._assertSupportedElement(element);
 
     if (!isString(this._config.input[element.id])) {
-      return this._getDefaultInputConfig();
+      return DEFAULT_INPUT_CONFIG;
     }
 
     return this._config.input[element.id];
   }
 
+  /**
+   * Computes a fresh input config from the element's input requirements,
+   * ignoring any stored user config. Used for resetting input to defaults.
+   *
+   * @param {Object} element
+   * @returns {Promise<string>} JSON string
+   */
+  async getDefaultInputForElement(element) {
+    this._assertSupportedElement(element);
+
+    return computeDefaultInput(this._elementVariables, element);
+  }
+
+  /**
+   * Merges current user input with fresh input requirements from the element.
+   * Removes null values (unfilled stubs) from user input, then adds new
+   * requirement stubs for any variables not yet present.
+   *
+   * Returns `null` when the current input is invalid JSON, signalling that
+   * no merge was possible and the caller should skip overwriting the config.
+   *
+   * @param {Object} element
+   * @returns {Promise<string|null>} merged JSON string, or null if current input is unparseable
+   */
+  async getMergedInputConfigForElement(element) {
+    this._assertSupportedElement(element);
+
+    return computeMergedInput(
+      this._config.input[element.id],
+      this._elementVariables,
+      element
+    );
+  }
+
   /**
    * @param {import('./types').Element} element
    * @returns {import('./types').ElementOutput}
    */
   getOutputConfigForElement(element) {
-    if (!isAny(element, SUPPORTED_ELEMENT_TYPES)) {
-      throw new Error(`Unsupported element type: ${element.type}`);
-    }
+    this._assertSupportedElement(element);
 
     if (!this._config.output[element.id]) {
       return DEFAULT_OUTPUT;
@@ -128,7 +156,13 @@ export class ElementConfig extends EventEmitter {
     return this._config.output[element.id];
   }
 
-  _getDefaultInputConfig() {
-    return '{}';
+  /**
+   * @param {Object} element
+   * @throws {Error} if the element type is not supported
+   */
+  _assertSupportedElement(element) {
+    if (!isAny(element, SUPPORTED_ELEMENT_TYPES)) {
+      throw new Error(`Unsupported element type: ${element.type}`);
+    }
   }
-}
+}

lib/ElementVariables.js

@@ -35,4 +35,18 @@ export class ElementVariables extends EventEmitter {
 
     return variablesWithoutLocal;
   }
-}
+
+  /**
+   * Returns input requirement variables for an element — variables
+   * the element needs as input for its expressions and mappings.
+   *
+   * @param {Object} element
+   * @returns {Promise<Array>}
+   */
+  async getInputRequirementsForElement(element) {
+    return this._variableResolver.getInputRequirementsForElement(element)
+      .catch(() => {
+        return [];
+      });
+  }
+}

lib/components/TaskTesting/TaskTesting.js

@@ -159,6 +159,16 @@ export default function TaskTesting({
       const variables = await elementVariablesRef.current.getVariablesForElement(element);
 
       setVariablesForElement(variables);
+
+      // Merge updated input requirements into the current input
+      if (elementConfigRef.current) {
+        const mergedInput = await elementConfigRef.current.getMergedInputConfigForElement(element);
+
+        // Skip update when merge was not possible (e.g. invalid JSON)
+        if (mergedInput !== null) {
+          elementConfigRef.current.setInputConfigForElement(element, mergedInput);
+        }
+      }
     };
 
     elementVariablesRef.current.on('variables.changed', handleVariablesChanged);
@@ -272,7 +282,13 @@ export default function TaskTesting({
       return;
     }
 
-    setInput(elementConfigRef?.current?.getInputConfigForElement(element));
+    elementConfigRef?.current?.getMergedInputConfigForElement(element).then(
+      merged => {
+        if (merged !== null) {
+          setInput(merged);
+        }
+      }
+    );
     setOutput(elementConfigRef?.current?.getOutputConfigForElement(element));
   }, [ element ]);
 
@@ -284,9 +300,10 @@ export default function TaskTesting({
     }
   }, [ element ]);
 
-  const handleResetInput = useCallback(() => {
+  const handleResetInput = useCallback(async () => {
     if (element && elementConfigRef.current) {
-      elementConfigRef.current.resetInputConfigForElement(element);
+      const prefilled = await elementConfigRef.current.getDefaultInputForElement(element);
+      elementConfigRef.current.setInputConfigForElement(element, prefilled);
     }
   }, [ element ]);
 

lib/utils/prefill.js

@@ -0,0 +1,176 @@
+import { has, isObject, isString } from 'min-dash';
+
+export const DEFAULT_INPUT_CONFIG = '{}';
+
+
+/**
+ * Compute a default input config from the element's input requirements,
+ * producing a JSON string with `null` stubs for each required variable.
+ *
+ * @param {Object} elementVariables
+ * @param {Object} element
+ * @returns {Promise<string>} JSON string
+ */
+export async function computeDefaultInput(elementVariables, element) {
+  const stub = await buildRequirementsStub(elementVariables, element);
+
+  if (Object.keys(stub).length === 0) {
+    return DEFAULT_INPUT_CONFIG;
+  }
+
+  return JSON.stringify(stub, null, 2);
+}
+
+
+/**
+ * Merge current user input with fresh input requirements from the element.
+ * Removes null values (unfilled stubs) from user input, then adds new
+ * requirement stubs for any variables not yet present.
+ *
+ * Returns `null` when the current input is invalid JSON, signalling that
+ * no merge was possible and the caller should skip overwriting the config.
+ *
+ * @param {string} currentInputString - stored JSON string (or undefined)
+ * @param {Object} elementVariables
+ * @param {Object} element
+ * @returns {Promise<string|null>} merged JSON string, or null if unparseable
+ */
+export async function computeMergedInput(currentInputString, elementVariables, element) {
+  const requirementsStub = await buildRequirementsStub(elementVariables, element);
+
+  const inputString = isString(currentInputString)
+    ? currentInputString
+    : DEFAULT_INPUT_CONFIG;
+
+  let currentConfig;
+  try {
+    currentConfig = JSON.parse(inputString);
+  } catch (e) {
+
+    // If user input is invalid JSON, signal that no merge is possible
+    return null;
+  }
+
+  // Remove null values from user input, then merge with requirements
+  const cleaned = removeNullValues(currentConfig);
+  const merged = mergeObjects(requirementsStub, cleaned);
+
+  if (Object.keys(merged).length === 0) {
+    return DEFAULT_INPUT_CONFIG;
+  }
+
+  return JSON.stringify(merged, null, 2);
+}
+
+
+// helpers //////////////////////
+
+/**
+ * Build a stub object from the element's input requirements.
+ * Each requirement variable becomes a key with `null` (or a nested
+ * object for context variables).
+ *
+ * @param {Object} elementVariables
+ * @param {Object} element
+ * @returns {Promise<Object>} requirements stub
+ */
+async function buildRequirementsStub(elementVariables, element) {
+  const requirements = await elementVariables
+    .getInputRequirementsForElement(element);
+
+  if (!requirements || requirements.length === 0) {
+    return {};
+  }
+
+  const stub = {};
+
+  for (const variable of requirements) {
+    stub[variable.name] = variableToStub(variable);
+  }
+
+  return stub;
+}
+
+/**
+ * Convert a variable with entries (nested context) into a JSON stub value.
+ * Produces nested objects for context variables, `null` for leaves.
+ *
+ * @param {Object} variable
+ * @returns {*} stub value
+ */
+function variableToStub(variable) {
+  if (variable.entries && variable.entries.length > 0) {
+    const result = {};
+
+    for (const entry of variable.entries) {
+      result[entry.name] = variableToStub(entry);
+    }
+
+    return result;
+  }
+
+  return null;
+}
+
+/**
+ * Recursively remove all null values from an object.
+ * Removes keys whose value is null, and recurses into nested objects.
+ * If all keys are removed, returns an empty object.
+ *
+ * @param {Object} obj
+ * @returns {Object}
+ */
+function removeNullValues(obj) {
+  if (!isObject(obj)) {
+    return obj;
+  }
+
+  const result = {};
+
+  for (const key in obj) {
+    if (!has(obj, key)) continue;
+
+    const value = obj[key];
+
+    if (value === null) continue;
+
+    if (isObject(value)) {
+      const cleaned = removeNullValues(value);
+
+      if (Object.keys(cleaned).length > 0) {
+        result[key] = cleaned;
+      }
+    } else {
+      result[key] = value;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Merge two objects: base provides the structure (stubs), override
+ * provides user values. User values take precedence.
+ *
+ * @param {Object} base - requirements stub (may contain null values)
+ * @param {Object} override - user input (cleaned of nulls)
+ * @returns {Object}
+ */
+function mergeObjects(base, override) {
+  const result = { ...base };
+
+  for (const key in override) {
+    if (!has(override, key)) continue;
+
+    const overrideValue = override[key];
+    const baseValue = result[key];
+
+    if (isObject(overrideValue) && isObject(baseValue)) {
+      result[key] = mergeObjects(baseValue, overrideValue);
+    } else {
+      result[key] = overrideValue;
+    }
+  }
+
+  return result;
+}