bpmnlint-plugin-camunda-compat 2.21.0 → 2.22.0

package/index.js

@@ -12,6 +12,7 @@ const camundaCloud10Rules = withConfig({
   'loop-characteristics': 'error',
   'message-reference': 'error',
   'no-candidate-users': 'error',
+  'no-execution-listeners': 'error',
   'no-expression': 'error',
   'no-loop': 'error',
   'no-multiple-none-start-events': 'error',
@@ -75,8 +76,11 @@ const camundaCloud85Rules = withConfig({
   'wait-for-completion': 'error'
 }, { version: '8.5' });
 
-const camundaCloud86Rules = withConfig(
-  omit(camundaCloud85Rules, 'inclusive-gateway'), { version: '8.6' });
+const camundaCloud86Rules = withConfig({
+  ...omit(camundaCloud85Rules, [ 'inclusive-gateway', 'no-execution-listeners' ]),
+  'duplicate-execution-listeners': 'error',
+  'execution-listener': 'error'
+}, { version: '8.6' });
 
 const camundaPlatform719Rules = withConfig({
   'history-time-to-live': 'info'
@@ -105,12 +109,14 @@ const rules = {
   'called-element': './rules/camunda-cloud/called-element',
   'collapsed-subprocess': './rules/camunda-cloud/collapsed-subprocess',
   'connector-properties': './rules/camunda-cloud/connector-properties',
+  'duplicate-execution-listeners': './rules/camunda-cloud/duplicate-execution-listeners',
   'duplicate-task-headers': './rules/camunda-cloud/duplicate-task-headers',
   'error-reference': './rules/camunda-cloud/error-reference',
   'escalation-boundary-event-attached-to-ref': './rules/camunda-cloud/escalation-boundary-event-attached-to-ref',
   'escalation-reference': './rules/camunda-cloud/escalation-reference',
   'event-based-gateway-target': './rules/camunda-cloud/event-based-gateway-target',
   'executable-process': './rules/camunda-cloud/executable-process',
+  'execution-listener': './rules/camunda-cloud/execution-listener',
   'feel': './rules/camunda-cloud/feel',
   'history-time-to-live': './rules/camunda-platform/history-time-to-live',
   'implementation': './rules/camunda-cloud/implementation',
@@ -119,6 +125,7 @@ const rules = {
   'loop-characteristics': './rules/camunda-cloud/loop-characteristics',
   'message-reference': './rules/camunda-cloud/message-reference',
   'no-candidate-users': './rules/camunda-cloud/no-candidate-users',
+  'no-execution-listeners': './rules/camunda-cloud/no-execution-listeners',
   'no-expression': './rules/camunda-cloud/no-expression',
   'no-loop': './rules/camunda-cloud/no-loop',
   'no-multiple-none-start-events': './rules/camunda-cloud/no-multiple-none-start-events',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bpmnlint-plugin-camunda-compat",
-  "version": "2.21.0",
+  "version": "2.22.0",
   "description": "A bpmnlint plug-in for Camunda compatibility",
   "main": "index.js",
   "scripts": {
@@ -34,7 +34,7 @@
     "modeler-moddle": "^0.2.0",
     "sinon": "^17.0.1",
     "sinon-chai": "^3.7.0",
-    "zeebe-bpmn-moddle": "^1.1.0"
+    "zeebe-bpmn-moddle": "^1.4.0"
   },
   "dependencies": {
     "@bpmn-io/feel-lint": "^1.2.0",

package/rules/camunda-cloud/duplicate-execution-listeners.js

@@ -0,0 +1,33 @@
+const {
+  findExtensionElement,
+  hasDuplicatedPropertiesValues
+} = require('../utils/element');
+
+const { reportErrors } = require('../utils/reporter');
+
+const { skipInNonExecutableProcess } = require('../utils/rule');
+
+module.exports = skipInNonExecutableProcess(function() {
+  function check(node, reporter) {
+    const executionListeners = findExtensionElement(node, 'zeebe:ExecutionListeners');
+
+    if (!executionListeners) {
+      return;
+    }
+
+    const errors = hasDuplicatedExecutionListeners(executionListeners, node);
+
+    if (errors && errors.length) {
+      reportErrors(node, reporter, errors);
+    }
+  }
+
+  return {
+    check
+  };
+});
+
+// helpers //////////
+function hasDuplicatedExecutionListeners(executionListeners, parentNode = null) {
+  return hasDuplicatedPropertiesValues(executionListeners, 'listeners', [ 'eventType', 'type' ], parentNode);
+}

package/rules/camunda-cloud/execution-listener.js

@@ -0,0 +1,34 @@
+const {
+  findExtensionElement,
+  hasProperties
+} = require('../utils/element');
+
+const { reportErrors } = require('../utils/reporter');
+
+const { skipInNonExecutableProcess } = require('../utils/rule');
+
+
+module.exports = skipInNonExecutableProcess(function() {
+  function check(node, reporter) {
+    const executionListeners = findExtensionElement(node, 'zeebe:ExecutionListeners');
+
+    if (!executionListeners) {
+      return;
+    }
+
+    const listeners = executionListeners.get('listeners');
+    const errors = listeners.flatMap(listener => hasProperties(listener, {
+      type: {
+        required: true
+      }
+    }, node));
+
+    if (errors.length) {
+      reportErrors(node, reporter, errors);
+    }
+  }
+
+  return {
+    check
+  };
+});

package/rules/camunda-cloud/no-execution-listeners.js

@@ -0,0 +1,21 @@
+const { reportErrors } = require('../utils/reporter');
+
+const { skipInNonExecutableProcess } = require('../utils/rule');
+
+const { hasNoExtensionElement } = require('../utils/element');
+
+const ALLOWED_VERSION = '8.6';
+
+module.exports = skipInNonExecutableProcess(function() {
+  function check(node, reporter) {
+    const errors = hasNoExtensionElement(node, 'zeebe:ExecutionListeners', node, ALLOWED_VERSION);
+
+    if (errors && errors.length) {
+      reportErrors(node, reporter, errors);
+    }
+  }
+
+  return {
+    check
+  };
+});

package/rules/camunda-cloud/no-loop.js

@@ -14,6 +14,10 @@ const { ERROR_TYPES } = require('../utils/error-types');
 
 const { skipInNonExecutableProcess } = require('../utils/rule');
 
+/**
+ * @typedef {import('bpmn-moddle').BaseElement} ModdleElement
+ **/
+
 const LOOP_REQUIRED_ELEMENT_TYPES = [
   'bpmn:CallActivity',
   'bpmn:ManualTask',
@@ -38,16 +42,22 @@ module.exports = skipInNonExecutableProcess(function() {
       return;
     }
 
-    const error = getFlowElements(node)
+    // 1. Remove all elements that can be part of an infinite loop
+    const relevantNodes = getFlowElements(node)
       .filter(flowElement => {
         return isAnyExactly(flowElement, LOOP_ELEMENT_TYPES);
-      })
-      .reduce((error, flowElement) => {
-        return error || findLoop(flowElement, node);
-      }, null);
+      });
+
+    // 2. Remove all non-required elements. This produces a graph that only contains the required elements,
+    // with annotated edges that preserve the original path.
+    // Any loop found within the simplified graph is a valid loop, as all Vertices in the graph are `LOOP_REQUIRED_ELEMENT_TYPES`.
+    const minimalGraph = simplifyGraph(relevantNodes);
 
-    if (error) {
-      reportErrors(node, reporter, error);
+    // 3. Use breadth-first search to find loops in the simplified Graph.
+    const errors = findLoops(minimalGraph, node);
+
+    if (errors) {
+      reportErrors(node, reporter, errors);
     }
   }
 
@@ -56,51 +66,112 @@ module.exports = skipInNonExecutableProcess(function() {
   };
 });
 
-function findLoop(flowElement, parentElement, visitedFlowElements = []) {
+/**
+ * @typedef {Object} GraphNode
+ * @property {ModdleElement} element the bpmn element this node represents
+ * @property {Map<ModdleElement, Array<ModdleElement>>} incoming Maps the target node with the shortest path to it
+ * @property {Map<ModdleElement, Array<ModdleElement>>} outgoing Maps the source node with the shortest path to it
+ */
 
-  // (1.1) is not a loop
-  if (!isAnyExactly(flowElement, LOOP_ELEMENT_TYPES)) {
-    return null;
-  }
+/**
+ * Simplifies the graph by removing all non-`LOOP_REQUIRED_ELEMENT_TYPES` elements and connecting incoming and outgoing nodes directly.
+ * Annotates the edges with the original path. Uses breadth-first search to find paths.
+ *
+ * @param {Array<ModdleElement>} flowElements
+ * @returns {Map<ModdleElement, GraphNode>}
+ */
+function simplifyGraph(flowElements) {
 
-  const nextFlowElements = getNextFlowElements(flowElement);
+  // Transform Array<ModdleElement> into Map<ModdleElement, GraphNode>
+  const graph = elementsToGraph(flowElements);
 
-  // (1.2) is not a loop
-  if (!nextFlowElements.length) {
-    return null;
-  }
+  breadthFirstSearch(graph, (node) => {
+    const { element, outgoing } = node;
 
-  // (2) may be a loop
-  if (!visitedFlowElements.includes(flowElement)) {
-    return nextFlowElements.reduce((error, nextFlowElement) => {
-      return error || findLoop(nextFlowElement, parentElement, [ ...visitedFlowElements, flowElement ]);
-    }, null);
-  }
+    // Remove non-required element and connect incoming and outgoing nodes directly
+    if (!isAnyExactly(element, LOOP_REQUIRED_ELEMENT_TYPES)) {
+      connectNodes(graph, node);
+    }
+
+    return Array.from(outgoing.keys(), key => graph.get(key));
+  });
+
+  // Clean up all references to removed elements
+  graph.forEach(({ incoming, outgoing }) => {
+    incoming.forEach((_, key) => {
+      if (!graph.has(key)) {
+        incoming.delete(key);
+      }
+    });
+
+    outgoing.forEach((_, key) => {
+      if (!graph.has(key)) {
+        outgoing.delete(key);
+      }
+    });
+  });
 
-  // (3) is a loop but ignored
-  if (isIgnoredLoop(visitedFlowElements)) {
+  return graph;
+}
+
+
+/**
+ * Uses breadth-first search to find loops in the graph and generate errors.
+ *
+ * @param {Map<ModdleElement, GraphNode>} graph The simplified graph containing only required elements
+ * @param {ModdleElement} root used for reporting the errors
+ * @returns {Array<Object>} errors
+ */
+function findLoops(graph, root) {
+  const errors = [];
+
+  // Traverse graph using breadth-first search, remembering the path. If we find a loop, report it.
+  breadthFirstSearch(graph, (node) => {
+    const { element, outgoing, path = [] } = node;
+
+    const nextElements = [ ];
+    outgoing.forEach((connectionPath, nextElement) => {
+      const newPath = [ ...path, element, ...connectionPath ];
+
+      // We already visited this node, we found a loop
+      if (newPath.includes(nextElement)) {
+        errors.push(handleLoop(newPath, nextElement, root));
+      } else {
+        const nextNode = graph.get(nextElement);
+        nextNode.path = nextNode.path || newPath;
+        nextElements.push(nextNode);
+      }
+    });
+
+    return nextElements;
+  });
+
+  return errors.filter(Boolean);
+}
+
+const handleLoop = (path, currentNode, root) => {
+  const loop = path.slice(path.indexOf(currentNode));
+
+  if (isIgnoredLoop(loop)) {
     return null;
   }
 
-  const elements = visitedFlowElements.slice(visitedFlowElements.indexOf(flowElement));
-
-  // (4) is a loop
   return {
-    message: `Loop detected: ${ elements.map(({ id }) => id).join(' -> ') } -> ${ flowElement.id }`,
+    message: `Loop detected: ${ loop.map(({ id }) => id).join(' -> ') } -> ${ currentNode.id }`,
     path: null,
     data: {
       type: ERROR_TYPES.LOOP_NOT_ALLOWED,
-      node: parentElement,
+      node: root,
       parentNode: null,
-      elements: elements.map(({ id }) => id)
+      elements: loop.map(({ id }) => id)
     }
   };
-}
+};
 
 function getFlowElements(node) {
   return node.get('flowElements').reduce((flowElements, flowElement) => {
     if (is(flowElement, 'bpmn:FlowElementsContainer')) {
-      return [ ...flowElements, ...getFlowElements(flowElement) ];
+      return [ ...flowElements, flowElement, ...getFlowElements(flowElement) ];
     }
 
     return [ ...flowElements, flowElement ];
@@ -143,4 +214,104 @@ function isIgnoredLoop(elements) {
 
 function isFeel(value) {
   return isString(value) && value.startsWith('=');
+}
+
+const getOrSet = (map, key, defaultValue) => {
+  if (!map.has(key)) {
+    map.set(key, defaultValue);
+  }
+
+  return map.get(key);
+};
+
+const setIfAbsent = (map, key, value) => {
+  map.has(key) || map.set(key, value);
+};
+
+/**
+ * Transform Array of flow elements into a Graph structure, adding implicit connections (e.g. SubProcess -> StartEvent)
+ * via `getNextFlowElements`.
+ *
+ * @param {Array<ModdleElement>} flowElements
+ * @returns Map<ModdleElement, GraphNode>
+ */
+function elementsToGraph(flowElements) {
+  return flowElements.reduce((currentMap, element) => {
+    const currentNode = getOrSet(currentMap, element, {
+      element,
+      incoming: new Map(),
+      outgoing: new Map(),
+    });
+
+    const nextFlowElements = getNextFlowElements(element);
+
+    nextFlowElements.forEach(nextElement => {
+      const nextNode = getOrSet(currentMap, nextElement, {
+        element: nextElement,
+        incoming: new Map(),
+        outgoing: new Map(),
+      });
+
+      nextNode.incoming.set(element, []);
+      currentNode.outgoing.set(nextElement, []);
+    });
+
+    return currentMap;
+  }, new Map());
+}
+
+/**
+ * Connects incoming and outgoing nodes directly, add current node to the path and remove node from graph.
+ */
+function connectNodes(graph, node) {
+  const { element, incoming, outgoing } = node;
+
+  incoming.forEach((fromPath, fromKey) => {
+    outgoing.forEach((toPath, toKey) => {
+      const fromNode = graph.get(fromKey);
+      const toNode = graph.get(toKey);
+
+      if (!fromNode || !toNode) {
+        return;
+      }
+
+      // We only care about the shortest path, so we don't need to update the path if it's already set
+      setIfAbsent(fromNode.outgoing, toKey, [ ...fromPath, element, ...toPath ]);
+      setIfAbsent(toNode.incoming, fromKey, [ ...fromPath, element, ...toPath ]);
+    });
+  });
+
+  graph.delete(element);
+}
+
+/**
+ * Iterates over all nodes in the graph using breadth-first search.
+ *
+ * @param {Map<ModdleElement, GraphNode>} graph
+ * @param {Function} iterationCallback
+ */
+function breadthFirstSearch(graph, iterationCallback) {
+  const unvisited = new Set(graph.values());
+
+  while (unvisited.size) {
+    let firstElement = unvisited.values().next().value;
+    unvisited.delete(firstElement);
+
+    const elementsToVisit = [ firstElement ];
+
+    while (elementsToVisit.length) {
+      const node = elementsToVisit.shift();
+
+      const nextElements = iterationCallback(node);
+
+      nextElements.forEach(nextElement => {
+        if (!unvisited.has(nextElement)) {
+          return;
+        }
+
+        unvisited.delete(nextElement);
+        elementsToVisit.push(nextElement);
+      });
+    }
+  }
 }

package/rules/utils/element.js

@@ -1,4 +1,5 @@
 const {
+  filter,
   isArray,
   isDefined,
   isFunction,
@@ -6,6 +7,7 @@ const {
   isObject,
   isString,
   isUndefined,
+  matchPattern,
   some
 } = require('min-dash');
 
@@ -133,6 +135,53 @@ module.exports.hasDuplicatedPropertyValues = function(node, propertiesName, prop
   return [];
 };
 
+// @TODO(@barmac): use tree algorithm to reduce complexity
+module.exports.hasDuplicatedPropertiesValues = function(node, containerPropertyName, propertiesNames, parentNode = null) {
+  const properties = node.get(containerPropertyName);
+
+  // (1) find duplicates
+  const duplicates = properties.reduce((foundDuplicates, property, index) => {
+    const previous = properties.slice(0, index);
+    const isDuplicate = previous.find(p => propertiesNames.every(propertyName => p.get(propertyName) === property.get(propertyName)));
+
+    if (isDuplicate) {
+      return foundDuplicates.concat(property);
+    }
+
+    return foundDuplicates;
+  }, []);
+
+  // (2) report error for each duplicate
+  if (duplicates.length) {
+    return duplicates.map(duplicate => {
+      const propertiesMap = {};
+      for (const property of propertiesNames) {
+        propertiesMap[property] = duplicate.get(property);
+      }
+
+      // (3) find properties with duplicate
+      const duplicateProperties = filter(properties, matchPattern(propertiesMap));
+      const duplicatesSummary = propertiesNames.map(propertyName => `property <${ propertyName }> with duplicate value of <${ propertiesMap[propertyName] }>`).join(', ');
+
+      // (4) report error
+      return {
+        message: `Properties of type <${ duplicate.$type }> have properties with duplicate values (${ duplicatesSummary })`,
+        path: null,
+        data: {
+          type: ERROR_TYPES.PROPERTY_VALUES_DUPLICATED,
+          node,
+          parentNode: parentNode == node ? null : parentNode,
+          duplicatedProperties: propertiesMap,
+          properties: duplicateProperties,
+          propertiesName: containerPropertyName
+        }
+      };
+    });
+  }
+
+  return [];
+};
+
 module.exports.hasProperties = function(node, properties, parentNode = null) {
   return Object.entries(properties).reduce((results, property) => {
     const [ propertyName, propertyChecks ] = property;

package/rules/utils/error-types.js

@@ -19,6 +19,7 @@ module.exports.ERROR_TYPES = Object.freeze({
   PROPERTY_REQUIRED: 'camunda.propertyRequired',
   PROPERTY_TYPE_NOT_ALLOWED: 'camunda.propertyTypeNotAllowed',
   PROPERTY_VALUE_DUPLICATED: 'camunda.propertyValueDuplicated',
+  PROPERTY_VALUES_DUPLICATED: 'camunda.propertiesValuesDuplicated',
   PROPERTY_VALUE_NOT_ALLOWED: 'camunda.propertyValueNotAllowed',
   PROPERTY_VALUE_REQUIRED: 'camunda.propertyValueRequired',
   SECRET_EXPRESSION_FORMAT_DEPRECATED: 'camunda.secretExpressionFormatDeprecated'