bpmnlint 10.1.0 → 10.2.1

package/config/all.js

@@ -4,6 +4,7 @@ const allRules = [
   'event-sub-process-typed-start-event',
   'fake-join',
   'label-required',
+  'link-event',
   'no-bpmndi',
   'no-complex-gateway',
   'no-disconnected',

package/config/recommended.js

@@ -5,6 +5,7 @@ module.exports = {
     'event-sub-process-typed-start-event': 'error',
     'fake-join': 'warn',
     'label-required': 'error',
+    'link-event': 'error',
     'no-bpmndi': 'error',
     'no-complex-gateway': 'error',
     'no-disconnected': 'error',

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bpmnlint",
   "description": "Validate your BPMN diagrams based on configurable lint rules",
-  "version": "10.1.0",
+  "version": "10.2.1",
   "main": "lib/index.js",
   "keywords": [
     "bpmnlint",
@@ -28,7 +28,7 @@
   "license": "MIT",
   "scripts": {
     "all": "run-s lint test-coverage",
-    "lint": "eslint .",
+    "lint": "eslint . --ext js,mjs",
     "dev": "npm test -- --watch",
     "test": "mocha --exclude 'test/integration/*/**' 'test/**/*.*js'",
     "test-coverage": "nyc --reporter=lcov --reporter=html npm test",

package/rules/link-event.js

@@ -0,0 +1,100 @@
+const {
+  groupBy
+} = require('min-dash');
+
+const {
+  is
+} = require('bpmnlint-utils');
+
+
+/**
+ * A rule that verifies that link events are properly used.
+ *
+ * This implies:
+ *
+ *   * for every link throw there exists a link catch within
+ *     the same scope, and vice versa
+ *   * there exists only a single pair of [ throw, catch ] links
+ *     with a given name, per scope
+ *   * link events have a name
+ *
+ */
+module.exports = function() {
+
+  function check(node, reporter) {
+
+    if (!is(node, 'bpmn:FlowElementsContainer')) {
+      return;
+    }
+
+    const links = (node.flowElements || []).filter(isLinkEvent);
+
+    for (const link of links) {
+      if (!link.name) {
+        reporter.report(link.id, 'Link event is missing name');
+      }
+    }
+
+    const names = groupBy(links, (link) => link.name);
+
+    for (const [ name, events ] of Object.entries(names)) {
+
+      // ignore unnamed (validated earlier)
+      if (!name) {
+        continue;
+      }
+
+      // missing catch or throw event
+      if (events.length === 1) {
+        const event = events[0];
+
+        reporter.report(event.id, `Link ${isThrowEvent(event) ? 'catch' : 'throw' } event with name <${ name }> missing in scope`);
+      }
+
+      const throwEvents = events.filter(isThrowEvent);
+
+      if (throwEvents.length > 1) {
+        for (const event of throwEvents) {
+          reporter.report(event.id, `Duplicate link throw event with name <${name}> in scope`);
+        }
+      }
+
+      const catchEvents = events.filter(isCatchEvent);
+
+      if (catchEvents.length > 1) {
+        for (const event of catchEvents) {
+          reporter.report(event.id, `Duplicate link catch event with name <${name}> in scope`);
+        }
+      }
+    }
+
+  }
+
+  return {
+    check
+  };
+};
+
+
+// helpers /////////////////
+
+function isLinkEvent(node) {
+
+  var eventDefinitions = node.eventDefinitions || [];
+
+  if (!is(node, 'bpmn:Event')) {
+    return false;
+  }
+
+  return eventDefinitions.some(
+    definition => is(definition, 'bpmn:LinkEventDefinition')
+  );
+}
+
+function isThrowEvent(node) {
+  return is(node, 'bpmn:ThrowEvent');
+}
+
+function isCatchEvent(node) {
+  return is(node, 'bpmn:CatchEvent');
+}

package/rules/no-implicit-start.js

@@ -20,6 +20,10 @@ module.exports = function() {
   function isImplicitStart(node) {
     const incoming = node.incoming || [];
 
+    if (is(node, 'bpmn:Activity') && node.isForCompensation) {
+      return false;
+    }
+
     if (is(node, 'bpmn:SubProcess') && node.triggeredByEvent) {
       return false;
     }