bpmnlint-plugin-camunda-compat 0.12.0 → 0.13.0

package/index.js

@@ -1,7 +1,8 @@
 const { omit } = require('min-dash');
 
 const calledDecisionOrTaskDefinitionConfig = require('./rules/called-decision-or-task-definition/config'),
-      elementTypeConfig = require('./rules/element-type/config');
+      elementTypeConfig = require('./rules/element-type/config'),
+      timerConfig = require('./rules/timer/config');
 
 const camundaCloud10Rules = {
   'called-decision-or-task-definition': [ 'error', calledDecisionOrTaskDefinitionConfig.camundaCloud10 ],
@@ -14,6 +15,7 @@ const camundaCloud10Rules = {
   'no-template': 'error',
   'no-zeebe-properties': 'error',
   'subscription': 'error',
+  'timer': [ 'error', timerConfig.camundaCloud10 ],
   'user-task-form': 'error'
 };
 
@@ -39,7 +41,8 @@ const camundaCloud80Rules = omit(camundaCloud13Rules, 'no-template');
 const camundaCloud81Rules = {
   ...omit(camundaCloud80Rules, 'no-zeebe-properties'),
   'element-type': [ 'error', elementTypeConfig.camundaCloud81 ],
-  'inclusive-gateway': 'error'
+  'inclusive-gateway': 'error',
+  'timer': [ 'error', timerConfig.camundaCloud81 ]
 };
 
 module.exports = {

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "bpmnlint-plugin-camunda-compat",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "A bpmnlint plug-in for Camunda Platform compatibility",
   "main": "index.js",
   "scripts": {
     "all": "npm run lint && npm test",
+    "dev": "npm run test:watch",
     "lint": "eslint .",
     "test": "mocha test/**/*.spec.js",
     "test:watch": "npm run test -- --watch"

package/rules/called-decision-or-task-definition/config.js

@@ -1,36 +1,33 @@
+const camundaCloud10ElementsTaskDefinition = [
+  'bpmn:ServiceTask'
+];
+
+const camundaCloud11ElementsTaskDefinition = [
+  ...camundaCloud10ElementsTaskDefinition,
+  'bpmn:BusinessRuleTask',
+  'bpmn:ScriptTask',
+  'bpmn:SendTask'
+];
+
+const camundaCloud12ElementsTaskDefinition = [
+  ...camundaCloud11ElementsTaskDefinition,
+  'bpmn:IntermediateThrowEvent'
+];
+
 module.exports = {
   camundaCloud10: {
-    elementsTaskDefinition: [
-      'bpmn:ServiceTask'
-    ]
+    elementsTaskDefinition: camundaCloud10ElementsTaskDefinition
   },
   camundaCloud11: {
-    elementsTaskDefinition: [
-      'bpmn:BusinessRuleTask',
-      'bpmn:ServiceTask',
-      'bpmn:ScriptTask',
-      'bpmn:SendTask'
-    ]
+    elementsTaskDefinition: camundaCloud11ElementsTaskDefinition
   },
   camundaCloud12: {
-    elementsTaskDefinition: [
-      'bpmn:BusinessRuleTask',
-      'bpmn:IntermediateThrowEvent',
-      'bpmn:ServiceTask',
-      'bpmn:ScriptTask',
-      'bpmn:SendTask'
-    ]
+    elementsTaskDefinition: camundaCloud12ElementsTaskDefinition
   },
   camundaCloud13: {
     elementsCalledDecision: [
       'bpmn:BusinessRuleTask'
     ],
-    elementsTaskDefinition: [
-      'bpmn:BusinessRuleTask',
-      'bpmn:IntermediateThrowEvent',
-      'bpmn:ServiceTask',
-      'bpmn:ScriptTask',
-      'bpmn:SendTask'
-    ]
+    elementsTaskDefinition: camundaCloud12ElementsTaskDefinition
   }
 };

package/rules/element-type/config.js

@@ -94,7 +94,11 @@ const camundaCloud12EventDefinitions = {
 };
 
 const camundaCloud81EventDefinitions = {
-  ...camundaCloud12EventDefinitions
+  ...camundaCloud12EventDefinitions,
+  'bpmn:EndEvent': [
+    ...camundaCloud12EventDefinitions['bpmn:EndEvent'],
+    'bpmn:TerminateEventDefinition'
+  ]
 };
 
 module.exports = {

package/rules/timer/config.js

@@ -0,0 +1,17 @@
+const camundaCloud10Formats = [
+  'iso8601'
+];
+
+const camundaCloud81Formats = [
+  ...camundaCloud10Formats,
+  'cron'
+];
+
+module.exports = {
+  camundaCloud10: {
+    formats: camundaCloud10Formats
+  },
+  camundaCloud81: {
+    formats: camundaCloud81Formats
+  }
+};

package/rules/timer/index.js

@@ -0,0 +1,164 @@
+const {
+  is
+} = require('bpmnlint-utils');
+
+const {
+  getEventDefinition,
+  hasProperties,
+  hasProperty
+} = require('../utils/element');
+
+const { validateCronExpression } = require('../utils/cron');
+
+const {
+  validateCycle: validateISO8601Cycle,
+  validateDate: validateISO8601Date,
+  validateDuration: validateISO8601Duration
+} = require('../utils/iso8601');
+
+const { reportErrors } = require('../utils/reporter');
+
+module.exports = function(config = {}) {
+  const { formats = [] } = config;
+
+  function check(node, reporter) {
+    if (!is(node, 'bpmn:Event')) {
+      return;
+    }
+
+    const eventDefinition = getEventDefinition(node);
+
+    if (!eventDefinition || !is(eventDefinition, 'bpmn:TimerEventDefinition')) {
+      return;
+    }
+
+    let errors = checkTimePropertyExists(eventDefinition, node);
+
+    if (errors && errors.length) {
+      reportErrors(node, reporter, errors);
+
+      return;
+    }
+
+    const timeProperty = getTimeProperty(eventDefinition);
+
+    errors = checkTimePropertyNotEmpty(timeProperty, node);
+
+    if (errors && errors.length) {
+      reportErrors(node, reporter, errors);
+
+      return;
+    }
+
+    errors = checkTimePropertyCorrectFormat(eventDefinition, node, formats);
+
+    if (errors && errors.length) {
+      reportErrors(node, reporter, errors);
+    }
+  }
+
+  return {
+    check
+  };
+};
+
+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 checkTimePropertyNotEmpty(timeProperty, event) {
+  return hasProperties(timeProperty, {
+    body: {
+      required: true,
+    }
+  }, event);
+}
+
+function checkTimePropertyCorrectFormat(eventDefinition, event, formats) {
+  const timeCycle = eventDefinition.get('timeCycle'),
+        timeDate = eventDefinition.get('timeDate'),
+        timeDuration = eventDefinition.get('timeDuration');
+
+  if (timeCycle) {
+    return hasProperties(timeCycle, {
+      body: {
+        allowed: cycle => validateCycle(cycle, formats)
+      }
+    }, event);
+  } else if (timeDate) {
+    return hasProperties(timeDate, {
+      body: {
+        allowed: date => validateDate(date, formats)
+      }
+    }, event);
+  } else if (timeDuration) {
+    return hasProperties(timeDuration, {
+      body: {
+        allowed: duration => validateDuration(duration, formats)
+      }
+    }, event);
+  }
+}
+
+
+
+// helper //////////////
+function getTimeProperty(eventDefinition) {
+  return eventDefinition.get('timeCycle') || eventDefinition.get('timeDate') || eventDefinition.get('timeDuration');
+}
+
+function isInterruptingBoundaryEvent(event) {
+  return is(event, 'bpmn:BoundaryEvent') && event.get('cancelActivity') !== false;
+}
+
+function validateDate(date, formats) {
+  if (validateExpression(date)) {
+    return true;
+  }
+
+  if (formats.includes('iso8601') && validateISO8601Date(date)) {
+    return true;
+  }
+}
+
+function validateCycle(cycle, formats) {
+  if (validateExpression(cycle)) {
+    return true;
+  }
+
+  if (formats.includes('iso8601') && validateISO8601Cycle(cycle)) {
+    return true;
+  }
+
+  if (formats.includes('cron') && validateCronExpression(cycle)) {
+    return true;
+  }
+}
+
+function validateDuration(duration, formats) {
+  if (validateExpression(duration)) {
+    return true;
+  }
+
+  if (formats.includes('iso8601') && validateISO8601Duration(duration)) {
+    return true;
+  }
+}
+
+function validateExpression(text) {
+  if (text.startsWith('=')) {
+    return true;
+  }
+}

package/rules/utils/cron.js

@@ -0,0 +1,95 @@
+const MACROS = [
+  '@yearly',
+  '@annually',
+  '@monthly',
+  '@weekly',
+  '@daily',
+  '@midnight',
+  '@hourly'
+];
+const MACRO_REGEX = new RegExp(`^(${ MACROS.join('|') })$`);
+
+function validateMacro(text) {
+  return MACRO_REGEX.test(text);
+}
+
+const ASTERISK = '\\*';
+const QUESTION_MARK = '\\?';
+const COMMA = ',';
+
+const SECOND = '([0-5]?[0-9])';
+const MINUTE = '([0-5]?[0-9])';
+const HOUR = '([01]?[0-9]|2[0-3])';
+const DAY_OF_MONTH = or(`L(-${ or('[0-2]?[0-9]', '3[0-1]') })?`, '[0-2]?[0-9]', '3[0-1]', dayOfMonthSuffix(or('L', '[0-2]?[0-9]', '3[0-1]')));
+
+const MONTHS = [
+  'JAN',
+  'FEB',
+  'MAR',
+  'APR',
+  'MAY',
+  'JUN',
+  'JUL',
+  'AUG',
+  'SEP',
+  'OCT',
+  'NOV',
+  'DEC'
+];
+const MONTH = or('[0]?[1-9]', '1[0-2]', ...MONTHS);
+
+const WEEK_DAYS = [
+  'MON',
+  'TUE',
+  'WED',
+  'THU',
+  'FRI',
+  'SAT',
+  'SUN'
+];
+const DAY_OF_WEEK = or('[0-7]', ...WEEK_DAYS);
+
+const SECOND_REGEX = or(ASTERISK, interval(ASTERISK), commaSeparated(or(interval(SECOND), optionalRange(SECOND))));
+const MINUTE_REGEX = or(ASTERISK, interval(ASTERISK), commaSeparated(or(interval(MINUTE), optionalRange(MINUTE))));
+const HOUR_REGEX = or(ASTERISK, interval(ASTERISK), commaSeparated(or(interval(HOUR), optionalRange(HOUR))));
+const DAY_OF_MONTH_REGEX = or(ASTERISK, QUESTION_MARK, commaSeparated(optionalRange(DAY_OF_MONTH)));
+const MONTH_REGEX = or(ASTERISK, commaSeparated(optionalRange(MONTH)));
+const DAY_OF_WEEK_REGEX = or(ASTERISK, QUESTION_MARK, commaSeparated(or(optionalRange(DAY_OF_WEEK), dayOfWeekSuffix(DAY_OF_WEEK))));
+
+const CRON_REGEX = new RegExp(`^${ SECOND_REGEX } ${ MINUTE_REGEX } ${ HOUR_REGEX } ${ DAY_OF_MONTH_REGEX } ${ MONTH_REGEX } ${ DAY_OF_WEEK_REGEX }$`, 'i');
+
+function validateCron(value) {
+  return CRON_REGEX.test(value);
+}
+
+module.exports.validateCronExpression = function(value) {
+  return validateMacro(value) || validateCron(value);
+};
+
+
+
+// helper //////////////
+
+function or(...patterns) {
+  return `(${patterns.join('|')})`;
+}
+
+function optionalRange(pattern) {
+  return `${pattern}(-${pattern})?`;
+}
+
+function commaSeparated(pattern) {
+  return `${pattern}(${COMMA}${pattern})*`;
+}
+
+function interval(pattern) {
+  return `${pattern}/\\d+`;
+}
+
+function dayOfMonthSuffix(pattern) {
+  return `${pattern}W`;
+}
+
+function dayOfWeekSuffix(pattern) {
+  return `${pattern}(#[1-5]|L)`;
+}

package/rules/utils/element.js

@@ -1,6 +1,7 @@
 const {
   isArray,
   isDefined,
+  isFunction,
   isNil,
   some
 } = require('min-dash');
@@ -223,10 +224,62 @@ module.exports.hasProperties = function(node, properties, parentNode = null) {
       ];
     }
 
+    if (isFunction(propertyChecks.allowed) && !propertyChecks.allowed(propertyValue)) {
+      return [
+        ...results,
+        {
+          message: `Property <${ propertyName }> of element of type <${ node.$type }> must not have value of <${ truncate(propertyValue) }>`,
+          path: path
+            ? [ ...path, propertyName ]
+            : [ propertyName ],
+          error: {
+            type: ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED,
+            node,
+            parentNode: parentNode == node ? null : parentNode,
+            property: propertyName,
+          }
+        }
+      ];
+    }
+
     return results;
   }, []);
 };
 
+module.exports.hasProperty = function(node, types, parentNode = null) {
+  const typesArray = isArray(types) ? types : [ types ];
+
+  const properties = findProperties(node, typesArray);
+
+  if (properties.length !== 1) {
+    return [
+      {
+        message: `Element of type <${ node.$type }> must have one property of type ${ formatTypes(typesArray, true) }`,
+        path: getPath(node, parentNode),
+        error: {
+          type: ERROR_TYPES.PROPERTY_REQUIRED,
+          node,
+          parentNode: parentNode == node ? null : parentNode,
+          requiredProperty: types
+        }
+      }
+    ];
+  }
+
+  return [];
+};
+
+function findProperties(node, types) {
+  const properties = [];
+  for (const type of types) {
+    if (isDefined(node.get(type))) {
+      properties.push(node.get(type));
+    }
+  }
+
+  return properties;
+}
+
 module.exports.hasExtensionElement = function(node, types, parentNode = null) {
   const typesArray = isArray(types) ? types : [ types ];
 
@@ -281,4 +334,10 @@ module.exports.isExactly = isExactly;
 
 module.exports.isAnyExactly = function(node, types) {
   return some(types, (type) => isExactly(node, type));
-};
+};
+
+function truncate(string, maxLength = 10) {
+  const stringified = `${ string }`;
+
+  return stringified.length > maxLength ? `${ stringified.slice(0, maxLength) }...` : stringified;
+}

package/rules/utils/error-types.js

@@ -6,5 +6,6 @@ module.exports.ERROR_TYPES = Object.freeze({
   PROPERTY_NOT_ALLOWED: 'propertyNotAllowed',
   PROPERTY_REQUIRED: 'propertyRequired',
   PROPERTY_TYPE_NOT_ALLOWED: 'propertyTypeNotAllowed',
-  PROPERTY_VALUE_DUPLICATED: 'propertyValueDuplicated'
+  PROPERTY_VALUE_DUPLICATED: 'propertyValueDuplicated',
+  PROPERTY_VALUE_NOT_ALLOWED: 'propertyValueNotAllowed',
 });

package/rules/utils/iso8601.js

@@ -0,0 +1,23 @@
+const ISO_DATE_REGEX = /^\d{4}(-\d\d){2}T(\d\d:){2}\d\d(Z|([+-]\d\d:\d\d)(\[\w+\/\w+\])?)?$/;
+const ISO_DURATION = 'P(?!$)(\\d+(\\.\\d+)?[Yy])?(\\d+(\\.\\d+)?[Mm])?(\\d+(\\.\\d+)?[Dd])?(T(?!$)(\\d+(\\.\\d+)?[Hh])?(\\d+(\\.\\d+)?[Mm])?(\\d+(\\.\\d+)?[Ss])?)?$';
+const ISO_DURATION_REGEX = new RegExp(`^${ISO_DURATION}$`);
+const ISO_CYCLE = `R(-1|\\d+)?/${ISO_DURATION}`;
+const ISO_CYCLE_REGEX = new RegExp(`^${ISO_CYCLE}$`);
+
+module.exports = {
+  validateCycle,
+  validateDate,
+  validateDuration
+};
+
+function validateCycle(value) {
+  return ISO_CYCLE_REGEX.test(value);
+}
+
+function validateDate(value) {
+  return ISO_DATE_REGEX.test(value);
+}
+
+function validateDuration(value) {
+  return ISO_DURATION_REGEX.test(value);
+}