bpmnlint-plugin-camunda-compat 2.5.1 → 2.6.0

package/index.js

@@ -50,6 +50,7 @@ const camundaCloud82Rules = withConfig({
   ]),
   'escalation-boundary-event-attached-to-ref': 'error',
   'escalation-reference': 'error',
+  'link-event': 'error',
   'no-signal-event-sub-process': 'error',
   'task-schedule': 'error'
 }, { version: '8.2' });
@@ -87,6 +88,7 @@ const rules = {
   'history-time-to-live': './rules/camunda-platform/history-time-to-live',
   'implementation': './rules/camunda-cloud/implementation',
   'inclusive-gateway': './rules/camunda-cloud/inclusive-gateway',
+  'link-event': './rules/camunda-cloud/link-event',
   'loop-characteristics': './rules/camunda-cloud/loop-characteristics',
   'message-reference': './rules/camunda-cloud/message-reference',
   'no-candidate-users': './rules/camunda-cloud/no-candidate-users',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bpmnlint-plugin-camunda-compat",
-  "version": "2.5.1",
+  "version": "2.6.0",
   "description": "A bpmnlint plug-in for Camunda Platform compatibility",
   "main": "index.js",
   "scripts": {

package/rules/camunda-cloud/link-event.js

@@ -0,0 +1,139 @@
+const { getPath } = require('@bpmn-io/moddle-utils');
+
+const {
+  is,
+  isAny
+} = require('bpmnlint-utils');
+
+const {
+  getEventDefinition,
+  hasProperties
+} = require('../utils/element');
+
+const { ERROR_TYPES } = require('../utils/error-types');
+
+const { reportErrors } = require('../utils/reporter');
+
+const { skipInNonExecutableProcess } = require('../utils/rule');
+
+module.exports = skipInNonExecutableProcess(function() {
+  function check(node, reporter) {
+
+    // check for duplicate link catch event names
+    if (is(node, 'bpmn:Process')) {
+      const linkCatchEvents = getLinkCatchEvents(node);
+
+      const { duplicateNames } = linkCatchEvents.reduce(({ duplicateNames, names }, linkCatchEvent, index) => {
+        const linkEventDefinition = getEventDefinition(linkCatchEvent, 'bpmn:LinkEventDefinition');
+
+        const name = linkEventDefinition.get('name');
+
+        if (!name) {
+          return {
+            duplicateNames,
+            names
+          };
+        }
+
+        names = [
+          ...names,
+          name
+        ];
+
+        if (names.indexOf(name) !== index && !duplicateNames.includes(name)) {
+          duplicateNames = [
+            ...duplicateNames,
+            name
+          ];
+        }
+
+        return {
+          duplicateNames,
+          names
+        };
+      }, {
+        duplicateNames: [],
+        names: []
+      });
+
+      duplicateNames.forEach((name) => {
+        const duplicates = linkCatchEvents
+          .filter(linkCatchEvent => {
+            const linkEventDefinition = getEventDefinition(linkCatchEvent, 'bpmn:LinkEventDefinition');
+
+            return linkEventDefinition.get('name') === name;
+          });
+
+        duplicates
+          .forEach(linkCatchEvent => {
+            const linkEventDefinition = getEventDefinition(linkCatchEvent, 'bpmn:LinkEventDefinition');
+
+            const path = getPath(linkEventDefinition, linkCatchEvent);
+
+            reportErrors(linkCatchEvent, reporter, {
+              message: `Property of type <bpmn:LinkEventDefinition> has property <name> with duplicate value of <${ name }>`,
+              path: path
+                ? [ ...path, 'name' ]
+                : [ 'name' ],
+              data: {
+                type: ERROR_TYPES.ELEMENT_PROPERTY_VALUE_DUPLICATED,
+                node: linkEventDefinition,
+                parentNode: linkCatchEvent,
+                duplicatedProperty: 'name',
+                duplicatedPropertyValue: name
+              }
+            });
+          });
+      });
+    }
+
+    // check for missing link catch & throw event names
+    if (isLinkEvent(node)) {
+      const linkEventDefinition = getEventDefinition(node, 'bpmn:LinkEventDefinition');
+
+      const errors = hasProperties(linkEventDefinition, {
+        name: {
+          required: true
+        }
+      }, node);
+
+      if (errors.length) {
+        reportErrors(node, reporter, errors);
+      }
+    }
+  }
+
+  return {
+    check
+  };
+});
+
+function isLinkEvent(element) {
+  return isAny(element, [
+    'bpmn:IntermediateCatchEvent',
+    'bpmn:IntermediateThrowEvent'
+  ]) && getEventDefinition(element, 'bpmn:LinkEventDefinition');
+}
+
+function isLinkCatchEvent(element) {
+  return is(element, 'bpmn:IntermediateCatchEvent')
+    && getEventDefinition(element, 'bpmn:LinkEventDefinition');
+}
+
+function getLinkCatchEvents(flowElementsContainer) {
+  return flowElementsContainer.get('flowElements').reduce((linkCatchEvents, flowElement) => {
+    if (isLinkCatchEvent(flowElement)) {
+      return [
+        ...linkCatchEvents,
+        flowElement
+      ];
+    } else if (is(flowElement, 'bpmn:SubProcess')) {
+      return [
+        ...linkCatchEvents,
+        ...getLinkCatchEvents(flowElement)
+      ];
+    }
+
+    return linkCatchEvents;
+  }, []);
+}

package/rules/utils/error-types.js

@@ -1,8 +1,9 @@
 module.exports.ERROR_TYPES = Object.freeze({
-  ELEMENT_COLLAPSED_NOT_ALLOWED: 'camunda.elementCollapsedNotAllowed',
   CHILD_ELEMENT_TYPE_NOT_ALLOWED: 'camunda.childElementTypeNotAllowed',
+  ELEMENT_COLLAPSED_NOT_ALLOWED: 'camunda.elementCollapsedNotAllowed',
   ELEMENT_MULTIPLE_NOT_ALLOWED: 'camunda.elementMultipleNotAllowed',
   ELEMENT_TYPE_NOT_ALLOWED: 'camunda.elementTypeNotAllowed',
+  ELEMENT_PROPERTY_VALUE_DUPLICATED: 'camunda.elementPropertyValueDuplicated',
   EVENT_BASED_GATEWAY_TARGET_NOT_ALLOWED: 'camunda.eventBasedGatewayTargetNotAllowed',
   EXPRESSION_NOT_ALLOWED: 'camunda.expressionNotAllowed',
   EXPRESSION_REQUIRED: 'camunda.expressionRequired',