@camunda/linting 0.3.5 → 0.4.0

package/CHANGELOG.md

@@ -6,6 +6,10 @@ All notable changes to [@camunda/linting](https://github.com/camunda/linting) ar
 
 ___Note:__ Yet to be released changes appear here._
 
+## 0.4.0
+
+* `FEAT`: add duplicate task headers rule ([#41](https://github.com/camunda/bpmnlint-plugin-camunda-compat/pull/41))
+
 ## 0.3.5
 
 * `FIX`: ignore null properties ([#39](https://github.com/camunda/bpmnlint-plugin-camunda-compat/pull/39))

package/lib/Linter.js

@@ -12,7 +12,7 @@ import modelerModdle from 'modeler-moddle/resources/modeler.json';
 import zeebeModdle from 'zeebe-bpmn-moddle/resources/zeebe.json';
 
 import { getErrorMessage } from './utils/error-messages';
-import { getEntryId } from './utils/properties-panel';
+import { getEntryIds } from './utils/properties-panel';
 
 const moddle = new BpmnModdle({
   modeler: modelerModdle,
@@ -63,6 +63,8 @@ export class Linter {
       return [
         ...allReports,
         ...reports.map(report => {
+          const entryIds = getEntryIds(report);
+
           return {
             ...report,
             message: getErrorMessage(
@@ -71,7 +73,7 @@ export class Linter {
               this._modeler
             ),
             propertiesPanel: {
-              entryId: getEntryId(report)
+              entryId: entryIds[ Math.max(0, entryIds.length - 1) ]
             }
           };
         })

package/lib/utils/error-messages.js

@@ -1,6 +1,7 @@
 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';
 
@@ -46,6 +47,10 @@ export function getErrorMessage(report, executionPlatformLabel, modeler = 'deskt
     return getPropertyTypeNotAllowedErrorMessage(report, executionPlatformLabel);
   }
 
+  if (type === ERROR_TYPES.PROPERTY_VALUE_DUPLICATED) {
+    return getPropertyValueDuplicatedErrorMessage(report);
+  }
+
   return message;
 }
 
@@ -73,6 +78,28 @@ function getElementTypeNotAllowedErrorMessage(report, executionPlatformLabel) {
   return `${ getIndefiniteArticle(typeString) } <${ typeString }> is not supported by ${ executionPlatformLabel }`;
 }
 
+function getPropertyValueDuplicatedErrorMessage(report) {
+  const {
+    error,
+    message
+  } = report;
+
+  const {
+    node,
+    parentNode,
+    duplicatedPropertyValue,
+    properties
+  } = error;
+
+  const typeString = getTypeString(parentNode || node);
+
+  if (is(node, 'zeebe:TaskHeaders') && every(properties, property => is(property, 'zeebe:Header'))) {
+    return `${ getIndefiniteArticle(typeString) } <${ typeString }> with two or more <Headers> with the same <Key> (${ duplicatedPropertyValue }) is not supported`;
+  }
+
+  return message;
+}
+
 function getExtensionElementNotAllowedErrorMessage(report, executionPlatformLabel) {
   const {
     error,

package/lib/utils/properties-panel.js

@@ -4,107 +4,125 @@ import { is } from 'bpmnlint-utils';
 
 import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types';
 
-export function getEntryId(report) {
+/**
+ * Get errors for a given element.
+ *
+ * @param {Object[]} reports
+ * @param {Object} element
+ *
+ * @returns {Object}
+ */
+export function getErrors(reports, element) {
+  return reports.reduce((errors, report) => {
+    if (!element || getBusinessObject(element).get('id') !== report.id) {
+      return errors;
+    }
+
+    const ids = getEntryIds(report);
+
+    if (!ids.length) {
+      return errors;
+    }
+
+    let { message } = report;
+
+    return {
+      ...errors,
+      ...ids.reduce((errors, id) => {
+        return {
+          ...errors,
+          [ id ]: getErrorMessage(id) || message
+        };
+      }, {})
+    };
+  }, {});
+}
+
+export function getEntryIds(report) {
   const {
-    error = {}
+    error = {},
+    id
   } = report;
 
   if (isExtensionElementRequiredError(error, 'zeebe:CalledDecision', 'bpmn:BusinessRuleTask')) {
-    return 'businessRuleImplementation';
+    return [ 'businessRuleImplementation' ];
   }
 
   if (isPropertyRequiredError(error, 'errorRef')) {
-    return 'errorRef';
+    return [ 'errorRef' ];
   }
 
   if (isPropertyRequiredError(error, 'messageRef')) {
-    return 'messageRef';
+    return [ 'messageRef' ];
   }
 
   if (isPropertyRequiredError(error, 'decisionId', 'zeebe:CalledDecision')) {
-    return 'decisionId';
+    return [ 'decisionId' ];
   }
 
   if (isPropertyRequiredError(error, 'resultVariable', 'zeebe:CalledDecision')) {
-    return 'resultVariable';
+    return [ 'resultVariable' ];
   }
 
   if (isPropertyRequiredError(error, 'errorCode', 'bpmn:Error')) {
-    return 'errorCode';
+    return [ 'errorCode' ];
   }
 
   if (isPropertyRequiredError(error, 'name', 'bpmn:Message')) {
-    return 'messageName';
+    return [ 'messageName' ];
   }
 
   if (isExtensionElementRequiredError(error, 'zeebe:LoopCharacteristics', 'bpmn:MultiInstanceLoopCharacteristics')
     || isPropertyRequiredError(error, 'inputCollection', 'zeebe:LoopCharacteristics')) {
-    return 'multiInstance-inputCollection';
+    return [ 'multiInstance-inputCollection' ];
   }
 
   if (isPropertyDependendRequiredError(error, 'outputCollection', 'zeebe:LoopCharacteristics')) {
-    return 'multiInstance-outputCollection';
+    return [ 'multiInstance-outputCollection' ];
   }
 
   if (isPropertyDependendRequiredError(error, 'outputElement', 'zeebe:LoopCharacteristics')) {
-    return 'multiInstance-outputElement';
+    return [ 'multiInstance-outputElement' ];
   }
 
   if (isExtensionElementRequiredError(error, 'zeebe:CalledElement', 'bpmn:CallActivity')
     || isPropertyRequiredError(error, 'processId', 'zeebe:CalledElement')) {
-    return 'targetProcessId';
+    return [ 'targetProcessId' ];
   }
 
   if (isExtensionElementRequiredError(error, 'zeebe:TaskDefinition')
     || isPropertyRequiredError(error, 'type', 'zeebe:TaskDefinition')) {
-    return 'taskDefinitionType';
+    return [ 'taskDefinitionType' ];
   }
 
   if (isExtensionElementRequiredError(error, 'zeebe:Subscription')
     || isPropertyRequiredError(error, 'correlationKey', 'zeebe:Subscription')) {
-    return 'messageSubscriptionCorrelationKey';
+    return [ 'messageSubscriptionCorrelationKey' ];
   }
 
   if (isPropertyRequiredError(error, 'formKey', 'zeebe:FormDefinition')) {
-    return 'customFormKey';
+    return [ 'customFormKey' ];
   }
 
   if (isPropertyRequiredError(error, 'body', 'zeebe:UserTaskForm')) {
-    return 'formConfiguration';
+    return [ 'formConfiguration' ];
   }
 
-  return null;
-}
-
-/**
- * Get errors for a given element.
- *
- * @param {Object[]} reports
- * @param {Object} element
- *
- * @returns {Object}
- */
-export function getErrors(reports, element) {
-  return reports.reduce((errors, report) => {
-    if (!element || getBusinessObject(element).get('id') !== report.id) {
-      return errors;
-    }
-
-    const id = getEntryId(report);
+  if (isPropertyValueDuplicatedError(error, 'values', 'key', 'zeebe:TaskHeaders')) {
+    const {
+      node,
+      properties,
+      propertiesName
+    } = error;
 
-    if (!id) {
-      return errors;
-    }
-
-    let { message } = report;
+    return properties.map(property => {
+      const index = node.get(propertiesName).indexOf(property);
 
-    message = getErrorMessage(id) || message;
+      return `${ id }-header-${ index }-key`;
+    });
+  }
 
-    return {
-      ...errors,
-      [ id ]: message
-    };
-  }, {});
+  return [];
 }
 
 export function getErrorMessage(id) {
@@ -167,6 +185,10 @@ export function getErrorMessage(id) {
   if (id === 'formConfiguration') {
     return 'Form JSON configuration must be defined.';
   }
+
+  if (/^.+-header-[0-9]+-key$/.test(id)) {
+    return 'Must be unique.';
+  }
 }
 
 function isExtensionElementRequiredError(error, requiredExtensionElement, type) {
@@ -188,6 +210,13 @@ function isPropertyRequiredError(error, requiredProperty, type) {
     && (!type || is(error.node, type));
 }
 
+function isPropertyValueDuplicatedError(error, propertiesName, duplicatedProperty, type) {
+  return error.type === ERROR_TYPES.PROPERTY_VALUE_DUPLICATED
+    && error.propertiesName === propertiesName
+    && error.duplicatedProperty === duplicatedProperty
+    && (!type || is(error.node, type));
+}
+
 function getBusinessObject(element) {
   return element.businessObject || element;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camunda/linting",
-  "version": "0.3.5",
+  "version": "0.4.0",
   "description": "Linting for Camunda Platform",
   "main": "index.js",
   "scripts": {
@@ -17,11 +17,15 @@
     "name": "Philipp Fromme",
     "url": "https://github.com/philippfromme"
   },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/camunda/linting"
+  },
   "license": "MIT",
   "dependencies": {
     "bpmn-moddle": "^7.1.2",
     "bpmnlint": "^7.8.0",
-    "bpmnlint-plugin-camunda-compat": "^0.9.2",
+    "bpmnlint-plugin-camunda-compat": "^0.10.0",
     "bpmnlint-utils": "^1.0.2",
     "modeler-moddle": "^0.2.0",
     "zeebe-bpmn-moddle": "^0.12.1"