bpmnlint-plugin-camunda-compat 0.24.0 → 1.0.0

package/index.js

@@ -43,6 +43,7 @@ const camundaCloud82Rules = withConfig({
     'no-task-schedule'
   ]),
   'escalation-reference': 'error',
+  'no-signal-event-sub-process': 'error',
   'task-schedule': 'error'
 }, { version: '8.2' });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bpmnlint-plugin-camunda-compat",
-  "version": "0.24.0",
+  "version": "1.0.0",
   "description": "A bpmnlint plug-in for Camunda Platform compatibility",
   "main": "index.js",
   "scripts": {

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/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
             }
           }
         ];

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',