bpmnlint-plugin-camunda-compat 0.23.0 → 1.0.0

package/index.js

@@ -12,6 +12,7 @@ const camundaCloud10Rules = withConfig({
   'message-reference': 'error',
   'no-candidate-users': 'error',
   'no-expression': 'error',
+  'no-task-schedule': 'error',
   'no-template': 'error',
   'no-zeebe-properties': 'error',
   'sequence-flow-condition': 'error',
@@ -37,8 +38,13 @@ const camundaCloud81Rules = withConfig({
 }, { version: '8.1' });
 
 const camundaCloud82Rules = withConfig({
-  ...omit(camundaCloud81Rules, 'no-candidate-users'),
-  'escalation-reference': 'error'
+  ...omit(camundaCloud81Rules, [
+    'no-candidate-users',
+    'no-task-schedule'
+  ]),
+  'escalation-reference': 'error',
+  'no-signal-event-sub-process': 'error',
+  'task-schedule': 'error'
 }, { version: '8.2' });
 
 const camundaPlatform719Rules = withConfig({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bpmnlint-plugin-camunda-compat",
-  "version": "0.23.0",
+  "version": "1.0.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.17.0"
+    "zeebe-bpmn-moddle": "^0.18.0"
   },
   "dependencies": {
     "@bpmn-io/feel-lint": "^0.1.1",

package/rules/element-type/config.js

@@ -50,6 +50,7 @@ module.exports = {
     'bpmn:ErrorEventDefinition': '1.0',
     'bpmn:EscalationEventDefinition': '8.2',
     'bpmn:MessageEventDefinition': '1.0',
+    'bpmn:SignalEventDefinition': '8.2',
     'bpmn:TimerEventDefinition': '1.0'
   },
   'bpmn:SubProcess': '1.0',

package/rules/element-type/index.js

@@ -27,17 +27,27 @@ module.exports = skipInNonExecutableProcess(function({ version }) {
       // (1) Element not allowed
       const allowedVersion = element || null;
 
+      let message = `Element of type <${ node.$type }> not allowed`;
+
+      let data = {
+        type: ERROR_TYPES.ELEMENT_TYPE_NOT_ALLOWED,
+        node,
+        parentNode: null
+      };
+
+      if (allowedVersion) {
+        message = `Element of type <${ node.$type }> only allowed by Camunda Platform ${ allowedVersion } or newer`;
+
+        data = {
+          ...data,
+          allowedVersion
+        };
+      }
+
       const error = {
-        message: allowedVersion
-          ? `Element of type <${ node.$type }> only allowed by Camunda Platform ${ allowedVersion } or newer`
-          : `Element of type <${ node.$type }> not allowed`,
+        message,
         path: null,
-        data: {
-          type: ERROR_TYPES.ELEMENT_TYPE_NOT_ALLOWED,
-          node,
-          parentNode: null,
-          allowedVersion
-        }
+        data
       };
 
       reportErrors(node, reporter, error);
@@ -57,18 +67,28 @@ module.exports = skipInNonExecutableProcess(function({ version }) {
         // (2) Element with event definition not allowed
         const allowedVersion = element[ eventDefinition.$type ] || null;
 
+        let message = `Element of type <${ node.$type }> with event definition of type <${ eventDefinition.$type }> not allowed`;
+
+        let data = {
+          type: ERROR_TYPES.ELEMENT_TYPE_NOT_ALLOWED,
+          node,
+          parentNode: null,
+          eventDefinition
+        };
+
+        if (allowedVersion) {
+          message = `Element of type <${ node.$type }> with event definition of type <${ eventDefinition.$type }> only allowed by Camunda Platform ${ allowedVersion } or newer`;
+
+          data = {
+            ...data,
+            allowedVersion
+          };
+        }
+
         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`,
+          message,
           path: null,
-          data: {
-            type: ERROR_TYPES.ELEMENT_TYPE_NOT_ALLOWED,
-            node,
-            parentNode: null,
-            eventDefinition,
-            allowedVersion
-          }
+          data
         };
 
         reportErrors(node, reporter, error);
@@ -79,18 +99,28 @@ module.exports = skipInNonExecutableProcess(function({ version }) {
         // (3) Element without event definition not allowed
         const allowedVersion = element[ '_' ] || null;
 
+        let message = `Element of type <${ node.$type }> with no event definition not allowed`;
+
+        let data = {
+          type: ERROR_TYPES.ELEMENT_TYPE_NOT_ALLOWED,
+          node,
+          parentNode: null,
+          eventDefinition
+        };
+
+        if (allowedVersion) {
+          message = `Element of type <${ node.$type }> with no event definition only allowed by Camunda Platform ${ allowedVersion } or newer`;
+
+          data = {
+            ...data,
+            allowedVersion
+          };
+        }
+
         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`,
+          message,
           path: null,
-          data: {
-            type: ERROR_TYPES.ELEMENT_TYPE_NOT_ALLOWED,
-            node,
-            parentNode: null,
-            eventDefinition,
-            allowedVersion
-          }
+          data
         };
 
         reportErrors(node, reporter, error);

package/rules/error-reference.js

@@ -47,8 +47,7 @@ module.exports = skipInNonExecutableProcess(function({ version }) {
 
     errors = hasProperties(errorRef, {
       errorCode: {
-        required: true,
-        allowedVersion: '8.2'
+        required: true
       }
     }, node);
 

package/rules/loop-characteristics.js

@@ -49,10 +49,10 @@ module.exports = skipInNonExecutableProcess(function() {
         required: true
       },
       outputCollection: {
-        dependendRequired: 'outputElement'
+        dependentRequired: 'outputElement'
       },
       outputElement: {
-        dependendRequired: 'outputCollection'
+        dependentRequired: 'outputCollection'
       }
     }, node);
 

package/rules/no-expression.js

@@ -68,29 +68,37 @@ function checkForVersion(node, version) {
 }
 
 function noExpression(node, propertyName, parentNode, allowedVersion) {
-  const propertyValue = node.get(propertyName);
-  const path = getPath(node, parentNode);
+  const path = getPath(node, parentNode),
+        propertyValue = node.get(propertyName);
 
   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`;
+  let message = `Expression statement <${truncate(propertyValue)}> not supported`;
+
+  let data = {
+    type: ERROR_TYPES.EXPRESSION_NOT_ALLOWED,
+    node,
+    parentNode: parentNode == node ? null : parentNode,
+    property: propertyName
+  };
+
+  if (allowedVersion) {
+    message = `Expression statement <${truncate(propertyValue)}> only supported by Camunda Platform ${allowedVersion} or newer`;
+
+    data = {
+      ...data,
+      allowedVersion
+    };
+  }
 
   return {
-    message: errorMessage,
+    message,
     path: path
       ? [ ...path, propertyName ]
       : [ propertyName ],
-    data: {
-      type: ERROR_TYPES.EXPRESSION_NOT_ALLOWED,
-      node,
-      parentNode: parentNode == node ? null : parentNode,
-      property: propertyName,
-      allowedVersion
-    }
+    data
   };
 }
 

package/rules/no-signal-event-sub-process.js

@@ -0,0 +1,45 @@
+const { is } = require('bpmnlint-utils');
+
+const { reportErrors } = require('./utils/reporter');
+
+const { getEventDefinition } = require('./utils/element');
+
+const { ERROR_TYPES } = require('./utils/error-types');
+
+const { skipInNonExecutableProcess } = require('./utils/rule');
+
+module.exports = skipInNonExecutableProcess(function() {
+  function check(node, reporter) {
+    if (!is(node, 'bpmn:StartEvent')) {
+      return;
+    }
+
+    const eventDefinition = getEventDefinition(node);
+
+    if (!eventDefinition || !is(eventDefinition, 'bpmn:SignalEventDefinition')) {
+      return;
+    }
+
+    const { $parent: parent } = node;
+
+    if (parent && is(parent, 'bpmn:SubProcess')) {
+      const error = {
+        message: 'Element of type <bpmn:StartEvent> with event definition of type <bpmn:SignalEventDefinition> not allowed as child of <bpmn:SubProcess>',
+        path: null,
+        data: {
+          type: ERROR_TYPES.CHILD_ELEMENT_TYPE_NOT_ALLOWED,
+          node,
+          parentNode: null,
+          eventDefinition,
+          parent
+        }
+      };
+
+      reportErrors(node, reporter, error);
+    }
+  }
+
+  return {
+    check
+  };
+});

package/rules/no-task-schedule.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:TaskSchedule', node, '8.2');
+
+    if (errors && errors.length) {
+      reportErrors(node, reporter, errors);
+    }
+  }
+
+  return {
+    check
+  };
+});

package/rules/no-zeebe-properties.js

@@ -1,5 +1,3 @@
-const { is } = require('bpmnlint-utils');
-
 const { hasNoExtensionElement } = require('./utils/element');
 
 const { reportErrors } = require('./utils/reporter');
@@ -8,10 +6,6 @@ const { skipInNonExecutableProcess } = require('./utils/rule');
 
 module.exports = skipInNonExecutableProcess(function() {
   function check(node, reporter) {
-    if (!is(node, 'zeebe:PropertiesHolder')) {
-      return;
-    }
-
     const errors = hasNoExtensionElement(node, 'zeebe:Properties', node, '8.1');
 
     if (errors && errors.length) {

package/rules/task-schedule.js

@@ -0,0 +1,68 @@
+const { is } = require('bpmnlint-utils');
+
+const { isDefined } = require('min-dash');
+
+const {
+  findExtensionElement,
+  hasExpression
+} = require('./utils/element');
+
+const { validateDate: validateISO8601Date } = require('./utils/iso8601');
+
+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 taskSchedule = findExtensionElement(node, 'zeebe:TaskSchedule');
+
+    if (!taskSchedule) {
+      return;
+    }
+
+    const dueDate = taskSchedule.get('dueDate');
+
+    let errors = [];
+
+    if (isDefined(dueDate)) {
+      errors = [
+        ...errors,
+        ...hasExpression(taskSchedule, 'dueDate', {
+          allowed: date => isValidDate(date)
+        }, node)
+      ];
+    }
+
+    const followUpDate = taskSchedule.get('followUpDate');
+
+    if (isDefined(followUpDate)) {
+      errors = [
+        ...errors,
+        ...hasExpression(taskSchedule, 'followUpDate', {
+          allowed: date => isValidDate(date)
+        }, node)
+      ];
+    }
+
+    if (errors.length) {
+      reportErrors(node, reporter, errors);
+    }
+  }
+
+  return {
+    check
+  };
+});
+
+function isValidDate(value) {
+  return isExpression(value) || validateISO8601Date(value);
+}
+
+function isExpression(value) {
+  return value.startsWith('=');
+}

package/rules/utils/element.js

@@ -161,23 +161,23 @@ module.exports.hasProperties = function(node, properties, parentNode = null) {
       ];
     }
 
-    if (propertyChecks.dependendRequired) {
-      const dependency = node.get(propertyChecks.dependendRequired);
+    if (propertyChecks.dependentRequired) {
+      const dependency = node.get(propertyChecks.dependentRequired);
 
       if (dependency && !propertyValue) {
         return [
           ...results,
           {
-            message: `Element of type <${ node.$type }> must have property <${ propertyName }> if it has property <${ propertyChecks.dependendRequired }>`,
+            message: `Element of type <${ node.$type }> must have property <${ propertyName }> if it has property <${ propertyChecks.dependentRequired }>`,
             path: path
               ? [ ...path, propertyName ]
               : [ propertyName ],
             data: {
-              type: ERROR_TYPES.PROPERTY_DEPENDEND_REQUIRED,
+              type: ERROR_TYPES.PROPERTY_DEPENDENT_REQUIRED,
               node,
               parentNode: parentNode == node ? null : parentNode,
-              property: propertyChecks.dependendRequired,
-              dependendRequiredProperty: propertyName
+              property: propertyChecks.dependentRequired,
+              dependentRequiredProperty: propertyName
             }
           }
         ];
@@ -363,11 +363,15 @@ module.exports.hasExpression = function(node, propertyName, check, parentNode =
     throw new Error('Expression not found');
   }
 
-  const body = expression.get('body');
+  let propertyValue = expression;
+
+  if (is(expression, 'bpmn:Expression')) {
+    propertyValue = expression.get('body');
+  }
 
   const path = getPath(node, parentNode);
 
-  if (!body) {
+  if (!propertyValue) {
     if (check.required !== false) {
       return [
         {
@@ -377,7 +381,7 @@ module.exports.hasExpression = function(node, propertyName, check, parentNode =
             : null,
           data: {
             type: ERROR_TYPES.EXPRESSION_REQUIRED,
-            node: expression,
+            node: is(expression, 'bpmn:Expression') ? expression : node,
             parentNode,
             property: propertyName
           }
@@ -388,7 +392,7 @@ module.exports.hasExpression = function(node, propertyName, check, parentNode =
     return [];
   }
 
-  const allowed = check.allowed(body);
+  const allowed = check.allowed(propertyValue);
 
   if (allowed !== true) {
     let allowedVersion = null;
@@ -400,14 +404,14 @@ module.exports.hasExpression = function(node, propertyName, check, parentNode =
     return [
       {
         message: allowedVersion
-          ? `Expression value of <${ body }> only allowed by Camunda Platform ${ allowedVersion }`
-          : `Expression value of <${ body }> not allowed`,
+          ? `Expression value of <${ propertyValue }> only allowed by Camunda Platform ${ allowedVersion }`
+          : `Expression value of <${ propertyValue }> not allowed`,
         path: path
           ? [ ...path, propertyName ]
           : null,
         data: addAllowedVersion({
           type: ERROR_TYPES.EXPRESSION_VALUE_NOT_ALLOWED,
-          node: expression,
+          node: is(expression, 'bpmn:Expression') ? expression : node,
           parentNode,
           property: propertyName
         }, allowedVersion)

package/rules/utils/error-types.js

@@ -1,5 +1,6 @@
 module.exports.ERROR_TYPES = Object.freeze({
   ELEMENT_COLLAPSED_NOT_ALLOWED: 'camunda.elementCollapsedNotAllowed',
+  CHILD_ELEMENT_TYPE_NOT_ALLOWED: 'camunda.childElementTypeNotAllowed',
   ELEMENT_TYPE_NOT_ALLOWED: 'camunda.elementTypeNotAllowed',
   EXPRESSION_NOT_ALLOWED: 'camunda.expressionNotAllowed',
   EXPRESSION_REQUIRED: 'camunda.expressionRequired',
@@ -7,7 +8,7 @@ module.exports.ERROR_TYPES = Object.freeze({
   EXTENSION_ELEMENT_NOT_ALLOWED: 'camunda.extensionElementNotAllowed',
   EXTENSION_ELEMENT_REQUIRED: 'camunda.extensionElementRequired',
   FEEL_EXPRESSION_INVALID: 'camunda.feelExpressionInvalid',
-  PROPERTY_DEPENDEND_REQUIRED: 'camunda.propertyDependendRequired',
+  PROPERTY_DEPENDENT_REQUIRED: 'camunda.propertyDependentRequired',
   PROPERTY_NOT_ALLOWED: 'camunda.propertyNotAllowed',
   PROPERTY_REQUIRED: 'camunda.propertyRequired',
   PROPERTY_TYPE_NOT_ALLOWED: 'camunda.propertyTypeNotAllowed',