bpmnlint-plugin-camunda-compat 2.2.0 → 2.3.0

package/index.js

@@ -44,13 +44,14 @@ const camundaCloud82Rules = withConfig({
     'no-candidate-users',
     'no-task-schedule'
   ]),
+  'escalation-boundary-event-attached-to-ref': 'error',
   'escalation-reference': 'error',
   'no-signal-event-sub-process': 'error',
   'task-schedule': 'error'
 }, { version: '8.2' });
 
 const camundaCloud83Rules = withConfig({
-  ...omit(camundaCloud82Rules, 'inclusive-gateway'),
+  ...camundaCloud82Rules,
   'signal-reference': 'error'
 }, { version: '8.3' });
 
@@ -72,6 +73,7 @@ const rules = {
   'collapsed-subprocess': './rules/camunda-cloud/collapsed-subprocess',
   'duplicate-task-headers': './rules/camunda-cloud/duplicate-task-headers',
   'error-reference': './rules/camunda-cloud/error-reference',
+  'escalation-boundary-event-attached-to-ref': './rules/camunda-cloud/escalation-boundary-event-attached-to-ref',
   'escalation-reference': './rules/camunda-cloud/escalation-reference',
   'event-based-gateway-target': './rules/camunda-cloud/event-based-gateway-target',
   'executable-process': './rules/camunda-cloud/executable-process',

package/package.json

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

package/rules/camunda-cloud/collapsed-subprocess.js

@@ -16,7 +16,7 @@ module.exports = skipInNonExecutableProcess(function() {
     const node = di.bpmnElement;
 
     const error = {
-      message: `A <${ node.$type }> must be expanded.`,
+      message: `A <${ node.$type }> must be expanded`,
       data: {
         type: ERROR_TYPES.ELEMENT_COLLAPSED_NOT_ALLOWED,
         node: node,

package/rules/camunda-cloud/escalation-boundary-event-attached-to-ref.js

@@ -0,0 +1,48 @@
+const {
+  is,
+  isAny
+} = require('bpmnlint-utils');
+
+const {
+  getEventDefinition,
+  isAnyExactly
+} = 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) {
+    if (!isAny(node, [ 'bpmn:CatchEvent', 'bpmn:ThrowEvent' ])) {
+      return;
+    }
+
+    const eventDefinition = getEventDefinition(node);
+
+    if (!eventDefinition || !is(eventDefinition, 'bpmn:EscalationEventDefinition')) {
+      return;
+    }
+
+    const attachedToRef = node.get('attachedToRef');
+
+    if (attachedToRef && !isAnyExactly(attachedToRef, [ 'bpmn:CallActivity', 'bpmn:SubProcess' ])) {
+      reportErrors(node, reporter, {
+        message: `Element of type <bpmn:BoundaryEvent> with event definition of type <bpmn:EscalationEventDefinition> is not allowed to be attached to element of type <${ attachedToRef.$type }>`,
+        path: null,
+        data: {
+          type: ERROR_TYPES.ATTACHED_TO_REF_ELEMENT_TYPE_NOT_ALLOWED,
+          node,
+          parentNode: null,
+          attachedToRef
+        }
+      });
+    }
+  }
+
+  return {
+    check
+  };
+});

package/rules/camunda-cloud/escalation-reference.js

@@ -24,27 +24,35 @@ module.exports = skipInNonExecutableProcess(function() {
       return;
     }
 
-    let errors = hasProperties(eventDefinition, {
-      escalationRef: {
-        required: true
-      }
-    }, node);
+    let errors = [];
 
-    if (errors && errors.length) {
-      reportErrors(node, reporter, errors);
+    if (!isNoEscalationRefAllowed(node)) {
+      errors = hasProperties(eventDefinition, {
+        escalationRef: {
+          required: true
+        }
+      }, node);
 
-      return;
+      if (errors.length) {
+        reportErrors(node, reporter, errors);
+
+        return;
+      }
     }
 
     const escalationRef = eventDefinition.get('escalationRef');
 
+    if (!escalationRef) {
+      return;
+    }
+
     errors = hasProperties(escalationRef, {
       escalationCode: {
         required: true
       }
     }, node);
 
-    if (errors && errors.length) {
+    if (errors.length) {
       reportErrors(node, reporter, errors);
     }
   }
@@ -53,3 +61,7 @@ module.exports = skipInNonExecutableProcess(function() {
     check
   };
 });
+
+function isNoEscalationRefAllowed(node, version) {
+  return is(node, 'bpmn:BoundaryEvent');
+}

package/rules/utils/error-types.js

@@ -10,6 +10,7 @@ module.exports.ERROR_TYPES = Object.freeze({
   EXTENSION_ELEMENT_NOT_ALLOWED: 'camunda.extensionElementNotAllowed',
   EXTENSION_ELEMENT_REQUIRED: 'camunda.extensionElementRequired',
   FEEL_EXPRESSION_INVALID: 'camunda.feelExpressionInvalid',
+  ATTACHED_TO_REF_ELEMENT_TYPE_NOT_ALLOWED: 'camunda.attachedToRefElementTypeNotAllowed',
   PROPERTY_DEPENDENT_REQUIRED: 'camunda.propertyDependentRequired',
   PROPERTY_NOT_ALLOWED: 'camunda.propertyNotAllowed',
   PROPERTY_REQUIRED: 'camunda.propertyRequired',