bpmnlint-plugin-camunda-compat 0.13.0 → 0.14.0

package/index.js

@@ -1,48 +1,56 @@
 const { omit } = require('min-dash');
 
-const calledDecisionOrTaskDefinitionConfig = require('./rules/called-decision-or-task-definition/config'),
-      elementTypeConfig = require('./rules/element-type/config'),
-      timerConfig = require('./rules/timer/config');
-
 const camundaCloud10Rules = {
-  'called-decision-or-task-definition': [ 'error', calledDecisionOrTaskDefinitionConfig.camundaCloud10 ],
+  'called-decision-or-task-definition': [ 'error', { version: '1.0' } ],
   'called-element': 'error',
+  'collapsed-subprocess': 'error',
   'duplicate-task-headers': 'error',
-  'element-type': [ 'error', elementTypeConfig.camundaCloud10 ],
+  'element-type': [ 'error', { version: '1.0' } ],
   'error-reference': 'error',
   'loop-characteristics': 'error',
   'message-reference': 'error',
   'no-template': 'error',
   'no-zeebe-properties': 'error',
   'subscription': 'error',
-  'timer': [ 'error', timerConfig.camundaCloud10 ],
-  'user-task-form': 'error'
+  'timer': [ 'error', { version: '1.0' } ],
+  'user-task-form': 'error',
+  'feel': 'error'
 };
 
 const camundaCloud11Rules = {
   ...camundaCloud10Rules,
-  'called-decision-or-task-definition': [ 'error', calledDecisionOrTaskDefinitionConfig.camundaCloud11 ],
-  'element-type': [ 'error', elementTypeConfig.camundaCloud11 ]
+  'called-decision-or-task-definition': [ 'error', { version: '1.1' } ],
+  'element-type': [ 'error', { version: '1.1' } ],
+  'timer': [ 'error', { version: '1.1' } ]
 };
 
 const camundaCloud12Rules = {
   ...camundaCloud11Rules,
-  'called-decision-or-task-definition': [ 'error', calledDecisionOrTaskDefinitionConfig.camundaCloud12 ],
-  'element-type': [ 'error', elementTypeConfig.camundaCloud12 ]
+  'called-decision-or-task-definition': [ 'error', { version: '1.2' } ],
+  'element-type': [ 'error', { version: '1.2' } ],
+  'timer': [ 'error', { version: '1.2' } ]
 };
 
 const camundaCloud13Rules = {
   ...camundaCloud12Rules,
-  'called-decision-or-task-definition': [ 'error', calledDecisionOrTaskDefinitionConfig.camundaCloud13 ]
+  'called-decision-or-task-definition': [ 'error', { version: '1.3' } ],
+  'element-type': [ 'error', { version: '1.3' } ],
+  'timer': [ 'error', { version: '1.3' } ]
 };
 
-const camundaCloud80Rules = omit(camundaCloud13Rules, 'no-template');
+const camundaCloud80Rules = {
+  ...omit(camundaCloud13Rules, 'no-template'),
+  'called-decision-or-task-definition': [ 'error', { version: '8.0' } ],
+  'element-type': [ 'error', { version: '8.0' } ],
+  'timer': [ 'error', { version: '8.0' } ]
+};
 
 const camundaCloud81Rules = {
   ...omit(camundaCloud80Rules, 'no-zeebe-properties'),
-  'element-type': [ 'error', elementTypeConfig.camundaCloud81 ],
+  'called-decision-or-task-definition': [ 'error', { version: '8.1' } ],
+  'element-type': [ 'error', { version: '8.1' } ],
   'inclusive-gateway': 'error',
-  'timer': [ 'error', timerConfig.camundaCloud81 ]
+  'timer': [ 'error', { version: '8.1' } ]
 };
 
 module.exports = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bpmnlint-plugin-camunda-compat",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "A bpmnlint plug-in for Camunda Platform compatibility",
   "main": "index.js",
   "scripts": {
@@ -36,9 +36,11 @@
     "zeebe-bpmn-moddle": "^0.14.0"
   },
   "dependencies": {
+    "@bpmn-io/feel-lint": "^0.1.0",
     "@bpmn-io/moddle-utils": "^0.1.0",
     "bpmnlint-utils": "^1.0.2",
-    "min-dash": "^3.8.1"
+    "min-dash": "^3.8.1",
+    "semver-compare": "^1.0.0"
   },
   "files": [
     "rules",

package/rules/called-decision-or-task-definition/config.js

@@ -1,33 +1,12 @@
-const camundaCloud10ElementsTaskDefinition = [
-  'bpmn:ServiceTask'
-];
-
-const camundaCloud11ElementsTaskDefinition = [
-  ...camundaCloud10ElementsTaskDefinition,
-  'bpmn:BusinessRuleTask',
-  'bpmn:ScriptTask',
-  'bpmn:SendTask'
-];
-
-const camundaCloud12ElementsTaskDefinition = [
-  ...camundaCloud11ElementsTaskDefinition,
-  'bpmn:IntermediateThrowEvent'
-];
-
 module.exports = {
-  camundaCloud10: {
-    elementsTaskDefinition: camundaCloud10ElementsTaskDefinition
+  calledDecision: {
+    'bpmn:BusinessRuleTask': '1.3'
   },
-  camundaCloud11: {
-    elementsTaskDefinition: camundaCloud11ElementsTaskDefinition
-  },
-  camundaCloud12: {
-    elementsTaskDefinition: camundaCloud12ElementsTaskDefinition
-  },
-  camundaCloud13: {
-    elementsCalledDecision: [
-      'bpmn:BusinessRuleTask'
-    ],
-    elementsTaskDefinition: camundaCloud12ElementsTaskDefinition
+  taskDefinition: {
+    'bpmn:BusinessRuleTask': '1.1',
+    'bpmn:IntermediateThrowEvent': '1.2',
+    'bpmn:ScriptTask': '1.1',
+    'bpmn:SendTask': '1.1',
+    'bpmn:ServiceTask': '1.0'
   }
 };

package/rules/called-decision-or-task-definition/index.js

@@ -1,10 +1,11 @@
-const {
-  is,
-  isAny
-} = require('bpmnlint-utils');
+const { is } = require('bpmnlint-utils');
 
 const { getPath } = require('@bpmn-io/moddle-utils');
 
+const config = require('./config');
+
+const { greaterOrEqual } = require('../utils/version');
+
 const {
   findExtensionElement,
   getEventDefinition,
@@ -16,14 +17,11 @@ const { reportErrors } = require('../utils/reporter');
 
 const { ERROR_TYPES } = require('../utils/error-types');
 
-module.exports = function(config) {
-  const {
-    elementsCalledDecision = [],
-    elementsTaskDefinition = []
-  } = config;
-
+module.exports = function({ version }) {
   function check(node, reporter) {
-    if (!isAny(node, elementsCalledDecision) && !isAny(node, elementsTaskDefinition)) {
+    if (
+      (!config.calledDecision[ node.$type ] || !greaterOrEqual(version, config.calledDecision[ node.$type ]))
+      && (!config.taskDefinition[ node.$type ] || !greaterOrEqual(version, config.taskDefinition[ node.$type ]))) {
       return;
     }
 
@@ -38,15 +36,20 @@ module.exports = function(config) {
 
     if (calledDecision && !taskDefinition) {
 
-      if (!isAny(node, elementsCalledDecision)) {
+      if (!isCalledDecisionAllowed(node, version)) {
+        const allowedVersion = config.calledDecision[ node.$type ] || null;
+
         reportErrors(node, reporter, {
-          message: 'Extension element of type <zeebe:CalledDecision> not allowed',
+          message: allowedVersion
+            ? `Extension element of type <zeebe:CalledDecision> only allowed by Camunda Platform ${ allowedVersion } or newer`
+            : 'Extension element of type <zeebe:CalledDecision> not allowed',
           path: getPath(calledDecision, node),
-          error: {
+          data: {
             type: ERROR_TYPES.EXTENSION_ELEMENT_NOT_ALLOWED,
             node,
             parentNode: null,
-            extensionElement: calledDecision
+            extensionElement: calledDecision,
+            allowedVersion
           }
         });
 
@@ -71,15 +74,20 @@ module.exports = function(config) {
 
     if (!calledDecision && taskDefinition) {
 
-      if (!isAny(node, elementsTaskDefinition)) {
+      if (!isTaskDefinitionAllowed(node, version)) {
+        const allowedVersion = config.taskDefinition[ node.$type ] || null;
+
         reportErrors(node, reporter, {
-          message: 'Extension element of type <zeebe:TaskDefinition> not allowed',
+          message: allowedVersion
+            ? `Extension element of type <zeebe:TaskDefinition> only allowed by Camunda Platform ${ allowedVersion } or newer`
+            : 'Extension element of type <zeebe:TaskDefinition> not allowed',
           path: getPath(taskDefinition, node),
-          error: {
+          data: {
             type: ERROR_TYPES.EXTENSION_ELEMENT_NOT_ALLOWED,
             node,
             parentNode: null,
-            extensionElement: taskDefinition
+            extensionElement: taskDefinition,
+            allowedVersion
           }
         });
 
@@ -97,12 +105,12 @@ module.exports = function(config) {
       }
     }
 
-    if (isAny(node, elementsCalledDecision) && isAny(node, elementsTaskDefinition)) {
+    if (isCalledDecisionAllowed(node, version) && isTaskDefinitionAllowed(node, version)) {
       errors = hasExtensionElement(node, [
         'zeebe:CalledDecision',
         'zeebe:TaskDefinition'
       ], node);
-    } else if (isAny(node, elementsCalledDecision)) {
+    } else if (isCalledDecisionAllowed(node, version)) {
       errors = hasExtensionElement(node, 'zeebe:CalledDecision', node);
     } else {
       errors = hasExtensionElement(node, 'zeebe:TaskDefinition', node);
@@ -118,4 +126,16 @@ module.exports = function(config) {
   return {
     check
   };
-};
+};
+
+function isCalledDecisionAllowed(node, version) {
+  const { calledDecision } = config;
+
+  return calledDecision[ node.$type ] && greaterOrEqual(version, calledDecision[ node.$type ]);
+}
+
+function isTaskDefinitionAllowed(node, version) {
+  const { taskDefinition } = config;
+
+  return taskDefinition[ node.$type ] && greaterOrEqual(version, taskDefinition[ node.$type ]);
+}

package/rules/collapsed-subprocess.js

@@ -0,0 +1,38 @@
+const { is } = require('bpmnlint-utils');
+
+const { ERROR_TYPES } = require('./utils/element');
+
+const { reportErrors } = require('./utils/reporter');
+
+module.exports = function() {
+  function check(di, reporter) {
+
+    if (!isCollapsedSubProcess(di)) {
+      return;
+    }
+
+    const node = di.bpmnElement;
+
+    const error = {
+      message: `A <${ node.$type }> must be expanded.`,
+      data: {
+        type: ERROR_TYPES.ELEMENT_COLLAPSED_NOT_ALLOWED,
+        node: node,
+        parentNode: null
+      }
+    };
+
+    reportErrors(node, reporter, error);
+  }
+
+  return {
+    check
+  };
+};
+
+
+function isCollapsedSubProcess(di) {
+  return is(di, 'bpmndi:BPMNShape') &&
+         is(di.bpmnElement, 'bpmn:SubProcess') &&
+         di.get('isExpanded') === false;
+}

package/rules/element-type/config.js

@@ -1,125 +1,49 @@
-const camundaCloud10Elements = [
-  'bpmn:Association',
-  'bpmn:BoundaryEvent',
-  'bpmn:CallActivity',
-  'bpmn:Collaboration',
-  'bpmn:Definitions',
-  'bpmn:EndEvent',
-  'bpmn:EventBasedGateway',
-  'bpmn:ExclusiveGateway',
-  'bpmn:Group',
-  'bpmn:IntermediateCatchEvent',
-  'bpmn:MessageFlow',
-  'bpmn:ParallelGateway',
-  'bpmn:Participant',
-  'bpmn:Process',
-  'bpmn:ReceiveTask',
-  'bpmn:SequenceFlow',
-  'bpmn:ServiceTask',
-  'bpmn:StartEvent',
-  'bpmn:SubProcess',
-  'bpmn:TextAnnotation',
-  'bpmn:UserTask'
-];
-
-const camundaCloud11Elements = [
-  ...camundaCloud10Elements,
-  'bpmn:BusinessRuleTask',
-  'bpmn:IntermediateThrowEvent',
-  'bpmn:ManualTask',
-  'bpmn:ScriptTask',
-  'bpmn:SendTask'
-];
-
-const camundaCloud12Elements = [
-  ...camundaCloud11Elements
-];
-
-const camundaCloud81Elements = [
-  ...camundaCloud12Elements,
-  'bpmn:InclusiveGateway'
-];
-
-const camundaCloud10ElementsNoEventDefinitionRequired = [
-  'bpmn:EndEvent',
-  'bpmn:StartEvent'
-];
-
-const camundaCloud11ElementsNoEventDefinitionRequired = [
-  ...camundaCloud10ElementsNoEventDefinitionRequired,
-  'bpmn:IntermediateThrowEvent'
-];
-
-const camundaCloud12ElementsNoEventDefinitionRequired = [
-  ...camundaCloud11ElementsNoEventDefinitionRequired
-];
-
-const camundaCloud81ElementsNoEventDefinitionRequired = [
-  ...camundaCloud12ElementsNoEventDefinitionRequired
-];
-
-const camundaCloud10EventDefinitions = {
-  'bpmn:BoundaryEvent': [
-    'bpmn:ErrorEventDefinition',
-    'bpmn:MessageEventDefinition',
-    'bpmn:TimerEventDefinition'
-  ],
-  'bpmn:EndEvent': [
-    'bpmn:ErrorEventDefinition'
-  ],
-  'bpmn:IntermediateCatchEvent': [
-    'bpmn:MessageEventDefinition',
-    'bpmn:TimerEventDefinition'
-  ],
-  'bpmn:StartEvent': [
-    'bpmn:ErrorEventDefinition',
-    'bpmn:MessageEventDefinition',
-    'bpmn:TimerEventDefinition'
-  ]
-};
-
-const camundaCloud11EventDefinitions = {
-  ...camundaCloud10EventDefinitions
-};
-
-const camundaCloud12EventDefinitions = {
-  ...camundaCloud11EventDefinitions,
-  'bpmn:EndEvent': [
-    ...camundaCloud11EventDefinitions['bpmn:EndEvent'],
-    'bpmn:MessageEventDefinition'
-  ],
-  'bpmn:IntermediateThrowEvent': [
-    'bpmn:MessageEventDefinition'
-  ]
-};
-
-const camundaCloud81EventDefinitions = {
-  ...camundaCloud12EventDefinitions,
-  'bpmn:EndEvent': [
-    ...camundaCloud12EventDefinitions['bpmn:EndEvent'],
-    'bpmn:TerminateEventDefinition'
-  ]
-};
-
 module.exports = {
-  camundaCloud10: {
-    elements: camundaCloud10Elements,
-    elementsNoEventDefinitionRequired: camundaCloud10ElementsNoEventDefinitionRequired,
-    eventDefinitions: camundaCloud10EventDefinitions
+  'bpmn:Association': '1.0',
+  'bpmn:BoundaryEvent': {
+    'bpmn:ErrorEventDefinition': '1.0',
+    'bpmn:MessageEventDefinition': '1.0',
+    'bpmn:TimerEventDefinition': '1.0'
   },
-  camundaCloud11: {
-    elements: camundaCloud11Elements,
-    elementsNoEventDefinitionRequired: camundaCloud11ElementsNoEventDefinitionRequired,
-    eventDefinitions: camundaCloud11EventDefinitions
+  'bpmn:BusinessRuleTask': '1.1',
+  'bpmn:CallActivity': '1.0',
+  'bpmn:Collaboration': '1.0',
+  'bpmn:Definitions': '1.0',
+  'bpmn:EndEvent': {
+    '_': '1.0',
+    'bpmn:ErrorEventDefinition': '1.0',
+    'bpmn:MessageEventDefinition': '1.2',
+    'bpmn:TerminateEventDefinition': '8.1'
   },
-  camundaCloud12: {
-    elements: camundaCloud12Elements,
-    elementsNoEventDefinitionRequired: camundaCloud12ElementsNoEventDefinitionRequired,
-    eventDefinitions: camundaCloud12EventDefinitions
+  'bpmn:EventBasedGateway': '1.0',
+  'bpmn:ExclusiveGateway': '1.0',
+  'bpmn:Group': '1.0',
+  'bpmn:InclusiveGateway': '8.1',
+  'bpmn:IntermediateCatchEvent': {
+    'bpmn:MessageEventDefinition': '1.0',
+    'bpmn:TimerEventDefinition': '1.0'
   },
-  camundaCloud81: {
-    elements: camundaCloud81Elements,
-    elementsNoEventDefinitionRequired: camundaCloud81ElementsNoEventDefinitionRequired,
-    eventDefinitions: camundaCloud81EventDefinitions
-  }
+  'bpmn:IntermediateThrowEvent': {
+    '_': '1.1',
+    'bpmn:MessageEventDefinition': '1.2'
+  },
+  'bpmn:ManualTask': '1.1',
+  'bpmn:MessageFlow': '1.0',
+  'bpmn:ParallelGateway': '1.0',
+  'bpmn:Participant': '1.0',
+  'bpmn:Process': '1.0',
+  'bpmn:ReceiveTask': '1.0',
+  'bpmn:ScriptTask': '1.1',
+  'bpmn:SendTask': '1.1',
+  'bpmn:SequenceFlow': '1.0',
+  'bpmn:ServiceTask': '1.0',
+  'bpmn:StartEvent': {
+    '_': '1.0',
+    'bpmn:ErrorEventDefinition': '1.0',
+    'bpmn:MessageEventDefinition': '1.0',
+    'bpmn:TimerEventDefinition': '1.0'
+  },
+  'bpmn:SubProcess': '1.0',
+  'bpmn:TextAnnotation': '1.0',
+  'bpmn:UserTask': '1.0'
 };

package/rules/element-type/index.js

@@ -1,53 +1,40 @@
+const { isString } = require('min-dash');
+
 const { isAny } = require('bpmnlint-utils');
 
-const {
-  isAnyExactly,
-  getEventDefinition
-} = require('../utils/element');
+const config = require('./config');
+
+const { greaterOrEqual } = require('../utils/version');
+
+const { getEventDefinition } = require('../utils/element');
 
 const { ERROR_TYPES } = require('../utils/error-types');
 
 const { reportErrors } = require('../utils/reporter');
 
-module.exports = function(config) {
-  const {
-    elements,
-    elementsNoEventDefinitionRequired,
-    eventDefinitions
-  } = config;
-
+module.exports = function({ version }) {
   function check(node, reporter) {
     if (!isAny(node, [ 'bpmn:FlowElement', 'bpmn:FlowElementsContainer' ])) {
       return;
     }
 
-    if (!isAnyExactly(node, elements)) {
-      const error = {
-        message: `Element of type <${ node.$type }> not allowed`,
-        path: null,
-        error: {
-          type: ERROR_TYPES.ELEMENT_TYPE_NOT_ALLOWED,
-          node,
-          parentNode: null
-        }
-      };
+    const element = config[ node.$type ];
 
-      reportErrors(node, reporter, error);
+    if (!element || (isString(element) && !greaterOrEqual(version, element))) {
 
-      return;
-    }
-
-    const eventDefinition = getEventDefinition(node);
+      // (1) Element not allowed
+      const allowedVersion = element || null;
 
-    if (isAny(node, [ 'bpmn:CatchEvent', 'ThrowEvent' ]) && !eventDefinition && !elementsNoEventDefinitionRequired.includes(node.$type)) {
       const error = {
-        message: `Element of type <${ node.$type }> must have property <eventDefinitions>`,
-        path: [ 'eventDefinitions' ],
-        error: {
-          type: ERROR_TYPES.PROPERTY_REQUIRED,
+        message: allowedVersion
+          ? `Element of type <${ node.$type }> only allowed by Camunda Platform ${ allowedVersion } or newer`
+          : `Element of type <${ node.$type }> not allowed`,
+        path: null,
+        data: {
+          type: ERROR_TYPES.ELEMENT_TYPE_NOT_ALLOWED,
           node,
           parentNode: null,
-          requiredProperty: 'eventDefinitions'
+          allowedVersion
         }
       };
 
@@ -56,27 +43,56 @@ module.exports = function(config) {
       return;
     }
 
-    if (!eventDefinition) {
+    if (!isAny(node, [ 'bpmn:CatchEvent', 'bpmn:ThrowEvent' ])) {
       return;
     }
 
-    if (!eventDefinitions[ node.$type ] || !isAny(eventDefinition, eventDefinitions[ node.$type ])) {
-      const error = {
-        message: `Property of type <${ eventDefinition.$type }> not allowed`,
-        path: [
-          'eventDefinitions',
-          0
-        ],
-        error: {
-          type: ERROR_TYPES.PROPERTY_TYPE_NOT_ALLOWED,
-          node: node,
-          parentNode: null,
-          property: 'eventDefinitions',
-          requiredPropertyType: eventDefinitions[ node.$type ]
-        }
-      };
+    const eventDefinition = getEventDefinition(node);
 
-      reportErrors(node, reporter, error);
+    if (eventDefinition) {
+      if (!element[ eventDefinition.$type ] || !greaterOrEqual(version, element[ eventDefinition.$type ])) {
+
+        // (2) Element with event definition not allowed
+        const allowedVersion = element[ eventDefinition.$type ] || null;
+
+        const error = {
+          message: allowedVersion
+            ? `Element of type <${ node.$type }> with event definition of type <${ eventDefinition.$type }> only allowed by Camunda Platform ${ allowedVersion } or newer`
+            : `Element of type <${ node.$type }> with event definition of type <${ eventDefinition.$type }> not allowed`,
+          path: null,
+          data: {
+            type: ERROR_TYPES.ELEMENT_TYPE_NOT_ALLOWED,
+            node,
+            parentNode: null,
+            eventDefinition,
+            allowedVersion
+          }
+        };
+
+        reportErrors(node, reporter, error);
+      }
+    } else {
+      if (!element[ '_' ] || !greaterOrEqual(version, element[ '_' ])) {
+
+        // (3) Element without event definition not allowed
+        const allowedVersion = element[ '_' ] || null;
+
+        const error = {
+          message: allowedVersion
+            ? `Element of type <${ node.$type }> with no event definition only allowed by Camunda Platform ${ allowedVersion } or newer`
+            : `Element of type <${ node.$type }> with no event definition not allowed`,
+          path: null,
+          data: {
+            type: ERROR_TYPES.ELEMENT_TYPE_NOT_ALLOWED,
+            node,
+            parentNode: null,
+            eventDefinition,
+            allowedVersion
+          }
+        };
+
+        reportErrors(node, reporter, error);
+      }
     }
   }
 

package/rules/feel.js

@@ -0,0 +1,81 @@
+const { isString } = require('min-dash');
+
+const { is } = require('bpmnlint-utils');
+
+const { lintExpression } = require('@bpmn-io/feel-lint');
+
+const { getPath } = require('@bpmn-io/moddle-utils');
+
+const { reportErrors } = require('./utils/reporter');
+
+const { ERROR_TYPES } = require('./utils/error-types');
+
+module.exports = function() {
+  function check(node, reporter) {
+    if (is(node, 'bpmn:Expression')) {
+      return;
+    }
+
+    const parentNode = findFlowElement(node);
+
+    if (!parentNode) {
+      return;
+    }
+
+    const errors = [];
+
+    Object.entries(node).forEach(([ propertyName, propertyValue ]) => {
+      if (propertyValue && is(propertyValue, 'bpmn:Expression')) {
+        propertyValue = propertyValue.get('body');
+      }
+
+      if (isFeelProperty([ propertyName, propertyValue ])) {
+        const lintErrors = lintExpression(propertyValue.substring(1));
+
+        // syntax error
+        if (lintErrors.find(({ type }) => type === 'syntaxError')) {
+          const path = getPath(node, parentNode);
+
+          errors.push(
+            {
+              message: `Property <${ propertyName }> is not valid FEEL expression`,
+              path: path
+                ? [ ...path, propertyName ]
+                : [ propertyName ],
+              data: {
+                type: ERROR_TYPES.FEEL_EXPRESSION_INVALID,
+                node,
+                parentNode,
+                property: propertyName
+              }
+            }
+          );
+        }
+      }
+    });
+
+    if (errors && errors.length) {
+      reportErrors(parentNode, reporter, errors);
+    }
+  }
+
+  return {
+    check
+  };
+};
+
+const isFeelProperty = ([ propertyName, value ]) => {
+  return !isIgnoredProperty(propertyName) && isString(value) && value.startsWith('=');
+};
+
+const isIgnoredProperty = propertyName => {
+  return propertyName.startsWith('$');
+};
+
+const findFlowElement = node => {
+  while (node && !is(node, 'bpmn:FlowElement')) {
+    node = node.$parent;
+  }
+
+  return node;
+};

package/rules/inclusive-gateway.js

@@ -16,7 +16,7 @@ module.exports = function() {
       const error = {
         message: `Element of type <${ node.$type }> must have one property <incoming> of type <bpmn:SequenceFlow>`,
         path: [ 'incoming' ],
-        error: {
+        data: {
           type: ERROR_TYPES.PROPERTY_NOT_ALLOWED,
           node,
           parentNode: null,

package/rules/no-template.js

@@ -6,7 +6,8 @@ module.exports = function() {
   function check(node, reporter) {
     const errors = hasProperties(node, {
       modelerTemplate: {
-        allowed: false
+        allowed: false,
+        allowedVersion: '8.0'
       }
     }, node);
 

package/rules/no-zeebe-properties.js

@@ -10,7 +10,7 @@ module.exports = function() {
       return;
     }
 
-    const errors = hasNoExtensionElement(node, 'zeebe:Properties', node);
+    const errors = hasNoExtensionElement(node, 'zeebe:Properties', node, '8.1');
 
     if (errors && errors.length) {
       reportErrors(node, reporter, errors);

package/rules/timer/config.js

@@ -1,17 +1,4 @@
-const camundaCloud10Formats = [
-  'iso8601'
-];
-
-const camundaCloud81Formats = [
-  ...camundaCloud10Formats,
-  'cron'
-];
-
 module.exports = {
-  camundaCloud10: {
-    formats: camundaCloud10Formats
-  },
-  camundaCloud81: {
-    formats: camundaCloud81Formats
-  }
-};
+  'cron': '8.1',
+  'iso8601': '1.0'
+};

package/rules/timer/index.js

@@ -2,8 +2,13 @@ const {
   is
 } = require('bpmnlint-utils');
 
+const config = require('./config');
+
+const { greaterOrEqual } = require('../utils/version');
+
 const {
   getEventDefinition,
+  hasExpression,
   hasProperties,
   hasProperty
 } = require('../utils/element');
@@ -18,9 +23,7 @@ const {
 
 const { reportErrors } = require('../utils/reporter');
 
-module.exports = function(config = {}) {
-  const { formats = [] } = config;
-
+module.exports = function({ version }) {
   function check(node, reporter) {
     if (!is(node, 'bpmn:Event')) {
       return;
@@ -40,17 +43,7 @@ module.exports = function(config = {}) {
       return;
     }
 
-    const timeProperty = getTimeProperty(eventDefinition);
-
-    errors = checkTimePropertyNotEmpty(timeProperty, node);
-
-    if (errors && errors.length) {
-      reportErrors(node, reporter, errors);
-
-      return;
-    }
-
-    errors = checkTimePropertyCorrectFormat(eventDefinition, node, formats);
+    errors = checkTimeProperty(eventDefinition, node, version);
 
     if (errors && errors.length) {
       reportErrors(node, reporter, errors);
@@ -78,36 +71,22 @@ function checkTimePropertyExists(eventDefinition, event) {
   return [];
 }
 
-function checkTimePropertyNotEmpty(timeProperty, event) {
-  return hasProperties(timeProperty, {
-    body: {
-      required: true,
-    }
-  }, event);
-}
-
-function checkTimePropertyCorrectFormat(eventDefinition, event, formats) {
+function checkTimeProperty(eventDefinition, event, version) {
   const timeCycle = eventDefinition.get('timeCycle'),
         timeDate = eventDefinition.get('timeDate'),
         timeDuration = eventDefinition.get('timeDuration');
 
   if (timeCycle) {
-    return hasProperties(timeCycle, {
-      body: {
-        allowed: cycle => validateCycle(cycle, formats)
-      }
+    return hasExpression(eventDefinition, 'timeCycle', {
+      allowed: cycle => validateCycle(cycle, version)
     }, event);
   } else if (timeDate) {
-    return hasProperties(timeDate, {
-      body: {
-        allowed: date => validateDate(date, formats)
-      }
+    return hasExpression(eventDefinition, 'timeDate', {
+      allowed: date => validateDate(date, version)
     }, event);
   } else if (timeDuration) {
-    return hasProperties(timeDuration, {
-      body: {
-        allowed: duration => validateDuration(duration, formats)
-      }
+    return hasExpression(eventDefinition, 'timeDuration', {
+      allowed: duration => validateDuration(duration, version)
     }, event);
   }
 }
@@ -115,45 +94,41 @@ function checkTimePropertyCorrectFormat(eventDefinition, event, formats) {
 
 
 // helper //////////////
-function getTimeProperty(eventDefinition) {
-  return eventDefinition.get('timeCycle') || eventDefinition.get('timeDate') || eventDefinition.get('timeDuration');
-}
-
 function isInterruptingBoundaryEvent(event) {
   return is(event, 'bpmn:BoundaryEvent') && event.get('cancelActivity') !== false;
 }
 
-function validateDate(date, formats) {
+function validateDate(date, version) {
   if (validateExpression(date)) {
     return true;
   }
 
-  if (formats.includes('iso8601') && validateISO8601Date(date)) {
-    return true;
+  if (validateISO8601Date(date)) {
+    return greaterOrEqual(version, config.iso8601);
   }
 }
 
-function validateCycle(cycle, formats) {
+function validateCycle(cycle, version) {
   if (validateExpression(cycle)) {
     return true;
   }
 
-  if (formats.includes('iso8601') && validateISO8601Cycle(cycle)) {
-    return true;
+  if (validateISO8601Cycle(cycle)) {
+    return greaterOrEqual(version, config.iso8601);
   }
 
-  if (formats.includes('cron') && validateCronExpression(cycle)) {
-    return true;
+  if (validateCronExpression(cycle)) {
+    return greaterOrEqual(version, config.cron) || { allowedVersion: config.cron };
   }
 }
 
-function validateDuration(duration, formats) {
+function validateDuration(duration, version) {
   if (validateExpression(duration)) {
     return true;
   }
 
-  if (formats.includes('iso8601') && validateISO8601Duration(duration)) {
-    return true;
+  if (validateISO8601Duration(duration)) {
+    return greaterOrEqual(version, config.iso8601);
   }
 }
 

package/rules/utils/element.js

@@ -3,6 +3,7 @@ const {
   isDefined,
   isFunction,
   isNil,
+  isObject,
   some
 } = require('min-dash');
 
@@ -114,7 +115,7 @@ module.exports.hasDuplicatedPropertyValues = function(node, propertiesName, prop
       return {
         message: `Properties of type <${ duplicateProperties[ 0 ].$type }> have property <${ propertyName }> with duplicate value of <${ duplicate }>`,
         path: null,
-        error: {
+        data: {
           type: ERROR_TYPES.PROPERTY_VALUE_DUPLICATED,
           node,
           parentNode: parentNode == node ? null : parentNode,
@@ -134,6 +135,8 @@ module.exports.hasProperties = function(node, properties, parentNode = null) {
   return Object.entries(properties).reduce((results, property) => {
     const [ propertyName, propertyChecks ] = property;
 
+    const { allowedVersion = null } = propertyChecks;
+
     const path = getPath(node, parentNode);
 
     const propertyValue = node.get(propertyName);
@@ -146,7 +149,7 @@ module.exports.hasProperties = function(node, properties, parentNode = null) {
           path: path
             ? [ ...path, propertyName ]
             : [ propertyName ],
-          error: {
+          data: {
             type: ERROR_TYPES.PROPERTY_REQUIRED,
             node,
             parentNode: parentNode == node ? null : parentNode,
@@ -167,7 +170,7 @@ module.exports.hasProperties = function(node, properties, parentNode = null) {
             path: path
               ? [ ...path, propertyName ]
               : [ propertyName ],
-            error: {
+            data: {
               type: ERROR_TYPES.PROPERTY_DEPENDEND_REQUIRED,
               node,
               parentNode: parentNode == node ? null : parentNode,
@@ -191,16 +194,19 @@ module.exports.hasProperties = function(node, properties, parentNode = null) {
       return [
         ...results,
         {
-          message: `Element of type <${ node.$type }> must not have property <${ propertyName }> of type <${ propertyValue.$type }>`,
+          message: allowedVersion
+            ? `Property <${ propertyName }> of type <${ propertyValue.$type }> only allowed by Camunda Platform ${ allowedVersion } or newer`
+            : `Property <${ propertyName }> of type <${ propertyValue.$type }> not allowed`,
           path: path
             ? [ ...path, propertyName ]
             : [ propertyName ],
-          error: {
+          data: {
             type: ERROR_TYPES.PROPERTY_TYPE_NOT_ALLOWED,
             node,
             parentNode: parentNode == node ? null : parentNode,
             property: propertyName,
-            allowedPropertyType: propertyChecks.type
+            allowedPropertyType: propertyChecks.type,
+            allowedVersion
           }
         }
       ];
@@ -210,15 +216,18 @@ module.exports.hasProperties = function(node, properties, parentNode = null) {
       return [
         ...results,
         {
-          message: `Element of type <${ node.$type }> must not have property <${ propertyName }>`,
+          message: allowedVersion
+            ? `Property <${ propertyName }> only allowed by Camunda Platform ${ allowedVersion } or newer`
+            : `Property <${ propertyName }> not allowed`,
           path: path
             ? [ ...path, propertyName ]
             : [ propertyName ],
-          error: {
+          data: {
             type: ERROR_TYPES.PROPERTY_NOT_ALLOWED,
             node,
             parentNode: parentNode == node ? null : parentNode,
-            property: propertyName
+            property: propertyName,
+            allowedVersion
           }
         }
       ];
@@ -228,15 +237,18 @@ module.exports.hasProperties = function(node, properties, parentNode = null) {
       return [
         ...results,
         {
-          message: `Property <${ propertyName }> of element of type <${ node.$type }> must not have value of <${ truncate(propertyValue) }>`,
+          message: allowedVersion
+            ? `Property value of <${ truncate(propertyValue) }> only allowed by Camunda Platform ${ allowedVersion } or newer`
+            : `Property value of <${ truncate(propertyValue) }> not allowed`,
           path: path
             ? [ ...path, propertyName ]
             : [ propertyName ],
-          error: {
+          data: {
             type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
             node,
             parentNode: parentNode == node ? null : parentNode,
             property: propertyName,
+            allowedVersion
           }
         }
       ];
@@ -256,7 +268,7 @@ module.exports.hasProperty = function(node, types, parentNode = null) {
       {
         message: `Element of type <${ node.$type }> must have one property of type ${ formatTypes(typesArray, true) }`,
         path: getPath(node, parentNode),
-        error: {
+        data: {
           type: ERROR_TYPES.PROPERTY_REQUIRED,
           node,
           parentNode: parentNode == node ? null : parentNode,
@@ -290,7 +302,7 @@ module.exports.hasExtensionElement = function(node, types, parentNode = null) {
       {
         message: `Element of type <${ node.$type }> must have one extension element of type ${ formatTypes(typesArray, true) }`,
         path: getPath(node, parentNode),
-        error: {
+        data: {
           type: ERROR_TYPES.EXTENSION_ELEMENT_REQUIRED,
           node,
           parentNode: parentNode == node ? null : parentNode,
@@ -303,19 +315,85 @@ module.exports.hasExtensionElement = function(node, types, parentNode = null) {
   return [];
 };
 
-module.exports.hasNoExtensionElement = function(node, type, parentNode = null) {
+module.exports.hasNoExtensionElement = function(node, type, parentNode = null, allowedVersion = null) {
   const extensionElement = findExtensionElement(node, type);
 
   if (extensionElement) {
     return [
       {
-        message: `Element of type <${ node.$type }> must not have extension element of type <${ type }>`,
+        message: allowedVersion
+          ? `Extension element of type <${ type }> only allowed by Camunda Platform ${ allowedVersion }`
+          : `Extension element of type <${ type }> not allowed`,
         path: getPath(extensionElement, parentNode),
-        error: {
+        data: {
           type: ERROR_TYPES.EXTENSION_ELEMENT_NOT_ALLOWED,
           node,
           parentNode: parentNode == node ? null : parentNode,
-          extensionElement
+          extensionElement,
+          allowedVersion
+        }
+      }
+    ];
+  }
+
+  return [];
+};
+
+module.exports.hasExpression = function(node, propertyName, check, parentNode = null) {
+  const expression = node.get(propertyName);
+
+  if (!expression) {
+    throw new Error('Expression not found');
+  }
+
+  const body = expression.get('body');
+
+  const path = getPath(node, parentNode);
+
+  if (!body) {
+    if (check.required !== false) {
+      return [
+        {
+          message: `Property <${ propertyName }> must have expression value`,
+          path: path
+            ? [ ...path, propertyName ]
+            : null,
+          data: {
+            type: ERROR_TYPES.EXPRESSION_REQUIRED,
+            node: expression,
+            parentNode,
+            property: propertyName
+          }
+        }
+      ];
+    }
+
+    return [];
+  }
+
+  const allowed = check.allowed(body);
+
+  if (allowed !== true) {
+    let allowedVersion = null;
+
+    if (isObject(allowed)) {
+      ({ allowedVersion } = allowed);
+    }
+
+    return [
+      {
+        message: allowedVersion
+          ? `Expression value of <${ body }> only allowed by Camunda Platform ${ allowedVersion }`
+          : `Expression value of <${ body }> not allowed`,
+        path: path
+          ? [ ...path, propertyName ]
+          : null,
+        data: {
+          type: ERROR_TYPES.EXPRESSION_VALUE_NOT_ALLOWED,
+          node: expression,
+          parentNode,
+          property: propertyName,
+          allowedVersion
         }
       }
     ];

package/rules/utils/error-types.js

@@ -1,11 +1,15 @@
 module.exports.ERROR_TYPES = Object.freeze({
-  ELEMENT_TYPE_NOT_ALLOWED: 'elementTypeNotAllowed',
-  EXTENSION_ELEMENT_NOT_ALLOWED: 'extensionElementNotAllowed',
-  EXTENSION_ELEMENT_REQUIRED: 'extensionElementRequired',
-  PROPERTY_DEPENDEND_REQUIRED: 'propertyDependendRequired',
-  PROPERTY_NOT_ALLOWED: 'propertyNotAllowed',
-  PROPERTY_REQUIRED: 'propertyRequired',
-  PROPERTY_TYPE_NOT_ALLOWED: 'propertyTypeNotAllowed',
-  PROPERTY_VALUE_DUPLICATED: 'propertyValueDuplicated',
-  PROPERTY_VALUE_NOT_ALLOWED: 'propertyValueNotAllowed',
+  ELEMENT_COLLAPSED_NOT_ALLOWED: 'camunda.elementCollapsedNotAllowed',
+  ELEMENT_TYPE_NOT_ALLOWED: 'camunda.elementTypeNotAllowed',
+  EXPRESSION_REQUIRED: 'camunda.expressionRequired',
+  EXPRESSION_VALUE_NOT_ALLOWED: 'camunda.expressionValueNotAllowed',
+  EXTENSION_ELEMENT_NOT_ALLOWED: 'camunda.extensionElementNotAllowed',
+  EXTENSION_ELEMENT_REQUIRED: 'camunda.extensionElementRequired',
+  FEEL_EXPRESSION_INVALID: 'camunda.feelExpressionInvalid',
+  PROPERTY_DEPENDEND_REQUIRED: 'camunda.propertyDependendRequired',
+  PROPERTY_NOT_ALLOWED: 'camunda.propertyNotAllowed',
+  PROPERTY_REQUIRED: 'camunda.propertyRequired',
+  PROPERTY_TYPE_NOT_ALLOWED: 'camunda.propertyTypeNotAllowed',
+  PROPERTY_VALUE_DUPLICATED: 'camunda.propertyValueDuplicated',
+  PROPERTY_VALUE_NOT_ALLOWED: 'camunda.propertyValueNotAllowed'
 });

package/rules/utils/iso8601.js

@@ -1,4 +1,14 @@
-const ISO_DATE_REGEX = /^\d{4}(-\d\d){2}T(\d\d:){2}\d\d(Z|([+-]\d\d:\d\d)(\[\w+\/\w+\])?)?$/;
+const YEAR = '\\d{4}';
+const MONTH = '(?<month>0[1-9]|1[0-2])';
+const DAY = '(0[1-9]|[12][0-9]|3[01])';
+const DATE = `(?<date>${YEAR}-${MONTH}-${DAY})`;
+const HOUR = '(0[0-9]|1[0-9]|2[0-3])';
+const MINUTE = '[0-5][0-9]';
+const SECOND = '[0-5][0-9]';
+const ZONE_ID = '(\\[[^\\]]+\\])';
+const TIMEZONE = `(Z|([+-](0[0-9]|1[0-3]):[0-5][0-9]${ZONE_ID}?))`;
+
+const ISO_DATE_REGEX = new RegExp(`^${DATE}T${HOUR}:${MINUTE}:${SECOND}${TIMEZONE}$`);
 const ISO_DURATION = 'P(?!$)(\\d+(\\.\\d+)?[Yy])?(\\d+(\\.\\d+)?[Mm])?(\\d+(\\.\\d+)?[Dd])?(T(?!$)(\\d+(\\.\\d+)?[Hh])?(\\d+(\\.\\d+)?[Mm])?(\\d+(\\.\\d+)?[Ss])?)?$';
 const ISO_DURATION_REGEX = new RegExp(`^${ISO_DURATION}$`);
 const ISO_CYCLE = `R(-1|\\d+)?/${ISO_DURATION}`;
@@ -15,9 +25,27 @@ function validateCycle(value) {
 }
 
 function validateDate(value) {
-  return ISO_DATE_REGEX.test(value);
+  const result = ISO_DATE_REGEX.exec(value);
+
+  if (!result) {
+    return false;
+  }
+
+  return isDateValid(result);
 }
 
 function validateDuration(value) {
   return ISO_DURATION_REGEX.test(value);
 }
+
+function isDateValid(result) {
+  const {
+    date,
+    month
+  } = result.groups;
+
+  const dateParsedMonth = new Date(date).getMonth() + 1;
+  const parsedMonth = Number.parseInt(month, 10);
+
+  return dateParsedMonth === parsedMonth;
+}

package/rules/utils/version.js

@@ -0,0 +1,5 @@
+const cmp = require('semver-compare');
+
+module.exports.greaterOrEqual = function(a, b) {
+  return cmp(a, b) !== -1;
+};