bpmnlint-plugin-camunda-compat 0.4.0 → 0.6.1

package/CHANGELOG.md

@@ -6,11 +6,27 @@ All notable changes to [bpmnlint-plugin-camunda-compat](https://github.com/camun
 
 ___Note:__ Yet to be released changes appear here._
 
+## 0.6.1
+
+* `FIX`: lanes supported ([#26](https://github.com/camunda/bpmnlint-plugin-camunda-compat/pull/26))
+
+## 0.6.0
+
+* `FEAT`: adjust error messages to be more friendly ([#22](https://github.com/camunda/bpmnlint-plugin-camunda-compat/pull/22))
+* `FEAT`: lint error code and message name ([#21](https://github.com/camunda/bpmnlint-plugin-camunda-compat/pull/21))
+* `FIX`: task definition retries not required ([#20](https://github.com/camunda/bpmnlint-plugin-camunda-compat/pull/20))
+
+## 0.5.0
+
+* `FEAT`: update Camunda Cloud rules to lint extension elements and their properties ([#18](https://github.com/camunda/bpmnlint-plugin-camunda-compat/pull/18))
+
 ## 0.4.0
+
 * `CHORE`: rename `Cloud` `1.4` to `8.0` ([#14](https://github.com/camunda/bpmnlint-plugin-camunda-compat/pull/14))
 * `CHORE`: rename `Cloud` to `Platform`/`Zeebe` ([#15](https://github.com/camunda/bpmnlint-plugin-camunda-compat/pull/15))
 
 ## 0.3.0
+
 * `FEAT`: support multiInstance for subprocesses with cloud 1.0 ([#6](https://github.com/camunda/bpmnlint-plugin-camunda-compat/pull/6))
 * `FEAT`: add Camunda Platform rules ([#5](https://github.com/camunda/bpmnlint-plugin-camunda-compat/pull/5))
 * `FEAT`: add Camunda Cloud 1.4 rule ([#5](https://github.com/camunda/bpmnlint-plugin-camunda-compat/pull/5))

package/index.js

@@ -41,4 +41,4 @@ module.exports = {
       }
     }
   }
-}
+};

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "bpmnlint-plugin-camunda-compat",
-  "version": "0.4.0",
+  "version": "0.6.1",
   "description": "A bpmnlint plug-in for Camunda Cloud and Platform compatibility",
   "main": "index.js",
   "scripts": {
-    "all": "npm test",
-    "test": "mocha test/**/*.spec.js"
+    "all": "npm run lint && npm test",
+    "lint": "eslint .",
+    "test": "mocha test/**/*.spec.js",
+    "test:watch": "npm run test -- --watch"
   },
   "repository": {
     "type": "git",
@@ -22,13 +24,19 @@
   "license": "MIT",
   "devDependencies": {
     "bpmn-moddle": "^7.1.2",
-    "bpmnlint": "^6.1.0",
+    "bpmnlint": "^7.6.0",
+    "camunda-bpmn-moddle": "^6.1.1",
     "chai": "^4.3.5",
+    "eslint": "^7.32.0",
+    "eslint-plugin-bpmn-io": "^0.13.0",
     "mocha": "^5.2.0",
     "modeler-moddle": "^0.1.0",
+    "sinon": "^13.0.1",
+    "sinon-chai": "^3.7.0",
     "zeebe-bpmn-moddle": "^0.10.0"
   },
   "dependencies": {
+    "@philippfromme/moddle-helpers": "^0.1.0",
     "bpmnlint-utils": "^1.0.2",
     "min-dash": "^3.8.0"
   },

package/rules/camunda-cloud-1-0-checks.js

@@ -1,19 +1,29 @@
 const {
-  checkSome,
+  checkEventDefinition,
+  checkFlowNode,
+  checkIf,
+  hasErrorReference,
   hasEventDefinitionOfType,
-  hasLoopCharacteristicsOfType,
-  hasNoEventDefinition,
-  hasNoLanes,
-  hasNoLoopCharacteristics,
-  isNotBpmn
-} = require('./utils/rule');
+  hasEventDefinitionOfTypeOrNone,
+  hasMessageReference,
+  isNotBpmn,
+  withTranslations
+} = require('./utils/element');
+
+const {
+  hasZeebeCalledElement,
+  hasZeebeLoopCharacteristics,
+  hasZeebeSubscription,
+  hasZeebeTaskDefinition
+} = require('./utils/cloud/element');
+
+const { checkEvery } = require('./utils/rule');
 
 module.exports = [
   {
     check: isNotBpmn
   },
   'bpmn:Association',
-  'bpmn:CallActivity',
   'bpmn:Collaboration',
   'bpmn:DataObject',
   'bpmn:DataObjectReference',
@@ -25,73 +35,202 @@ module.exports = [
   'bpmn:MessageFlow',
   'bpmn:ParallelGateway',
   'bpmn:Participant',
+  'bpmn:Process',
   'bpmn:SequenceFlow',
   'bpmn:TextAnnotation',
   {
     type: 'bpmn:BoundaryEvent',
-    check: hasEventDefinitionOfType([
-      'bpmn:ErrorEventDefinition',
-      'bpmn:MessageEventDefinition',
-      'bpmn:TimerEventDefinition'
-    ])
+    check: withTranslations(
+      checkEvery(
+        hasEventDefinitionOfType([
+          'bpmn:ErrorEventDefinition',
+          'bpmn:MessageEventDefinition',
+          'bpmn:TimerEventDefinition'
+        ]),
+        checkIf(
+          checkEventDefinition(hasErrorReference),
+          hasEventDefinitionOfType('bpmn:ErrorEventDefinition')
+        ),
+        checkIf(
+          checkEvery(
+            checkEventDefinition(hasMessageReference),
+            checkIf(
+              checkEventDefinition(hasZeebeSubscription),
+              checkEventDefinition(hasMessageReference)
+            )
+          ),
+          hasEventDefinitionOfType('bpmn:MessageEventDefinition')
+        )
+      ),
+      {
+        'Element of type <bpmn:BoundaryEvent> not supported by {{ executionPlatform }}': 'An <Undefined Boundary Event> is not supported by {{ executionPlatform }}',
+        'Element of type <bpmn:ErrorEventDefinition> must have property <errorRef>': 'An <Error Boundary Event> must have a defined <Error Reference>',
+        'Element of type <bpmn:Error> must have property <errorCode>': 'An <Error Boundary Event> with <Error Reference> must have a defined <Error code>',
+        'Element of type <bpmn:MessageEventDefinition> must have property <messageRef>': 'A <Message Boundary Event> must have a defined <Message Reference>',
+        'Element of type <bpmn:Message> must have property <name>': 'A <Message Boundary Event> with <Message Reference> must have a defined <Name>',
+        'Element of type <bpmn:Message> must have extension element of type <zeebe:Subscription>': 'A <Message Boundary Event> with <Message Reference> must have a defined <Subscription correlation key>',
+        'Element of type <zeebe:Subscription> must have property <correlationKey>': 'A <Message Boundary Event> with <Message Reference> must have a defined <Subscription correlation key>'
+      }
+    )
   },
   {
-    type: 'bpmn:EndEvent',
-    check: checkSome(
-      hasNoEventDefinition,
-      hasEventDefinitionOfType([
-        'bpmn:ErrorEventDefinition'
-      ])
+    type: 'bpmn:CallActivity',
+    check: withTranslations(
+      checkEvery(
+        hasZeebeCalledElement,
+        hasZeebeLoopCharacteristics
+      ),
+      {
+        'Element of type <bpmn:CallActivity> must have extension element of type <zeebe:CalledElement>': 'A <Call Activity> must have a defined <Called element>',
+        'Element of type <zeebe:CalledElement> must have property <processId>': 'A <Call Activity> must have a defined <Called element>',
+        'Element of type <bpmn:MultiInstanceLoopCharacteristics> must have extension element of type <zeebe:LoopCharacteristics>': 'A <Call Activity> with <Multi-instance marker> must have a defined <Input collection>',
+        'Element of type <zeebe:LoopCharacteristics> must have property <inputCollection>': 'A <Call Activity> with <Multi-instance marker> must have a defined <Input collection>',
+        'Element of type <zeebe:LoopCharacteristics> must have property <outputElement> if it has property <outputCollection>': 'A <Call Activity> with <Multi-instance marker> and defined <Output collection> must have a defined <Output element>',
+        'Element of type <zeebe:LoopCharacteristics> must have property <outputCollection> if it has property <outputElement>': 'A <Call Activity> with <Multi-instance marker> and defined <Output element> must have a defined <Output collection>'
+      }
     )
   },
   {
-    type: 'bpmn:IntermediateCatchEvent',
-    check: hasEventDefinitionOfType([
-      'bpmn:MessageEventDefinition',
-      'bpmn:TimerEventDefinition'
-    ])
+    type: 'bpmn:EndEvent',
+    check: withTranslations(
+      checkEvery(
+        hasEventDefinitionOfTypeOrNone('bpmn:ErrorEventDefinition'),
+        checkIf(
+          checkEventDefinition(hasErrorReference),
+          hasEventDefinitionOfType('bpmn:ErrorEventDefinition')
+        )
+      ),
+      {
+        'Element of type <bpmn:EndEvent> (<bpmn:MessageEventDefinition>) not supported by {{ executionPlatform }}': 'A <Message End Event> is not supported by {{ executionPlatform }}',
+        'Element of type <bpmn:ErrorEventDefinition> must have property <errorRef>': 'An <Error End Event> must have a defined <Error Reference>',
+        'Element of type <bpmn:Error> must have property <errorCode>': 'An <Error End Event> with <Error Reference> must have a defined <Error code>'
+      }
+    )
   },
   {
-    type: 'bpmn:Process',
-    check: hasNoLanes
+    type: 'bpmn:IntermediateCatchEvent',
+    check: withTranslations(
+      checkEvery(
+        hasEventDefinitionOfType([
+          'bpmn:TimerEventDefinition',
+          'bpmn:MessageEventDefinition'
+        ]),
+        checkIf(
+          checkEvery(
+            checkEventDefinition(hasMessageReference),
+            checkIf(
+              checkEventDefinition(hasZeebeSubscription),
+              checkEventDefinition(hasMessageReference)
+            )
+          ),
+          hasEventDefinitionOfType('bpmn:MessageEventDefinition')
+        )
+      ),
+      {
+        'Element of type <bpmn:IntermediateCatchEvent> not supported by {{ executionPlatform }}': 'A <Undefined Intermediate Catch Event> is not supported by {{ executionPlatform }}',
+        'Element of type <bpmn:MessageEventDefinition> must have property <messageRef>': 'A <Message Intermediate Catch Event> must have a defined <Message Reference>',
+        'Element of type <bpmn:Message> must have property <name>': 'A <Message Intermediate Catch Event> with <Message Reference> must have a defined <Name>',
+        'Element of type <bpmn:Message> must have extension element of type <zeebe:Subscription>': 'A <Message Intermediate Catch Event> with <Message Reference> must have a defined <Subscription correlation key>',
+        'Element of type <zeebe:Subscription> must have property <correlationKey>': 'A <Message Intermediate Catch Event> with <Message Reference> must have a defined <Subscription correlation key>'
+      }
+    )
   },
   {
     type: 'bpmn:ReceiveTask',
-    check: checkSome(
-      hasNoLoopCharacteristics,
-      hasLoopCharacteristicsOfType('bpmn:MultiInstanceLoopCharacteristics')
+    check: withTranslations(
+      checkEvery(
+        checkFlowNode(hasMessageReference),
+        checkIf(
+          checkFlowNode(hasZeebeSubscription),
+          checkFlowNode(hasMessageReference)
+        ),
+        hasZeebeLoopCharacteristics
+      ),
+      {
+        'Element of type <bpmn:MultiInstanceLoopCharacteristics> must have extension element of type <zeebe:LoopCharacteristics>': 'A <Receive Task> with <Multi-instance marker> must have a defined <Input collection>',
+        'Element of type <zeebe:LoopCharacteristics> must have property <inputCollection>': 'A <Receive Task> with <Multi-instance marker> must have a defined <Input collection>',
+        'Element of type <zeebe:LoopCharacteristics> must have property <outputElement> if it has property <outputCollection>': 'A <Receive Task> with <Multi-instance marker> and defined <Output collection> must have a defined <Output element>',
+        'Element of type <zeebe:LoopCharacteristics> must have property <outputCollection> if it has property <outputElement>': 'A <Receive Task> with <Multi-instance marker> and defined <Output element> must have a defined <Output collection>',
+        'Element of type <bpmn:ReceiveTask> must have property <messageRef>': 'A <Receive Task> must have a defined <Message Reference>',
+        'Element of type <bpmn:Message> must have property <name>': 'A <Receive Task> with <Message Reference> must have a defined <Name>',
+        'Element of type <bpmn:Message> must have extension element of type <zeebe:Subscription>': 'A <Receive Task> with <Message Reference> must have a defined <Subscription correlation key>',
+        'Element of type <zeebe:Subscription> must have property <correlationKey>': 'A <Receive Task> with <Message Reference> must have a defined <Subscription correlation key>'
+      }
     )
   },
   {
     type: 'bpmn:ServiceTask',
-    check: checkSome(
-      hasNoLoopCharacteristics,
-      hasLoopCharacteristicsOfType('bpmn:MultiInstanceLoopCharacteristics')
+    check: withTranslations(
+      checkEvery(
+        hasZeebeLoopCharacteristics,
+        hasZeebeTaskDefinition
+      ),
+      {
+        'Element of type <bpmn:ServiceTask> must have extension element of type <zeebe:TaskDefinition>': 'A <Service Task> must have a <Task definition type>',
+        'Element of type <zeebe:TaskDefinition> must have property <type>': 'A <Service Task> must have a <Task definition type>',
+        'Element of type <bpmn:MultiInstanceLoopCharacteristics> must have extension element of type <zeebe:LoopCharacteristics>': 'A <Service Task> with <Multi-instance marker> must have a defined <Input collection>',
+        'Element of type <zeebe:LoopCharacteristics> must have property <inputCollection>': 'A <Service Task> with <Multi-instance marker> must have a defined <Input collection>',
+        'Element of type <zeebe:LoopCharacteristics> must have property <outputElement> if it has property <outputCollection>': 'A <Service Task> with <Multi-instance marker> and defined <Output collection> must have a defined <Output element>',
+        'Element of type <zeebe:LoopCharacteristics> must have property <outputCollection> if it has property <outputElement>': 'A <Service Task> with <Multi-instance marker> and defined <Output element> must have a defined <Output collection>'
+      }
     )
   },
   {
     type: 'bpmn:StartEvent',
-    check: checkSome(
-      hasNoEventDefinition,
-      hasEventDefinitionOfType([
-        'bpmn:ErrorEventDefinition',
-        'bpmn:MessageEventDefinition',
-        'bpmn:TimerEventDefinition'
-      ])
+    check: withTranslations(
+      checkEvery(
+        hasEventDefinitionOfTypeOrNone([
+          'bpmn:ErrorEventDefinition',
+          'bpmn:MessageEventDefinition',
+          'bpmn:TimerEventDefinition'
+        ]),
+        checkIf(
+          checkEventDefinition(hasErrorReference),
+          hasEventDefinitionOfType('bpmn:ErrorEventDefinition')
+        ),
+        checkIf(
+          checkEvery(
+            checkEventDefinition(hasMessageReference),
+            checkIf(
+              checkEventDefinition(hasZeebeSubscription),
+              checkEventDefinition(hasMessageReference)
+            )
+          ),
+          hasEventDefinitionOfType('bpmn:MessageEventDefinition')
+        )
+      ),
+      {
+        'Element of type <bpmn:ErrorEventDefinition> must have property <errorRef>': 'An <Error Start Event> must have a defined <Error Reference>',
+        'Element of type <bpmn:Error> must have property <errorCode>': 'An <Error Start Event> with <Error Reference> must have a defined <Error code>',
+        'Element of type <bpmn:MessageEventDefinition> must have property <messageRef>': 'A <Message Start Event> must have a defined <Message Reference>',
+        'Element of type <bpmn:Message> must have property <name>': 'A <Message Start Event> with <Message Reference> must have a defined <Name>',
+        'Element of type <bpmn:Message> must have extension element of type <zeebe:Subscription>': 'A <Message Start Event> with <Message Reference> must have a defined <Subscription correlation key>',
+        'Element of type <zeebe:Subscription> must have property <correlationKey>': 'A <Message Start Event> with <Message Reference> must have a defined <Subscription correlation key>'
+      }
     )
   },
   {
     type: 'bpmn:SubProcess',
-    check: checkSome(
-      hasNoLoopCharacteristics,
-      hasLoopCharacteristicsOfType('bpmn:MultiInstanceLoopCharacteristics')
+    check: withTranslations(
+      hasZeebeLoopCharacteristics,
+      {
+        'Element of type <bpmn:MultiInstanceLoopCharacteristics> must have extension element of type <zeebe:LoopCharacteristics>': 'A <Sub Process> with <Multi-instance marker> must have a defined <Input collection>',
+        'Element of type <zeebe:LoopCharacteristics> must have property <inputCollection>': 'A <Sub Process> with <Multi-instance marker> must have a defined <Input collection>',
+        'Element of type <zeebe:LoopCharacteristics> must have property <outputElement> if it has property <outputCollection>': 'A <Sub Process> with <Multi-instance marker> and defined <Output collection> must have a defined <Output element>',
+        'Element of type <zeebe:LoopCharacteristics> must have property <outputCollection> if it has property <outputElement>': 'A <Sub Process> with <Multi-instance marker> and defined <Output element> must have a defined <Output collection>'
+      }
     )
   },
   {
     type: 'bpmn:UserTask',
-    check: checkSome(
-      hasNoLoopCharacteristics,
-      hasLoopCharacteristicsOfType('bpmn:MultiInstanceLoopCharacteristics')
+    check: withTranslations(
+      hasZeebeLoopCharacteristics,
+      {
+        'Element of type <bpmn:MultiInstanceLoopCharacteristics> must have extension element of type <zeebe:LoopCharacteristics>': 'A <User Task> with <Multi-instance marker> must have a defined <Input collection>',
+        'Element of type <zeebe:LoopCharacteristics> must have property <inputCollection>': 'A <User Task> with <Multi-instance marker> must have a defined <Input collection>',
+        'Element of type <zeebe:LoopCharacteristics> must have property <outputElement> if it has property <outputCollection>': 'A <User Task> with <Multi-instance marker> and defined <Output collection> must have a defined <Output element>',
+        'Element of type <zeebe:LoopCharacteristics> must have property <outputCollection> if it has property <outputElement>': 'A <User Task> with <Multi-instance marker> and defined <Output element> must have a defined <Output collection>'
+      }
     )
   }
 ];

package/rules/camunda-cloud-1-0.js

@@ -2,4 +2,4 @@ const { createRule } = require('./utils/rule');
 
 const checks = require('./camunda-cloud-1-0-checks');
 
-module.exports = createRule('Camunda Cloud', '1.0', checks, 'Zeebe');
+module.exports = createRule('Camunda Cloud', '1.0', checks, 'Camunda Platform 8 (Zeebe 1.0)');

package/rules/camunda-cloud-1-1-checks.js

@@ -1,44 +1,89 @@
 const camundaCloud10Checks = require('./camunda-cloud-1-0-checks');
 
+const { checkEvery } = require('./utils/rule');
+
 const {
-  checkSome,
-  hasLoopCharacteristicsOfType,
   hasNoEventDefinition,
-  hasNoLoopCharacteristics
-} = require('./utils/rule');
+  withTranslations
+} = require('./utils/element');
+
+const {
+  hasZeebeTaskDefinition,
+  hasZeebeLoopCharacteristics
+} = require('./utils/cloud/element');
 
 module.exports = [
   ...camundaCloud10Checks,
   {
     type: 'bpmn:BusinessRuleTask',
-    check: checkSome(
-      hasNoLoopCharacteristics,
-      hasLoopCharacteristicsOfType('bpmn:MultiInstanceLoopCharacteristics')
+    check: withTranslations(
+      checkEvery(
+        hasZeebeLoopCharacteristics,
+        hasZeebeTaskDefinition
+      ),
+      {
+        'Element of type <bpmn:BusinessRuleTask> must have extension element of type <zeebe:TaskDefinition>': 'A <Business Rule Task> must have a <Task definition type>',
+        'Element of type <zeebe:TaskDefinition> must have property <type>': 'A <Business Rule Task> must have a <Task definition type>',
+        'Element of type <bpmn:MultiInstanceLoopCharacteristics> must have extension element of type <zeebe:LoopCharacteristics>': 'A <Business Rule Task> with <Multi-instance marker> must have a defined <Input collection>',
+        'Element of type <zeebe:LoopCharacteristics> must have property <inputCollection>': 'A <Business Rule Task> with <Multi-instance marker> must have a defined <Input collection>',
+        'Element of type <zeebe:LoopCharacteristics> must have property <outputElement> if it has property <outputCollection>': 'A <Business Rule Task> with <Multi-instance marker> and defined <Output collection> must have a defined <Output element>',
+        'Element of type <zeebe:LoopCharacteristics> must have property <outputCollection> if it has property <outputElement>': 'A <Business Rule Task> with <Multi-instance marker> and defined <Output element> must have a defined <Output collection>'
+      }
     )
   },
   {
     type: 'bpmn:IntermediateThrowEvent',
-    check: hasNoEventDefinition
+    check: withTranslations(
+      hasNoEventDefinition,
+      {
+        'Element of type <bpmn:IntermediateThrowEvent> (<bpmn:MessageEventDefinition>) not supported by {{ executionPlatform }}': 'A <Message Intermediate Throw Event> is not supported by {{ executionPlatform }}'
+      }
+    )
   },
   {
     type: 'bpmn:ManualTask',
-    check: checkSome(
-      hasNoLoopCharacteristics,
-      hasLoopCharacteristicsOfType('bpmn:MultiInstanceLoopCharacteristics')
+    check: withTranslations(
+      hasZeebeLoopCharacteristics,
+      {
+        'Element of type <bpmn:MultiInstanceLoopCharacteristics> must have extension element of type <zeebe:LoopCharacteristics>': 'A <Manual Task> with <Multi-instance marker> must have a defined <Input collection>',
+        'Element of type <zeebe:LoopCharacteristics> must have property <inputCollection>': 'A <Manual Task> with <Multi-instance marker> must have a defined <Input collection>',
+        'Element of type <zeebe:LoopCharacteristics> must have property <outputElement> if it has property <outputCollection>': 'A <Manual Task> with <Multi-instance marker> and defined <Output collection> must have a defined <Output element>',
+        'Element of type <zeebe:LoopCharacteristics> must have property <outputCollection> if it has property <outputElement>': 'A <Manual Task> with <Multi-instance marker> and defined <Output element> must have a defined <Output collection>'
+      }
     )
   },
   {
     type: 'bpmn:ScriptTask',
-    check: checkSome(
-      hasNoLoopCharacteristics,
-      hasLoopCharacteristicsOfType('bpmn:MultiInstanceLoopCharacteristics')
+    check: withTranslations(
+      checkEvery(
+        hasZeebeLoopCharacteristics,
+        hasZeebeTaskDefinition
+      ),
+      {
+        'Element of type <bpmn:ScriptTask> must have extension element of type <zeebe:TaskDefinition>': 'A <Script Task> must have a <Task definition type>',
+        'Element of type <zeebe:TaskDefinition> must have property <type>': 'A <Script Task> must have a <Task definition type>',
+        'Element of type <bpmn:MultiInstanceLoopCharacteristics> must have extension element of type <zeebe:LoopCharacteristics>': 'A <Script Task> with <Multi-instance marker> must have a defined <Input collection>',
+        'Element of type <zeebe:LoopCharacteristics> must have property <inputCollection>': 'A <Script Task> with <Multi-instance marker> must have a defined <Input collection>',
+        'Element of type <zeebe:LoopCharacteristics> must have property <outputElement> if it has property <outputCollection>': 'A <Script Task> with <Multi-instance marker> and defined <Output collection> must have a defined <Output element>',
+        'Element of type <zeebe:LoopCharacteristics> must have property <outputCollection> if it has property <outputElement>': 'A <Script Task> with <Multi-instance marker> and defined <Output element> must have a defined <Output collection>'
+      }
     )
   },
   {
     type: 'bpmn:SendTask',
-    check: checkSome(
-      hasNoLoopCharacteristics,
-      hasLoopCharacteristicsOfType('bpmn:MultiInstanceLoopCharacteristics')
+    check: withTranslations(
+      checkEvery(
+        hasZeebeLoopCharacteristics,
+        hasZeebeTaskDefinition
+      ),
+      {
+        'Element of type <bpmn:SendTask> must have extension element of type <zeebe:TaskDefinition>': 'A <Send Task> must have a <Task definition type>',
+        'Element of type <zeebe:TaskDefinition> must have property <type>': 'A <Send Task> must have a <Task definition type>',
+        'Element of type <bpmn:MultiInstanceLoopCharacteristics> must have extension element of type <zeebe:LoopCharacteristics>': 'A <Send Task> with <Multi-instance marker> must have a defined <Input collection>',
+        'Element of type <zeebe:LoopCharacteristics> must have property <inputCollection>': 'A <Send Task> with <Multi-instance marker> must have a defined <Input collection>',
+        'Element of type <zeebe:LoopCharacteristics> must have property <outputElement> if it has property <outputCollection>': 'A <Send Task> with <Multi-instance marker> and defined <Output collection> must have a defined <Output element>',
+        'Element of type <zeebe:LoopCharacteristics> must have property <outputCollection> if it has property <outputElement>': 'A <Send Task> with <Multi-instance marker> and defined <Output element> must have a defined <Output collection>'
+      }
     )
   }
 ];

package/rules/camunda-cloud-1-1.js

@@ -2,4 +2,4 @@ const { createRule } = require('./utils/rule');
 
 const checks = require('./camunda-cloud-1-1-checks');
 
-module.exports = createRule('Camunda Cloud', '1.1', checks, 'Zeebe');
+module.exports = createRule('Camunda Cloud', '1.1', checks, 'Camunda Platform 8 (Zeebe 1.1)');

package/rules/camunda-cloud-1-2-checks.js

@@ -1,19 +1,60 @@
 const camundaCloud11Checks = require('./camunda-cloud-1-1-checks');
 
-const { hasEventDefinitionOfType } = require('./utils/rule');
- 
+const {
+  checkEvery,
+  replaceChecks
+} = require('./utils/rule');
+
+const {
+  checkEventDefinition,
+  checkIf,
+  hasErrorReference,
+  hasEventDefinitionOfType,
+  hasEventDefinitionOfTypeOrNone,
+  withTranslations
+} = require('./utils/element');
+
+const { hasZeebeTaskDefinition } = require('./utils/cloud/element');
+
 module.exports = [
-  ...camundaCloud11Checks,
-  {
-    type: 'bpmn:EndEvent',
-    check: hasEventDefinitionOfType([
-      'bpmn:MessageEventDefinition'
-    ])
-  },
-  {
-    type: 'bpmn:IntermediateThrowEvent',
-    check: hasEventDefinitionOfType([
-      'bpmn:MessageEventDefinition'
-    ])
-  }
+  ...replaceChecks(
+    camundaCloud11Checks,
+    [
+      {
+        type: 'bpmn:IntermediateThrowEvent',
+        check: withTranslations(
+          checkEvery(
+            hasEventDefinitionOfTypeOrNone('bpmn:MessageEventDefinition'),
+            checkIf(
+              hasZeebeTaskDefinition,
+              hasEventDefinitionOfType('bpmn:MessageEventDefinition')
+            )
+          ),
+          {
+            'Element of type <bpmn:IntermediateThrowEvent> must have extension element of type <zeebe:TaskDefinition>': 'An <Intermediate Throw Event> must have a <Task definition type>',
+            'Element of type <zeebe:TaskDefinition> must have property <type>': 'An <Intermediate Throw Event> must have a <Task definition type>'
+          }
+        )
+      },
+      {
+        type: 'bpmn:EndEvent',
+        check: withTranslations(
+          checkEvery(
+            hasEventDefinitionOfTypeOrNone([
+              'bpmn:ErrorEventDefinition',
+              'bpmn:MessageEventDefinition'
+            ]),
+            checkIf(
+              checkEventDefinition(hasErrorReference),
+              hasEventDefinitionOfType('bpmn:ErrorEventDefinition')
+            )
+          ),
+          {
+            'Element of type <bpmn:ErrorEventDefinition> must have property <errorRef>': 'An <Error End Event> must have a defined <Error Reference>',
+            'Element of type <bpmn:Error> must have property <errorCode>': 'An <Error End Event> with <Error Reference> must have a defined <Error code>'
+          }
+        )
+      }
+    ]
+  )
 ];

package/rules/camunda-cloud-1-2.js

@@ -2,4 +2,4 @@ const { createRule } = require('./utils/rule');
 
 const checks = require('./camunda-cloud-1-2-checks');
 
-module.exports = createRule('Camunda Cloud', '1.2', checks, 'Zeebe');
+module.exports = createRule('Camunda Cloud', '1.2', checks, 'Camunda Platform 8 (Zeebe 1.2)');

package/rules/camunda-cloud-1-3-checks.js

@@ -1,5 +1,37 @@
 const camundaCloud12Checks = require('./camunda-cloud-1-2-checks');
 
+const {
+  checkEvery,
+  replaceCheck
+} = require('./utils/rule');
+
+const { withTranslations } = require('./utils/element');
+
+const {
+  hasZeebeCalledDecisionOrTaskDefinition,
+  hasZeebeLoopCharacteristics
+} = require('./utils/cloud/element');
+
 module.exports = [
-  ...camundaCloud12Checks
+  ...replaceCheck(
+    camundaCloud12Checks,
+    'bpmn:BusinessRuleTask',
+    withTranslations(
+      checkEvery(
+        hasZeebeCalledDecisionOrTaskDefinition,
+        hasZeebeLoopCharacteristics
+      ),
+      {
+        'Element of type <bpmn:BusinessRuleTask> must have one extension element of type <zeebe:CalledDecision> or <zeebe:TaskDefinition>': 'A <Business Rule Task> must have a defined <Implementation>',
+        'Element of type <bpmn:BusinessRuleTask> must have one or many extension elements of type <zeebe:CalledDecision> or <zeebe:TaskDefinition>': 'A <Business Rule Task> must have a defined <Implementation>',
+        'Element of type <zeebe:TaskDefinition> must have property <type>': 'A <Business Rule Task> with <Implementation: Job worker> must have a defined <Task definition type>',
+        'Element of type <zeebe:CalledDecision> must have property <decisionId>': 'A <Business Rule Task> with <Implementation: DMN decision> must have a defined <Called decision ID>',
+        'Element of type <zeebe:CalledDecision> must have property <resultVariable>': 'A Business Rule Task with <Implementation: DMN decision> must have a defined <Result variable>',
+        'Element of type <bpmn:MultiInstanceLoopCharacteristics> must have extension element of type <zeebe:LoopCharacteristics>': 'A <Business Rule Task> with <Multi-instance marker> must have a defined <Input collection>',
+        'Element of type <zeebe:LoopCharacteristics> must have property <inputCollection>': 'A <Business Rule Task> with <Multi-instance marker> must have a defined <Input collection>',
+        'Element of type <zeebe:LoopCharacteristics> must have property <outputElement> if it has property <outputCollection>': 'A <Business Rule Task> with <Multi-instance marker> and defined <Output collection> must have a defined <Output element>',
+        'Element of type <zeebe:LoopCharacteristics> must have property <outputCollection> if it has property <outputElement>': 'A <Business Rule Task> with <Multi-instance marker> and defined <Output element> must have a defined <Output collection>'
+      }
+    )
+  )
 ];

package/rules/camunda-cloud-1-3.js

@@ -2,4 +2,4 @@ const { createRule } = require('./utils/rule');
 
 const checks = require('./camunda-cloud-1-3-checks');
 
-module.exports = createRule('Camunda Cloud', '1.3', checks, 'Zeebe');
+module.exports = createRule('Camunda Cloud', '1.3', checks, 'Camunda Platform 8 (Zeebe 1.3)');

package/rules/camunda-cloud-8-0.js

@@ -2,4 +2,4 @@ const { createRule } = require('./utils/rule');
 
 const checks = require('./camunda-cloud-8-0-checks');
 
-module.exports = createRule('Camunda Cloud', '8.0', checks, 'Camunda Platform');
+module.exports = createRule('Camunda Cloud', '8.0', checks, 'Camunda Platform 8');