bpmnlint-plugin-camunda-compat 1.0.0 → 1.1.0

package/index.js

@@ -47,6 +47,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 +79,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.0",
+  "version": "1.1.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/error-reference.js

@@ -14,44 +14,50 @@ const { skipInNonExecutableProcess } = require('./utils/rule');
 
 const { greaterOrEqual } = require('./utils/version');
 
+const noErrorRefAllowedVersion = '8.2';
+
 module.exports = skipInNonExecutableProcess(function({ version }) {
   function check(node, reporter) {
     if (!isAny(node, [ 'bpmn:CatchEvent', 'bpmn:ThrowEvent' ])) {
       return;
     }
 
-    if (is(node, 'bpmn:CatchEvent') && greaterOrEqual(version, '8.2')) {
-      return;
-    }
-
     const eventDefinition = getEventDefinition(node);
 
     if (!eventDefinition || !is(eventDefinition, 'bpmn:ErrorEventDefinition')) {
       return;
     }
 
-    let errors = hasProperties(eventDefinition, {
-      errorRef: {
-        required: true,
-        allowedVersion: '8.2'
-      }
-    }, node);
+    let errors = [];
 
-    if (errors && errors.length) {
-      reportErrors(node, reporter, errors);
+    if (!isNoErrorRefAllowed(node, version)) {
+      errors = hasProperties(eventDefinition, {
+        errorRef: {
+          required: true,
+          allowedVersion: '8.2'
+        }
+      }, node);
 
-      return;
+      if (errors.length) {
+        reportErrors(node, reporter, errors);
+
+        return;
+      }
     }
 
     const errorRef = eventDefinition.get('errorRef');
 
+    if (!errorRef) {
+      return;
+    }
+
     errors = hasProperties(errorRef, {
       errorCode: {
         required: true
       }
     }, node);
 
-    if (errors && errors.length) {
+    if (errors.length) {
       reportErrors(node, reporter, errors);
     }
   }
@@ -59,4 +65,8 @@ module.exports = skipInNonExecutableProcess(function({ version }) {
   return {
     check
   };
-});
+});
+
+function isNoErrorRefAllowed(node, version) {
+  return is(node, 'bpmn:CatchEvent') && greaterOrEqual(version, noErrorRefAllowedVersion);
+}

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/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
+  };
+});