bpmnlint-plugin-camunda-compat 0.6.1 → 0.7.1

package/CHANGELOG.md

@@ -6,6 +6,27 @@ All notable changes to [bpmnlint-plugin-camunda-compat](https://github.com/camun
 
 ___Note:__ Yet to be released changes appear here._
 
+## 0.7.1
+
+* `FIX`: lint subscription only if start event child of sub process ([#34](https://github.com/camunda/bpmnlint-plugin-camunda-compat/pull/34))
+
+## 0.7.0
+
+* `FEAT`: refactor plugin structure ([#29](https://github.com/camunda/bpmnlint-plugin-camunda-compat/pull/29))
+* `DEPS`: update to `bpmnlint@7.8.0` ([#29](https://github.com/camunda/bpmnlint-plugin-camunda-compat/pull/29))
+
+### Breaking Changes
+
+* configuration not selected based on execution platform and version anymore
+* error message not adjusted to be shown in Camunda Modeler anymore
+* error type ELEMENT_TYPE changed to ELEMENT_TYPE_NOT_ALLOWED
+* error type PROPERTY_TYPE changed to PROPERTY_TYPE_NOT_ALLOWED
+* error data changed (cf. docs/ERRORS.md)
+
+## 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))

package/index.js

@@ -1,43 +1,61 @@
+const hasCalledDecisionOrTaskDefinitionConfig = require('./rules/has-called-decision-or-task-definition/config'),
+      isElementConfig = require('./rules/is-element/config');
+
 module.exports = {
   configs: {
-    all: {
+    'camunda-cloud-1-0': {
       rules: {
-        'camunda-cloud-1-0': 'error',
-        'camunda-cloud-1-1': 'error',
-        'camunda-cloud-1-2': 'error',
-        'camunda-cloud-1-3': 'error',
-        'camunda-cloud-8-0': 'error',
-        'camunda-platform-7-15': 'error',
-        'camunda-platform-7-16': 'error',
-        'camunda-platform-7-17': 'error'
+        'has-called-decision-or-task-definition': [ 'error', hasCalledDecisionOrTaskDefinitionConfig.camundaCloud10 ],
+        'has-called-element': 'error',
+        'has-error-reference': 'error',
+        'has-loop-characteristics': 'error',
+        'has-message-reference': 'error',
+        'has-subscription': 'error',
+        'is-element': [ 'error', isElementConfig.camundaCloud10 ]
       }
     },
-    recommended: {
+    'camunda-cloud-1-1': {
       rules: {
-        'camunda-cloud-1-0': 'error',
-        'camunda-cloud-1-1': 'error',
-        'camunda-cloud-1-2': 'error',
-        'camunda-cloud-1-3': 'error',
-        'camunda-cloud-8-0': 'error',
-        'camunda-platform-7-15': 'error',
-        'camunda-platform-7-16': 'error',
-        'camunda-platform-7-17': 'error'
+        'has-called-decision-or-task-definition': [ 'error', hasCalledDecisionOrTaskDefinitionConfig.camundaCloud11 ],
+        'has-called-element': 'error',
+        'has-error-reference': 'error',
+        'has-loop-characteristics': 'error',
+        'has-message-reference': 'error',
+        'has-subscription': 'error',
+        'is-element': [ 'error', isElementConfig.camundaCloud11 ]
       }
     },
-    cloud: {
+    'camunda-cloud-1-2': {
       rules: {
-        'camunda-cloud-1-0': 'error',
-        'camunda-cloud-1-1': 'error',
-        'camunda-cloud-1-2': 'error',
-        'camunda-cloud-1-3': 'error',
-        'camunda-cloud-8-0': 'error'
+        'has-called-decision-or-task-definition': [ 'error', hasCalledDecisionOrTaskDefinitionConfig.camundaCloud12 ],
+        'has-called-element': 'error',
+        'has-error-reference': 'error',
+        'has-loop-characteristics': 'error',
+        'has-message-reference': 'error',
+        'has-subscription': 'error',
+        'is-element': [ 'error', isElementConfig.camundaCloud12 ]
       }
     },
-    platform: {
+    'camunda-cloud-1-3': {
       rules: {
-        'camunda-platform-7-15': 'error',
-        'camunda-platform-7-16': 'error',
-        'camunda-platform-7-17': 'error'
+        'has-called-decision-or-task-definition': [ 'error', hasCalledDecisionOrTaskDefinitionConfig.camundaCloud13 ],
+        'has-called-element': 'error',
+        'has-error-reference': 'error',
+        'has-loop-characteristics': 'error',
+        'has-message-reference': 'error',
+        'has-subscription': 'error',
+        'is-element': [ 'error', isElementConfig.camundaCloud12 ]
+      }
+    },
+    'camunda-cloud-8-0': {
+      rules: {
+        'has-called-decision-or-task-definition': [ 'error', hasCalledDecisionOrTaskDefinitionConfig.camundaCloud13 ],
+        'has-called-element': 'error',
+        'has-error-reference': 'error',
+        'has-loop-characteristics': 'error',
+        'has-message-reference': 'error',
+        'has-subscription': 'error',
+        'is-element': [ 'error', isElementConfig.camundaCloud12 ]
       }
     }
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bpmnlint-plugin-camunda-compat",
-  "version": "0.6.1",
-  "description": "A bpmnlint plug-in for Camunda Cloud and Platform compatibility",
+  "version": "0.7.1",
+  "description": "A bpmnlint plug-in for Camunda Platform compatibility",
   "main": "index.js",
   "scripts": {
     "all": "npm run lint && npm test",
@@ -24,7 +24,7 @@
   "license": "MIT",
   "devDependencies": {
     "bpmn-moddle": "^7.1.2",
-    "bpmnlint": "^7.6.0",
+    "bpmnlint": "^7.8.0",
     "camunda-bpmn-moddle": "^6.1.1",
     "chai": "^4.3.5",
     "eslint": "^7.32.0",

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

@@ -0,0 +1,36 @@
+module.exports = {
+  camundaCloud10: {
+    elementsTaskDefinition: [
+      'bpmn:ServiceTask'
+    ]
+  },
+  camundaCloud11: {
+    elementsTaskDefinition: [
+      'bpmn:BusinessRuleTask',
+      'bpmn:ServiceTask',
+      'bpmn:ScriptTask',
+      'bpmn:SendTask'
+    ]
+  },
+  camundaCloud12: {
+    elementsTaskDefinition: [
+      'bpmn:BusinessRuleTask',
+      'bpmn:IntermediateThrowEvent',
+      'bpmn:ServiceTask',
+      'bpmn:ScriptTask',
+      'bpmn:SendTask'
+    ]
+  },
+  camundaCloud13: {
+    elementsCalledDecision: [
+      'bpmn:BusinessRuleTask'
+    ],
+    elementsTaskDefinition: [
+      'bpmn:BusinessRuleTask',
+      'bpmn:IntermediateThrowEvent',
+      'bpmn:ServiceTask',
+      'bpmn:ScriptTask',
+      'bpmn:SendTask'
+    ]
+  }
+};

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

@@ -0,0 +1,122 @@
+const {
+  is,
+  isAny
+} = require('bpmnlint-utils');
+
+const { getPath } = require('@philippfromme/moddle-helpers');
+
+const {
+  findExtensionElement,
+  getEventDefinition,
+  hasProperties,
+  hasExtensionElementOfType,
+  hasExtensionElementsOfTypes
+} = require('../utils/element');
+
+const { reportErrors } = require('../utils/reporter');
+
+const { ERROR_TYPES } = require('../utils/error-types');
+
+module.exports = function(config) {
+  const {
+    elementsCalledDecision = [],
+    elementsTaskDefinition = []
+  } = config;
+
+  function check(node, reporter) {
+    if (!isAny(node, elementsCalledDecision) && !isAny(node, elementsTaskDefinition)) {
+      return;
+    }
+
+    if (is(node, 'bpmn:ThrowEvent') && !getEventDefinition(node)) {
+      return;
+    }
+
+    let errors;
+
+    const calledDecision = findExtensionElement(node, 'zeebe:CalledDecision'),
+          taskDefinition = findExtensionElement(node, 'zeebe:TaskDefinition');
+
+    if (calledDecision && !taskDefinition) {
+
+      if (!isAny(node, elementsCalledDecision)) {
+        reportErrors(node, reporter, {
+          message: 'Extension element of type <zeebe:CalledDecision> not allowed',
+          path: getPath(calledDecision, node),
+          error: {
+            type: ERROR_TYPES.EXTENSION_ELEMENT_NOT_ALLOWED,
+            node,
+            parentNode: null,
+            extensionElement: calledDecision
+          }
+        });
+
+        return;
+      }
+
+      errors = hasProperties(calledDecision, {
+        decisionId: {
+          required: true
+        },
+        resultVariable: {
+          required: true
+        }
+      }, node);
+
+      if (errors && errors.length) {
+        reportErrors(node, reporter, errors);
+
+        return;
+      }
+    }
+
+    if (!calledDecision && taskDefinition) {
+
+      if (!isAny(node, elementsTaskDefinition)) {
+        reportErrors(node, reporter, {
+          message: 'Extension element of type <zeebe:TaskDefinition> not allowed',
+          path: getPath(taskDefinition, node),
+          error: {
+            type: ERROR_TYPES.EXTENSION_ELEMENT_NOT_ALLOWED,
+            node,
+            parentNode: null,
+            extensionElement: taskDefinition
+          }
+        });
+
+        return;
+      }
+
+      errors = hasProperties(taskDefinition, {
+        type: {
+          required: true
+        }
+      }, node);
+
+      if (errors && errors.length) {
+        reportErrors(node, reporter, errors);
+      }
+    }
+
+    if (isAny(node, elementsCalledDecision) && isAny(node, elementsTaskDefinition)) {
+      errors = hasExtensionElementsOfTypes(node, [
+        'zeebe:CalledDecision',
+        'zeebe:TaskDefinition'
+      ], node, true);
+    } else if (isAny(node, elementsCalledDecision)) {
+      errors = hasExtensionElementOfType(node, 'zeebe:CalledDecision', node);
+    } else {
+      errors = hasExtensionElementOfType(node, 'zeebe:TaskDefinition', node);
+    }
+
+    if (errors && errors.length) {
+      reportErrors(node, reporter, errors);
+
+      return;
+    }
+  }
+
+  return {
+    check
+  };
+};

package/rules/has-called-element.js

@@ -0,0 +1,41 @@
+const { is } = require('bpmnlint-utils');
+
+const {
+  findExtensionElement,
+  hasExtensionElementOfType,
+  hasProperties
+} = require('./utils/element');
+
+const { reportErrors } = require('./utils/reporter');
+
+module.exports = function() {
+  function check(node, reporter) {
+    if (!is(node, 'bpmn:CallActivity')) {
+      return;
+    }
+
+    let errors = hasExtensionElementOfType(node, 'zeebe:CalledElement', node);
+
+    if (errors && errors.length) {
+      reportErrors(node, reporter, errors);
+
+      return;
+    }
+
+    const calledElement = findExtensionElement(node, 'zeebe:CalledElement');
+
+    errors = hasProperties(calledElement, {
+      processId: {
+        required: true
+      }
+    }, node);
+
+    if (errors && errors.length) {
+      reportErrors(node, reporter, errors);
+    }
+  }
+
+  return {
+    check
+  };
+};

package/rules/has-error-reference.js

@@ -0,0 +1,53 @@
+const {
+  is,
+  isAny
+} = require('bpmnlint-utils');
+
+const {
+  getEventDefinition,
+  hasProperties
+} = require('./utils/element');
+
+const { reportErrors } = require('./utils/reporter');
+
+module.exports = function() {
+  function check(node, reporter) {
+    if (!isAny(node, [ 'bpmn:CatchEvent', 'bpmn:ThrowEvent' ])) {
+      return;
+    }
+
+    const eventDefinition = getEventDefinition(node);
+
+    if (!eventDefinition || !is(eventDefinition, 'bpmn:ErrorEventDefinition')) {
+      return;
+    }
+
+    let errors = hasProperties(eventDefinition, {
+      errorRef: {
+        required: true
+      }
+    }, node);
+
+    if (errors && errors.length) {
+      reportErrors(node, reporter, errors);
+
+      return;
+    }
+
+    const errorRef = eventDefinition.get('errorRef');
+
+    errors = hasProperties(errorRef, {
+      errorCode: {
+        required: true
+      }
+    }, node);
+
+    if (errors && errors.length) {
+      reportErrors(node, reporter, errors);
+    }
+  }
+
+  return {
+    check
+  };
+};

package/rules/has-loop-characteristics.js

@@ -0,0 +1,65 @@
+const { is } = require('bpmnlint-utils');
+
+const {
+  findExtensionElement,
+  hasProperties,
+  hasExtensionElementOfType
+} = require('./utils/element');
+
+const { reportErrors } = require('./utils/reporter');
+
+module.exports = function() {
+  function check(node, reporter) {
+    if (!is(node, 'bpmn:Activity')) {
+      return;
+    }
+
+    let loopCharacteristics = node.get('loopCharacteristics');
+
+    if (!loopCharacteristics) {
+      return;
+    }
+
+    let errors = hasProperties(node, {
+      loopCharacteristics: {
+        type: 'bpmn:MultiInstanceLoopCharacteristics'
+      }
+    }, node);
+
+    if (errors && errors.length) {
+      reportErrors(node, reporter, errors);
+
+      return;
+    }
+
+    errors = hasExtensionElementOfType(loopCharacteristics, 'zeebe:LoopCharacteristics', node);
+
+    if (errors && errors.length) {
+      reportErrors(node, reporter, errors);
+
+      return;
+    }
+
+    loopCharacteristics = findExtensionElement(loopCharacteristics, 'zeebe:LoopCharacteristics');
+
+    errors = hasProperties(loopCharacteristics, {
+      inputCollection: {
+        required: true
+      },
+      outputCollection: {
+        dependendRequired: 'outputElement'
+      },
+      outputElement: {
+        dependendRequired: 'outputCollection'
+      }
+    }, node);
+
+    if (errors && errors.length) {
+      reportErrors(node, reporter, errors);
+    }
+  }
+
+  return {
+    check
+  };
+};

package/rules/has-message-reference.js

@@ -0,0 +1,59 @@
+const {
+  is,
+  isAny
+} = require('bpmnlint-utils');
+
+const {
+  getEventDefinition,
+  hasProperties
+} = require('./utils/element');
+
+const { reportErrors } = require('./utils/reporter');
+
+module.exports = function() {
+  function check(node, reporter) {
+    if (!isAny(node, [ 'bpmn:CatchEvent', 'bpmn:ReceiveTask' ])) {
+      return;
+    }
+
+    let eventDefinitionOrReceiveTask = node;
+
+    if (!is(node, 'bpmn:ReceiveTask')) {
+      const eventDefinition = getEventDefinition(node);
+
+      if (!eventDefinition || !is(eventDefinition, 'bpmn:MessageEventDefinition')) {
+        return;
+      }
+
+      eventDefinitionOrReceiveTask = eventDefinition;
+    }
+
+    let errors = hasProperties(eventDefinitionOrReceiveTask, {
+      messageRef: {
+        required: true
+      }
+    }, node);
+
+    if (errors && errors.length) {
+      reportErrors(node, reporter, errors);
+
+      return;
+    }
+
+    const messageRef = eventDefinitionOrReceiveTask.get('messageRef');
+
+    errors = hasProperties(messageRef, {
+      name: {
+        required: true
+      }
+    }, node);
+
+    if (errors && errors.length) {
+      reportErrors(node, reporter, errors);
+    }
+  }
+
+  return {
+    check
+  };
+};

package/rules/has-subscription.js

@@ -0,0 +1,64 @@
+const {
+  is,
+  isAny
+} = require('bpmnlint-utils');
+
+const {
+  findExtensionElement,
+  getEventDefinition,
+  hasExtensionElementOfType,
+  hasProperties
+} = require('./utils/element');
+
+const { reportErrors } = require('./utils/reporter');
+
+module.exports = function() {
+  function check(node, reporter) {
+    if (!isAny(node, [ 'bpmn:CatchEvent', 'bpmn:ThrowEvent', 'bpmn:ReceiveTask' ])
+      || (is(node, 'bpmn:StartEvent') && !is(node.$parent, 'bpmn:SubProcess'))) {
+      return;
+    }
+
+    let eventDefinitionOrReceiveTask = node;
+
+    if (!is(node, 'bpmn:ReceiveTask')) {
+      const eventDefinition = getEventDefinition(node);
+
+      if (!eventDefinition || !is(eventDefinition, 'bpmn:MessageEventDefinition')) {
+        return;
+      }
+
+      eventDefinitionOrReceiveTask = eventDefinition;
+    }
+
+    const messageRef = eventDefinitionOrReceiveTask.get('messageRef');
+
+    if (!messageRef) {
+      return;
+    }
+
+    let errors = hasExtensionElementOfType(messageRef, 'zeebe:Subscription', node);
+
+    if (errors && errors.length) {
+      reportErrors(node, reporter, errors);
+
+      return;
+    }
+
+    const subscription = findExtensionElement(messageRef, 'zeebe:Subscription');
+
+    errors = hasProperties(subscription, {
+      correlationKey: {
+        required: true
+      }
+    }, node);
+
+    if (errors && errors.length) {
+      reportErrors(node, reporter, errors);
+    }
+  }
+
+  return {
+    check
+  };
+};