bpmnlint-plugin-camunda-compat 0.16.0 → 0.17.0

package/index.js

@@ -1,7 +1,7 @@
 const { omit } = require('min-dash');
 
 const camundaCloud10Rules = {
-  'called-decision-or-task-definition': [ 'error', { version: '1.0' } ],
+  'implementation': [ 'error', { version: '1.0' } ],
   'called-element': 'error',
   'collapsed-subprocess': 'error',
   'duplicate-task-headers': 'error',
@@ -21,35 +21,35 @@ const camundaCloud10Rules = {
 
 const camundaCloud11Rules = {
   ...camundaCloud10Rules,
-  'called-decision-or-task-definition': [ 'error', { version: '1.1' } ],
+  'implementation': [ 'error', { version: '1.1' } ],
   'element-type': [ 'error', { version: '1.1' } ],
   'timer': [ 'error', { version: '1.1' } ]
 };
 
 const camundaCloud12Rules = {
   ...camundaCloud11Rules,
-  'called-decision-or-task-definition': [ 'error', { version: '1.2' } ],
+  'implementation': [ 'error', { version: '1.2' } ],
   'element-type': [ 'error', { version: '1.2' } ],
   'timer': [ 'error', { version: '1.2' } ]
 };
 
 const camundaCloud13Rules = {
   ...camundaCloud12Rules,
-  'called-decision-or-task-definition': [ 'error', { version: '1.3' } ],
+  'implementation': [ 'error', { version: '1.3' } ],
   'element-type': [ 'error', { version: '1.3' } ],
   'timer': [ 'error', { version: '1.3' } ]
 };
 
 const camundaCloud80Rules = {
   ...omit(camundaCloud13Rules, 'no-template'),
-  'called-decision-or-task-definition': [ 'error', { version: '8.0' } ],
+  'implementation': [ 'error', { version: '8.0' } ],
   'element-type': [ 'error', { version: '8.0' } ],
   'timer': [ 'error', { version: '8.0' } ]
 };
 
 const camundaCloud81Rules = {
   ...omit(camundaCloud80Rules, 'no-zeebe-properties'),
-  'called-decision-or-task-definition': [ 'error', { version: '8.1' } ],
+  'implementation': [ 'error', { version: '8.1' } ],
   'element-type': [ 'error', { version: '8.1' } ],
   'inclusive-gateway': 'error',
   'timer': [ 'error', { version: '8.1' } ]
@@ -57,7 +57,7 @@ const camundaCloud81Rules = {
 
 const camundaCloud82Rules = {
   ...camundaCloud81Rules,
-  'called-decision-or-task-definition': [ 'error', { version: '8.2' } ],
+  'implementation': [ 'error', { version: '8.2' } ],
   'element-type': [ 'error', { version: '8.2' } ],
   'timer': [ 'error', { version: '8.2' } ]
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bpmnlint-plugin-camunda-compat",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "description": "A bpmnlint plug-in for Camunda Platform compatibility",
   "main": "index.js",
   "scripts": {
@@ -33,7 +33,7 @@
     "modeler-moddle": "^0.1.0",
     "sinon": "^14.0.0",
     "sinon-chai": "^3.7.0",
-    "zeebe-bpmn-moddle": "^0.14.0"
+    "zeebe-bpmn-moddle": "^0.17.0"
   },
   "dependencies": {
     "@bpmn-io/feel-lint": "^0.1.1",

package/rules/{called-decision-or-task-definition → implementation}/config.js

@@ -5,10 +5,13 @@ module.exports = {
   taskDefinition: {
     'bpmn:BusinessRuleTask': '1.1',
     'bpmn:IntermediateThrowEvent': {
-      'bpmn:MessageEventDefinition': '1.2',
+      'bpmn:MessageEventDefinition': '1.2'
     },
     'bpmn:ScriptTask': '1.1',
     'bpmn:SendTask': '1.1',
     'bpmn:ServiceTask': '1.0'
+  },
+  script: {
+    'bpmn:ScriptTask': '8.2'
   }
 };

package/rules/{called-decision-or-task-definition → implementation}/index.js

@@ -22,10 +22,12 @@ const { ERROR_TYPES } = require('../utils/error-types');
 module.exports = function({ version }) {
   function check(node, reporter) {
     const calledDecisionConfig = config.calledDecision[ node.$type ];
+    const scriptConfig = config.script[ node.$type ];
     const taskDefinitionConfig = config.taskDefinition[ node.$type ];
 
     if (
       (!calledDecisionConfig || (isString(calledDecisionConfig) && !greaterOrEqual(version, calledDecisionConfig)))
+      && (!scriptConfig || (isString(scriptConfig) && !greaterOrEqual(version, scriptConfig)))
       && (!taskDefinitionConfig || (isString(taskDefinitionConfig) && !greaterOrEqual(version, taskDefinitionConfig)))) {
       return;
     }
@@ -37,9 +39,10 @@ module.exports = function({ version }) {
     let errors;
 
     const calledDecision = findExtensionElement(node, 'zeebe:CalledDecision'),
+          script = findExtensionElement(node, 'zeebe:Script'),
           taskDefinition = findExtensionElement(node, 'zeebe:TaskDefinition');
 
-    if (calledDecision && !taskDefinition) {
+    if (calledDecision && !script && !taskDefinition) {
 
       if (!isCalledDecisionAllowed(node, version)) {
         const allowedVersion = getAllowedVersion(calledDecisionConfig, node);
@@ -77,7 +80,45 @@ module.exports = function({ version }) {
       }
     }
 
-    if (!calledDecision && taskDefinition) {
+    if (!calledDecision && script && !taskDefinition) {
+
+      if (!isScriptAllowed(node, version)) {
+        const allowedVersion = getAllowedVersion(scriptConfig, node);
+
+        reportErrors(node, reporter, {
+          message: allowedVersion
+            ? `Extension element of type <zeebe:Script> only allowed by Camunda Platform ${ allowedVersion } or newer`
+            : 'Extension element of type <zeebe:Script> not allowed',
+          path: getPath(script, node),
+          data: {
+            type: ERROR_TYPES.EXTENSION_ELEMENT_NOT_ALLOWED,
+            node,
+            parentNode: null,
+            extensionElement: script,
+            allowedVersion
+          }
+        });
+
+        return;
+      }
+
+      errors = hasProperties(script, {
+        expression: {
+          required: true
+        },
+        resultVariable: {
+          required: true
+        }
+      }, node);
+
+      if (errors && errors.length) {
+        reportErrors(node, reporter, errors);
+
+        return;
+      }
+    }
+
+    if (!calledDecision && !script && taskDefinition) {
 
       if (!isTaskDefinitionAllowed(node, version)) {
         const allowedVersion = getAllowedVersion(taskDefinitionConfig, node);
@@ -110,15 +151,18 @@ module.exports = function({ version }) {
       }
     }
 
-    if (isCalledDecisionAllowed(node, version) && isTaskDefinitionAllowed(node, version)) {
-      errors = hasExtensionElement(node, [
-        'zeebe:CalledDecision',
-        'zeebe:TaskDefinition'
-      ], node);
-    } else if (isCalledDecisionAllowed(node, version)) {
-      errors = hasExtensionElement(node, 'zeebe:CalledDecision', node);
-    } else if (isTaskDefinitionAllowed(node, version)) {
-      errors = hasExtensionElement(node, 'zeebe:TaskDefinition', node);
+    const allowedTypes = [
+      isCalledDecisionAllowed(node, version) ? 'zeebe:CalledDecision' : false,
+      isScriptAllowed(node, version) ? 'zeebe:Script' : false,
+      isTaskDefinitionAllowed(node, version) ? 'zeebe:TaskDefinition' : false
+    ].filter(isAllowed => isAllowed);
+
+    if (allowedTypes.length === 0) {
+      return;
+    } else if (allowedTypes.length === 1) {
+      errors = hasExtensionElement(node, allowedTypes[0], node);
+    } else {
+      errors = hasExtensionElement(node, allowedTypes, node);
     }
 
     if (errors && errors.length) {
@@ -136,7 +180,17 @@ module.exports = function({ version }) {
 function isCalledDecisionAllowed(node, version) {
   const { calledDecision } = config;
 
-  return calledDecision[ node.$type ] && greaterOrEqual(version, calledDecision[ node.$type ]);
+  const allowedVersion = getAllowedVersion(calledDecision[ node.$type ], node);
+
+  return calledDecision[ node.$type ] && greaterOrEqual(version, allowedVersion);
+}
+
+function isScriptAllowed(node, version) {
+  const { script } = config;
+
+  const allowedVersion = getAllowedVersion(script[ node.$type ], node);
+
+  return allowedVersion && greaterOrEqual(version, allowedVersion);
 }
 
 function isTaskDefinitionAllowed(node, version) {
@@ -159,4 +213,4 @@ function getAllowedVersion(config, node) {
   const eventDefinition = getEventDefinition(node);
 
   return eventDefinition && config[ eventDefinition.$type ];
-}
+}