bpmnlint-plugin-camunda-compat 1.0.1 → 1.2.0

package/index.js

@@ -7,6 +7,7 @@ const camundaCloud10Rules = withConfig({
   'duplicate-task-headers': 'error',
   'element-type': 'error',
   'error-reference': 'error',
+  'event-based-gateway-target': 'error',
   'executable-process': 'error',
   'loop-characteristics': 'error',
   'message-reference': 'error',
@@ -47,6 +48,11 @@ const camundaCloud82Rules = withConfig({
   'task-schedule': 'error'
 }, { version: '8.2' });
 
+const camundaCloud83Rules = withConfig({
+  ...camundaCloud82Rules,
+  'signal-reference': 'error'
+}, { version: '8.3' });
+
 const camundaPlatform719Rules = withConfig({
   'history-time-to-live': 'error'
 }, { platform: 'camunda-platform', version: '7.19' });
@@ -74,6 +80,9 @@ module.exports = {
     'camunda-cloud-8-2': {
       rules: camundaCloud82Rules
     },
+    'camunda-cloud-8-3': {
+      rules: camundaCloud83Rules
+    },
     'camunda-platform-7-19': {
       rules: camundaPlatform719Rules
     }

package/package.json

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

package/rules/element-type/config.js

@@ -18,6 +18,7 @@ module.exports = {
     'bpmn:ErrorEventDefinition': '1.0',
     'bpmn:EscalationEventDefinition': '8.2',
     'bpmn:MessageEventDefinition': '1.2',
+    'bpmn:SignalEventDefinition': '8.3',
     'bpmn:TerminateEventDefinition': '8.1'
   },
   'bpmn:EventBasedGateway': '1.0',
@@ -26,14 +27,15 @@ module.exports = {
   'bpmn:InclusiveGateway': '8.1',
   'bpmn:IntermediateCatchEvent': {
     'bpmn:MessageEventDefinition': '1.0',
-    'bpmn:TimerEventDefinition': '1.0',
-    'bpmn:LinkEventDefinition': '8.2'
+    'bpmn:LinkEventDefinition': '8.2',
+    'bpmn:TimerEventDefinition': '1.0'
   },
   'bpmn:IntermediateThrowEvent': {
     '_': '1.1',
     'bpmn:EscalationEventDefinition': '8.2',
+    'bpmn:LinkEventDefinition': '8.2',
     'bpmn:MessageEventDefinition': '1.2',
-    'bpmn:LinkEventDefinition': '8.2'
+    'bpmn:SignalEventDefinition': '8.3'
   },
   'bpmn:ManualTask': '1.1',
   'bpmn:MessageFlow': '1.0',

package/rules/event-based-gateway-target.js

@@ -0,0 +1,39 @@
+const { is } = require('bpmnlint-utils');
+
+const { ERROR_TYPES } = require('./utils/element');
+
+const { reportErrors } = require('./utils/reporter');
+
+const { skipInNonExecutableProcess } = require('./utils/rule');
+
+module.exports = skipInNonExecutableProcess(function() {
+  function check(node, reporter) {
+    if (!is(node, 'bpmn:ReceiveTask')) {
+      return;
+    }
+
+    // receive task as event-based gateway target is allowed by BPMN 2.0 but not
+    // supported by Zeebe
+    const error = node.get('incoming').some((sequenceFlow) => {
+      const source = sequenceFlow.get('sourceRef');
+
+      return is(source, 'bpmn:EventBasedGateway');
+    });
+
+    if (error) {
+      reportErrors(node, reporter, {
+        message: 'Element of type <bpmn:ReceiveTask> not allowed as event-based gateway target',
+        path: null,
+        data: {
+          type: ERROR_TYPES.EVENT_BASED_GATEWAY_TARGET_NOT_ALLOWED,
+          node,
+          parentNode: null
+        }
+      });
+    }
+  }
+
+  return {
+    check
+  };
+});

package/rules/no-expression.js

@@ -35,6 +35,10 @@ const handlersMap = {
   '8.2': [
     checkErrorCatchEvent,
     checkEscalationCatchEvent
+  ],
+  '8.3': [
+    checkErrorCatchEvent,
+    checkEscalationCatchEvent
   ]
 };
 
@@ -61,6 +65,10 @@ function noExpressionRule({ version }) {
 function checkForVersion(node, version) {
   const handlers = handlersMap[version];
 
+  if (!handlers) {
+    return [];
+  }
+
   return handlers.reduce((errors, handler) => {
     const handlerErrors = handler(node) || [];
     return errors.concat(handlerErrors);

package/rules/sequence-flow-condition.js

@@ -1,6 +1,12 @@
-const { isAny } = require('bpmnlint-utils');
+const {
+  is,
+  isAny
+} = require('bpmnlint-utils');
 
-const { hasProperties } = require('./utils/element');
+const {
+  ERROR_TYPES,
+  hasProperties
+} = require('./utils/element');
 
 const { reportErrors } = require('./utils/reporter');
 
@@ -8,26 +14,40 @@ const { skipInNonExecutableProcess } = require('./utils/rule');
 
 module.exports = skipInNonExecutableProcess(function() {
   function check(node, reporter) {
-    if (!isAny(node, [ 'bpmn:ExclusiveGateway', 'bpmn:InclusiveGateway' ])) {
-      return;
-    }
-
-    const outgoing = node.get('outgoing');
-
-    if (outgoing && outgoing.length > 1) {
-      for (let sequenceFlow of outgoing) {
-        if (node.get('default') !== sequenceFlow) {
-          const errors = hasProperties(sequenceFlow, {
-            conditionExpression: {
-              required: true
+    if (isAny(node, [ 'bpmn:ExclusiveGateway', 'bpmn:InclusiveGateway' ])) {
+      const outgoing = node.get('outgoing');
+
+      if (outgoing && outgoing.length > 1) {
+        for (let sequenceFlow of outgoing) {
+          if (node.get('default') !== sequenceFlow) {
+            const errors = hasProperties(sequenceFlow, {
+              conditionExpression: {
+                required: true
+              }
+            }, sequenceFlow);
+
+            if (errors.length) {
+              reportErrors(sequenceFlow, reporter, errors);
             }
-          }, sequenceFlow);
-
-          if (errors.length) {
-            reportErrors(sequenceFlow, reporter, errors);
           }
         }
       }
+    } else if (is(node, 'bpmn:SequenceFlow')) {
+      const source = node.get('sourceRef'),
+            conditionExpression = node.get('conditionExpression');
+
+      if (!isAny(source, [ 'bpmn:ExclusiveGateway', 'bpmn:InclusiveGateway' ]) && conditionExpression) {
+        reportErrors(node, reporter, {
+          message: 'Property <conditionExpression> only allowed if source is of type <bpmn:ExclusiveGateway> or <bpmn:InclusiveGateway>',
+          path: [ 'conditionExpression' ],
+          data: {
+            type: ERROR_TYPES.PROPERTY_NOT_ALLOWED,
+            node: node,
+            parentNode: null,
+            property: 'conditionExpression'
+          }
+        });
+      }
     }
   }
 

package/rules/signal-reference.js

@@ -0,0 +1,59 @@
+const {
+  is,
+  isAny
+} = require('bpmnlint-utils');
+
+const {
+  getEventDefinition,
+  hasProperties
+} = require('./utils/element');
+
+const { reportErrors } = require('./utils/reporter');
+
+const { skipInNonExecutableProcess } = require('./utils/rule');
+
+module.exports = skipInNonExecutableProcess(function() {
+  function check(node, reporter) {
+    if (!isAny(node, [ 'bpmn:StartEvent', 'bpmn:IntermediateThrowEvent', 'bpmn:EndEvent' ])) {
+      return;
+    }
+
+    const eventDefinition = getEventDefinition(node);
+
+    if (!eventDefinition || !is(eventDefinition, 'bpmn:SignalEventDefinition')) {
+      return;
+    }
+
+    let errors = hasProperties(eventDefinition, {
+      signalRef: {
+        required: true
+      }
+    }, node);
+
+    if (errors.length) {
+      reportErrors(node, reporter, errors);
+
+      return;
+    }
+
+    const signalRef = eventDefinition.get('signalRef');
+
+    if (!signalRef) {
+      return;
+    }
+
+    errors = hasProperties(signalRef, {
+      name: {
+        required: true
+      }
+    }, node);
+
+    if (errors.length) {
+      reportErrors(node, reporter, errors);
+    }
+  }
+
+  return {
+    check
+  };
+});

package/rules/utils/error-types.js

@@ -2,6 +2,7 @@ module.exports.ERROR_TYPES = Object.freeze({
   ELEMENT_COLLAPSED_NOT_ALLOWED: 'camunda.elementCollapsedNotAllowed',
   CHILD_ELEMENT_TYPE_NOT_ALLOWED: 'camunda.childElementTypeNotAllowed',
   ELEMENT_TYPE_NOT_ALLOWED: 'camunda.elementTypeNotAllowed',
+  EVENT_BASED_GATEWAY_TARGET_NOT_ALLOWED: 'camunda.eventBasedGatewayTargetNotAllowed',
   EXPRESSION_NOT_ALLOWED: 'camunda.expressionNotAllowed',
   EXPRESSION_REQUIRED: 'camunda.expressionRequired',
   EXPRESSION_VALUE_NOT_ALLOWED: 'camunda.expressionValueNotAllowed',