bpmnlint 10.3.0 → 11.0.0

package/README.md

@@ -72,6 +72,8 @@ import NodeResolver from 'bpmnlint/lib/resolver/node-resolver';
 
 import BpmnModdle from 'bpmn-moddle';
 
+const moddle = new BpmnModdle();
+
 const linter = new Linter({ 
   config: {
     extends: 'bpmnlint:recommended'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bpmnlint",
   "description": "Validate your BPMN diagrams based on configurable lint rules",
-  "version": "10.3.0",
+  "version": "11.0.0",
   "main": "lib/index.js",
   "keywords": [
     "bpmnlint",
@@ -23,12 +23,12 @@
     }
   ],
   "engines": {
-    "node": ">= 16"
+    "node": ">= 20"
   },
   "license": "MIT",
   "scripts": {
     "all": "run-s lint test-coverage",
-    "lint": "eslint . --ext js,mjs",
+    "lint": "eslint .",
     "dev": "npm test -- --watch",
     "test": "mocha --exclude 'test/integration/*/**' 'test/**/*.*js'",
     "test-coverage": "nyc --reporter=lcov --reporter=html npm test",
@@ -40,26 +40,25 @@
   "dependencies": {
     "@bpmn-io/moddle-utils": "^0.2.1",
     "ansi-colors": "^4.1.3",
-    "bpmn-moddle": "^8.1.0",
+    "bpmn-moddle": "^9.0.1",
     "bpmnlint-utils": "^1.1.1",
     "cli-table": "^0.3.11",
     "color-support": "^1.1.3",
-    "min-dash": "^4.2.1",
+    "min-dash": "^4.2.2",
     "mri": "^1.2.0",
     "pluralize": "^7.0.0",
     "tiny-glob": "^0.2.9"
   },
   "devDependencies": {
     "@bpmn-io/bpmnlint-generate-docs-images": "^0.4.0",
-    "bpmnlint": ".",
-    "chai": "^4.4.1",
-    "eslint": "^8.57.0",
-    "eslint-plugin-bpmn-io": "^1.0.0",
-    "execa": "^8.0.1",
+    "chai": "^4.5.0",
+    "eslint": "^9.17.0",
+    "eslint-plugin-bpmn-io": "^2.0.2",
+    "execa": "^9.5.2",
     "install-local": "^3.0.1",
-    "mocha": "^10.4.0",
+    "mocha": "^11.0.1",
     "npm-run-all": "^4.1.5",
-    "nyc": "^15.1.0",
+    "nyc": "^17.1.0",
     "strip-indent": "^3.0.0"
   },
   "files": [

package/rules/global.js

@@ -1,5 +1,6 @@
 const {
-  isAny, is
+  is,
+  isAny
 } = require('bpmnlint-utils');
 
 
@@ -10,13 +11,13 @@ const {
  *
  *   * `bpmn:Error`
  *   * `bpmn:Escalation`
- *   * `bpmn:Signal`
  *   * `bpmn:Message`
+ *   * `bpmn:Signal`
  *
  * For each of these elements proper usage implies:
  *
  *   * element must have a name
- *   * element is used (referenced) from event definitions
+ *   * element is referenced by at least one element
  *   * there exists only a single element per type with a given name
  */
 module.exports = function() {
@@ -27,20 +28,21 @@ module.exports = function() {
       return false;
     }
 
-    const events = getEvents(node);
-    const eventDefinitions = getEventDefinitions(node);
+    const rootElements = getRootElements(node);
 
-    events.forEach(event => {
-      if (!hasName(event)) {
-        reporter.report(event.id, 'Element is missing name');
+    const referencingElements = getReferencingElements(node);
+
+    rootElements.forEach(rootElement => {
+      if (!hasName(rootElement)) {
+        reporter.report(rootElement.id, 'Element is missing name');
       }
 
-      if (!isReferenced(event, eventDefinitions)) {
-        reporter.report(event.id, 'Element is unused');
+      if (!isReferenced(rootElement, referencingElements)) {
+        reporter.report(rootElement.id, 'Element is unused');
       }
 
-      if (!isUnique(event, events)) {
-        reporter.report(event.id, 'Element name is not unique');
+      if (!isUnique(rootElement, rootElements)) {
+        reporter.report(rootElement.id, 'Element name is not unique');
       }
     });
 
@@ -52,29 +54,42 @@ module.exports = function() {
 
   // helpers /////////////////////////////
 
-  function getEvents(definition) {
-    return definition.rootElements.filter(node => isAny(node, [ 'bpmn:Error', 'bpmn:Escalation', 'bpmn:Message', 'bpmn:Signal' ]));
+  function getRootElements(definitions) {
+    return definitions.rootElements.filter(node => isAny(node, [ 'bpmn:Error', 'bpmn:Escalation', 'bpmn:Message', 'bpmn:Signal' ]));
   }
 
-  function getEventDefinitions(definition) {
-    const eventDefinitions = [];
+  function getReferencingElements(definitions) {
+    const referencingElements = [];
 
     function traverse(element) {
-      if (element.rootElements) {
-        element.rootElements.forEach(traverse);
+      if (is(element, 'bpmn:Definitions') && element.get('rootElements').length) {
+        element.get('rootElements').forEach(traverse);
+      }
+
+      if (is(element, 'bpmn:FlowElementsContainer') && element.get('flowElements').length) {
+        element.get('flowElements').forEach(traverse);
+      }
+
+      if (is(element, 'bpmn:Event') && element.get('eventDefinitions').length) {
+        element.get('eventDefinitions').forEach(eventDefinition => referencingElements.push(eventDefinition));
       }
 
-      if (element.flowElements) {
-        element.flowElements.forEach(traverse);
+      if (is(element, 'bpmn:Collaboration') && element.get('messageFlows').length) {
+        element.get('messageFlows').forEach(traverse);
       }
 
-      if (element.eventDefinitions) {
-        element.eventDefinitions.forEach(eventDefinition => eventDefinitions.push(eventDefinition));
+      if (isAny(element, [
+        'bpmn:MessageFlow',
+        'bpmn:ReceiveTask',
+        'bpmn:SendTask'
+      ])) {
+        referencingElements.push(element);
       }
     }
 
-    traverse(definition);
-    return eventDefinitions;
+    traverse(definitions);
+
+    return referencingElements;
   }
 
   function hasName(event) {
@@ -83,35 +98,43 @@ module.exports = function() {
     );
   }
 
-  function isReferenced(event, eventDefinitions) {
-    if (is(event, 'bpmn:Error')) {
-      return (
-        eventDefinitions.some(node => is(node, 'bpmn:ErrorEventDefinition') && event.id === node.errorRef?.id)
-      );
+  function isReferenced(rootElement, referencingElements) {
+    if (is(rootElement, 'bpmn:Error')) {
+      return referencingElements.some(referencingElement => {
+        return is(referencingElement, 'bpmn:ErrorEventDefinition')
+          && rootElement.get('id') === referencingElement.get('errorRef')?.get('id');
+      });
     }
 
-    if (is(event, 'bpmn:Escalation')) {
-      return (
-        eventDefinitions.some(node => is(node, 'bpmn:EscalationEventDefinition') && event.id === node.escalationRef?.id)
-      );
+    if (is(rootElement, 'bpmn:Escalation')) {
+      return referencingElements.some(referencingElement => {
+        return is(referencingElement, 'bpmn:EscalationEventDefinition')
+          && rootElement.get('id') === referencingElement.get('escalationRef')?.get('id');
+      });
     }
 
-    if (is(event, 'bpmn:Message')) {
-      return (
-        eventDefinitions.some(node => is(node, 'bpmn:MessageEventDefinition') && event.id === node.messageRef?.id)
-      );
+    if (is(rootElement, 'bpmn:Message')) {
+      return referencingElements.some(referencingElement => {
+        return isAny(referencingElement, [
+          'bpmn:MessageEventDefinition',
+          'bpmn:MessageFlow',
+          'bpmn:ReceiveTask',
+          'bpmn:SendTask'
+        ]) && rootElement.get('id') === referencingElement.get('messageRef')?.get('id');
+      });
     }
 
-    if (is(event, 'bpmn:Signal')) {
-      return (
-        eventDefinitions.some(node => is(node, 'bpmn:SignalEventDefinition') && event.id === node.signalRef?.id)
-      );
+    if (is(rootElement, 'bpmn:Signal')) {
+      return referencingElements.some(referencingElement => {
+        return is(referencingElement, 'bpmn:SignalEventDefinition')
+          && rootElement.get('id') === referencingElement.get('signalRef')?.get('id');
+      });
     }
   }
 
-  function isUnique(event, events) {
+  function isUnique(rootElement, rootElements) {
     return (
-      events.filter(node => is(node, event.$type) && event.name === node.name).length === 1
+      rootElements.filter(otherRootElement => is(otherRootElement, rootElement.$type) && rootElement.name === otherRootElement.name).length === 1
     );
   }
 };

package/rules/helper.js

@@ -28,4 +28,34 @@ function disallowNodeType(type) {
 
 }
 
-module.exports.disallowNodeType = disallowNodeType;
+module.exports.disallowNodeType = disallowNodeType;
+
+/**
+ * Find a parent for the given element
+ *
+ * @param {ModdleElement} node
+ *
+ *  @param {String} type
+ *
+ * @return {ModdleElement} element
+ */
+
+function findParent(node, type) {
+  if (!node) {
+    return null;
+  }
+
+  const parent = node.$parent;
+
+  if (!parent) {
+    return node;
+  }
+
+  if (is(parent, type)) {
+    return parent;
+  }
+
+  return findParent(parent, type);
+}
+
+module.exports.findParent = findParent;

package/rules/label-required.js

@@ -23,10 +23,6 @@ module.exports = function() {
       return;
     }
 
-    if (is(node, 'bpmn:BoundaryEvent')) {
-      return;
-    }
-
     // ignore sub-processes
     if (is(node, 'bpmn:SubProcess')) {
 

package/rules/no-bpmndi.js

@@ -103,13 +103,13 @@ function getAllBpmnElements(rootElements) {
  */
 function getAllDiBpmnReferences(definitionsNode) {
   return flatten(
-    definitionsNode.diagrams.map((diagram) => {
+    definitionsNode.get('diagrams').map((diagram) => {
 
       const diElements = diagram.plane.planeElement || [];
 
       return diElements.map((element) => {
 
-        return element.bpmnElement.id;
+        return element.bpmnElement?.id;
       });
     })
   );

package/rules/no-implicit-end.js

@@ -3,6 +3,9 @@ const {
   isAny
 } = require('bpmnlint-utils');
 
+const {
+  findParent
+} = require('./helper');
 
 /**
  * A rule that checks that an element is not an implicit end (token sink).
@@ -17,6 +20,34 @@ module.exports = function() {
     );
   }
 
+  function isCompensationEvent(node) {
+    const eventDefinitions = node.eventDefinitions || [];
+
+    return eventDefinitions.length && eventDefinitions.every(
+      definition => is(definition, 'bpmn:CompensateEventDefinition')
+    );
+  }
+
+  function hasCompensationActivity(node) {
+    const parent = findParent(node, 'bpmn:Process');
+
+    const artifacts = parent.artifacts || [];
+
+    return artifacts.some((element) => {
+      if (!is(element, 'bpmn:Association')) {
+        return false;
+      }
+
+      const source = element.sourceRef;
+
+      return source.id === node.id;
+    });
+  }
+
+  function isForCompensation(node) {
+    return node.isForCompensation;
+  }
+
   function isImplicitEnd(node) {
     const outgoing = node.outgoing || [];
 
@@ -32,6 +63,14 @@ module.exports = function() {
       return false;
     }
 
+    if (is(node, 'bpmn:BoundaryEvent') && isCompensationEvent(node) && hasCompensationActivity(node)) {
+      return false;
+    }
+
+    if (is(node, 'bpmn:Task') && isForCompensation(node)) {
+      return false;
+    }
+
     return outgoing.length === 0;
   }
 
@@ -47,4 +86,4 @@ module.exports = function() {
   }
 
   return { check };
-};
+};

package/rules/no-overlapping-elements.js

@@ -108,7 +108,15 @@ function checkElementsArray(elements, elementsToReport, diObjects) {
         continue;
       }
 
-      if (isCollision(diObjects.get(element).bounds, diObjects.get(element2).bounds)) {
+      const bounds1 = diObjects.get(element)?.bounds;
+      const bounds2 = diObjects.get(element2)?.bounds;
+
+      // ignore if an element doesn't have bounds
+      if (!bounds1 || !bounds2) {
+        continue;
+      }
+
+      if (isCollision(bounds1, bounds2)) {
         elementsToReport.add(element);
         elementsToReport.add(element2);
       }