@camunda/linting 0.1.1 → 0.3.1

package/CHANGELOG.md

@@ -6,6 +6,24 @@ All notable changes to [@camunda/linting](https://github.com/camunda/linting) ar
 
 ___Note:__ Yet to be released changes appear here._
 
+## 0.3.1
+
+* `FIX`: include `properties-panel.js` in published package ([a532ba5b](https://github.com/camunda/linting/commit/a532ba5b7bf0b126477c218484e668c418875b4e))
+
+## 0.3.0
+
+* `FEAT`: add properties panel entry ID to reports ([#7](https://github.com/camunda/bpmnlint-plugin-camunda-compat/pull/7))
+* `FEAT`: add #getErrors function that creates properties panel errors from reports ([#7](https://github.com/camunda/bpmnlint-plugin-camunda-compat/pull/7))
+* `FEAT`: adjust connectors error message ([#6](https://github.com/camunda/bpmnlint-plugin-camunda-compat/pull/6))
+
+### BREAKING CHANGES
+
+* #lint is not static anymore, Linter must be instantiated
+
+## 0.2.0
+
+* `FEAT`: add templates rule ([#31](https://github.com/camunda/bpmnlint-plugin-camunda-compat/pull/31))
+
 ## 0.1.1
 
 * `FIX`: lint subscription only if start event child of sub process ([#34](https://github.com/camunda/bpmnlint-plugin-camunda-compat/pull/34))

package/README.md

@@ -6,20 +6,32 @@ The BPMN linter used by the Camunda Desktop and Web Modeler. Batteries included.
 
 * bundles [bpmnlint](https://github.com/bpmn-io/bpmnlint) and [bpmnlint-plugin-camunda-compat](https://github.com/camunda/bpmnlint-plugin-camunda-compat/)
 * configures linter based on `modeler:executionPlatform` and `modeler:executionPlatformVersion`
-* adjusts error messages to be shown in desktop and web modeler
+* creates error messages to be shown in desktop and web modeler
+* creates errors to be shown in properties panel
 
 # Usage
 
 ```javascript
 import { Linter } from '@camunda/linting';
+import { getErrors } from '@camunda/linting/properties-panel';
 
-...
+// configure to be used with desktop or web modeler
+const linter = new Linter({
+  modeler: 'web'
+});
 
 // lint by passing definitions
-const reports = await Linter.lint(definitions);
+const reports = await linter.lint(definitions);
 
 // or passing XML
-const reports = await Linter.lint(xml);
+const reports = await linter.lint(xml);
+
+...
+
+const errors = getErrors(reports, element);
+
+// bpmn-js-properties-panel >=1.3.0
+eventBus.fire('propertiesPanel.setErrors', { errors });
 ```
 
 # License

package/lib/Linter.js

@@ -11,7 +11,8 @@ import { isString } from 'min-dash';
 import modelerModdle from 'modeler-moddle/resources/modeler.json';
 import zeebeModdle from 'zeebe-bpmn-moddle/resources/zeebe.json';
 
-import { adjustErrorMessages } from './utils/error-messages';
+import { getErrorMessage } from './utils/error-messages';
+import { getEntryId } from './utils/properties-panel';
 
 const moddle = new BpmnModdle({
   modeler: modelerModdle,
@@ -19,7 +20,13 @@ const moddle = new BpmnModdle({
 });
 
 export class Linter {
-  static async lint(contents) {
+  constructor(options = {}) {
+    const { modeler = 'desktop' } = options;
+
+    this._modeler = modeler;
+  }
+
+  async lint(contents) {
     let rootElement;
 
     if (isString(contents)) {
@@ -50,12 +57,25 @@ export class Linter {
       resolver: new StaticResolver(rules)
     });
 
-    let reports = await linter.lint(rootElement);
-
-    reports = adjustErrorMessages(reports, getExecutionPlatformLabel(executionPlatform, toSemverMinor(executionPlatformVersion)));
-
-    return Object.values(reports).reduce((reports, report) => {
-      return [ ...reports, ...report ];
+    const allReports = await linter.lint(rootElement);
+
+    return Object.values(allReports).reduce((allReports, reports) => {
+      return [
+        ...allReports,
+        ...reports.map(report => {
+          return {
+            ...report,
+            message: getErrorMessage(
+              report,
+              getExecutionPlatformLabel(executionPlatform, toSemverMinor(executionPlatformVersion)),
+              this._modeler
+            ),
+            propertiesPanel: {
+              entryId: getEntryId(report)
+            }
+          };
+        })
+      ];
     }, []);
   }
 }

package/lib/utils/error-messages.js

@@ -6,7 +6,7 @@ import { isArray } from 'min-dash';
 
 import { getTypeString } from './types';
 
-export function adjustErrorMessage(report, executionPlatformLabel) {
+export function getErrorMessage(report, executionPlatformLabel, modeler = 'desktop') {
   const {
     error,
     message
@@ -34,6 +34,10 @@ export function adjustErrorMessage(report, executionPlatformLabel) {
     return getPropertyDependendRequiredErrorMessage(report);
   }
 
+  if (type === ERROR_TYPES.PROPERTY_NOT_ALLOWED) {
+    return getPropertyNotAllowedErrorMessage(report, executionPlatformLabel, modeler);
+  }
+
   if (type === ERROR_TYPES.PROPERTY_REQUIRED) {
     return getPropertyRequiredErrorMessage(report, executionPlatformLabel);
   }
@@ -45,16 +49,6 @@ export function adjustErrorMessage(report, executionPlatformLabel) {
   return message;
 }
 
-export function adjustErrorMessages(reports, executionPlatformLabel) {
-  Object.values(reports).forEach(reportsForRule => {
-    reportsForRule.forEach(report => {
-      report.message = adjustErrorMessage(report, executionPlatformLabel);
-    });
-  });
-
-  return reports;
-}
-
 function getIndefiniteArticle(type) {
   if ([
     'Error',
@@ -160,6 +154,32 @@ function getPropertyDependendRequiredErrorMessage(report) {
   return message;
 }
 
+function getPropertyNotAllowedErrorMessage(report, executionPlatformLabel, modeler = 'desktop') {
+  const {
+    error,
+    message
+  } = report;
+
+  const {
+    node,
+    parentNode,
+    property
+  } = error;
+
+  if (property === 'modelerTemplate') {
+    const typeString = getTypeString(parentNode || node);
+
+    if (modeler === 'desktop') {
+      return `${ getIndefiniteArticle(typeString) } <Template ${ typeString }> is not supported by ${ executionPlatformLabel }`;
+    } else if (modeler === 'web') {
+      return `${ getIndefiniteArticle(typeString) } <Connector ${ typeString }> is not supported by ${ executionPlatformLabel }`;
+    }
+  }
+
+  return message;
+}
+
+
 function getPropertyRequiredErrorMessage(report, executionPlatformLabel) {
   const {
     error,
@@ -222,6 +242,14 @@ function getPropertyRequiredErrorMessage(report, executionPlatformLabel) {
     return `${ getIndefiniteArticle(typeString) } <${ typeString }> must have a defined <Message Reference>`;
   }
 
+  if (is(node, 'zeebe:FormDefinition') && requiredProperty === 'formKey') {
+    return `${ getIndefiniteArticle(typeString) } <${ typeString }> with <Form type: Custom form key> must have a defined <Form key>`;
+  }
+
+  if (is(node, 'zeebe:UserTaskForm') && requiredProperty === 'body') {
+    return `${ getIndefiniteArticle(typeString) } <${ typeString }> with <Form type: Camunda forms> must have a defined <Form JSON configuration>`;
+  }
+
   return message;
 }
 

package/lib/utils/properties-panel.js

@@ -0,0 +1,193 @@
+import { isArray } from 'min-dash';
+
+import { is } from 'bpmnlint-utils';
+
+import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/error-types';
+
+export function getEntryId(report) {
+  const {
+    error = {}
+  } = report;
+
+  if (isExtensionElementRequiredError(error, 'zeebe:CalledDecision', 'bpmn:BusinessRuleTask')) {
+    return 'businessRuleImplementation';
+  }
+
+  if (isPropertyRequiredError(error, 'errorRef')) {
+    return 'errorRef';
+  }
+
+  if (isPropertyRequiredError(error, 'messageRef')) {
+    return 'messageRef';
+  }
+
+  if (isPropertyRequiredError(error, 'decisionId', 'zeebe:CalledDecision')) {
+    return 'decisionId';
+  }
+
+  if (isPropertyRequiredError(error, 'resultVariable', 'zeebe:CalledDecision')) {
+    return 'resultVariable';
+  }
+
+  if (isPropertyRequiredError(error, 'errorCode', 'bpmn:Error')) {
+    return 'errorCode';
+  }
+
+  if (isPropertyRequiredError(error, 'name', 'bpmn:Message')) {
+    return 'messageName';
+  }
+
+  if (isExtensionElementRequiredError(error, 'zeebe:LoopCharacteristics', 'bpmn:MultiInstanceLoopCharacteristics')
+    || isPropertyRequiredError(error, 'inputCollection', 'zeebe:LoopCharacteristics')) {
+    return 'multiInstance-inputCollection';
+  }
+
+  if (isPropertyDependendRequiredError(error, 'outputCollection', 'zeebe:LoopCharacteristics')) {
+    return 'multiInstance-outputCollection';
+  }
+
+  if (isPropertyDependendRequiredError(error, 'outputElement', 'zeebe:LoopCharacteristics')) {
+    return 'multiInstance-outputElement';
+  }
+
+  if (isExtensionElementRequiredError(error, 'zeebe:CalledElement', 'bpmn:CallActivity')
+    || isPropertyRequiredError(error, 'processId', 'zeebe:CalledElement')) {
+    return 'targetProcessId';
+  }
+
+  if (isExtensionElementRequiredError(error, 'zeebe:TaskDefinition')
+    || isPropertyRequiredError(error, 'type', 'zeebe:TaskDefinition')) {
+    return 'taskDefinitionType';
+  }
+
+  if (isExtensionElementRequiredError(error, 'zeebe:Subscription')
+    || isPropertyRequiredError(error, 'correlationKey', 'zeebe:Subscription')) {
+    return 'messageSubscriptionCorrelationKey';
+  }
+
+  if (isPropertyRequiredError(error, 'formKey', 'zeebe:FormDefinition')) {
+    return 'customFormKey';
+  }
+
+  if (isPropertyRequiredError(error, 'body', 'zeebe:UserTaskForm')) {
+    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 (!id) {
+      return errors;
+    }
+
+    let { message } = report;
+
+    message = getErrorMessage(id) || message;
+
+    return {
+      ...errors,
+      [ id ]: message
+    };
+  }, {});
+}
+
+export function getErrorMessage(id) {
+  if (id === 'businessRuleTaskImplementation') {
+    return 'Implementation must be defined.';
+  }
+
+  if (id === 'errorRef') {
+    return 'Global error reference must be defined.';
+  }
+
+  if (id === 'messageRef') {
+    return 'Global message reference must be defined.';
+  }
+
+  if (id === 'decisionId') {
+    return 'Decision ID must be defined.';
+  }
+
+  if (id === 'resultVariable') {
+    return 'Result variable must be defined.';
+  }
+
+  if (id === 'errorCode') {
+    return 'Code must be defined.';
+  }
+
+  if (id === 'messageName') {
+    return 'Name must be defined.';
+  }
+
+  if (id === 'multiInstance-inputCollection') {
+    return 'Input collection must be defined.';
+  }
+
+  if (id === 'multiInstance-outputCollection') {
+    return 'Output collection must be defined.';
+  }
+
+  if (id === 'multiInstance-outputElement') {
+    return 'Output element must be defined.';
+  }
+
+  if (id === 'targetProcessId') {
+    return 'Process ID must be defined.';
+  }
+
+  if (id === 'taskDefinitionType') {
+    return 'Type must be defined.';
+  }
+
+  if (id === 'messageSubscriptionCorrelationKey') {
+    return 'Subscription correlation key must be defined.';
+  }
+
+  if (id === 'customFormKey') {
+    return 'Form key must be defined.';
+  }
+
+  if (id === 'formConfiguration') {
+    return 'Form JSON configuration must be defined.';
+  }
+}
+
+function isExtensionElementRequiredError(error, requiredExtensionElement, type) {
+  return error.type === ERROR_TYPES.EXTENSION_ELEMENT_REQUIRED
+    && (isArray(error.requiredExtensionElement) && error.requiredExtensionElement.includes(requiredExtensionElement)
+      || error.requiredExtensionElement === requiredExtensionElement)
+    && (!type || is(error.node, type));
+}
+
+function isPropertyDependendRequiredError(error, dependendRequiredProperty, type) {
+  return error.type === ERROR_TYPES.PROPERTY_DEPENDEND_REQUIRED
+    && error.dependendRequiredProperty === dependendRequiredProperty
+    && (!type || is(error.node, type));
+}
+
+function isPropertyRequiredError(error, requiredProperty, type) {
+  return error.type === ERROR_TYPES.PROPERTY_REQUIRED
+    && error.requiredProperty === requiredProperty
+    && (!type || is(error.node, type));
+}
+
+function getBusinessObject(element) {
+  return element.businessObject || element;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camunda/linting",
-  "version": "0.1.1",
+  "version": "0.3.1",
   "description": "Linting for Camunda Platform",
   "main": "index.js",
   "scripts": {
@@ -20,7 +20,7 @@
   "license": "MIT",
   "dependencies": {
     "bpmnlint": "^7.8.0",
-    "bpmnlint-plugin-camunda-compat": "^0.7.1",
+    "bpmnlint-plugin-camunda-compat": "^0.9.1",
     "bpmnlint-utils": "^1.0.2"
   },
   "devDependencies": {
@@ -34,8 +34,17 @@
     "modeler-moddle": "^0.2.0",
     "zeebe-bpmn-moddle": "^0.12.1"
   },
+  "peerDependencies": {
+    "bpmn-js-properties-panel": "1.3.x"
+  },
+  "peerDependenciesMeta": {
+    "bpmn-js-properties-panel": {
+      "optional": true
+    }
+  },
   "files": [
-    "lib"
+    "lib",
+    "properties-panel.js"
   ],
   "publishConfig": {
     "access": "public"

package/properties-panel.js

@@ -0,0 +1 @@
+export * from './lib/utils/properties-panel';