bpmnlint-plugin-camunda-compat 0.17.0 → 0.19.0

package/README.md

@@ -2,28 +2,36 @@
 
 [![CI](https://github.com/camunda/bpmnlint-plugin-camunda-compat/workflows/CI/badge.svg)](https://github.com/camunda/bpmnlint-plugin-camunda-compat/actions?query=workflow%3ACI)
 
-Camunda BPMN compatibility provided as a [bpmnlint](https://github.com/bpmn-io/bpmnlint) plug-in.
+A [bpmnlint](https://github.com/bpmn-io/bpmnlint) plug-in that checks whether a given BPMN process can be executed with [Camunda](https://camunda.com/).
 
 
 ## Usage
 
-To configure the linter dynamically based on the [execution platform and version](https://github.com/camunda/modeler-moddle), use [`@camunda/linting`](https://github.com/camunda/linting).
+Add configuration corresponding to your execution platform and version to your [`.bpmnlintrc` configuration](https://github.com/bpmn-io/bpmnlint#configuration):
 
-To configure the linter statically, add the configuration corresponding to your execution platform and version to your `.bpmnlintrc` file:
-
-```
+```json
 {
   "extends": [
     "bpmnlint:recommended",
     "plugin:camunda-compat/camunda-cloud-8-0"
-  ]
+  ],
+  "rules": {
+    "camunda-compat/timer": "off"
+  }
 }
 ```
 
+Use [`@camunda/linting`](https://github.com/camunda/linting) to configure the linter dynamically based on the [execution platform and version](https://github.com/camunda/modeler-moddle).
+
+
 ## Resources
 
 * [Issues](https://github.com/camunda/bpmnlint-plugin-camunda-compat/issues)
-* BPMN coverage for [Camunda Cloud](https://docs.camunda.io/docs/reference/bpmn-processes/bpmn-coverage/) and [Camunda Platform](https://docs.camunda.org/manual/latest/reference/bpmn20/)
+
+
+## Related
+
+* BPMN coverage for [Camunda 8](https://docs.camunda.io/docs/reference/bpmn-processes/bpmn-coverage/) and [Camunda 7](https://docs.camunda.org/manual/latest/reference/bpmn20/)
 
 
 ## License

package/index.js

@@ -10,6 +10,7 @@ const camundaCloud10Rules = {
   'executable-process': 'error',
   'loop-characteristics': 'error',
   'message-reference': 'error',
+  'no-expression': [ 'error', { version: '1.0' } ],
   'no-template': 'error',
   'no-zeebe-properties': 'error',
   'sequence-flow-condition': 'error',
@@ -23,6 +24,7 @@ const camundaCloud11Rules = {
   ...camundaCloud10Rules,
   'implementation': [ 'error', { version: '1.1' } ],
   'element-type': [ 'error', { version: '1.1' } ],
+  'no-expression': [ 'error', { version: '1.1' } ],
   'timer': [ 'error', { version: '1.1' } ]
 };
 
@@ -30,6 +32,7 @@ const camundaCloud12Rules = {
   ...camundaCloud11Rules,
   'implementation': [ 'error', { version: '1.2' } ],
   'element-type': [ 'error', { version: '1.2' } ],
+  'no-expression': [ 'error', { version: '1.2' } ],
   'timer': [ 'error', { version: '1.2' } ]
 };
 
@@ -37,6 +40,7 @@ const camundaCloud13Rules = {
   ...camundaCloud12Rules,
   'implementation': [ 'error', { version: '1.3' } ],
   'element-type': [ 'error', { version: '1.3' } ],
+  'no-expression': [ 'error', { version: '1.3' } ],
   'timer': [ 'error', { version: '1.3' } ]
 };
 
@@ -44,6 +48,7 @@ const camundaCloud80Rules = {
   ...omit(camundaCloud13Rules, 'no-template'),
   'implementation': [ 'error', { version: '8.0' } ],
   'element-type': [ 'error', { version: '8.0' } ],
+  'no-expression': [ 'error', { version: '8.0' } ],
   'timer': [ 'error', { version: '8.0' } ]
 };
 
@@ -52,6 +57,7 @@ const camundaCloud81Rules = {
   'implementation': [ 'error', { version: '8.1' } ],
   'element-type': [ 'error', { version: '8.1' } ],
   'inclusive-gateway': 'error',
+  'no-expression': [ 'error', { version: '8.1' } ],
   'timer': [ 'error', { version: '8.1' } ]
 };
 
@@ -59,6 +65,7 @@ const camundaCloud82Rules = {
   ...camundaCloud81Rules,
   'implementation': [ 'error', { version: '8.2' } ],
   'element-type': [ 'error', { version: '8.2' } ],
+  'no-expression': [ 'error', { version: '8.2' } ],
   'timer': [ 'error', { version: '8.2' } ]
 };
 

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "bpmnlint-plugin-camunda-compat",
-  "version": "0.17.0",
+  "version": "0.19.0",
   "description": "A bpmnlint plug-in for Camunda Platform compatibility",
   "main": "index.js",
   "scripts": {
     "all": "npm run lint && npm test",
     "dev": "npm run test:watch",
     "lint": "eslint .",
-    "test": "mocha test/**/*.spec.js",
+    "test": "mocha 'test/**/*.spec.js'",
     "test:watch": "npm run test -- --watch"
   },
   "repository": {

package/rules/element-type/config.js

@@ -2,6 +2,7 @@ module.exports = {
   'bpmn:Association': '1.0',
   'bpmn:BoundaryEvent': {
     'bpmn:ErrorEventDefinition': '1.0',
+    'bpmn:EscalationEventDefinition': '8.2',
     'bpmn:MessageEventDefinition': '1.0',
     'bpmn:TimerEventDefinition': '1.0'
   },
@@ -15,6 +16,7 @@ module.exports = {
   'bpmn:EndEvent': {
     '_': '1.0',
     'bpmn:ErrorEventDefinition': '1.0',
+    'bpmn:EscalationEventDefinition': '8.2',
     'bpmn:MessageEventDefinition': '1.2',
     'bpmn:TerminateEventDefinition': '8.1'
   },
@@ -29,6 +31,7 @@ module.exports = {
   },
   'bpmn:IntermediateThrowEvent': {
     '_': '1.1',
+    'bpmn:EscalationEventDefinition': '8.2',
     'bpmn:MessageEventDefinition': '1.2',
     'bpmn:LinkEventDefinition': '8.2'
   },
@@ -45,6 +48,7 @@ module.exports = {
   'bpmn:StartEvent': {
     '_': '1.0',
     'bpmn:ErrorEventDefinition': '1.0',
+    'bpmn:EscalationEventDefinition': '8.2',
     'bpmn:MessageEventDefinition': '1.0',
     'bpmn:TimerEventDefinition': '1.0'
   },

package/rules/no-expression.js

@@ -0,0 +1,155 @@
+const {
+  is
+} = require('bpmnlint-utils');
+
+const { getPath } = require('@bpmn-io/moddle-utils');
+
+const {
+  ERROR_TYPES,
+  getEventDefinition
+} = require('./utils/element');
+
+const { reportErrors } = require('./utils/reporter');
+
+const handlersMap = {
+  '1.0': [
+    checkErrorCode
+  ],
+  '1.1': [
+    checkErrorCode
+  ],
+  '1.2': [
+    checkErrorCode
+  ],
+  '1.3': [
+    checkErrorCode
+  ],
+  '8.0': [
+    checkErrorCode
+  ],
+  '8.1': [
+    checkErrorCode
+  ],
+  '8.2': [
+    checkErrorCatchEvent,
+    checkEscalationCatchEvent
+  ]
+};
+
+module.exports = noExpressionRule;
+
+/**
+ * Make sure that certain properties do not contain expressions in older versions.
+ * @param {{ version: string }} config
+ */
+function noExpressionRule({ version }) {
+  function check(node, reporter) {
+    const errors = checkForVersion(node, version);
+
+    if (errors && errors.length) {
+      reportErrors(node, reporter, errors);
+    }
+  }
+
+  return {
+    check
+  };
+}
+
+function checkForVersion(node, version) {
+  const handlers = handlersMap[version];
+
+  return handlers.reduce((errors, handler) => {
+    const handlerErrors = handler(node) || [];
+    return errors.concat(handlerErrors);
+  }, []);
+}
+
+function noExpression(node, propertyName, parentNode, allowedVersion) {
+  const propertyValue = node.get(propertyName);
+  const path = getPath(node, parentNode);
+
+  if (!isExpression(propertyValue)) {
+    return;
+  }
+
+  const errorMessage = allowedVersion ?
+    `Expression statement <${truncate(propertyValue)}> only supported by Camunda Platform ${allowedVersion} or newer` :
+    `Expression statement <${truncate(propertyValue)}> not supported`;
+
+  return {
+    message: errorMessage,
+    path: path
+      ? [ ...path, propertyName ]
+      : [ propertyName ],
+    data: {
+      type: ERROR_TYPES.EXPRESSION_NOT_ALLOWED,
+      node,
+      parentNode: parentNode == node ? null : parentNode,
+      property: propertyName,
+      allowedVersion
+    }
+  };
+}
+
+function isExpression(value) {
+  return value && value.startsWith('=');
+}
+
+function checkErrorCode(node) {
+  if (!is(node, 'bpmn:Event')) {
+    return;
+  }
+
+  const eventDefinition = getEventDefinition(node);
+
+  if (!eventDefinition || !is(eventDefinition, 'bpmn:ErrorEventDefinition')) {
+    return;
+  }
+
+  const errorRef = eventDefinition.get('errorRef');
+
+  if (!errorRef) {
+    return;
+  }
+
+  if (is(node, 'bpmn:CatchEvent')) {
+    return noExpression(errorRef, 'errorCode', node, null);
+  } else {
+    return noExpression(errorRef, 'errorCode', node, '8.2');
+  }
+}
+
+function checkErrorCatchEvent(node) {
+  if (!is(node, 'bpmn:CatchEvent')) {
+    return;
+  }
+
+  return checkErrorCode(node);
+}
+
+function checkEscalationCatchEvent(node) {
+  if (!is(node, 'bpmn:CatchEvent')) {
+    return;
+  }
+
+  const eventDefinition = getEventDefinition(node);
+
+  if (!eventDefinition || !is(eventDefinition, 'bpmn:EscalationEventDefinition')) {
+    return;
+  }
+
+  const escalationRef = eventDefinition.get('escalationRef');
+
+  if (!escalationRef) {
+    return;
+  }
+
+  return noExpression(escalationRef, 'escalationCode', node, null);
+}
+
+function truncate(string, maxLength = 10) {
+  const stringified = `${ string }`;
+
+  return stringified.length > maxLength ? `${ stringified.slice(0, maxLength) }...` : stringified;
+}

package/rules/utils/error-types.js

@@ -1,6 +1,7 @@
 module.exports.ERROR_TYPES = Object.freeze({
   ELEMENT_COLLAPSED_NOT_ALLOWED: 'camunda.elementCollapsedNotAllowed',
   ELEMENT_TYPE_NOT_ALLOWED: 'camunda.elementTypeNotAllowed',
+  EXPRESSION_NOT_ALLOWED: 'camunda.expressionNotAllowed',
   EXPRESSION_REQUIRED: 'camunda.expressionRequired',
   EXPRESSION_VALUE_NOT_ALLOWED: 'camunda.expressionValueNotAllowed',
   EXTENSION_ELEMENT_NOT_ALLOWED: 'camunda.extensionElementNotAllowed',