bpmnlint-plugin-camunda-compat 2.3.0 → 2.5.0

package/index.js

@@ -14,10 +14,12 @@ const camundaCloud10Rules = withConfig({
   'no-candidate-users': 'error',
   'no-expression': 'error',
   'no-multiple-none-start-events': 'error',
+  'no-propagate-all-parent-variables': 'error',
   'no-task-schedule': 'error',
   'no-template': 'error',
   'no-zeebe-properties': 'error',
   'sequence-flow-condition': 'error',
+  'start-form': 'error',
   'subscription': 'error',
   'timer': 'error',
   'user-task-form': 'error',
@@ -31,7 +33,8 @@ const camundaCloud12Rules = withConfig(camundaCloud11Rules, { version: '1.2' });
 const camundaCloud13Rules = withConfig(camundaCloud12Rules, { version: '1.3' });
 
 const camundaCloud80Rules = withConfig({
-  ...omit(camundaCloud13Rules, 'no-template')
+  ...omit(camundaCloud13Rules, 'no-template'),
+  'secrets': 'error'
 }, { version: '8.0' });
 
 const camundaCloud81Rules = withConfig({
@@ -42,6 +45,7 @@ const camundaCloud81Rules = withConfig({
 const camundaCloud82Rules = withConfig({
   ...omit(camundaCloud81Rules, [
     'no-candidate-users',
+    'no-propagate-all-parent-variables',
     'no-task-schedule'
   ]),
   'escalation-boundary-event-attached-to-ref': 'error',
@@ -51,7 +55,9 @@ const camundaCloud82Rules = withConfig({
 }, { version: '8.2' });
 
 const camundaCloud83Rules = withConfig({
-  ...camundaCloud82Rules,
+  ...omit(camundaCloud82Rules, [
+    'start-form'
+  ]),
   'signal-reference': 'error'
 }, { version: '8.3' });
 
@@ -86,12 +92,15 @@ const rules = {
   'no-candidate-users': './rules/camunda-cloud/no-candidate-users',
   'no-expression': './rules/camunda-cloud/no-expression',
   'no-multiple-none-start-events': './rules/camunda-cloud/no-multiple-none-start-events',
+  'no-propagate-all-parent-variables': './rules/camunda-cloud/no-propagate-all-parent-variables',
   'no-signal-event-sub-process': './rules/camunda-cloud/no-signal-event-sub-process',
   'no-task-schedule': './rules/camunda-cloud/no-task-schedule',
   'no-template': './rules/camunda-cloud/no-template',
   'no-zeebe-properties': './rules/camunda-cloud/no-zeebe-properties',
+  'secrets': './rules/camunda-cloud/secrets',
   'sequence-flow-condition': './rules/camunda-cloud/sequence-flow-condition',
   'signal-reference': './rules/camunda-cloud/signal-reference',
+  'start-form': './rules/camunda-cloud/start-form',
   'subscription': './rules/camunda-cloud/subscription',
   'task-schedule': './rules/camunda-cloud/task-schedule',
   'timer': './rules/camunda-cloud/timer',

package/package.json

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

package/rules/camunda-cloud/no-propagate-all-parent-variables.js

@@ -0,0 +1,39 @@
+const { is } = require('bpmnlint-utils');
+
+const {
+  findExtensionElement,
+  hasProperties
+} = require('../utils/element');
+
+const { reportErrors } = require('../utils/reporter');
+
+const { skipInNonExecutableProcess } = require('../utils/rule');
+
+module.exports = skipInNonExecutableProcess(function() {
+  function check(node, reporter) {
+    if (!is(node, 'bpmn:CallActivity')) {
+      return;
+    }
+
+    const calledElement = findExtensionElement(node, 'zeebe:CalledElement');
+
+    if (!calledElement) {
+      return;
+    }
+
+    const errors = hasProperties(calledElement, {
+      propagateAllParentVariables: {
+        allowed: false,
+        allowedVersion: '8.2'
+      }
+    }, node);
+
+    if (errors && errors.length) {
+      reportErrors(node, reporter, errors);
+    }
+  }
+
+  return {
+    check
+  };
+});

package/rules/camunda-cloud/secrets.js

@@ -0,0 +1,115 @@
+const { isString } = require('min-dash');
+
+const { is } = require('bpmnlint-utils');
+
+const { getPath } = require('@bpmn-io/moddle-utils');
+
+const {
+  findExtensionElement,
+  getEventDefinition
+} = require('../utils/element');
+
+const { ERROR_TYPES } = require('../utils/error-types');
+
+const { reportErrors } = require('../utils/reporter');
+
+const { skipInNonExecutableProcess } = require('../utils/rule');
+
+module.exports = skipInNonExecutableProcess(function() {
+  function check(node, reporter) {
+    const errors = [
+      validateIoMapping,
+      validateProperties,
+      validateSubscription
+    ].reduce((errors, validationFunction) => {
+      return [
+        ...errors,
+        ...validationFunction(node)
+      ];
+    }, []);
+
+    if (errors.length) {
+      reportErrors(node, reporter, errors);
+    }
+  }
+
+  return {
+    check
+  };
+});
+
+function validateIoMapping(node) {
+  const ioMapping = findExtensionElement(node, 'zeebe:IoMapping');
+
+  if (!ioMapping) {
+    return [];
+  }
+
+  return ioMapping.get('inputParameters')
+    .filter(inputParameter => !isValidSecret(inputParameter.get('source')))
+    .map(inputParameter => getReport('source', inputParameter, node));
+}
+
+function validateProperties(node) {
+  const properties = findExtensionElement(node, 'zeebe:Properties');
+
+  if (!properties) {
+    return [];
+  }
+
+  return (properties.get('properties'))
+    .filter(property => !isValidSecret(property.get('value')))
+    .map(property => getReport('value', property, node));
+}
+
+function validateSubscription(node) {
+  let message;
+
+  if (is(node, 'bpmn:ReceiveTask')) {
+    message = node.get('messageRef');
+  } else {
+    const messageEventDefinition = getEventDefinition(node, 'bpmn:MessageEventDefinition');
+
+    if (!messageEventDefinition) {
+      return [];
+    }
+
+    message = messageEventDefinition.get('messageRef');
+  }
+
+  if (!message) {
+    return [];
+  }
+
+  const subscription = findExtensionElement(message, 'zeebe:Subscription');
+
+  if (!subscription) {
+    return [];
+  }
+
+  const correlationKey = subscription.get('correlationKey');
+
+  return isValidSecret(correlationKey)
+    ? []
+    : [ getReport('correlationKey', subscription, node) ];
+}
+
+function getReport(propertyName, node, parentNode) {
+  return {
+    message: `Property <${ propertyName }> is not a valid secret`,
+    path: [ ...getPath(node, parentNode), propertyName ],
+    data: {
+      type: ERROR_TYPES.SECRET_EXPRESSION_INVALID,
+      node,
+      parentNode: parentNode,
+      property: propertyName
+    }
+  };
+}
+
+function isValidSecret(value) {
+  return !value
+    || !isString(value)
+    || !value.includes('secrets.')
+    || /{{secrets\.[a-zA-Z0-9_]+}}/.test(value);
+}

package/rules/camunda-cloud/start-form.js

@@ -0,0 +1,29 @@
+const { is } = require('bpmnlint-utils');
+
+const { hasNoExtensionElement } = require('../utils/element');
+
+const { reportErrors } = require('../utils/reporter');
+
+const { skipInNonExecutableProcess } = require('../utils/rule');
+
+const { greaterOrEqual } = require('../utils/version');
+
+const startFormAllowedVersion = '8.3';
+
+module.exports = skipInNonExecutableProcess(function({ version }) {
+  function check(node, reporter) {
+    if (!is(node, 'bpmn:StartEvent') || greaterOrEqual(version, startFormAllowedVersion)) {
+      return;
+    }
+
+    let errors = hasNoExtensionElement(node, 'zeebe:FormDefinition', node, startFormAllowedVersion);
+
+    if (errors.length) {
+      reportErrors(node, reporter, errors);
+    }
+  }
+
+  return {
+    check
+  };
+});

package/rules/utils/error-types.js

@@ -17,5 +17,6 @@ module.exports.ERROR_TYPES = Object.freeze({
   PROPERTY_TYPE_NOT_ALLOWED: 'camunda.propertyTypeNotAllowed',
   PROPERTY_VALUE_DUPLICATED: 'camunda.propertyValueDuplicated',
   PROPERTY_VALUE_NOT_ALLOWED: 'camunda.propertyValueNotAllowed',
-  PROPERTY_VALUE_REQUIRED: 'camunda.propertyValueRequired'
+  PROPERTY_VALUE_REQUIRED: 'camunda.propertyValueRequired',
+  SECRET_EXPRESSION_INVALID: 'camunda.secretExpressionInvalid'
 });