bpmnlint-plugin-camunda-compat 2.52.0 → 2.53.0

package/index.js

@@ -36,6 +36,7 @@ const camundaCloud10Rules = withConfig({
   'user-task-form': 'error',
   'variable-name': 'error',
   'feel': 'error',
+  'feel-compatibility': 'error',
   'bpmnlint/start-event-required': 'error',
 }, { version: '1.0' });
 
@@ -182,6 +183,7 @@ const rules = {
   'executable-process': './rules/camunda-cloud/executable-process',
   'execution-listener': './rules/camunda-cloud/execution-listener',
   'feel': './rules/camunda-cloud/feel',
+  'feel-compatibility': './rules/camunda-cloud/feel-compatibility',
   'history-time-to-live': './rules/camunda-platform/history-time-to-live',
   'implementation': './rules/camunda-cloud/implementation',
   'inclusive-gateway': './rules/camunda-cloud/inclusive-gateway',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bpmnlint-plugin-camunda-compat",
-  "version": "2.52.0",
+  "version": "2.53.0",
   "description": "A bpmnlint plug-in for Camunda compatibility",
   "main": "index.js",
   "scripts": {
@@ -37,9 +37,10 @@
     "zeebe-bpmn-moddle": "^1.13.0"
   },
   "dependencies": {
-    "@bpmn-io/feel-lint": "^3.1.0",
+    "@bpmn-io/feel-analyzer": "^0.3.0",
     "@bpmn-io/moddle-utils": "^0.3.0",
-    "@camunda/feel-builtins": "^1.0.0",
+    "@bpmn-io/semver-compat": "^0.1.0",
+    "@camunda/feel-builtins": "^1.2.0",
     "bpmnlint-utils": "^1.1.1",
     "min-dash": "^5.0.0",
     "semver-compare": "^1.0.0"

package/rules/camunda-cloud/feel-compatibility.js

@@ -0,0 +1,129 @@
+const { is } = require('bpmnlint-utils');
+
+const { getPath } = require('@bpmn-io/moddle-utils');
+const { camundaBuiltins, camundaReservedNameBuiltins } = require('@camunda/feel-builtins');
+
+const { FeelAnalyzer } = require('@bpmn-io/feel-analyzer');
+const { isCompatible } = require('@bpmn-io/semver-compat');
+
+const { reportErrors } = require('../utils/reporter');
+
+const { ERROR_TYPES } = require('../utils/error-types');
+
+const { skipInNonExecutableProcess } = require('../utils/rule');
+
+const { findParentNode } = require('../utils/element');
+
+const { isFeelProperty } = require('./utils/feel');
+
+/**
+ * Reports calls to FEEL builtins that aren't available in the target Camunda
+ * engine (configured via `config.version`).
+ */
+module.exports = skipInNonExecutableProcess(function(config = {}) {
+
+  const { version } = config;
+  const builtins = [ ...camundaBuiltins, ...camundaReservedNameBuiltins ];
+  const unavailableByName = getUnavailableBuiltins(builtins, version);
+
+  const feelAnalyzer = new FeelAnalyzer({
+    parserDialect: 'camunda',
+    builtins: camundaBuiltins,
+    reservedNameBuiltins: camundaReservedNameBuiltins
+  });
+
+  function check(node, reporter) {
+    if (is(node, 'bpmn:Expression')) {
+      return;
+    }
+
+    if (!unavailableByName.size) {
+      return;
+    }
+
+    const parentNode = findParentNode(node);
+
+    if (!parentNode) {
+      return;
+    }
+
+    const errors = [];
+
+    Object.entries(node).forEach(([ propertyName, propertyValue ]) => {
+      if (propertyValue && is(propertyValue, 'bpmn:Expression')) {
+        propertyValue = propertyValue.get('body');
+      }
+
+      if (!isFeelProperty(node, propertyName, propertyValue)) {
+        return;
+      }
+
+      const expression = propertyValue.substring(1);
+
+      const { valid, functions = [] } = feelAnalyzer.analyzeExpression(expression);
+
+      // Skip invalid expressions; the `feel` rule reports the syntax error
+      if (!valid) {
+        return;
+      }
+
+      const unsupported = functions.find(
+        ({ name, type }) => type === 'builtin' && unavailableByName.has(name)
+      );
+
+      if (unsupported) {
+        const builtin = unavailableByName.get(unsupported.name);
+        const path = getPath(node, parentNode);
+
+        errors.push({
+          message: `FEEL function <${ builtin.name }> requires Camunda ${ builtin.engines.camunda }`,
+          path: path
+            ? [ ...path, propertyName ]
+            : [ propertyName ],
+          data: {
+            type: ERROR_TYPES.FEEL_EXPRESSION_UNSUPPORTED_FUNCTION,
+            node,
+            parentNode,
+            property: propertyName
+          }
+        });
+      }
+    });
+
+    if (errors && errors.length) {
+      reportErrors(parentNode, reporter, errors);
+    }
+  }
+
+  return {
+    check
+  };
+});
+
+/**
+ * Returns a map of builtin names to their definitions for builtins
+ * that are incompatible with the provided engine versions.
+ *
+ * @param { Array<{ name: string, engines?: Record<string, string> }> } builtins
+ * @param { string } version
+ * @returns { Map<string, { name: string, engines: Record<string, string> }> }
+ */
+function getUnavailableBuiltins(builtins, version) {
+  const unavailable = new Map();
+
+  if (!version) {
+    return unavailable;
+  }
+
+  for (const builtin of builtins) {
+    if (unavailable.has(builtin.name)) {
+      continue;
+    }
+
+    if (builtin.engines && !isCompatible(builtin.engines, { camunda: version })) {
+      unavailable.set(builtin.name, builtin);
+    }
+  }
+
+  return unavailable;
+}

package/rules/camunda-cloud/feel.js

@@ -1,13 +1,9 @@
-const { isString } = require('min-dash');
+const { is } = require('bpmnlint-utils');
 
-const {
-  is,
-  isAny
-} = require('bpmnlint-utils');
+const { getPath } = require('@bpmn-io/moddle-utils');
 
-const { lintExpression } = require('@bpmn-io/feel-lint');
+const { FeelAnalyzer } = require('@bpmn-io/feel-analyzer');
 
-const { getPath } = require('@bpmn-io/moddle-utils');
 const { camundaReservedNameBuiltins } = require('@camunda/feel-builtins');
 
 const { reportErrors } = require('../utils/reporter');
@@ -17,22 +13,16 @@ const { ERROR_TYPES } = require('../utils/error-types');
 const { skipInNonExecutableProcess } = require('../utils/rule');
 const { annotateRule } = require('../helper');
 
-// Properties ignored globally
-const IGNORED_PROPERTIES = [
-  'name'
-];
-
-// Properties ignored only for specific element types
-const IGNORED_PROPERTIES_BY_TYPE = {
-  'zeebe:Input': [ 'target' ],
-  'zeebe:Output': [ 'target' ],
-  'zeebe:Header': [ 'key', 'value' ],
-  'zeebe:Property': [ 'name', 'value' ],
-  'zeebe:CalledDecision': [ 'resultVariable' ],
-  'zeebe:Script': [ 'resultVariable' ]
-};
+const { findParentNode } = require('../utils/element');
+
+const { isFeelProperty } = require('./utils/feel');
 
 module.exports = skipInNonExecutableProcess(function() {
+  const feelAnalyzer = new FeelAnalyzer({
+    parserDialect: 'camunda',
+    reservedNameBuiltins: camundaReservedNameBuiltins
+  });
+
   function check(node, reporter) {
     if (is(node, 'bpmn:Expression')) {
       return;
@@ -51,31 +41,27 @@ module.exports = skipInNonExecutableProcess(function() {
         propertyValue = propertyValue.get('body');
       }
 
-      if (isFeelProperty(node, propertyName, propertyValue)) {
-        const lintErrors = lintExpression(propertyValue.substring(1), {
-          parserDialect: 'camunda',
-          builtins: camundaReservedNameBuiltins
-        });
+      if (!isFeelProperty(node, propertyName, propertyValue)) {
+        return;
+      }
 
-        // syntax error
-        if (lintErrors.find(({ type }) => type === 'Syntax Error')) {
-          const path = getPath(node, parentNode);
-
-          errors.push(
-            {
-              message: `Property <${ propertyName }> is not a valid FEEL expression`,
-              path: path
-                ? [ ...path, propertyName ]
-                : [ propertyName ],
-              data: {
-                type: ERROR_TYPES.FEEL_EXPRESSION_INVALID,
-                node,
-                parentNode,
-                property: propertyName
-              }
-            }
-          );
-        }
+      const { valid } = feelAnalyzer.analyzeExpression(propertyValue.substring(1));
+
+      if (!valid) {
+        const path = getPath(node, parentNode);
+
+        errors.push({
+          message: `Property <${ propertyName }> is not a valid FEEL expression`,
+          path: path
+            ? [ ...path, propertyName ]
+            : [ propertyName ],
+          data: {
+            type: ERROR_TYPES.FEEL_EXPRESSION_INVALID,
+            node,
+            parentNode,
+            property: propertyName
+          }
+        });
       }
     });
 
@@ -88,26 +74,3 @@ module.exports = skipInNonExecutableProcess(function() {
     check
   });
 });
-
-const isFeelProperty = (node, propertyName, value) => {
-  return !isIgnoredProperty(node, propertyName) && isString(value) && value.startsWith('=');
-};
-
-const isIgnoredProperty = (node, propertyName) => {
-  if (propertyName.startsWith('$') || IGNORED_PROPERTIES.includes(propertyName)) {
-    return true;
-  }
-
-  const nodeType = node.$type;
-  const ignoredForType = IGNORED_PROPERTIES_BY_TYPE[nodeType];
-
-  return ignoredForType && ignoredForType.includes(propertyName);
-};
-
-const findParentNode = node => {
-  while (node && !isAny(node, [ 'bpmn:FlowElement', 'bpmn:FlowElementsContainer' ])) {
-    node = node.$parent;
-  }
-
-  return node;
-};

package/rules/camunda-cloud/utils/feel.js

@@ -0,0 +1,35 @@
+const { isString } = require('min-dash');
+
+// Properties ignored globally
+const IGNORED_PROPERTIES = [
+  'name'
+];
+
+// Properties ignored only for specific element types
+const IGNORED_PROPERTIES_BY_TYPE = {
+  'zeebe:Input': [ 'target' ],
+  'zeebe:Output': [ 'target' ],
+  'zeebe:Header': [ 'key', 'value' ],
+  'zeebe:Property': [ 'name', 'value' ],
+  'zeebe:CalledDecision': [ 'resultVariable' ],
+  'zeebe:Script': [ 'resultVariable' ]
+};
+
+const isIgnoredProperty = (node, propertyName) => {
+  if (propertyName.startsWith('$') || IGNORED_PROPERTIES.includes(propertyName)) {
+    return true;
+  }
+
+  const nodeType = node.$type;
+  const ignoredForType = IGNORED_PROPERTIES_BY_TYPE[nodeType];
+
+  return ignoredForType && ignoredForType.includes(propertyName);
+};
+
+const isFeelProperty = (node, propertyName, value) => {
+  return !isIgnoredProperty(node, propertyName) && isString(value) && value.startsWith('=');
+};
+
+module.exports = {
+  isFeelProperty
+};

package/rules/utils/element.js

@@ -525,6 +525,16 @@ function findParent(node, type) {
 
 module.exports.findParent = findParent;
 
+function findParentNode(node) {
+  while (node && !isAny(node, [ 'bpmn:FlowElement', 'bpmn:FlowElementsContainer' ])) {
+    node = node.$parent;
+  }
+
+  return node;
+}
+
+module.exports.findParentNode = findParentNode;
+
 function isEmptyString(value) {
   return isString(value) && value.trim() === '';
 }

package/rules/utils/error-types.js

@@ -13,6 +13,7 @@ module.exports.ERROR_TYPES = Object.freeze({
   EXTENSION_ELEMENT_NOT_ALLOWED: 'camunda.extensionElementNotAllowed',
   EXTENSION_ELEMENT_REQUIRED: 'camunda.extensionElementRequired',
   FEEL_EXPRESSION_INVALID: 'camunda.feelExpressionInvalid',
+  FEEL_EXPRESSION_UNSUPPORTED_FUNCTION: 'camunda.feelExpressionUnsupportedFunction',
   LOOP_NOT_ALLOWED: 'camunda.loopNotAllowed',
   ATTACHED_TO_REF_ELEMENT_TYPE_NOT_ALLOWED: 'camunda.attachedToRefElementTypeNotAllowed',
   PROPERTY_DEPENDENT_REQUIRED: 'camunda.propertyDependentRequired',