bpmnlint-plugin-camunda-compat 2.22.0 → 2.24.0

package/index.js

@@ -11,11 +11,13 @@ const camundaCloud10Rules = withConfig({
   'executable-process': 'error',
   'loop-characteristics': 'error',
   'message-reference': 'error',
+  'no-binding-type': 'error',
   'no-candidate-users': 'error',
   'no-execution-listeners': 'error',
   'no-expression': 'error',
   'no-loop': 'error',
   'no-multiple-none-start-events': 'error',
+  'no-priority-definition': 'error',
   'no-propagate-all-parent-variables': 'error',
   'no-task-schedule': 'error',
   'no-template': 'error',
@@ -77,9 +79,15 @@ const camundaCloud85Rules = withConfig({
 }, { version: '8.5' });
 
 const camundaCloud86Rules = withConfig({
-  ...omit(camundaCloud85Rules, [ 'inclusive-gateway', 'no-execution-listeners' ]),
+  ...omit(camundaCloud85Rules, [
+    'inclusive-gateway',
+    'no-binding-type',
+    'no-execution-listeners',
+    'no-priority-definition'
+  ]),
   'duplicate-execution-listeners': 'error',
-  'execution-listener': 'error'
+  'execution-listener': 'error',
+  'priority-definition': 'error'
 }, { version: '8.6' });
 
 const camundaPlatform719Rules = withConfig({
@@ -124,17 +132,20 @@ const rules = {
   'link-event': './rules/camunda-cloud/link-event',
   'loop-characteristics': './rules/camunda-cloud/loop-characteristics',
   'message-reference': './rules/camunda-cloud/message-reference',
+  'no-binding-type': './rules/camunda-cloud/no-binding-type',
   'no-candidate-users': './rules/camunda-cloud/no-candidate-users',
   'no-execution-listeners': './rules/camunda-cloud/no-execution-listeners',
   'no-expression': './rules/camunda-cloud/no-expression',
   'no-loop': './rules/camunda-cloud/no-loop',
   'no-multiple-none-start-events': './rules/camunda-cloud/no-multiple-none-start-events',
+  'no-priority-definition': './rules/camunda-cloud/no-priority-definition',
   'no-propagate-all-parent-variables': './rules/camunda-cloud/no-propagate-all-parent-variables',
   'no-signal-event-sub-process': './rules/camunda-cloud/no-signal-event-sub-process',
   'no-task-schedule': './rules/camunda-cloud/no-task-schedule',
   'no-template': './rules/camunda-cloud/no-template',
   'no-zeebe-properties': './rules/camunda-cloud/no-zeebe-properties',
   'no-zeebe-user-task': './rules/camunda-cloud/no-zeebe-user-task',
+  'priority-definition': './rules/camunda-cloud/priority-definition',
   'secrets': './rules/camunda-cloud/secrets',
   'sequence-flow-condition': './rules/camunda-cloud/sequence-flow-condition',
   'signal-reference': './rules/camunda-cloud/signal-reference',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bpmnlint-plugin-camunda-compat",
-  "version": "2.22.0",
+  "version": "2.24.0",
   "description": "A bpmnlint plug-in for Camunda compatibility",
   "main": "index.js",
   "scripts": {
@@ -34,7 +34,7 @@
     "modeler-moddle": "^0.2.0",
     "sinon": "^17.0.1",
     "sinon-chai": "^3.7.0",
-    "zeebe-bpmn-moddle": "^1.4.0"
+    "zeebe-bpmn-moddle": "^1.5.1"
   },
   "dependencies": {
     "@bpmn-io/feel-lint": "^1.2.0",

package/rules/camunda-cloud/no-binding-type.js

@@ -0,0 +1,44 @@
+const { isAny } = require('bpmnlint-utils');
+
+const { hasProperties, findExtensionElement } = require('../utils/element');
+
+const { reportErrors } = require('../utils/reporter');
+
+const { skipInNonExecutableProcess } = require('../utils/rule');
+
+module.exports = skipInNonExecutableProcess(function() {
+  function check(node, reporter) {
+    if (!isAny(node, [
+      'bpmn:BusinessRuleTask',
+      'bpmn:CallActivity',
+      'bpmn:UserTask'
+    ])) {
+      return;
+    }
+
+    const extensionElement = findExtensionElement(node, [
+      'zeebe:CalledDecision',
+      'zeebe:CalledElement',
+      'zeebe:FormDefinition'
+    ]);
+
+    if (!extensionElement) {
+      return;
+    }
+
+    const errors = hasProperties(extensionElement, {
+      bindingType: {
+        allowed: (value) => !value || value === 'latest',
+        allowedVersion: '8.6'
+      }
+    }, node);
+
+    if (errors && errors.length) {
+      reportErrors(node, reporter, errors);
+    }
+  }
+
+  return {
+    check
+  };
+});

package/rules/camunda-cloud/no-priority-definition.js

@@ -0,0 +1,19 @@
+const { hasNoExtensionElement } = require('../utils/element');
+
+const { reportErrors } = require('../utils/reporter');
+
+const { skipInNonExecutableProcess } = require('../utils/rule');
+
+module.exports = skipInNonExecutableProcess(function() {
+  function check(node, reporter) {
+    const errors = hasNoExtensionElement(node, 'zeebe:PriorityDefinition', node, '8.6');
+
+    if (errors && errors.length) {
+      reportErrors(node, reporter, errors);
+    }
+  }
+
+  return {
+    check
+  };
+});

package/rules/camunda-cloud/priority-definition.js

@@ -0,0 +1,62 @@
+const { is } = require('bpmnlint-utils');
+const { isDefined } = require('min-dash');
+
+const {
+  findExtensionElement,
+  hasExpression
+} = require('../utils/element');
+
+const { reportErrors } = require('../utils/reporter');
+
+const { skipInNonExecutableProcess } = require('../utils/rule');
+
+module.exports = skipInNonExecutableProcess(function() {
+  function check(node, reporter) {
+    if (!is(node, 'bpmn:UserTask')) {
+      return;
+    }
+
+    const priorityDefinition = findExtensionElement(node, 'zeebe:PriorityDefinition');
+
+    if (!priorityDefinition) {
+      return;
+    }
+
+    const priority = priorityDefinition.get('priority');
+
+    let errors = [];
+
+    if (isDefined(priority)) {
+      errors = [
+        ...errors,
+        ...hasExpression(priorityDefinition, 'priority', {
+          allowed: value => isValidPriority(value)
+        }, node)
+      ];
+    }
+
+    if (errors.length) {
+      reportErrors(node, reporter, errors);
+    }
+  }
+
+  return {
+    check
+  };
+});
+
+function isValidPriority(value) {
+  return isExpression(value) || isIntegerStringBetween(value, 0, 100);
+}
+
+function isExpression(value) {
+  return value.startsWith('=');
+}
+
+function isIntegerStringBetween(value, min, max) {
+  if (/^\d+$/.test(value)) {
+    const number = parseInt(value, 10);
+    return number >= min && number <= max;
+  }
+  return false;
+}