bpmnlint 10.2.3 → 10.3.1

package/config/all.js

@@ -3,6 +3,7 @@ const allRules = [
   'end-event-required',
   'event-sub-process-typed-start-event',
   'fake-join',
+  'global',
   'label-required',
   'link-event',
   'no-bpmndi',

package/config/recommended.js

@@ -4,6 +4,7 @@ module.exports = {
     'end-event-required': 'error',
     'event-sub-process-typed-start-event': 'error',
     'fake-join': 'warn',
+    'global': 'warn',
     'label-required': 'error',
     'link-event': 'error',
     'no-bpmndi': 'error',

package/lib/testers/rule-tester.d.ts

@@ -0,0 +1,37 @@
+export type TestFn = (...any) => any;
+
+export type ModdleElement = any;
+
+export type ValidRuleTest = {
+  config?: any,
+  it?: TestFn,
+  moddleElement: ModdleElement,
+  name?: string
+};
+
+export type InvalidReport = {
+  id: string,
+  message: string
+};
+
+export type InvalidRuleTest = {
+  config?: any,
+  it?: TestFn,
+  moddleElement: ModdleElement,
+  name?: string,
+  report: InvalidReport | InvalidReport[]
+};
+
+export type RuleTests = {
+  valid?: ValidRuleTest[],
+  invalid?: InvalidRuleTest[]
+};
+
+/**
+ * Verify a rule.
+ *
+ * @param ruleName
+ * @param rule the rule implementation
+ * @param tests the tests to verify
+ */
+export function verify(ruleName: string, rule: any, tests: RuleTests): void;

package/lib/traverse.js

@@ -1,9 +1,14 @@
+/**
+ * @typedef { import('./types.js').EnterFn } EnterFn
+ * @typedef { import('./types.js').LeaveFn } LeaveFn
+ */
+
 /**
  * Traverse a moddle tree, depth first from top to bottom
  * and call the passed visitor fn.
  *
  * @param {ModdleElement} element
- * @param {{ enter?: Function; leave?: Function }} options
+ * @param {{ enter?: EnterFn; leave?: LeaveFn }} options
  */
 module.exports = function traverse(element, options) {
 

package/lib/types.d.ts

@@ -0,0 +1,5 @@
+export type ModdleElement = any;
+
+export type EnterFn = (element: ModdleElement) => boolean | null;
+
+export type LeaveFn = (element: ModdleElement) => void;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bpmnlint",
   "description": "Validate your BPMN diagrams based on configurable lint rules",
-  "version": "10.2.3",
+  "version": "10.3.1",
   "main": "lib/index.js",
   "keywords": [
     "bpmnlint",
@@ -40,11 +40,11 @@
   "dependencies": {
     "@bpmn-io/moddle-utils": "^0.2.1",
     "ansi-colors": "^4.1.3",
-    "bpmn-moddle": "^8.0.1",
+    "bpmn-moddle": "^8.1.0",
     "bpmnlint-utils": "^1.1.1",
     "cli-table": "^0.3.11",
     "color-support": "^1.1.3",
-    "min-dash": "^4.1.1",
+    "min-dash": "^4.2.1",
     "mri": "^1.2.0",
     "pluralize": "^7.0.0",
     "tiny-glob": "^0.2.9"
@@ -52,12 +52,12 @@
   "devDependencies": {
     "@bpmn-io/bpmnlint-generate-docs-images": "^0.4.0",
     "bpmnlint": ".",
-    "chai": "^4.3.8",
-    "eslint": "^8.49.0",
+    "chai": "^4.4.1",
+    "eslint": "^8.57.0",
     "eslint-plugin-bpmn-io": "^1.0.0",
     "execa": "^8.0.1",
     "install-local": "^3.0.1",
-    "mocha": "^10.2.0",
+    "mocha": "^10.4.0",
     "npm-run-all": "^4.1.5",
     "nyc": "^15.1.0",
     "strip-indent": "^3.0.0"

package/rules/global.js

@@ -0,0 +1,140 @@
+const {
+  is,
+  isAny
+} = require('bpmnlint-utils');
+
+
+/**
+ * A rule that verifies that global elements are properly used.
+ *
+ * Currently recognized global elements are:
+ *
+ *   * `bpmn:Error`
+ *   * `bpmn:Escalation`
+ *   * `bpmn:Message`
+ *   * `bpmn:Signal`
+ *
+ * For each of these elements proper usage implies:
+ *
+ *   * element must have a name
+ *   * element is referenced by at least one element
+ *   * there exists only a single element per type with a given name
+ */
+module.exports = function() {
+
+  function check(node, reporter) {
+
+    if (!is(node, 'bpmn:Definitions')) {
+      return false;
+    }
+
+    const rootElements = getRootElements(node);
+
+    const referencingElements = getReferencingElements(node);
+
+    rootElements.forEach(rootElement => {
+      if (!hasName(rootElement)) {
+        reporter.report(rootElement.id, 'Element is missing name');
+      }
+
+      if (!isReferenced(rootElement, referencingElements)) {
+        reporter.report(rootElement.id, 'Element is unused');
+      }
+
+      if (!isUnique(rootElement, rootElements)) {
+        reporter.report(rootElement.id, 'Element name is not unique');
+      }
+    });
+
+  }
+
+  return {
+    check
+  };
+
+  // helpers /////////////////////////////
+
+  function getRootElements(definitions) {
+    return definitions.rootElements.filter(node => isAny(node, [ 'bpmn:Error', 'bpmn:Escalation', 'bpmn:Message', 'bpmn:Signal' ]));
+  }
+
+  function getReferencingElements(definitions) {
+    const referencingElements = [];
+
+    function traverse(element) {
+      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 (is(element, 'bpmn:Collaboration') && element.get('messageFlows').length) {
+        element.get('messageFlows').forEach(traverse);
+      }
+
+      if (isAny(element, [
+        'bpmn:MessageFlow',
+        'bpmn:ReceiveTask',
+        'bpmn:SendTask'
+      ])) {
+        referencingElements.push(element);
+      }
+    }
+
+    traverse(definitions);
+
+    return referencingElements;
+  }
+
+  function hasName(event) {
+    return (
+      event.name?.trim() !== ''
+    );
+  }
+
+  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(rootElement, 'bpmn:Escalation')) {
+      return referencingElements.some(referencingElement => {
+        return is(referencingElement, 'bpmn:EscalationEventDefinition')
+          && rootElement.get('id') === referencingElement.get('escalationRef')?.get('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(rootElement, 'bpmn:Signal')) {
+      return referencingElements.some(referencingElement => {
+        return is(referencingElement, 'bpmn:SignalEventDefinition')
+          && rootElement.get('id') === referencingElement.get('signalRef')?.get('id');
+      });
+    }
+  }
+
+  function isUnique(rootElement, rootElements) {
+    return (
+      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-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 };
-};
+};