bpmnlint-plugin-camunda-compat 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+All notable changes to [bpmnlint-plugin-example](https://github.com/camunda/bpmnlint-plugin-camunda-compat) are documented here. We use [semantic versioning](http://semver.org/) for releases.
+
+## Unreleased
+
+___Note:__ Yet to be released changes appear here._
+
+## 0.0.1
+
+* `FEAT`: initial support for Camunda Cloud 1.0, 1.1, 1.2, and 1.3
+
+## ...
+
+Check `git log` for earlier history.

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021-present bpmn.io Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,32 @@
+# bpmnlint-plugin-camunda-compat
+
+[![CI](https://github.com/camunda/bpmnlint-plugin-camunda-compat/workflows/CI/badge.svg)](https://github.com/camunda/bpmnlint-plugin-camunda-compat/actions?query=workflow%3ACI)
+
+Camunda BPMN compatibility, packed as a [bpmnlint](https://github.com/bpmn-io/bpmnlint) plug-in.
+
+
+## Usage
+
+Add the plug-in via your `.bpmnlintrc` file:
+
+```
+{
+  "extends": [
+    "bpmnlint:recommended",
+    "plugin:camunda-compat/recommended"
+  ]
+}
+```
+
+To validate a diagram it must be pinned to a particular execution platform via the [`modeler`](https://github.com/camunda/modeler-moddle) BPMN 2.0 extension.
+
+
+## Resources
+
+* [Documentation](https://github.com/camunda/bpmnlint-plugin-camunda-compat/tree/master/docs/rules)
+* [Issues](https://github.com/camunda/bpmnlint-plugin-camunda-compat/issues)
+
+
+## License
+
+MIT

package/index.js

@@ -0,0 +1,20 @@
+module.exports = {
+  configs: {
+    recommended: {
+      rules: {
+        'camunda-cloud-1-0': 'error',
+        'camunda-cloud-1-1': 'error',
+        'camunda-cloud-1-2': 'error',
+        'camunda-cloud-1-3': 'error'
+      }
+    },
+    all: {
+      rules: {
+        'camunda-cloud-1-0': 'warn',
+        'camunda-cloud-1-1': 'warn',
+        'camunda-cloud-1-2': 'warn',
+        'camunda-cloud-1-3': 'warn'
+      }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "bpmnlint-plugin-camunda-compat",
+  "version": "0.1.1",
+  "description": "A bpmnlint plug-in for Camunda Cloud and Platform compatibility",
+  "main": "index.js",
+  "scripts": {
+    "all": "npm test",
+    "test": "mocha test/**/*.spec.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/camunda/bpmnlint-plugin-camunda-compat"
+  },
+  "keywords": [
+    "bpmnlint",
+    "plugin"
+  ],
+  "author": {
+    "name": "Philipp Fromme",
+    "url": "https://github.com/philippfromme"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "bpmn-moddle": "^7.1.2",
+    "bpmnlint": "^6.1.0",
+    "chai": "^4.2.0",
+    "mocha": "^5.2.0",
+    "modeler-moddle": "^0.1.0",
+    "zeebe-bpmn-moddle": "^0.10.0"
+  },
+  "dependencies": {
+    "bpmnlint-utils": "^1.0.2",
+    "min-dash": "^3.8.0"
+  },
+  "files": [
+    "rules",
+    "index.js"
+  ]
+}

package/rules/camunda-cloud-1-0-checks.js

@@ -0,0 +1,94 @@
+const {
+  checkSome,
+  hasEventDefinitionOfType,
+  hasLoopCharacteristicsOfType,
+  hasNoEventDefinition,
+  hasNoLanes,
+  hasNoLoopCharacteristics,
+  isNotBpmn
+} = require('./utils/rule');
+
+module.exports = [
+  {
+    check: isNotBpmn
+  },
+  'bpmn:Association',
+  'bpmn:CallActivity',
+  'bpmn:Collaboration',
+  'bpmn:DataObject',
+  'bpmn:DataObjectReference',
+  'bpmn:DataStoreReference',
+  'bpmn:Definitions',
+  'bpmn:EventBasedGateway',
+  'bpmn:ExclusiveGateway',
+  'bpmn:Group',
+  'bpmn:MessageFlow',
+  'bpmn:ParallelGateway',
+  'bpmn:Participant',
+  'bpmn:SequenceFlow',
+  'bpmn:TextAnnotation',
+  {
+    type: 'bpmn:BoundaryEvent',
+    check: hasEventDefinitionOfType([
+      'bpmn:ErrorEventDefinition',
+      'bpmn:MessageEventDefinition',
+      'bpmn:TimerEventDefinition'
+    ])
+  },
+  {
+    type: 'bpmn:EndEvent',
+    check: checkSome(
+      hasNoEventDefinition,
+      hasEventDefinitionOfType([
+        'bpmn:ErrorEventDefinition'
+      ])
+    )
+  },
+  {
+    type: 'bpmn:IntermediateCatchEvent',
+    check: hasEventDefinitionOfType([
+      'bpmn:MessageEventDefinition',
+      'bpmn:TimerEventDefinition'
+    ])
+  },
+  {
+    type: 'bpmn:Process',
+    check: hasNoLanes
+  },
+  {
+    type: 'bpmn:ReceiveTask',
+    check: checkSome(
+      hasNoLoopCharacteristics,
+      hasLoopCharacteristicsOfType('bpmn:MultiInstanceLoopCharacteristics')
+    )
+  },
+  {
+    type: 'bpmn:ServiceTask',
+    check: checkSome(
+      hasNoLoopCharacteristics,
+      hasLoopCharacteristicsOfType('bpmn:MultiInstanceLoopCharacteristics')
+    )
+  },
+  {
+    type: 'bpmn:StartEvent',
+    check: checkSome(
+      hasNoEventDefinition,
+      hasEventDefinitionOfType([
+        'bpmn:ErrorEventDefinition',
+        'bpmn:MessageEventDefinition',
+        'bpmn:TimerEventDefinition'
+      ])
+    )
+  },
+  {
+    type: 'bpmn:SubProcess',
+    check: hasNoLoopCharacteristics
+  },
+  {
+    type: 'bpmn:UserTask',
+    check: checkSome(
+      hasNoLoopCharacteristics,
+      hasLoopCharacteristicsOfType('bpmn:MultiInstanceLoopCharacteristics')
+    )
+  }
+];

package/rules/camunda-cloud-1-0.js

@@ -0,0 +1,5 @@
+const { createRule } = require('./utils/rule');
+
+const checks = require('./camunda-cloud-1-0-checks');
+
+module.exports = createRule('1.0', checks);

package/rules/camunda-cloud-1-1-checks.js

@@ -0,0 +1,44 @@
+const camundaCloud10Checks = require('./camunda-cloud-1-0-checks');
+
+const {
+  checkSome,
+  hasLoopCharacteristicsOfType,
+  hasNoEventDefinition,
+  hasNoLoopCharacteristics
+} = require('./utils/rule');
+
+module.exports = [
+  ...camundaCloud10Checks,
+  {
+    type: 'bpmn:BusinessRuleTask',
+    check: checkSome(
+      hasNoLoopCharacteristics,
+      hasLoopCharacteristicsOfType('bpmn:MultiInstanceLoopCharacteristics')
+    )
+  },
+  {
+    type: 'bpmn:IntermediateThrowEvent',
+    check: hasNoEventDefinition
+  },
+  {
+    type: 'bpmn:ManualTask',
+    check: checkSome(
+      hasNoLoopCharacteristics,
+      hasLoopCharacteristicsOfType('bpmn:MultiInstanceLoopCharacteristics')
+    )
+  },
+  {
+    type: 'bpmn:ScriptTask',
+    check: checkSome(
+      hasNoLoopCharacteristics,
+      hasLoopCharacteristicsOfType('bpmn:MultiInstanceLoopCharacteristics')
+    )
+  },
+  {
+    type: 'bpmn:SendTask',
+    check: checkSome(
+      hasNoLoopCharacteristics,
+      hasLoopCharacteristicsOfType('bpmn:MultiInstanceLoopCharacteristics')
+    )
+  }
+];

package/rules/camunda-cloud-1-1.js

@@ -0,0 +1,5 @@
+const { createRule } = require('./utils/rule');
+
+const checks = require('./camunda-cloud-1-1-checks');
+
+module.exports = createRule('1.1', checks);

package/rules/camunda-cloud-1-2-checks.js

@@ -0,0 +1,19 @@
+const camundaCloud11Checks = require('./camunda-cloud-1-1-checks');
+
+const { hasEventDefinitionOfType } = require('./utils/rule');
+ 
+module.exports = [
+  ...camundaCloud11Checks,
+  {
+    type: 'bpmn:EndEvent',
+    check: hasEventDefinitionOfType([
+      'bpmn:MessageEventDefinition'
+    ])
+  },
+  {
+    type: 'bpmn:IntermediateThrowEvent',
+    check: hasEventDefinitionOfType([
+      'bpmn:MessageEventDefinition'
+    ])
+  }
+];

package/rules/camunda-cloud-1-2.js

@@ -0,0 +1,5 @@
+const { createRule } = require('./utils/rule');
+
+const checks = require('./camunda-cloud-1-2-checks');
+
+module.exports = createRule('1.2', checks);

package/rules/camunda-cloud-1-3-checks.js

@@ -0,0 +1,5 @@
+const camundaCloud12Checks = require('./camunda-cloud-1-2-checks');
+
+module.exports = [
+  ...camundaCloud12Checks
+];

package/rules/camunda-cloud-1-3.js

@@ -0,0 +1,5 @@
+const { createRule } = require('./utils/rule');
+
+const checks = require('./camunda-cloud-1-3-checks');
+
+module.exports = createRule('1.3', checks);

package/rules/utils/engine-profile.js

@@ -0,0 +1,10 @@
+/**
+ * Strip patch version of a major.minor.patch
+ * semver identifier.
+ *
+ * @param {String|null} string
+ * @return {String|null}
+ */
+module.exports.toSemverMinor = function(string) {
+  return string && string.split(/\./).slice(0, 2).join('.');
+}

package/rules/utils/rule.js

@@ -0,0 +1,236 @@
+const {
+  isArray,
+  isNil,
+  isString,
+} = require('min-dash');
+
+const {
+  is,
+  isAny
+} = require('bpmnlint-utils');
+
+const { toSemverMinor } = require('./engine-profile');
+
+module.exports.createRule = function(version, checks) {
+  return () => {
+    return {
+      check: (node, reporter) => {
+
+        // do not lint properties (yet)
+        if (!isAny(node, [ 'bpmn:FlowElement', 'bpmn:FlowElementsContainer' ])) {
+          return;
+        }
+
+        const engineProfile = getEngineProfile(node);
+
+        if (!engineProfile) {
+          return;
+        }
+
+        const {
+          executionPlatform,
+          executionPlatformVersion
+        } = engineProfile;
+
+        if (!executionPlatformVersion || toSemverMinor(executionPlatformVersion) !== version) {
+          return;
+        }
+
+        const result = checkNode(node, checks);
+
+        if (result === false) {
+          reporter.report(node.get('id') || '', `Element of type <${ node.$type }> not supported by ${ executionPlatform } ${ toSemverMinor(executionPlatformVersion) }`);
+        }
+
+        if (isString(result)) {
+          reporter.report(node.get('id') || '', `Element of type <${ result }> not supported by ${ executionPlatform } ${ toSemverMinor(executionPlatformVersion) }`);
+        }
+      }
+    };
+  };
+}
+
+function getDefinitions(node) {
+  if (is(node, 'bpmn:Definitions')) {
+    return node;
+  }
+
+  const parent = node.$parent;
+
+  if (!parent) {
+    return null;
+  }
+
+  return getDefinitions(parent);
+}
+
+function getEngineProfile(node) {
+  const definitions = getDefinitions(node);
+
+  if (!definitions) {
+    return null;
+  }
+
+  const executionPlatform = definitions.get('modeler:executionPlatform'),
+        executionPlatformVersion = definitions.get('modeler:executionPlatformVersion');
+
+  if (!executionPlatform) {
+    return null;
+  }
+
+  return {
+    executionPlatform,
+    executionPlatformVersion
+  };
+}
+
+/**
+ * @param {ModdleElement} node
+ * @param {Array<Function>} checks
+ *
+ * @returns boolean|String
+ */
+function checkNode(node, checks) {
+  return checks.reduce((previousResult, check) => {
+    if (previousResult === true) {
+      return previousResult;
+    }
+
+    // (1) check using type only
+    if (isString(check)) {
+      return is(node, check) || previousResult;
+    }
+
+    const { type } = check;
+
+    // (2) check using function only
+    if (!type) {
+      return check.check(node) || previousResult;
+    }
+
+    // (3) check using type and function
+    if (!is(node, type)) {
+      return previousResult;
+    }
+
+    return check.check(node) || previousResult;
+  }, false);
+}
+
+/**
+ * If every check returns true return true.
+ * Otherwise return the first false or string returned by a check.
+ *
+ * @param  {Array<Function>} checks
+ *
+ * @returns {boolean|String}
+ */
+module.exports.checkEvery = function(...checks) {
+  return function(node) {
+    return checks.reduce((previousResult, check) => {
+      if (!isNil(previousResult) && previousResult !== true) {
+        return previousResult;
+      }
+
+      const result = check(node);
+
+      return result;
+    }, null);
+  };
+}
+
+/**
+ * If some check returns true return true.
+ * Otherwise return the first false or string returned by a check.
+ *
+ * @param  {Array<Function>} checks
+ *
+ * @returns {boolean|String}
+ */
+module.exports.checkSome = function(...checks) {
+  return function(node) {
+    return checks.reduce((previousResult, check) => {
+      if (previousResult === true) {
+        return previousResult;
+      }
+
+      const result = check(node);
+
+      if (isNil(previousResult) || result === true) {
+        return result;
+      }
+
+      return previousResult;
+    }, null);
+  };
+}
+
+module.exports.hasEventDefinition = function(node) {
+  const eventDefinitions = node.get('eventDefinitions');
+
+  return eventDefinitions && eventDefinitions.length === 1;
+}
+
+module.exports.hasNoEventDefinition = function(node) {
+  const eventDefinitions = node.get('eventDefinitions');
+
+  return !eventDefinitions || !eventDefinitions.length || `${ node.$type} (${ eventDefinitions[ 0 ].$type })`;
+}
+
+module.exports.hasEventDefinitionOfType = function(types) {
+  return function(node) {
+    if (!isArray(types)) {
+      types = [ types ];
+    }
+
+    const eventDefinitions = node.get('eventDefinitions');
+
+    if (!eventDefinitions || eventDefinitions.length !== 1) {
+      return false;
+    }
+
+    const eventDefinition = eventDefinitions[ 0 ];
+
+    return isAny(eventDefinition, types) || `${ node.$type} (${ eventDefinition.$type })`;
+  };
+}
+
+module.exports.hasLoopCharacteristics = function(node) {
+  const loopCharacteristics = node.get('loopCharacteristics');
+
+  return !!loopCharacteristics;
+}
+
+module.exports.hasNoLoopCharacteristics = function(node) {
+  const loopCharacteristics = node.get('loopCharacteristics');
+
+  return !loopCharacteristics || `${ node.$type} (${ loopCharacteristics.$type })`;
+}
+
+module.exports.hasNoLanes = function(node) {
+  const laneSets = node.get('laneSets');
+
+  return !laneSets || !laneSets.length || `${ node.$type} (bpmn:LaneSet)`;
+}
+
+module.exports.hasLoopCharacteristicsOfType = function(type) {
+  return function(node) {
+    const loopCharacteristics = node.get('loopCharacteristics');
+
+    if (!loopCharacteristics) {
+      return false;
+    }
+
+    return is(loopCharacteristics, type) || `${ node.$type} (${ loopCharacteristics.$type })`;
+  };
+}
+
+module.exports.isNotBpmn = function(node) {
+  const { $descriptor: descriptor } = node;
+
+  const { $pkg: package } = descriptor;
+
+  const { uri } = package;
+
+  return uri !== 'http://www.omg.org/spec/BPMN/20100524/MODEL';
+}