bpmnlint 10.0.0 → 10.2.0

package/config/all.js

@@ -4,13 +4,14 @@ const allRules = [
   'event-sub-process-typed-start-event',
   'fake-join',
   'label-required',
+  'link-event',
   'no-bpmndi',
   'no-complex-gateway',
   'no-disconnected',
   'no-duplicate-sequence-flows',
   'no-gateway-join-fork',
-  'no-implicit-split',
   'no-implicit-end',
+  'no-implicit-split',
   'no-implicit-start',
   'no-inclusive-gateway',
   'no-overlapping-elements',
@@ -18,7 +19,8 @@ const allRules = [
   'single-event-definition',
   'start-event-required',
   'sub-process-blank-start-event',
-  'superfluous-gateway'
+  'superfluous-gateway',
+  'superfluous-termination'
 ];
 
 

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',
@@ -19,6 +20,7 @@ module.exports = {
     'single-event-definition': 'error',
     'start-event-required': 'error',
     'sub-process-blank-start-event': 'error',
-    'superfluous-gateway': 'warn'
+    'superfluous-gateway': 'warn',
+    'superfluous-termination': 'warn'
   }
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bpmnlint",
   "description": "Validate your BPMN diagrams based on configurable lint rules",
-  "version": "10.0.0",
+  "version": "10.2.0",
   "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/superfluous-termination.js

@@ -0,0 +1,63 @@
+const {
+  is, isAny
+} = require('bpmnlint-utils');
+
+/**
+ * A rule that checks, whether a gateway has only one source and target.
+ *
+ * Those gateways are superfluous since they don't do anything.
+ */
+module.exports = function() {
+
+  function check(node, reporter) {
+
+    if (!isAny(node, [ 'bpmn:Process', 'bpmn:SubProcess' ])) {
+      return;
+    }
+
+    const flowElements = node.flowElements || [];
+
+    const ends = flowElements.filter(
+      element => is(element, 'bpmn:FlowNode') && (element.outgoing || []).length === 0
+    );
+
+    const terminateEnds = ends.filter(isTerminateEnd);
+
+    if (terminateEnds.length !== 1) {
+
+      // TODO(nikku): only detect basic cases, do not
+      // do any kinds of elaborate flow analysis
+      return;
+    }
+
+    const superfluous = ends.every(
+      (end) => isInterruptingEventSub(end) || isTerminateEnd(end)
+    );
+
+    if (superfluous) {
+
+      for (const node of terminateEnds) {
+        reporter.report(node.id, 'Termination is superfluous.');
+      }
+    }
+  }
+
+  return {
+    check
+  };
+
+};
+
+function isTerminateEnd(element) {
+  return is(element, 'bpmn:EndEvent') && (element.eventDefinitions || []).some(
+    eventDefinition => is(eventDefinition, 'bpmn:TerminateEventDefinition')
+  );
+}
+
+function isInterruptingEventSub(element) {
+  const isEventSub = is(element, 'bpmn:SubProcess') && element.triggeredByEvent;
+
+  return isEventSub && (element.flowElements || []).some(
+    element => is(element, 'bpmn:StartEvent') && element.isInterrupting
+  );
+}