@camunda/linting 0.8.0 → 0.9.1

package/lib/Linter.js

@@ -10,9 +10,11 @@ import { isString } from 'min-dash';
 import modelerModdle from 'modeler-moddle/resources/modeler.json';
 import zeebeModdle from 'zeebe-bpmn-moddle/resources/zeebe.json';
 
-import { getErrorMessage, getExecutionPlatformLabel } from './utils/error-messages';
+import { getErrorMessage } from './utils/error-messages';
 import { getEntryIds } from './utils/properties-panel';
 
+import { toSemverMinor } from './utils/version';
+
 const moddle = new BpmnModdle({
   modeler: modelerModdle,
   zeebe: zeebeModdle
@@ -68,7 +70,8 @@ export class Linter {
             ...report,
             message: getErrorMessage(
               report,
-              getExecutionPlatformLabel(executionPlatform, toSemverMinor(executionPlatformVersion)),
+              executionPlatform,
+              executionPlatformVersion,
               this._modeler
             ),
             propertiesPanel: {
@@ -132,10 +135,6 @@ function toLowerCase(string) {
   return string.toLowerCase();
 }
 
-function toSemverMinor(executionPlatformVersion) {
-  return executionPlatformVersion.split('.').slice(0, 2).join('.');
-}
-
 async function createCache(configName) {
   let config = require('bpmnlint-plugin-camunda-compat').configs[ configName ];
 

package/lib/utils/error-messages.js

@@ -1,6 +1,7 @@
 import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/element';
 
 import { is } from 'bpmnlint-utils';
+
 import {
   every,
   isArray
@@ -8,30 +9,78 @@ import {
 
 import { getTypeString } from './types';
 
+import { toSemverMinor } from './version';
+
 const TIMER_PROPERTIES = [
+  'timeCycle',
   'timeDate',
-  'timeDuration',
-  'timeCycle'
+  'timeDuration'
 ];
 
-export function getErrorMessage(report, executionPlatformLabel, modeler = 'desktop') {
+const executionPlatformLabels = {
+  'Camunda Cloud': {
+    'default': 'Camunda',
+    '1.0': 'Camunda 8 (Zeebe 1.0)',
+    '1.1': 'Camunda 8 (Zeebe 1.1)',
+    '1.2': 'Camunda 8 (Zeebe 1.2)',
+    '1.3': 'Camunda 8 (Zeebe 1.3)'
+  }
+};
+
+export function getExecutionPlatformLabel(executionPlatform, executionPlatformVersion) {
+  const executionPlatformLabel = executionPlatformLabels[ executionPlatform ]
+    && executionPlatformLabels[ executionPlatform ][ toSemverMinor(executionPlatformVersion) ];
+
+  if (executionPlatformLabel) {
+    return executionPlatformLabel;
+  }
+
+  if (executionPlatformLabels[ executionPlatform ]
+    && executionPlatformLabels[ executionPlatform ][ 'default' ]) {
+    executionPlatform = executionPlatformLabels[ executionPlatform ][ 'default' ];
+  }
+
+  return `${ executionPlatform } ${ toSemverMinor(executionPlatformVersion) }`;
+}
+
+function getIndefiniteArticle(type) {
+  if ([
+    'Ad',
+    'Error',
+    'Escalation',
+    'Event',
+    'Inclusive',
+    'Intermediate',
+    'Undefined'
+  ].includes(type.split(' ')[ 0 ])) {
+    return 'An';
+  }
+
+  return 'A';
+}
+
+export function getErrorMessage(report, executionPlatform, executionPlatformVersion, modeler = 'desktop') {
   const {
-    error,
+    data,
     message
   } = report;
 
-  if (!error) {
+  if (!data) {
     return message;
   }
 
-  const { type } = error;
+  const { type } = data;
+
+  if (type === ERROR_TYPES.ELEMENT_COLLAPSED_NOT_ALLOWED) {
+    return getElementCollapsedNotAllowedErrorMessage(report);
+  }
 
   if (type === ERROR_TYPES.ELEMENT_TYPE_NOT_ALLOWED) {
-    return getElementTypeNotAllowedErrorMessage(report, executionPlatformLabel);
+    return getElementTypeNotAllowedErrorMessage(report, executionPlatform, executionPlatformVersion);
   }
 
   if (type === ERROR_TYPES.EXTENSION_ELEMENT_NOT_ALLOWED) {
-    return getExtensionElementNotAllowedErrorMessage(report, executionPlatformLabel);
+    return getExtensionElementNotAllowedErrorMessage(report, executionPlatform, executionPlatformVersion);
   }
 
   if (type === ERROR_TYPES.EXTENSION_ELEMENT_REQUIRED) {
@@ -43,80 +92,61 @@ export function getErrorMessage(report, executionPlatformLabel, modeler = 'deskt
   }
 
   if (type === ERROR_TYPES.PROPERTY_NOT_ALLOWED) {
-    return getPropertyNotAllowedErrorMessage(report, executionPlatformLabel, modeler);
+    return getPropertyNotAllowedErrorMessage(report, executionPlatform, executionPlatformVersion, modeler);
   }
 
   if (type === ERROR_TYPES.PROPERTY_REQUIRED) {
-    return getPropertyRequiredErrorMessage(report, executionPlatformLabel);
-  }
-
-  if (type === ERROR_TYPES.PROPERTY_TYPE_NOT_ALLOWED) {
-    return getPropertyTypeNotAllowedErrorMessage(report, executionPlatformLabel);
+    return getPropertyRequiredErrorMessage(report);
   }
 
   if (type === ERROR_TYPES.PROPERTY_VALUE_DUPLICATED) {
     return getPropertyValueDuplicatedErrorMessage(report);
   }
 
-  if (type === ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED) {
-    return getPropertyValueNotAllowedErrorMessage(report, executionPlatformLabel);
+  if (type === ERROR_TYPES.EXPRESSION_REQUIRED) {
+    return getExpressionRequiredErrorMessage(report);
   }
 
-  return message;
-}
-
-const executionPlatformLabels = {
-  'Camunda Cloud': {
-    'defaultPlatformName': 'Camunda',
-    '1.0': 'Camunda 8 (Zeebe 1.0)',
-    '1.1': 'Camunda 8 (Zeebe 1.1)',
-    '1.2': 'Camunda 8 (Zeebe 1.2)',
-    '1.3': 'Camunda 8 (Zeebe 1.3)'
+  if (type === ERROR_TYPES.EXPRESSION_VALUE_NOT_ALLOWED) {
+    return getExpressionValueNotAllowedErrorMessage(report);
   }
-};
 
-export function getExecutionPlatformLabel(executionPlatform, executionPlatformVersion) {
-  const translatedLabel = executionPlatformLabels[ executionPlatform ] && executionPlatformLabels[ executionPlatform ][ executionPlatformVersion ];
+  return message;
+}
 
-  if (translatedLabel) {
-    return translatedLabel;
-  }
+function getElementCollapsedNotAllowedErrorMessage(report) {
+  const {
+    data,
+    message
+  } = report;
 
-  if (executionPlatformLabels[executionPlatform] && executionPlatformLabels[executionPlatform]['defaultPlatformName']) {
-    executionPlatform = executionPlatformLabels[executionPlatform]['defaultPlatformName'];
-  }
+  const { node } = data;
 
-  return `${ executionPlatform } ${ executionPlatformVersion }`;
-}
+  const typeString = getTypeString(node);
 
-function getIndefiniteArticle(type) {
-  if ([
-    'Error',
-    'Escalation',
-    'Event',
-    'Inclusive',
-    'Intermediate',
-    'Undefined'
-  ].includes(type.split(' ')[ 0 ])) {
-    return 'An';
+  if (is(node, 'bpmn:SubProcess')) {
+    return `${ getIndefiniteArticle(typeString) } <${ typeString }> must be expanded`;
   }
 
-  return 'A';
+  return message;
 }
 
-function getElementTypeNotAllowedErrorMessage(report, executionPlatformLabel) {
-  const { error } = report;
+function getElementTypeNotAllowedErrorMessage(report, executionPlatform, executionPlatformVersion) {
+  const { data } = report;
 
-  const { node } = error;
+  const {
+    allowedVersion,
+    node
+  } = data;
 
   const typeString = getTypeString(node);
 
-  return `${ getIndefiniteArticle(typeString) } <${ typeString }> is not supported by ${ executionPlatformLabel }`;
+  return getSupportedMessage(`${ getIndefiniteArticle(typeString) } <${ typeString }>`, executionPlatform, executionPlatformVersion, allowedVersion);
 }
 
 function getPropertyValueDuplicatedErrorMessage(report) {
   const {
-    error,
+    data,
     message
   } = report;
 
@@ -125,7 +155,7 @@ function getPropertyValueDuplicatedErrorMessage(report) {
     parentNode,
     duplicatedPropertyValue,
     properties
-  } = error;
+  } = data;
 
   const typeString = getTypeString(parentNode || node);
 
@@ -136,26 +166,27 @@ function getPropertyValueDuplicatedErrorMessage(report) {
   return message;
 }
 
-function getExtensionElementNotAllowedErrorMessage(report, executionPlatformLabel) {
+function getExtensionElementNotAllowedErrorMessage(report, executionPlatform, executionPlatformVersion) {
   const {
-    error,
+    data,
     message
   } = report;
 
   const {
+    allowedVersion,
     node,
     parentNode,
     extensionElement
-  } = error;
+  } = data;
 
   const typeString = getTypeString(parentNode || node);
 
   if (is(node, 'bpmn:BusinessRuleTask') && is(extensionElement, 'zeebe:CalledDecision')) {
-    return `A <Business Rule Task> with <Implementation: DMN decision> is not supported by ${ executionPlatformLabel }`;
+    return getSupportedMessage('A <Business Rule Task> with <Implementation: DMN decision>', executionPlatform, executionPlatformVersion, allowedVersion);
   }
 
   if (is(extensionElement, 'zeebe:Properties')) {
-    return `${ getIndefiniteArticle(typeString) } <${ typeString }> with <Extension properties> is not supported by ${ executionPlatformLabel }`;
+    return getSupportedMessage(`${ getIndefiniteArticle(typeString) } <${ typeString }> with <Extension properties>`, executionPlatform, executionPlatformVersion, allowedVersion);
   }
 
   return message;
@@ -163,7 +194,7 @@ function getExtensionElementNotAllowedErrorMessage(report, executionPlatformLabe
 
 function getExtensionElementRequiredErrorMessage(report) {
   const {
-    error,
+    data,
     message
   } = report;
 
@@ -171,7 +202,7 @@ function getExtensionElementRequiredErrorMessage(report) {
     node,
     parentNode,
     requiredExtensionElement
-  } = error;
+  } = data;
 
   const typeString = getTypeString(parentNode || node);
 
@@ -200,7 +231,7 @@ function getExtensionElementRequiredErrorMessage(report) {
 
 function getPropertyDependendRequiredErrorMessage(report) {
   const {
-    error,
+    data,
     message
   } = report;
 
@@ -209,7 +240,7 @@ function getPropertyDependendRequiredErrorMessage(report) {
     parentNode,
     property,
     dependendRequiredProperty
-  } = error;
+  } = data;
 
   const typeString = getTypeString(parentNode || node);
 
@@ -224,39 +255,40 @@ function getPropertyDependendRequiredErrorMessage(report) {
   return message;
 }
 
-function getPropertyNotAllowedErrorMessage(report, executionPlatformLabel, modeler = 'desktop') {
+function getPropertyNotAllowedErrorMessage(report, executionPlatform, executionPlatformVersion, modeler = 'desktop') {
   const {
-    error,
+    data,
     message
   } = report;
 
   const {
+    allowedVersion,
     node,
     parentNode,
     property
-  } = error;
+  } = data;
 
   const typeString = getTypeString(parentNode || node);
 
   if (property === 'modelerTemplate') {
     if (modeler === 'desktop') {
-      return `${ getIndefiniteArticle(typeString) } <Template ${ typeString }> is not supported by ${ executionPlatformLabel }`;
+      return getSupportedMessage(`${ getIndefiniteArticle(typeString) } <Template ${ typeString }>`, executionPlatform, executionPlatformVersion, allowedVersion);
     } else if (modeler === 'web') {
-      return `${ getIndefiniteArticle(typeString) } <Connector ${ typeString }> is not supported by ${ executionPlatformLabel }`;
+      return getSupportedMessage(`${ getIndefiniteArticle(typeString) } <Connector ${ typeString }>`, executionPlatform, executionPlatformVersion, allowedVersion);
     }
   }
 
   if (is(node, 'bpmn:InclusiveGateway') && property === 'incoming') {
-    return `${ getIndefiniteArticle(typeString) } <${ typeString }> with more than one incoming <Sequence Flow> is not supported by ${ executionPlatformLabel }`;
+    return `${ getIndefiniteArticle(typeString) } <${ typeString }> with more than one incoming <Sequence Flow> is not supported by ${ getExecutionPlatformLabel(executionPlatform, executionPlatformVersion) }`;
   }
 
   return message;
 }
 
 
-function getPropertyRequiredErrorMessage(report, executionPlatformLabel) {
+function getPropertyRequiredErrorMessage(report) {
   const {
-    error,
+    data,
     message
   } = report;
 
@@ -264,7 +296,7 @@ function getPropertyRequiredErrorMessage(report, executionPlatformLabel) {
     node,
     parentNode,
     requiredProperty
-  } = error;
+  } = data;
 
   const typeString = getTypeString(parentNode || node);
 
@@ -288,10 +320,6 @@ function getPropertyRequiredErrorMessage(report, executionPlatformLabel) {
     return `${ getIndefiniteArticle(typeString) } <${ typeString }> with <Error Reference> must have a defined <Error code>`;
   }
 
-  if (is(node, 'bpmn:Event') && requiredProperty === 'eventDefinitions') {
-    return `${ getIndefiniteArticle(typeString) } <${ typeString }> is not supported by ${ executionPlatformLabel }`;
-  }
-
   if (is(node, 'zeebe:LoopCharacteristics') && requiredProperty === 'inputCollection') {
     return `${ getIndefiniteArticle(typeString) } <${ typeString }> with <Multi-instance marker> must have a defined <Input collection>`;
   }
@@ -339,72 +367,57 @@ function getPropertyRequiredErrorMessage(report, executionPlatformLabel) {
     return `${ getIndefiniteArticle(typeString) } <${ typeString }> must have a defined <Timer duration>`;
   }
 
-  if (is(node, 'bpmn:FormalExpression')
-    && requiredProperty === 'body'
-    && TIMER_PROPERTIES.includes(secondLast(report.path))
-  ) {
-    return `${ getIndefiniteArticle(typeString) } <${ typeString }> must have a defined <Timer value>`;
-  }
-
   return message;
 }
 
-function getPropertyTypeNotAllowedErrorMessage(report, executionPlatformLabel) {
+function getExpressionRequiredErrorMessage(report) {
   const {
-    error,
-    message
+    data
   } = report;
 
   const {
     node,
     parentNode,
     property
-  } = error;
+  } = data;
 
   const typeString = getTypeString(parentNode || node);
 
-  if (is(node, 'bpmn:Event') && property === 'eventDefinitions') {
-    return `${ getIndefiniteArticle(typeString) } <${ typeString }> is not supported by ${ executionPlatformLabel }`;
+  if (is(node, 'bpmn:FormalExpression') && TIMER_PROPERTIES.includes(property)) {
+    return `${ getIndefiniteArticle(typeString) } <${ typeString }> must have a defined <Timer value>`;
   }
-
-  return message;
 }
 
-function getPropertyValueNotAllowedErrorMessage(report, executionPlatformLabel) {
+function getExpressionValueNotAllowedErrorMessage(report) {
   const {
-    error
+    data
   } = report;
 
   const {
     node,
     parentNode,
     property
-  } = error;
+  } = data;
 
   const typeString = getTypeString(parentNode || node);
 
-  if (is(node, 'bpmn:FormalExpression')
-    && property === 'body'
-    && secondLast(report.path) === 'timeCycle'
-  ) {
+  if (is(node, 'bpmn:FormalExpression') && property === 'timeCycle') {
     return `${ getIndefiniteArticle(typeString) } <${ typeString }> <Time cycle> should be an expression, an ISO 8601 repeating interval, or a cron expression (cron requires Camunda Platform 8.1 or newer)`;
   }
 
-  if (is(node, 'bpmn:FormalExpression')
-    && property === 'body'
-    && secondLast(report.path) === 'timeDate'
-  ) {
+  if (is(node, 'bpmn:FormalExpression') && property === 'timeDate') {
     return `${ getIndefiniteArticle(typeString) } <${ typeString }> <Time date> should be an expression, or an ISO 8601 date`;
   }
 
-  if (is(node, 'bpmn:FormalExpression')
-    && property === 'body'
-    && secondLast(report.path) === 'timeDuration'
-  ) {
+  if (is(node, 'bpmn:FormalExpression') && property === 'timeDuration') {
     return `${ getIndefiniteArticle(typeString) } <${ typeString }> <Time duration> should be an expression, or an ISO 8601 interval`;
   }
 }
 
-function secondLast(array) {
-  return array[array.length - 2];
-}
+function getSupportedMessage(prefix, executionPlatform, executionPlatformVersion, allowedVersion) {
+  if (allowedVersion) {
+    return `${ prefix } is only supported by ${ getExecutionPlatformLabel(executionPlatform, allowedVersion) } or newer`;
+  }
+
+  return `${ prefix } is not supported by ${ getExecutionPlatformLabel(executionPlatform, executionPlatformVersion) }`;
+}

package/lib/utils/properties-panel.js

@@ -46,80 +46,85 @@ export function getErrors(reports, element) {
 
 export function getEntryIds(report) {
   const {
-    error = {},
-    id
+    data = {},
+    id,
+    path
   } = report;
 
-  if (isExtensionElementRequiredError(error, 'zeebe:CalledDecision', 'bpmn:BusinessRuleTask')) {
+  if (isExtensionElementRequiredError(data, 'zeebe:CalledDecision', 'bpmn:BusinessRuleTask')) {
     return [ 'businessRuleImplementation' ];
   }
 
-  if (isPropertyRequiredError(error, 'errorRef')) {
+  if (isPropertyError(data, 'errorRef')) {
     return [ 'errorRef' ];
   }
 
-  if (isPropertyRequiredError(error, 'messageRef')) {
+  if (isPropertyError(data, 'messageRef')) {
     return [ 'messageRef' ];
   }
 
-  if (isPropertyRequiredError(error, 'decisionId', 'zeebe:CalledDecision')) {
+  if (isPropertyError(data, 'decisionId', 'zeebe:CalledDecision')) {
     return [ 'decisionId' ];
   }
 
-  if (isPropertyRequiredError(error, 'resultVariable', 'zeebe:CalledDecision')) {
+  if (isPropertyError(data, 'resultVariable', 'zeebe:CalledDecision')) {
     return [ 'resultVariable' ];
   }
 
-  if (isPropertyRequiredError(error, 'errorCode', 'bpmn:Error')) {
+  if (isPropertyError(data, 'errorCode', 'bpmn:Error')) {
     return [ 'errorCode' ];
   }
 
-  if (isPropertyRequiredError(error, 'name', 'bpmn:Message')) {
+  if (isPropertyError(data, 'name', 'bpmn:Message')) {
     return [ 'messageName' ];
   }
 
-  if (isExtensionElementRequiredError(error, 'zeebe:LoopCharacteristics', 'bpmn:MultiInstanceLoopCharacteristics')
-    || isPropertyRequiredError(error, 'inputCollection', 'zeebe:LoopCharacteristics')) {
+  if (isExtensionElementRequiredError(data, 'zeebe:LoopCharacteristics', 'bpmn:MultiInstanceLoopCharacteristics')
+    || isPropertyError(data, 'inputCollection', 'zeebe:LoopCharacteristics')) {
     return [ 'multiInstance-inputCollection' ];
   }
 
-  if (isPropertyDependendRequiredError(error, 'outputCollection', 'zeebe:LoopCharacteristics')) {
+  if (isPropertyDependendRequiredError(data, 'outputCollection', 'zeebe:LoopCharacteristics')) {
     return [ 'multiInstance-outputCollection' ];
   }
 
-  if (isPropertyDependendRequiredError(error, 'outputElement', 'zeebe:LoopCharacteristics')) {
+  if (isPropertyDependendRequiredError(data, 'outputElement', 'zeebe:LoopCharacteristics')) {
     return [ 'multiInstance-outputElement' ];
   }
 
-  if (isExtensionElementRequiredError(error, 'zeebe:CalledElement', 'bpmn:CallActivity')
-    || isPropertyRequiredError(error, 'processId', 'zeebe:CalledElement')) {
+  if (isExtensionElementRequiredError(data, 'zeebe:CalledElement', 'bpmn:CallActivity')
+    || isPropertyError(data, 'processId', 'zeebe:CalledElement')) {
     return [ 'targetProcessId' ];
   }
 
-  if (isExtensionElementRequiredError(error, 'zeebe:TaskDefinition')
-    || isPropertyRequiredError(error, 'type', 'zeebe:TaskDefinition')) {
+  if (isExtensionElementRequiredError(data, 'zeebe:TaskDefinition')
+    || isPropertyError(data, 'type', 'zeebe:TaskDefinition')) {
     return [ 'taskDefinitionType' ];
   }
 
-  if (isExtensionElementRequiredError(error, 'zeebe:Subscription')
-    || isPropertyRequiredError(error, 'correlationKey', 'zeebe:Subscription')) {
+  if (isPropertyError(data, 'retries', 'zeebe:TaskDefinition')) {
+    return [ 'taskDefinitionRetries' ];
+  }
+
+  if (isExtensionElementRequiredError(data, 'zeebe:Subscription')
+    || isPropertyError(data, 'correlationKey', 'zeebe:Subscription')) {
     return [ 'messageSubscriptionCorrelationKey' ];
   }
 
-  if (isPropertyRequiredError(error, 'formKey', 'zeebe:FormDefinition')) {
+  if (isPropertyError(data, 'formKey', 'zeebe:FormDefinition')) {
     return [ 'customFormKey' ];
   }
 
-  if (isPropertyRequiredError(error, 'body', 'zeebe:UserTaskForm')) {
+  if (isPropertyError(data, 'body', 'zeebe:UserTaskForm')) {
     return [ 'formConfiguration' ];
   }
 
-  if (isPropertyValueDuplicatedError(error, 'values', 'key', 'zeebe:TaskHeaders')) {
+  if (isPropertyValueDuplicatedError(data, 'values', 'key', 'zeebe:TaskHeaders')) {
     const {
       node,
       properties,
       propertiesName
-    } = error;
+    } = data;
 
     return properties.map(property => {
       const index = node.get(propertiesName).indexOf(property);
@@ -128,40 +133,76 @@ export function getEntryIds(report) {
     });
   }
 
-  if (isExtensionElementNotAllowedError(error, 'zeebe:Properties')) {
-    const { extensionElement } = error;
+  if (isExtensionElementNotAllowedError(data, 'zeebe:Properties')) {
+    const { extensionElement } = data;
 
     return extensionElement.get('zeebe:properties').map((zeebeProperty, index) => {
       return `${ id }-extensionProperty-${ index }-name`;
     });
   }
 
-  if (isPropertyRequiredError(error, 'conditionExpression', 'bpmn:SequenceFlow')) {
+  if (isPropertyError(data, 'conditionExpression', 'bpmn:SequenceFlow')) {
     return [ 'conditionExpression' ];
   }
 
-  if (isPropertyRequiredError(error, 'timeDuration', 'bpmn:TimerEventDefinition')) {
+  if (isPropertyError(data, 'timeDuration', 'bpmn:TimerEventDefinition')) {
     return [ 'timerEventDefinitionDurationValue' ];
   }
 
+  if (isPropertyError(data, 'completionCondition', 'bpmn:MultiInstanceLoopCharacteristics')) {
+    return [ 'multiInstance-completionCondition' ];
+  }
+
   if (TIMER_PROPERTIES.some(property =>
-    isOneOfPropertiesRequiredError(error, property , 'bpmn:TimerEventDefinition'))
+    isOneOfPropertiesRequiredError(data, property, 'bpmn:TimerEventDefinition'))
   ) {
     return [ 'timerEventDefinitionType' ];
   }
 
-  if (isPropertyRequiredError(error, 'body', 'bpmn:FormalExpression') && TIMER_PROPERTIES.includes(secondLast(report.path))) {
-    return hasOnlyDurationTimer(error.parentNode) ? [ 'timerEventDefinitionDurationValue' ] : [ 'timerEventDefinitionValue' ];
+  if (isExpressionRequiredError(data, 'timeCycle', 'bpmn:FormalExpression')
+    || isExpressionRequiredError(data, 'timeDate', 'bpmn:FormalExpression')
+    || isExpressionRequiredError(data, 'timeDuration', 'bpmn:FormalExpression')) {
+    return hasOnlyDurationTimer(data.parentNode) ? [ 'timerEventDefinitionDurationValue' ] : [ 'timerEventDefinitionValue' ];
   }
 
-  if (isPropertyValueNotAllowedError(error, 'body', 'bpmn:FormalExpression') && TIMER_PROPERTIES.includes(secondLast(report.path))) {
-    return hasOnlyDurationTimer(error.parentNode) ? [ 'timerEventDefinitionDurationValue' ] : [ 'timerEventDefinitionValue' ];
+  if (isExpressionValueNotAllowedError(data, 'timeCycle', 'bpmn:FormalExpression')
+    || isExpressionValueNotAllowedError(data, 'timeDate', 'bpmn:FormalExpression')
+    || isExpressionValueNotAllowedError(data, 'timeDuration', 'bpmn:FormalExpression')) {
+    return hasOnlyDurationTimer(data.parentNode) ? [ 'timerEventDefinitionDurationValue' ] : [ 'timerEventDefinitionValue' ];
+  }
+
+  const LIST_PROPERTIES = [
+    [ 'zeebe:Input', 'input' ],
+    [ 'zeebe:Output', 'output' ],
+    [ 'zeebe:Property', 'extensionProperty' ],
+    [ 'zeebe:Header', 'header' ]
+  ];
+
+  for (const [ type, prefix ] of LIST_PROPERTIES) {
+    if (hasType(data, type)
+        && getPropertyName(data)) {
+
+      const index = path[path.length - 2];
+
+      return [ `${ id }-${prefix}-${index}-${ getPropertyName(data) }` ];
+    }
+  }
+
+  if (hasType(data, 'zeebe:LoopCharacteristics')) {
+    return [ `multiInstance-${getPropertyName(data)}` ];
   }
 
   return [];
 }
 
 export function getErrorMessage(id, report) {
+  const { data } = report;
+
+  // do not override FEEL message
+  if (data.type === ERROR_TYPES.FEEL_EXPRESSION_INVALID) {
+    return;
+  }
+
   if (id === 'businessRuleImplementation') {
     return 'Implementation must be defined.';
   }
@@ -235,16 +276,16 @@ export function getErrorMessage(id, report) {
   }
 
   if (id === 'timerEventDefinitionDurationValue') {
-    return report.error.type === ERROR_TYPES.PROPERTY_REQUIRED ?
+    return data.type === ERROR_TYPES.EXPRESSION_REQUIRED ?
       'Duration must be defined.' : 'Must be an expression, or an ISO 8601 interval.';
   }
 
   if (id === 'timerEventDefinitionValue') {
-    if (report.error.type === ERROR_TYPES.PROPERTY_REQUIRED) {
+    if (data.type === ERROR_TYPES.EXPRESSION_REQUIRED) {
       return 'Value must be defined.';
     }
 
-    const property = secondLast(report.path);
+    const { property } = data;
 
     if (property === 'timeCycle') {
       return 'Must be an expression, an ISO 8601 repeating interval, or a cron expression (cron requires Camunda Platform 8.1 or newer).';
@@ -260,56 +301,68 @@ export function getErrorMessage(id, report) {
   }
 }
 
-function isExtensionElementNotAllowedError(error, extensionElement, type) {
-  return error.type === ERROR_TYPES.EXTENSION_ELEMENT_NOT_ALLOWED
-    && is(error.extensionElement, extensionElement)
-    && (!type || is(error.node, type));
+function isExtensionElementNotAllowedError(data, extensionElement, type) {
+  return data.type === ERROR_TYPES.EXTENSION_ELEMENT_NOT_ALLOWED
+    && is(data.extensionElement, extensionElement)
+    && (!type || is(data.node, type));
 }
 
-function isExtensionElementRequiredError(error, requiredExtensionElement, type) {
-  return error.type === ERROR_TYPES.EXTENSION_ELEMENT_REQUIRED
-    && (isArray(error.requiredExtensionElement) && error.requiredExtensionElement.includes(requiredExtensionElement)
-      || error.requiredExtensionElement === requiredExtensionElement)
-    && (!type || is(error.node, type));
+function isExtensionElementRequiredError(data, requiredExtensionElement, type) {
+  return data.type === ERROR_TYPES.EXTENSION_ELEMENT_REQUIRED
+    && (isArray(data.requiredExtensionElement) && data.requiredExtensionElement.includes(requiredExtensionElement)
+      || data.requiredExtensionElement === requiredExtensionElement)
+    && (!type || is(data.node, type));
 }
 
-function isPropertyDependendRequiredError(error, dependendRequiredProperty, type) {
-  return error.type === ERROR_TYPES.PROPERTY_DEPENDEND_REQUIRED
-    && error.dependendRequiredProperty === dependendRequiredProperty
-    && (!type || is(error.node, type));
+function isPropertyDependendRequiredError(data, dependendRequiredProperty, type) {
+  return data.type === ERROR_TYPES.PROPERTY_DEPENDEND_REQUIRED
+    && data.dependendRequiredProperty === dependendRequiredProperty
+    && (!type || is(data.node, type));
 }
 
-function isPropertyRequiredError(error, requiredProperty, type) {
-  return error.type === ERROR_TYPES.PROPERTY_REQUIRED
-    && (error.requiredProperty === requiredProperty)
-    && (!type || is(error.node, type));
+
+function isPropertyError(data, property, type) {
+  return getPropertyName(data) === property
+    && (!type || is(data.node, type));
 }
 
-function isOneOfPropertiesRequiredError(error, requiredProperty, type) {
-  return error.type === ERROR_TYPES.PROPERTY_REQUIRED
-    && (isArray(error.requiredProperty) && error.requiredProperty.includes(requiredProperty))
-    && (!type || is(error.node, type));
+function hasType(data, type) {
+  return data.node && is(data.node, type);
 }
 
-function isPropertyValueDuplicatedError(error, propertiesName, duplicatedProperty, type) {
-  return error.type === ERROR_TYPES.PROPERTY_VALUE_DUPLICATED
-    && error.propertiesName === propertiesName
-    && error.duplicatedProperty === duplicatedProperty
-    && (!type || is(error.node, type));
+function getPropertyName(data) {
+  const propertyKey = data.type === ERROR_TYPES.PROPERTY_REQUIRED ? 'requiredProperty' : 'property';
+
+  return data[ propertyKey ];
 }
 
-function isPropertyValueNotAllowedError(error, propertyName, type) {
-  return error.type === ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED
-    && error.property === propertyName
-    && (!type || is(error.node, type));
+function isOneOfPropertiesRequiredError(data, requiredProperty, type) {
+  return data.type === ERROR_TYPES.PROPERTY_REQUIRED
+    && (isArray(data.requiredProperty) && data.requiredProperty.includes(requiredProperty))
+    && (!type || is(data.node, type));
 }
 
-function getBusinessObject(element) {
-  return element.businessObject || element;
+function isPropertyValueDuplicatedError(data, propertiesName, duplicatedProperty, type) {
+  return data.type === ERROR_TYPES.PROPERTY_VALUE_DUPLICATED
+    && data.propertiesName === propertiesName
+    && data.duplicatedProperty === duplicatedProperty
+    && (!type || is(data.node, type));
 }
 
-function secondLast(array) {
-  return array[array.length - 2];
+function isExpressionRequiredError(data, propertyName, type) {
+  return data.type === ERROR_TYPES.EXPRESSION_REQUIRED
+    && data.property === propertyName
+    && (!type || is(data.node, type));
+}
+
+function isExpressionValueNotAllowedError(data, propertyName, type) {
+  return data.type === ERROR_TYPES.EXPRESSION_VALUE_NOT_ALLOWED
+    && data.property === propertyName
+    && (!type || is(data.node, type));
+}
+
+function getBusinessObject(element) {
+  return element.businessObject || element;
 }
 
 function hasOnlyDurationTimer(node) {

package/lib/utils/version.js

@@ -0,0 +1,3 @@
+export function toSemverMinor(executionPlatformVersion) {
+  return executionPlatformVersion.split('.').slice(0, 2).join('.');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camunda/linting",
-  "version": "0.8.0",
+  "version": "0.9.1",
   "description": "Linting for Camunda Platform",
   "main": "index.js",
   "scripts": {
@@ -27,7 +27,7 @@
   "dependencies": {
     "bpmn-moddle": "^7.1.3",
     "bpmnlint": "^8.0.0",
-    "bpmnlint-plugin-camunda-compat": "^0.13.1",
+    "bpmnlint-plugin-camunda-compat": "^0.14.1",
     "bpmnlint-utils": "^1.0.2",
     "min-dash": "^4.0.0",
     "min-dom": "^4.0.1",