bpmnlint-plugin-camunda-compat 0.5.0 → 0.6.2

package/CHANGELOG.md

@@ -6,6 +6,20 @@ All notable changes to [bpmnlint-plugin-camunda-compat](https://github.com/camun
 
 ___Note:__ Yet to be released changes appear here._
 
+## 0.6.2
+
+* `FIX`: fix error message formatting ([#27](https://github.com/camunda/bpmnlint-plugin-camunda-compat/pull/27))
+
+## 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))

package/package.json

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

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

@@ -5,7 +5,7 @@ const {
   hasErrorReference,
   hasEventDefinitionOfType,
   hasEventDefinitionOfTypeOrNone,
-  hasNoLanes,
+  hasMessageReference,
   isNotBpmn,
   withTranslations
 } = require('./utils/element');
@@ -35,65 +35,127 @@ module.exports = [
   'bpmn:MessageFlow',
   'bpmn:ParallelGateway',
   'bpmn:Participant',
+  'bpmn:Process',
   'bpmn:SequenceFlow',
   'bpmn:TextAnnotation',
   {
     type: 'bpmn:BoundaryEvent',
-    check: checkEvery(
-      hasEventDefinitionOfType([
-        'bpmn:ErrorEventDefinition',
-        'bpmn:MessageEventDefinition',
-        'bpmn:TimerEventDefinition'
-      ]),
-      checkIf(
-        checkEventDefinition(hasErrorReference),
-        hasEventDefinitionOfType('bpmn:ErrorEventDefinition')
+    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')
+        )
       ),
-      checkIf(
-        checkEventDefinition(hasZeebeSubscription),
-        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:CallActivity',
-    check: checkEvery(
-      hasZeebeCalledElement,
-      hasZeebeLoopCharacteristics
+    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:EndEvent',
-    check: checkEvery(
-      hasEventDefinitionOfTypeOrNone('bpmn:ErrorEventDefinition'),
-      checkIf(
-        checkEventDefinition(hasErrorReference),
-        hasEventDefinitionOfType('bpmn:ErrorEventDefinition')
-      )
+    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:IntermediateCatchEvent',
-    check: checkEvery(
-      hasEventDefinitionOfType([
-        'bpmn:TimerEventDefinition',
-        'bpmn:MessageEventDefinition'
-      ]),
-      checkIf(
-        checkEventDefinition(hasZeebeSubscription),
-        hasEventDefinitionOfType('bpmn:MessageEventDefinition')
-      )
+    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:Process',
-    check: hasNoLanes
-  },
   {
     type: 'bpmn:ReceiveTask',
-    check: checkEvery(
-      checkFlowNode(hasZeebeSubscription),
-      hasZeebeLoopCharacteristics
+    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>'
+      }
     )
   },
   {
@@ -104,34 +166,71 @@ module.exports = [
         hasZeebeTaskDefinition
       ),
       {
-        'foo': 'bar'
+        '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: checkEvery(
-      hasEventDefinitionOfTypeOrNone([
-        'bpmn:ErrorEventDefinition',
-        'bpmn:MessageEventDefinition',
-        'bpmn:TimerEventDefinition'
-      ]),
-      checkIf(
-        checkEventDefinition(hasErrorReference),
-        hasEventDefinitionOfType('bpmn:ErrorEventDefinition')
+    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')
+        )
       ),
-      checkIf(
-        checkEventDefinition(hasZeebeSubscription),
-        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: hasZeebeLoopCharacteristics
+    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: hasZeebeLoopCharacteristics
+    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

@@ -2,7 +2,10 @@ const camundaCloud10Checks = require('./camunda-cloud-1-0-checks');
 
 const { checkEvery } = require('./utils/rule');
 
-const { hasNoEventDefinition } = require('./utils/element');
+const {
+  hasNoEventDefinition,
+  withTranslations
+} = require('./utils/element');
 
 const {
   hasZeebeTaskDefinition,
@@ -13,31 +16,74 @@ module.exports = [
   ...camundaCloud10Checks,
   {
     type: 'bpmn:BusinessRuleTask',
-    check: checkEvery(
-      hasZeebeLoopCharacteristics,
-      hasZeebeTaskDefinition
+    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: hasZeebeLoopCharacteristics
+    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: checkEvery(
-      hasZeebeLoopCharacteristics,
-      hasZeebeTaskDefinition
+    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: checkEvery(
-      hasZeebeLoopCharacteristics,
-      hasZeebeTaskDefinition
+    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

@@ -11,6 +11,7 @@ const {
   hasErrorReference,
   hasEventDefinitionOfType,
   hasEventDefinitionOfTypeOrNone,
+  withTranslations
 } = require('./utils/element');
 
 const { hasZeebeTaskDefinition } = require('./utils/cloud/element');
@@ -21,25 +22,37 @@ module.exports = [
     [
       {
         type: 'bpmn:IntermediateThrowEvent',
-        check: checkEvery(
-          hasEventDefinitionOfTypeOrNone('bpmn:MessageEventDefinition'),
-          checkIf(
-            hasZeebeTaskDefinition,
-            hasEventDefinitionOfType('bpmn:MessageEventDefinition')
-          )
+        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: checkEvery(
-          hasEventDefinitionOfTypeOrNone([
-            'bpmn:ErrorEventDefinition',
-            'bpmn:MessageEventDefinition'
-          ]),
-          checkIf(
-            checkEventDefinition(hasErrorReference),
-            hasEventDefinitionOfType('bpmn:ErrorEventDefinition')
-          )
+        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

@@ -5,6 +5,8 @@ const {
   replaceCheck
 } = require('./utils/rule');
 
+const { withTranslations } = require('./utils/element');
+
 const {
   hasZeebeCalledDecisionOrTaskDefinition,
   hasZeebeLoopCharacteristics
@@ -14,9 +16,22 @@ module.exports = [
   ...replaceCheck(
     camundaCloud12Checks,
     'bpmn:BusinessRuleTask',
-    checkEvery(
-      hasZeebeCalledDecisionOrTaskDefinition,
-      hasZeebeLoopCharacteristics
+    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');

package/rules/utils/cloud/element.js

@@ -29,9 +29,6 @@ module.exports.hasZeebeCalledDecisionOrTaskDefinition = checkFlowNode(
       properties: {
         type: {
           required: true
-        },
-        retries: {
-          required: true
         }
       }
     }
@@ -102,9 +99,6 @@ module.exports.hasZeebeTaskDefinition = checkFlowNode(
     properties: {
       type: {
         required: true
-      },
-      retries: {
-        required: true
       }
     }
   })

package/rules/utils/element.js

@@ -131,14 +131,6 @@ module.exports.hasMultiInstanceLoopCharacteristics = function(node) {
   return true;
 };
 
-module.exports.hasNoLanes = function(node) {
-  const laneSets = node.get('laneSets');
-
-  return !laneSets
-    || !laneSets.length
-    || getElementNotSupportedError(node.$type, 'bpmn:LaneSet', [ 'laneSets' ]);
-};
-
 module.exports.isNotBpmn = function(node) {
   return !is(node, 'bpmn:BaseElement');
 };
@@ -176,7 +168,7 @@ module.exports.findExtensionElement = findExtensionElement;
 function getElementNotSupportedError(type, propertyType, path = null) {
   if (propertyType) {
     return {
-      message: `Element of type <${ type }> (<${ propertyType }>) not supported by {{ executionPlatform }} {{ executionPlatformVersion }}`,
+      message: `Element of type <${ type }> (<${ propertyType }>) not supported by {{ executionPlatform }}`,
       path,
       error: {
         type: ERROR_TYPES.ELEMENT_TYPE,
@@ -187,7 +179,7 @@ function getElementNotSupportedError(type, propertyType, path = null) {
   }
 
   return {
-    message: `Element of type <${ type }> not supported by {{ executionPlatform }} {{ executionPlatformVersion }}`,
+    message: `Element of type <${ type }> not supported by {{ executionPlatform }}`,
     path,
     error: {
       type: ERROR_TYPES.ELEMENT_TYPE,
@@ -288,7 +280,7 @@ function checkProperties(node, properties, parentNode) {
         return [
           ...results,
           {
-            message: `Element of type <${ node.$type }> must have property <${ propertyName }> if property <${ propertyChecks.dependendRequired }> is set`,
+            message: `Element of type <${ node.$type }> must have property <${ propertyName }> if it has property <${ propertyChecks.dependendRequired }>`,
             path: path
               ? [ ...path, propertyName ]
               : [ propertyName ],
@@ -343,8 +335,7 @@ module.exports.checkProperties = checkProperties;
  *   {
  *     type: 'zeebe:TaskDefinition',
  *     properties: {
- *       type: { required: true },
- *       retries: { required: true }
+ *       type: { required: true }
  *     }
  *   }
  * ]);
@@ -361,7 +352,7 @@ module.exports.hasExtensionElementsOfTypes = function(types, exclusive = false)
 
     if (!extensionElements || !extensionElements.length) {
       return {
-        message: `Element of type <${ node.$type }> must have have at least one ${ formatTypes(types, true) } extension element`,
+        message: `Element of type <${ node.$type }> must have one or many extension elements of type ${ formatTypes(types, true) }`,
         path: getPath(node, parentNode),
         error: {
           type: ERROR_TYPES.EXTENSION_ELEMENT_REQUIRED,
@@ -372,7 +363,7 @@ module.exports.hasExtensionElementsOfTypes = function(types, exclusive = false)
 
     if (exclusive && extensionElements.length > 1) {
       return {
-        message: `Element of type <${ node.$type }> must have have either one ${ formatTypes(types, true) } extension element`,
+        message: `Element of type <${ node.$type }> must have one extension element of type ${ formatTypes(types, true) }`,
         path: getPath(node, parentNode)
       };
     }
@@ -415,8 +406,7 @@ module.exports.hasExtensionElementsOfTypes = function(types, exclusive = false)
  *   {
  *     type: 'zeebe:TaskDefinition',
  *     properties: {
- *       type: { required: true },
- *       retries: { required: true }
+ *       type: { required: true }
  *     }
  *   }
  * );
@@ -433,9 +423,7 @@ module.exports.hasExtensionElementOfType = function(type) {
 
     if (!extensionElement) {
       return {
-        message: `Element of type <${ node.$type }> must have <${getType(
-          type
-        )}> extension element`,
+        message: `Element of type <${ node.$type }> must have extension element of type <${ getType(type) }>`,
         path: getPath(node, parentNode),
         error: {
           type: ERROR_TYPES.EXTENSION_ELEMENT_REQUIRED,
@@ -552,7 +540,7 @@ module.exports.checkFlowNode = function(check) {
  *
  * @returns {Function}
  */
-module.exports.checkMessage = function(check) {
+function checkMessage(check) {
   return function(node, parentNode) {
     const results = checkProperties(node, {
       messageRef: {
@@ -570,7 +558,9 @@ module.exports.checkMessage = function(check) {
 
     return check(message);
   };
-};
+}
+
+module.exports.checkMessage = checkMessage;
 
 /**
  * @example
@@ -603,7 +593,41 @@ module.exports.checkLoopCharacteristics = function(check) {
   };
 };
 
-module.exports.hasErrorReference = checkError(() => true);
+module.exports.hasErrorReference = checkError(
+  (node) => {
+    const results = checkProperties(node, {
+      errorCode: {
+        required: true
+      }
+    });
+
+    if (results.length === 1) {
+      return results[ 0 ];
+    } else if (results.length > 1) {
+      return results;
+    }
+
+    return true;
+  }
+);
+
+module.exports.hasMessageReference = checkMessage(
+  (node) => {
+    const results = checkProperties(node, {
+      name: {
+        required: true
+      }
+    });
+
+    if (results.length === 1) {
+      return results[ 0 ];
+    } else if (results.length > 1) {
+      return results;
+    }
+
+    return true;
+  }
+);
 
 function translate(result, translations) {
   if (isString(result)) {

package/rules/utils/rule.js

@@ -13,6 +13,10 @@ const {
 
 const { toSemverMinor } = require('./engine-profile');
 
+const { ERROR_TYPES } = require('./element');
+
+const { getTypeString } = require('./type');
+
 /**
  * Factory function for rules. Returns a rule for a given execution platform,
  * execution platform version and an array of checks. Must be run on
@@ -23,6 +27,7 @@ const { toSemverMinor } = require('./engine-profile');
  * @param {string} ruleExecutionPlatform
  * @param {string} ruleExecutionPlatformVersion
  * @param {(Object|string)[]} checks
+ * @param {string} executionPlatformLabel
  *
  * @returns {Function}
  */
@@ -52,8 +57,26 @@ module.exports.createRule = function(ruleExecutionPlatform, ruleExecutionPlatfor
 
         const id = node.get('id') || '';
 
+        const label = getLabel(node);
+
         if (results === false) {
-          reporter.report(id, `Element of type <${ node.$type }> not supported by ${ executionPlatformLabel || ruleExecutionPlatform } ${ toSemverMinor(ruleExecutionPlatformVersion) }`);
+          const message = getMessage(node, ruleExecutionPlatform, ruleExecutionPlatformVersion, executionPlatformLabel);
+
+          let options = {
+            error: {
+              type: ERROR_TYPES.ELEMENT_TYPE,
+              element: node.$type
+            }
+          };
+
+          if (label) {
+            options = {
+              ...options,
+              label
+            };
+          }
+
+          reporter.report(id, message, options);
         } else {
           if (!isArray(results)) {
             results = [ results ];
@@ -69,9 +92,20 @@ module.exports.createRule = function(ruleExecutionPlatform, ruleExecutionPlatfor
               ...rest
             } = result;
 
-            message = addExecutionPlatform(message, executionPlatformLabel || ruleExecutionPlatform, toSemverMinor(ruleExecutionPlatformVersion));
+            message = addExecutionPlatform(message, executionPlatformLabel || `${ ruleExecutionPlatform } ${ toSemverMinor(ruleExecutionPlatformVersion) }`);
+
+            let options = {
+              ...rest
+            };
 
-            reporter.report(id, message, rest);
+            if (label) {
+              options = {
+                ...options,
+                label
+              };
+            }
+
+            reporter.report(id, message, options);
           });
         }
       }
@@ -106,7 +140,7 @@ function checkNode(node, checks) {
 
     // (1) check using type only
     if (isString(check)) {
-      return is(node, check);
+      return isExactly(node, check);
     }
 
     const { type } = check;
@@ -117,7 +151,7 @@ function checkNode(node, checks) {
     }
 
     // (3) check using type and function
-    if (!is(node, type)) {
+    if (!isExactly(node, type)) {
       return false;
     }
 
@@ -209,10 +243,9 @@ function replaceChecks(checks, replacements) {
 
 module.exports.replaceChecks = replaceChecks;
 
-function addExecutionPlatform(string, executionPlatform, executionPlatformVersion) {
+function addExecutionPlatform(string, executionPlatform) {
   return string
-    .replace('{{ executionPlatform }}', executionPlatform)
-    .replace('{{ executionPlatformVersion }}', executionPlatformVersion);
+    .replace('{{ executionPlatform }}', executionPlatform);
 }
 
 /**
@@ -248,4 +281,44 @@ function getErrors(results) {
   }
 
   return false;
+}
+
+function isExactly(node, type) {
+  const { $model } = node;
+
+  return $model.getType(node.$type) === $model.getType(type);
+}
+
+function getIndefiniteArticle(type) {
+  if ([
+    'Error',
+    'Escalation',
+    'Event',
+    'Intermediate',
+    'Undefined'
+  ].includes(type.split(' ')[ 0 ])) {
+    return 'An';
+  }
+
+  return 'A';
+}
+
+function getMessage(node, executionPlatform, executionPlatformVersion, label) {
+  const type = getTypeString(node);
+
+  const indefiniteArticle = getIndefiniteArticle(type);
+
+  return addExecutionPlatform(`${ indefiniteArticle } <${ type }> is not supported by {{ executionPlatform }}`, label || `${ executionPlatform } ${ toSemverMinor(executionPlatformVersion) }`);
+}
+
+function getLabel(node) {
+  if (is(node, 'bpmn:Group')) {
+    const categoryValueRef = node.get('categoryValueRef');
+
+    return categoryValueRef && categoryValueRef.get('value');
+  } else if (is(node, 'bpmn:TextAnnotation')) {
+    return node.get('text');
+  }
+
+  return node.get('name');
 }

package/rules/utils/type.js

@@ -0,0 +1,47 @@
+function getEventDefinition(node) {
+  const eventDefinitions = node.get('eventDefinitions');
+
+  return eventDefinitions && eventDefinitions[0];
+}
+
+function getEventDefinitionPrefix(eventDefinition) {
+  const localType = getLocalType(eventDefinition);
+
+  return localType.replace('EventDefinition', '');
+}
+
+function getLocalType(node) {
+  const { $descriptor } = node;
+
+  const { localName } = $descriptor.ns;
+
+  return localName;
+}
+
+function formatTypeString(string) {
+  return string.replace(/([a-z])([A-Z])/g, '$1 $2').trim();
+}
+
+module.exports.getTypeString = function(node) {
+  let type = getLocalType(node);
+
+  const eventDefinition = getEventDefinition(node);
+
+  if (eventDefinition) {
+    type = `${ getEventDefinitionPrefix(eventDefinition) }${ type }`;
+  } else if ([
+    'BoundaryEvent',
+    'EndEvent',
+    'IntermediateCatchEvent',
+    'IntermediateThrowEvent',
+    'StartEvent'
+  ].includes(type)) {
+    type = `Undefined ${ type }`;
+  }
+
+  if (type === 'Task') {
+    type = 'Undefined Task';
+  }
+
+  return formatTypeString(type);
+};