bpmnlint-plugin-camunda-compat 2.19.0 → 2.20.0

package/index.js

@@ -37,6 +37,7 @@ const camundaCloud13Rules = withConfig(camundaCloud12Rules, { version: '1.3' });
 
 const camundaCloud80Rules = withConfig({
   ...omit(camundaCloud13Rules, 'no-template'),
+  'connector-properties': 'warn'
 }, { version: '8.0' });
 
 const camundaCloud81Rules = withConfig({
@@ -102,6 +103,7 @@ const rules = {
   'element-type': './rules/camunda-cloud/element-type',
   'called-element': './rules/camunda-cloud/called-element',
   'collapsed-subprocess': './rules/camunda-cloud/collapsed-subprocess',
+  'connector-properties': './rules/camunda-cloud/connector-properties',
   'duplicate-task-headers': './rules/camunda-cloud/duplicate-task-headers',
   'error-reference': './rules/camunda-cloud/error-reference',
   'escalation-boundary-event-attached-to-ref': './rules/camunda-cloud/escalation-boundary-event-attached-to-ref',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bpmnlint-plugin-camunda-compat",
-  "version": "2.19.0",
+  "version": "2.20.0",
   "description": "A bpmnlint plug-in for Camunda compatibility",
   "main": "index.js",
   "scripts": {

package/rules/camunda-cloud/connector-properties/config.js

@@ -0,0 +1,93 @@
+const { getPath } = require('@bpmn-io/moddle-utils');
+
+const { findExtensionElement } = require('../../utils/element');
+
+const { ERROR_TYPES } = require('../../utils/error-types');
+
+const INBOUND_CONNECTOR_PROPERTY = 'inbound.type';
+
+module.exports = {
+  messageTtl: {
+    version: '8.6',
+    getError: (node) => getInboundConnectorError(node, 'messageTtl', '8.6'),
+    getProperty: (node) => getZeebeProperty(node, 'messageTtl'),
+    isConnector: (node) => isInboundConnector(node, [
+      'io.camunda:webhook:1',
+      'io.camunda:connector-rabbitmq-inbound:1',
+      'io.camunda:http-polling:1',
+      'io.camunda:connector-kafka-inbound:1',
+      'io.camunda:slack-webhook:1',
+      'io.camunda:aws-sqs-inbound:1',
+      'io.camunda:aws-sns-webhook:1'
+    ])
+  },
+  consumeUnmatchedEvents: {
+    version: '8.6',
+    getError: (node) => getInboundConnectorError(node, 'consumeUnmatchedEvents', '8.6'),
+    getProperty: (node) => getZeebeProperty(node, 'consumeUnmatchedEvents'),
+    isConnector: (node) => isInboundConnector(node, [
+      'io.camunda:webhook:1',
+      'io.camunda:connector-rabbitmq-inbound:1',
+      'io.camunda:http-polling:1',
+      'io.camunda:connector-kafka-inbound:1',
+      'io.camunda:slack-webhook:1',
+      'io.camunda:aws-sqs-inbound:1',
+      'io.camunda:aws-sns-webhook:1'
+    ])
+  },
+  deduplicationModeManualFlag: {
+    version: '8.6',
+    getError: (node) => getInboundConnectorError(node, 'deduplicationModeManualFlag', '8.6'),
+    getProperty: (node) => getZeebeProperty(node, 'deduplicationModeManualFlag'),
+    isConnector: (node) => isInboundConnector(node, [
+      'io.camunda:connector-rabbitmq-inbound:1',
+      'io.camunda:http-polling:1',
+      'io.camunda:connector-kafka-inbound:1',
+      'io.camunda:aws-sqs-inbound:1'
+    ])
+  }
+};
+
+function isInboundConnector(node, names) {
+  const zeebeProperty = getZeebeProperty(node, INBOUND_CONNECTOR_PROPERTY);
+
+  return zeebeProperty && names.includes(zeebeProperty.get('value'));
+}
+
+function getZeebeProperty(node, propertyName) {
+  const zeebeProperties = findExtensionElement(node, 'zeebe:Properties');
+
+  if (!zeebeProperties) {
+    return false;
+  }
+
+  return zeebeProperties.get('properties').find(property => {
+    return property.get('name') === propertyName;
+  });
+}
+
+function getInboundConnectorError(node, propertyName, allowedVersion) {
+  const property = getZeebeProperty(node, propertyName);
+
+  const connectorProperty = getZeebeProperty(node, INBOUND_CONNECTOR_PROPERTY);
+
+  const path = getPath(property, node);
+
+  return {
+    message: `Connector property <name> with value <${ propertyName }> only allowed by Camunda ${ allowedVersion } or newer.`,
+    path: path ? [ ...path, 'name' ] : [ 'name' ],
+    data: {
+      type: ERROR_TYPES.CONNECTORS_PROPERTY_VALUE_NOT_ALLOWED,
+      node: property,
+      parentNode: node,
+      property: 'name',
+      connectorProperty: {
+        type: connectorProperty,
+        properties: {
+          name: connectorProperty.get('name'),
+          value: connectorProperty.get('value')
+        }
+      }
+    }
+  };
+}

package/rules/camunda-cloud/connector-properties/index.js

@@ -0,0 +1,47 @@
+const { isAny } = require('bpmnlint-utils');
+
+const config = require('./config');
+
+const { reportErrors } = require('../../utils/reporter');
+
+const { skipInNonExecutableProcess } = require('../../utils/rule');
+
+const { greaterOrEqual } = require('../../utils/version');
+
+module.exports = skipInNonExecutableProcess(function({ version }) {
+  function check(node, reporter) {
+    if (!isAny(node, [ 'bpmn:FlowElement', 'bpmn:FlowElementsContainer' ])) {
+      return;
+    }
+
+    const errors = Object.entries(config).reduce((errors, [ propertyName, {
+      getError,
+      getProperty,
+      isConnector,
+      version: allowedVersion
+    } ]) => {
+      if (greaterOrEqual(version, allowedVersion) || !isConnector(node)) {
+        return errors;
+      }
+
+      const property = getProperty(node);
+
+      if (property) {
+        return [
+          ...errors,
+          getError(node)
+        ];
+      }
+
+      return errors;
+    }, []);
+
+    if (errors.length) {
+      reportErrors(node, reporter, errors);
+    }
+  }
+
+  return {
+    check
+  };
+});

package/rules/utils/error-types.js

@@ -1,5 +1,6 @@
 module.exports.ERROR_TYPES = Object.freeze({
   CHILD_ELEMENT_TYPE_NOT_ALLOWED: 'camunda.childElementTypeNotAllowed',
+  CONNECTORS_PROPERTY_VALUE_NOT_ALLOWED: 'camunda.connectors.propertyValueNotAllowed',
   ELEMENT_COLLAPSED_NOT_ALLOWED: 'camunda.elementCollapsedNotAllowed',
   ELEMENT_MULTIPLE_NOT_ALLOWED: 'camunda.elementMultipleNotAllowed',
   ELEMENT_TYPE_NOT_ALLOWED: 'camunda.elementTypeNotAllowed',