bpmnlint-plugin-camunda-compat 1.2.0 → 1.3.1

package/package.json

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

package/rules/timer/config.js

@@ -1,4 +1,47 @@
+const { is } = require('bpmnlint-utils');
+
 module.exports = {
-  'cron': '8.1',
-  'iso8601': '1.0'
-};
+  expressionType: {
+    'cron': '8.1',
+    'iso8601': '1.0'
+  },
+  elementType: {
+    'bpmn:StartEvent': {
+      'timeCycle': (isInterrupting, parent) => {
+        if (!isInterrupting || !isEventSubProcess(parent)) {
+          return '1.0';
+        }
+
+        return null;
+      },
+      'timeDate': () => '1.0',
+      'timeDuration': (_, parent) => {
+        if (isEventSubProcess(parent)) {
+          return '1.0';
+        }
+
+        return null;
+      }
+    },
+    'bpmn:BoundaryEvent': {
+      'timeCycle': (cancelActivity) => {
+        if (!cancelActivity) {
+          return '1.0';
+        }
+
+        return null;
+      },
+      'timeDate': () => '8.3',
+      'timeDuration': () => '1.0'
+    },
+    'bpmn:IntermediateCatchEvent': {
+      'timeCycle': () => null,
+      'timeDate': () => '8.3',
+      'timeDuration': () => '1.0'
+    }
+  }
+};
+
+function isEventSubProcess(element) {
+  return is(element, 'bpmn:SubProcess') && element.get('triggeredByEvent') === true;
+}

package/rules/timer/index.js

@@ -2,14 +2,16 @@ const {
   is
 } = require('bpmnlint-utils');
 
-const config = require('./config');
+const {
+  elementType: elementTypeConfig,
+  expressionType: expressionTypeConfig
+} = require('./config');
 
 const { greaterOrEqual } = require('../utils/version');
 
 const {
   getEventDefinition,
   hasExpression,
-  hasProperties,
   hasProperty
 } = require('../utils/element');
 
@@ -37,7 +39,7 @@ module.exports = skipInNonExecutableProcess(function({ version }) {
       return;
     }
 
-    let errors = checkTimePropertyExists(eventDefinition, node);
+    let errors = checkTimePropertyExists(eventDefinition, node, version);
 
     if (errors && errors.length) {
       reportErrors(node, reporter, errors);
@@ -57,20 +59,8 @@ module.exports = skipInNonExecutableProcess(function({ version }) {
   };
 });
 
-function checkTimePropertyExists(eventDefinition, event) {
-  if (is(event, 'bpmn:StartEvent')) {
-    return hasProperty(eventDefinition, [ 'timeCycle', 'timeDate' ], event);
-  } else if (is(event, 'bpmn:IntermediateCatchEvent') || isInterruptingBoundaryEvent(event)) {
-    return hasProperties(eventDefinition, {
-      timeDuration: {
-        required: true
-      }
-    }, event);
-  } else if (is(event, 'bpmn:BoundaryEvent')) {
-    return hasProperty(eventDefinition, [ 'timeCycle', 'timeDuration' ], event);
-  }
-
-  return [];
+function checkTimePropertyExists(eventDefinition, node, version) {
+  return hasProperty(eventDefinition, getSupportedTimePropertiesForVersion(node, version), node);
 }
 
 function checkTimeProperty(eventDefinition, event, version) {
@@ -95,32 +85,28 @@ function checkTimeProperty(eventDefinition, event, version) {
 
 
 
-// helper //////////////
-function isInterruptingBoundaryEvent(event) {
-  return is(event, 'bpmn:BoundaryEvent') && event.get('cancelActivity') !== false;
-}
-
-function validateDate(date, version) {
-  if (validateExpression(date)) {
-    return true;
-  }
-
-  if (validateISO8601Date(date)) {
-    return greaterOrEqual(version, config.iso8601);
-  }
-}
-
+// helpers //////////
 function validateCycle(cycle, version) {
   if (validateExpression(cycle)) {
     return true;
   }
 
   if (validateISO8601Cycle(cycle)) {
-    return greaterOrEqual(version, config.iso8601);
+    return greaterOrEqual(version, expressionTypeConfig.iso8601);
   }
 
   if (validateCronExpression(cycle)) {
-    return greaterOrEqual(version, config.cron) || { allowedVersion: config.cron };
+    return greaterOrEqual(version, expressionTypeConfig.cron) || { allowedVersion: expressionTypeConfig.cron };
+  }
+}
+
+function validateDate(date, version) {
+  if (validateExpression(date)) {
+    return true;
+  }
+
+  if (validateISO8601Date(date)) {
+    return greaterOrEqual(version, expressionTypeConfig.iso8601);
   }
 }
 
@@ -130,7 +116,7 @@ function validateDuration(duration, version) {
   }
 
   if (validateISO8601Duration(duration)) {
-    return greaterOrEqual(version, config.iso8601);
+    return greaterOrEqual(version, expressionTypeConfig.iso8601);
   }
 }
 
@@ -139,3 +125,21 @@ function validateExpression(text) {
     return true;
   }
 }
+
+function getSupportedTimePropertiesForVersion(element, version) {
+  const config = elementTypeConfig[ element.$type ];
+
+  return Object.keys(config).filter((property) => {
+    const supportedVersion = config[ property ](isInterrupting(element), element.$parent);
+
+    return supportedVersion && greaterOrEqual(version, supportedVersion);
+  });
+}
+
+function isInterrupting(element) {
+  if (is(element, 'bpmn:BoundaryEvent')) {
+    return element.get('cancelActivity') !== false;
+  }
+
+  return element.get('isInterrupting') !== false;
+}

package/rules/utils/element.js

@@ -68,24 +68,24 @@ function findExtensionElement(node, types) {
 
 module.exports.findExtensionElement = findExtensionElement;
 
-function formatTypes(types, exclusive = false) {
-  return types.reduce((string, type, index) => {
+function formatNames(names, exclusive = false) {
+  return names.reduce((string, name, index) => {
 
     // first
     if (index === 0) {
-      return `<${ type }>`;
+      return `<${ name }>`;
     }
 
     // last
-    if (index === types.length - 1) {
-      return `${ string } ${ exclusive ? 'or' : 'and' } <${ type }>`;
+    if (index === names.length - 1) {
+      return `${ string } ${ exclusive ? 'or' : 'and' } <${ name }>`;
     }
 
-    return `${ string }, <${ type }>`;
+    return `${ string }, <${ name }>`;
   }, '');
 }
 
-module.exports.formatTypes = formatTypes;
+module.exports.formatNames = formatNames;
 
 module.exports.hasDuplicatedPropertyValues = function(node, propertiesName, propertyName, parentNode = null) {
   const properties = node.get(propertiesName);
@@ -276,21 +276,21 @@ module.exports.hasProperties = function(node, properties, parentNode = null) {
   }, []);
 };
 
-module.exports.hasProperty = function(node, types, parentNode = null) {
-  const typesArray = isArray(types) ? types : [ types ];
+module.exports.hasProperty = function(node, propertyNames, parentNode = null) {
+  propertyNames = isArray(propertyNames) ? propertyNames : [ propertyNames ];
 
-  const properties = findProperties(node, typesArray);
+  const properties = findProperties(node, propertyNames);
 
   if (properties.length !== 1) {
     return [
       {
-        message: `Element of type <${ node.$type }> must have one property of type ${ formatTypes(typesArray, true) }`,
+        message: `Element of type <${ node.$type }> must have property ${ formatNames(propertyNames, true) }`,
         path: getPath(node, parentNode),
         data: {
           type: ERROR_TYPES.PROPERTY_REQUIRED,
           node,
           parentNode: parentNode == node ? null : parentNode,
-          requiredProperty: types
+          requiredProperty: propertyNames
         }
       }
     ];
@@ -299,11 +299,12 @@ module.exports.hasProperty = function(node, types, parentNode = null) {
   return [];
 };
 
-function findProperties(node, types) {
+function findProperties(node, propertyNames) {
   const properties = [];
-  for (const type of types) {
-    if (isDefined(node.get(type))) {
-      properties.push(node.get(type));
+
+  for (const propertyName of propertyNames) {
+    if (isDefined(node.get(propertyName))) {
+      properties.push(node.get(propertyName));
     }
   }
 
@@ -318,7 +319,7 @@ module.exports.hasExtensionElement = function(node, types, parentNode = null) {
   if (!extensionElements || extensionElements.length !== 1) {
     return [
       {
-        message: `Element of type <${ node.$type }> must have one extension element of type ${ formatTypes(typesArray, true) }`,
+        message: `Element of type <${ node.$type }> must have one extension element of type ${ formatNames(typesArray, true) }`,
         path: getPath(node, parentNode),
         data: {
           type: ERROR_TYPES.EXTENSION_ELEMENT_REQUIRED,