@camunda/linting 0.6.1 → 0.7.1

package/lib/Linter.js

@@ -1,17 +1,16 @@
 import BpmnModdle from 'bpmn-moddle/dist/index';
 
 import { Linter as BpmnLinter } from 'bpmnlint';
-
 import StaticResolver from 'bpmnlint/lib/resolver/static-resolver';
 
-import { configs } from 'bpmnlint-plugin-camunda-compat';
+import Resolver from './Resolver';
 
 import { isString } from 'min-dash';
 
 import modelerModdle from 'modeler-moddle/resources/modeler.json';
 import zeebeModdle from 'zeebe-bpmn-moddle/resources/zeebe.json';
 
-import { getErrorMessage } from './utils/error-messages';
+import { getErrorMessage, getExecutionPlatformLabel } from './utils/error-messages';
 import { getEntryIds } from './utils/properties-panel';
 
 const moddle = new BpmnModdle({
@@ -21,9 +20,13 @@ const moddle = new BpmnModdle({
 
 export class Linter {
   constructor(options = {}) {
-    const { modeler = 'desktop' } = options;
+    const {
+      modeler = 'desktop',
+      plugins = []
+    } = options;
 
     this._modeler = modeler;
+    this._plugins = plugins;
   }
 
   async lint(contents) {
@@ -44,22 +47,18 @@ export class Linter {
 
     const configName = getConfigName(executionPlatform, executionPlatformVersion);
 
-    const config = configs[ configName ];
-
-    if (!config) {
-      return [];
-    }
+    const config = this._createConfig(configName);
 
-    const rules = await importRules(config);
+    const resolver = await this._createResolver(configName);
 
     const linter = new BpmnLinter({
-      config: prefixRules(config),
-      resolver: new StaticResolver(rules)
+      config,
+      resolver
     });
 
-    const allReports = await linter.lint(rootElement);
+    const reportsByRule = await linter.lint(rootElement);
 
-    return Object.values(allReports).reduce((allReports, reports) => {
+    return Object.values(reportsByRule).reduce((allReports, reports) => {
       return [
         ...allReports,
         ...reports.map(report => {
@@ -80,6 +79,46 @@ export class Linter {
       ];
     }, []);
   }
+
+  _createConfig(configName) {
+    const configs = [
+      {
+        extends: `plugin:bpmnlint-plugin-camunda-compat/${ configName }`
+      },
+      ...this._plugins.map(({ config }) => config)
+    ];
+
+    return configs.reduce(
+      (config, _config) => {
+        let { extends: _extends = [], rules = {} } = _config;
+
+        if (isString(_extends)) {
+          _extends = [ _extends ];
+        }
+
+        return {
+          extends: [ ...config.extends, ..._extends ],
+          rules: {
+            ...config.rules,
+            ...rules
+          }
+        };
+      },
+      {
+        extends: [],
+        rules: {}
+      }
+    );
+  }
+
+  async _createResolver(configName) {
+    const cache = await createCache(configName);
+
+    return new Resolver([
+      new StaticResolver(cache),
+      ...this._plugins.map(({ resolver }) => resolver)
+    ]);
+  }
 }
 
 function getConfigName(executionPlatform, executionPlatformVersion) {
@@ -89,50 +128,42 @@ function getConfigName(executionPlatform, executionPlatformVersion) {
   ].join('-');
 }
 
-function prefixRules({ rules }) {
-  return {
-    rules: Object.entries(rules).reduce((rules, [ key, value ]) => {
-      return {
-        ...rules,
-        [ `bpmnlint-plugin-camunda-compat/${ key }` ]: value
-      };
-    }, {})
-  };
+function toLowerCase(string) {
+  return string.toLowerCase();
 }
 
-async function importRules({ rules }) {
-  let importedRules = {};
+function toSemverMinor(executionPlatformVersion) {
+  return executionPlatformVersion.split('.').slice(0, 2).join('.');
+}
 
-  for (let key of Object.keys(rules)) {
-    const importedRule = require(`bpmnlint-plugin-camunda-compat/rules/${ key }`);
+async function createCache(configName) {
+  let config = require('bpmnlint-plugin-camunda-compat').configs[ configName ];
 
-    importedRules = {
-      ...importedRules,
-      [ `rule:bpmnlint-plugin-camunda-compat/${ key }` ]: importedRule
+  if (!config) {
+    config = {
+      rules: {}
     };
   }
 
-  return importedRules;
+  const rules = await requireRules(config);
+
+  return {
+    [ `config:bpmnlint-plugin-camunda-compat/${ configName }` ]: config,
+    ...rules
+  };
 }
 
-const executionPlatformLabels = {
-  'Camunda Cloud': {
-    '1.0': 'Camunda 8 (Zeebe 1.0)',
-    '1.1': 'Camunda 8 (Zeebe 1.1)',
-    '1.2': 'Camunda 8 (Zeebe 1.2)',
-    '1.3': 'Camunda 8 (Zeebe 1.3)',
-    '8.0': 'Camunda 8'
-  }
-};
+function requireRules({ rules }) {
+  let requiredRules = {};
 
-function getExecutionPlatformLabel(executionPlatform, executionPlatformVersion) {
-  return executionPlatformLabels[ executionPlatform ] && executionPlatformLabels[ executionPlatform ][ executionPlatformVersion ];
-}
+  for (let ruleName of Object.keys(rules)) {
+    const requiredRule = require(`bpmnlint-plugin-camunda-compat/rules/${ ruleName }`);
 
-function toLowerCase(string) {
-  return string.toLowerCase();
-}
+    requiredRules = {
+      ...requiredRules,
+      [ `rule:bpmnlint-plugin-camunda-compat/${ ruleName }` ]: requiredRule
+    };
+  }
 
-function toSemverMinor(executionPlatformVersion) {
-  return executionPlatformVersion.split('.').slice(0, 2).join('.');
+  return requiredRules;
 }

package/lib/Resolver.js

@@ -0,0 +1,31 @@
+export default class NestedResolver {
+  constructor(resolvers) {
+    this.resolvers = resolvers.slice().reverse();
+  }
+
+  resolveRule(pkg, ruleName) {
+    for (const resolver of this.resolvers) {
+      try {
+        return resolver.resolveRule(pkg, ruleName);
+      } catch (err) {
+
+        // ignore
+      }
+    }
+
+    throw new Error(`unknown rule <${ pkg }/${ ruleName }>`);
+  }
+
+  resolveConfig(pkg, configName) {
+    for (const resolver of this.resolvers) {
+      try {
+        return resolver.resolveConfig(pkg, configName);
+      } catch (err) {
+
+        // ignore
+      }
+    }
+
+    throw new Error(`unknown config <${ pkg }/${ configName }>`);
+  }
+}

package/lib/modeler/Linting.js

@@ -28,7 +28,9 @@ export default class Linting {
       this._canvas.scrollToElement(element);
     }
 
-    this._selection.select(element);
+    if (element !== this._canvas.getRootElement()) {
+      this._selection.select(element);
+    }
 
     const { entryId } = propertiesPanel;
 

package/lib/modeler/LintingAnnotations.js

@@ -9,7 +9,8 @@ const errorSvg = `
 `;
 
 export default class LintingAnnotations {
-  constructor(elementRegistry, eventBus, overlays) {
+  constructor(canvas, elementRegistry, eventBus, overlays) {
+    this._canvas = canvas;
     this._elementRegistry = elementRegistry;
     this._eventBus = eventBus;
     this._overlays = overlays;
@@ -35,7 +36,7 @@ export default class LintingAnnotations {
     Object.entries(reportsByElement).forEach(([ id, reports ]) => {
       const element = this._elementRegistry.get(id);
 
-      if (!element) {
+      if (!element || element === this._canvas.getRootElement()) {
         return;
       }
 
@@ -66,6 +67,7 @@ export default class LintingAnnotations {
 }
 
 LintingAnnotations.$inject = [
+  'canvas',
   'elementRegistry',
   'eventBus',
   'overlays'

package/lib/utils/error-messages.js

@@ -1,12 +1,19 @@
 import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/element';
 
 import { is } from 'bpmnlint-utils';
-import { every } from 'min-dash';
-
-import { isArray } from 'min-dash';
+import {
+  every,
+  isArray
+} from 'min-dash';
 
 import { getTypeString } from './types';
 
+const TIMER_PROPERTIES = [
+  'timeDate',
+  'timeDuration',
+  'timeCycle'
+];
+
 export function getErrorMessage(report, executionPlatformLabel, modeler = 'desktop') {
   const {
     error,
@@ -14,7 +21,7 @@ export function getErrorMessage(report, executionPlatformLabel, modeler = 'deskt
   } = report;
 
   if (!error) {
-    return report;
+    return message;
   }
 
   const { type } = error;
@@ -51,9 +58,38 @@ export function getErrorMessage(report, executionPlatformLabel, modeler = 'deskt
     return getPropertyValueDuplicatedErrorMessage(report);
   }
 
+  if (type === ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED) {
+    return getPropertyValueNotAllowedErrorMessage(report, executionPlatformLabel);
+  }
+
   return message;
 }
 
+const executionPlatformLabels = {
+  'Camunda Cloud': {
+    'defaultPlatformName': 'Camunda',
+    '1.0': 'Camunda 8 (Zeebe 1.0)',
+    '1.1': 'Camunda 8 (Zeebe 1.1)',
+    '1.2': 'Camunda 8 (Zeebe 1.2)',
+    '1.3': 'Camunda 8 (Zeebe 1.3)',
+    '8.0': 'Camunda 8'
+  }
+};
+
+export function getExecutionPlatformLabel(executionPlatform, executionPlatformVersion) {
+  const translatedLabel = executionPlatformLabels[ executionPlatform ] && executionPlatformLabels[ executionPlatform ][ executionPlatformVersion ];
+
+  if (translatedLabel) {
+    return translatedLabel;
+  }
+
+  if (executionPlatformLabels[executionPlatform] && executionPlatformLabels[executionPlatform]['defaultPlatformName']) {
+    executionPlatform = executionPlatformLabels[executionPlatform]['defaultPlatformName'];
+  }
+
+  return `${ executionPlatform } ${ executionPlatformVersion }`;
+}
+
 function getIndefiniteArticle(type) {
   if ([
     'Error',
@@ -293,6 +329,24 @@ function getPropertyRequiredErrorMessage(report, executionPlatformLabel) {
     return `${ getIndefiniteArticle(typeString) } <${ typeString }> must have a defined <Condition expression> or be the default <Sequence Flow>`;
   }
 
+  if (is(node, 'bpmn:TimerEventDefinition')
+    && isArray(requiredProperty)
+    && TIMER_PROPERTIES.some(property => requiredProperty.includes(property))
+  ) {
+    return `${ getIndefiniteArticle(typeString) } <${ typeString }> must have a defined <Timer type>`;
+  }
+
+  if (is(node, 'bpmn:TimerEventDefinition') && requiredProperty === 'timeDuration') {
+    return `${ getIndefiniteArticle(typeString) } <${ typeString }> must have a defined <Timer duration>`;
+  }
+
+  if (is(node, 'bpmn:FormalExpression')
+    && requiredProperty === 'body'
+    && TIMER_PROPERTIES.includes(secondLast(report.path))
+  ) {
+    return `${ getIndefiniteArticle(typeString) } <${ typeString }> must have a defined <Timer value>`;
+  }
+
   return message;
 }
 
@@ -315,4 +369,43 @@ function getPropertyTypeNotAllowedErrorMessage(report, executionPlatformLabel) {
   }
 
   return message;
-}
+}
+
+function getPropertyValueNotAllowedErrorMessage(report, executionPlatformLabel) {
+  const {
+    error
+  } = report;
+
+  const {
+    node,
+    parentNode,
+    property
+  } = error;
+
+  const typeString = getTypeString(parentNode || node);
+
+  if (is(node, 'bpmn:FormalExpression')
+    && property === 'body'
+    && secondLast(report.path) === 'timeCycle'
+  ) {
+    return `${ getIndefiniteArticle(typeString) } <${ typeString }> <Time cycle> should be an expression, an ISO 8601 repeating interval, or a cron expression (cron requires Camunda Platform 8.1 or newer)`;
+  }
+
+  if (is(node, 'bpmn:FormalExpression')
+    && property === 'body'
+    && secondLast(report.path) === 'timeDate'
+  ) {
+    return `${ getIndefiniteArticle(typeString) } <${ typeString }> <Time date> should be an expression, or an ISO 8601 date`;
+  }
+
+  if (is(node, 'bpmn:FormalExpression')
+    && property === 'body'
+    && secondLast(report.path) === 'timeDuration'
+  ) {
+    return `${ getIndefiniteArticle(typeString) } <${ typeString }> <Time duration> should be an expression, or an ISO 8601 interval`;
+  }
+}
+
+function secondLast(array) {
+  return array[array.length - 2];
+}

package/lib/utils/properties-panel.js

@@ -4,6 +4,12 @@ import { is } from 'bpmnlint-utils';
 
 import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types';
 
+const TIMER_PROPERTIES = [
+  'timeDate',
+  'timeDuration',
+  'timeCycle'
+];
+
 /**
  * Get errors for a given element.
  *
@@ -31,7 +37,7 @@ export function getErrors(reports, element) {
       ...ids.reduce((errors, id) => {
         return {
           ...errors,
-          [ id ]: getErrorMessage(id) || message
+          [ id ]: getErrorMessage(id, report) || message
         };
       }, {})
     };
@@ -134,10 +140,28 @@ export function getEntryIds(report) {
     return [ 'conditionExpression' ];
   }
 
+  if (isPropertyRequiredError(error, 'timeDuration', 'bpmn:TimerEventDefinition')) {
+    return [ 'timerEventDefinitionDurationValue' ];
+  }
+
+  if (TIMER_PROPERTIES.some(property =>
+    isOneOfPropertiesRequiredError(error, property , 'bpmn:TimerEventDefinition'))
+  ) {
+    return [ 'timerEventDefinitionType' ];
+  }
+
+  if (isPropertyRequiredError(error, 'body', 'bpmn:FormalExpression') && TIMER_PROPERTIES.includes(secondLast(report.path))) {
+    return hasOnlyDurationTimer(error.parentNode) ? [ 'timerEventDefinitionDurationValue' ] : [ 'timerEventDefinitionValue' ];
+  }
+
+  if (isPropertyValueNotAllowedError(error, 'body', 'bpmn:FormalExpression') && TIMER_PROPERTIES.includes(secondLast(report.path))) {
+    return hasOnlyDurationTimer(error.parentNode) ? [ 'timerEventDefinitionDurationValue' ] : [ 'timerEventDefinitionValue' ];
+  }
+
   return [];
 }
 
-export function getErrorMessage(id) {
+export function getErrorMessage(id, report) {
   if (id === 'businessRuleImplementation') {
     return 'Implementation must be defined.';
   }
@@ -182,7 +206,7 @@ export function getErrorMessage(id) {
     return 'Process ID must be defined.';
   }
 
-  if (id === 'taskDefinitionType') {
+  if (id === 'taskDefinitionType' || id === 'timerEventDefinitionType') {
     return 'Type must be defined.';
   }
 
@@ -209,6 +233,31 @@ export function getErrorMessage(id) {
   if (id === 'conditionExpression') {
     return 'Condition expression must be defined.';
   }
+
+  if (id === 'timerEventDefinitionDurationValue') {
+    return report.error.type === ERROR_TYPES.PROPERTY_REQUIRED ?
+      'Duration must be defined.' : 'Must be an expression, or an ISO 8601 interval.';
+  }
+
+  if (id === 'timerEventDefinitionValue') {
+    if (report.error.type === ERROR_TYPES.PROPERTY_REQUIRED) {
+      return 'Value must be defined.';
+    }
+
+    const property = secondLast(report.path);
+
+    if (property === 'timeCycle') {
+      return 'Must be an expression, an ISO 8601 repeating interval, or a cron expression (cron requires Camunda Platform 8.1 or newer).';
+    }
+
+    if (property === 'timeDate') {
+      return 'Must be an expression, or an ISO 8601 date.';
+    }
+
+    if (property === 'timeDuration') {
+      return 'Must be an expression, or an ISO 8601 interval.';
+    }
+  }
 }
 
 function isExtensionElementNotAllowedError(error, extensionElement, type) {
@@ -232,7 +281,13 @@ function isPropertyDependendRequiredError(error, dependendRequiredProperty, type
 
 function isPropertyRequiredError(error, requiredProperty, type) {
   return error.type === ERROR_TYPES.PROPERTY_REQUIRED
-    && error.requiredProperty === requiredProperty
+    && (error.requiredProperty === requiredProperty)
+    && (!type || is(error.node, type));
+}
+
+function isOneOfPropertiesRequiredError(error, requiredProperty, type) {
+  return error.type === ERROR_TYPES.PROPERTY_REQUIRED
+    && (isArray(error.requiredProperty) && error.requiredProperty.includes(requiredProperty))
     && (!type || is(error.node, type));
 }
 
@@ -243,6 +298,24 @@ function isPropertyValueDuplicatedError(error, propertiesName, duplicatedPropert
     && (!type || is(error.node, type));
 }
 
+function isPropertyValueNotAllowedError(error, propertyName, type) {
+  return error.type === ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED
+    && error.property === propertyName
+    && (!type || is(error.node, type));
+}
+
 function getBusinessObject(element) {
   return element.businessObject || element;
-}
+}
+
+function secondLast(array) {
+  return array[array.length - 2];
+}
+
+function hasOnlyDurationTimer(node) {
+  return is(node, 'bpmn:IntermediateCatchEvent') || isInterruptingBoundaryEvent(node);
+}
+
+function isInterruptingBoundaryEvent(event) {
+  return is(event, 'bpmn:BoundaryEvent') && event.get('cancelActivity') !== false;
+}

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@camunda/linting",
-  "version": "0.6.1",
+  "version": "0.7.1",
   "description": "Linting for Camunda Platform",
   "main": "index.js",
   "scripts": {
     "all": "npm run lint && npm test",
+    "dev": "npm run test:watch",
     "lint": "eslint .",
     "start": "cross-env SINGLE_START=modeler npm run test:watch",
     "test": "karma start",
@@ -24,12 +25,12 @@
   },
   "license": "MIT",
   "dependencies": {
-    "bpmn-moddle": "^7.1.2",
-    "bpmnlint": "^7.8.0",
-    "bpmnlint-plugin-camunda-compat": "^0.12.0",
+    "bpmn-moddle": "^7.1.3",
+    "bpmnlint": "^8.0.0",
+    "bpmnlint-plugin-camunda-compat": "^0.13.1",
     "bpmnlint-utils": "^1.0.2",
-    "min-dash": "^3.8.1",
-    "min-dom": "^3.2.1",
+    "min-dash": "^4.0.0",
+    "min-dom": "^4.0.1",
     "zeebe-bpmn-moddle": "^0.15.0"
   },
   "devDependencies": {
@@ -38,8 +39,8 @@
     "bpmn-js-properties-panel": "^1.6.1",
     "chai": "^4.3.6",
     "cross-env": "^7.0.3",
-    "eslint": "^4.11.0",
-    "eslint-plugin-bpmn-io": "^0.4.1",
+    "eslint": "^8.23.1",
+    "eslint-plugin-bpmn-io": "^0.16.0",
     "karma": "^6.4.0",
     "karma-chrome-launcher": "^3.1.1",
     "karma-debug-launcher": "0.0.5",
@@ -47,7 +48,7 @@
     "karma-mocha": "^2.0.1",
     "karma-sinon-chai": "^2.0.2",
     "karma-webpack": "^5.0.0",
-    "mocha": "^4.0.1",
+    "mocha": "^10.0.0",
     "mocha-test-container-support": "^0.2.0",
     "modeler-moddle": "^0.2.0",
     "puppeteer": "^16.2.0",