bpmnlint-plugin-camunda-compat 2.6.3 → 2.7.1

package/index.js

@@ -13,6 +13,7 @@ const camundaCloud10Rules = withConfig({
   'message-reference': 'error',
   'no-candidate-users': 'error',
   'no-expression': 'error',
+  'no-loop': 'error',
   'no-multiple-none-start-events': 'error',
   'no-propagate-all-parent-variables': 'error',
   'no-task-schedule': 'error',
@@ -33,8 +34,7 @@ const camundaCloud12Rules = withConfig(camundaCloud11Rules, { version: '1.2' });
 const camundaCloud13Rules = withConfig(camundaCloud12Rules, { version: '1.3' });
 
 const camundaCloud80Rules = withConfig({
-  ...omit(camundaCloud13Rules, 'no-template'),
-  'secrets': 'error'
+  ...omit(camundaCloud13Rules, 'no-template')
 }, { version: '8.0' });
 
 const camundaCloud81Rules = withConfig({
@@ -93,6 +93,7 @@ const rules = {
   'message-reference': './rules/camunda-cloud/message-reference',
   'no-candidate-users': './rules/camunda-cloud/no-candidate-users',
   'no-expression': './rules/camunda-cloud/no-expression',
+  'no-loop': './rules/camunda-cloud/no-loop',
   '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',
@@ -153,10 +154,11 @@ module.exports = {
   rules
 };
 
-function withConfig(rules, config, type = 'error') {
+function withConfig(rules, config) {
   let rulesWithConfig = {};
 
   for (let name in rules) {
+    const type = Array.isArray(rules[ name ]) ? rules[ name ][0] : rules[ name ];
     rulesWithConfig[ name ] = [ type, config ];
   }
 

package/package.json

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

package/rules/camunda-cloud/link-event.js

@@ -89,7 +89,7 @@ module.exports = skipInNonExecutableProcess(function() {
 
     // check for missing link catch & throw event names
     if (isLinkEvent(node)) {
-      const linkEventDefinition = getEventDefinition(node, 'bpmn:LinkEventDefinition');
+      const linkEventDefinition = getEventDefinition(node);
 
       const errors = hasProperties(linkEventDefinition, {
         name: {
@@ -109,15 +109,19 @@ module.exports = skipInNonExecutableProcess(function() {
 });
 
 function isLinkEvent(element) {
+  const eventDefinition = getEventDefinition(element);
+
   return isAny(element, [
     'bpmn:IntermediateCatchEvent',
     'bpmn:IntermediateThrowEvent'
-  ]) && getEventDefinition(element, 'bpmn:LinkEventDefinition');
+  ]) && eventDefinition && is(eventDefinition, 'bpmn:LinkEventDefinition');
 }
 
 function isLinkCatchEvent(element) {
+  const eventDefinition = getEventDefinition(element);
+
   return is(element, 'bpmn:IntermediateCatchEvent')
-    && getEventDefinition(element, 'bpmn:LinkEventDefinition');
+    && eventDefinition && is(eventDefinition, 'bpmn:LinkEventDefinition');
 }
 
 function getLinkCatchEvents(flowElementsContainer) {

package/rules/camunda-cloud/no-loop.js

@@ -0,0 +1,146 @@
+const { isString } = require('min-dash');
+
+const { is } = require('bpmnlint-utils');
+
+const {
+  findExtensionElement,
+  findParent,
+  isAnyExactly
+} = require('../utils/element');
+
+const { reportErrors } = require('../utils/reporter');
+
+const { ERROR_TYPES } = require('../utils/error-types');
+
+const { skipInNonExecutableProcess } = require('../utils/rule');
+
+const LOOP_REQUIRED_ELEMENT_TYPES = [
+  'bpmn:CallActivity',
+  'bpmn:ManualTask',
+  'bpmn:Task'
+];
+
+const LOOP_ELEMENT_TYPES = [
+  ...LOOP_REQUIRED_ELEMENT_TYPES,
+  'bpmn:StartEvent',
+  'bpmn:EndEvent',
+  'bpmn:ManualTask',
+  'bpmn:ExclusiveGateway',
+  'bpmn:InclusiveGateway',
+  'bpmn:ParallelGateway',
+  'bpmn:SubProcess',
+  'bpmn:Task'
+];
+
+module.exports = skipInNonExecutableProcess(function() {
+  function check(node, reporter) {
+    if (!is(node, 'bpmn:Process')) {
+      return;
+    }
+
+    const error = getFlowElements(node)
+      .filter(flowElement => {
+        return isAnyExactly(flowElement, LOOP_ELEMENT_TYPES);
+      })
+      .reduce((error, flowElement) => {
+        return error || findLoop(flowElement, node);
+      }, null);
+
+    if (error) {
+      reportErrors(node, reporter, error);
+    }
+  }
+
+  return {
+    check
+  };
+});
+
+function findLoop(flowElement, parentElement, visitedFlowElements = []) {
+
+  // (1.1) is not a loop
+  if (!isAnyExactly(flowElement, LOOP_ELEMENT_TYPES)) {
+    return null;
+  }
+
+  const nextFlowElements = getNextFlowElements(flowElement);
+
+  // (1.2) is not a loop
+  if (!nextFlowElements.length) {
+    return null;
+  }
+
+  // (2) may be a loop
+  if (!visitedFlowElements.includes(flowElement)) {
+    return nextFlowElements.reduce((error, nextFlowElement) => {
+      return error || findLoop(nextFlowElement, parentElement, [ ...visitedFlowElements, flowElement ]);
+    }, null);
+  }
+
+  // (3) is a loop but ignored
+  if (isIgnoredLoop(visitedFlowElements)) {
+    return null;
+  }
+
+  const elements = visitedFlowElements.slice(visitedFlowElements.indexOf(flowElement));
+
+  // (4) is a loop
+  return {
+    message: `Loop detected: ${ elements.map(({ id }) => id).join(' -> ') } -> ${ flowElement.id }`,
+    path: null,
+    data: {
+      type: ERROR_TYPES.LOOP_NOT_ALLOWED,
+      node: parentElement,
+      parentNode: null,
+      elements: elements.map(({ id }) => id)
+    }
+  };
+}
+
+function getFlowElements(node) {
+  return node.get('flowElements').reduce((flowElements, flowElement) => {
+    if (is(flowElement, 'bpmn:FlowElementsContainer')) {
+      return [ ...flowElements, ...getFlowElements(flowElement) ];
+    }
+
+    return [ ...flowElements, flowElement ];
+  }, []);
+}
+
+function getNextFlowElements(flowElement) {
+  if (is(flowElement, 'bpmn:CallActivity')) {
+    const calledElement = findExtensionElement(flowElement, 'zeebe:CalledElement');
+
+    if (calledElement) {
+      const processId = calledElement.get('processId');
+
+      if (isString(processId) && !isFeel(processId)) {
+        const process = findParent(flowElement, 'bpmn:Process');
+
+        if (process && process.get('id') === processId) {
+          return process.get('flowElements').filter(flowElement => is(flowElement, 'bpmn:StartEvent'));
+        }
+      }
+    }
+  } else if (is(flowElement, 'bpmn:SubProcess')) {
+    return flowElement
+      .get('flowElements').filter(flowElement => is(flowElement, 'bpmn:StartEvent'));
+  } else if (is(flowElement, 'bpmn:EndEvent')) {
+    const parent = flowElement.$parent;
+
+    if (is(parent, 'bpmn:SubProcess')) {
+      flowElement = parent;
+    }
+  }
+
+  return flowElement
+    .get('outgoing').filter(outgoing => is(outgoing, 'bpmn:SequenceFlow')).map(sequenceFlow => sequenceFlow.get('targetRef'));
+}
+
+function isIgnoredLoop(elements) {
+  return !elements.some(element => isAnyExactly(element, LOOP_REQUIRED_ELEMENT_TYPES));
+}
+
+function isFeel(value) {
+  return isString(value) && value.startsWith('=');
+}

package/rules/camunda-cloud/secrets.js

@@ -98,12 +98,12 @@ function getReport(propertyName, node, parentNode) {
   const path = getPath(node, parentNode);
 
   return {
-    message: `Property <${ propertyName }> is not a valid secret`,
+    message: `Property <${ propertyName }> uses deprecated secret expression format`,
     path: path
       ? [ ...getPath(node, parentNode), propertyName ]
       : [ propertyName ],
     data: {
-      type: ERROR_TYPES.SECRET_EXPRESSION_INVALID,
+      type: ERROR_TYPES.SECRET_EXPRESSION_FORMAT_DEPRECATED,
       node,
       parentNode: parentNode,
       property: propertyName

package/rules/camunda-cloud/user-task-form.js

@@ -3,6 +3,7 @@ const { is } = require('bpmnlint-utils');
 const {
   findExtensionElement,
   findExtensionElements,
+  findParent,
   hasProperties
 } = require('../utils/element');
 
@@ -76,22 +77,4 @@ function findUserTaskForm(node, formKey) {
       return `camunda-forms:bpmn:${ id }` === formKey;
     });
   }
-}
-
-function findParent(node, type) {
-  if (!node) {
-    return null;
-  }
-
-  const parent = node.$parent;
-
-  if (!parent) {
-    return node;
-  }
-
-  if (is(parent, type)) {
-    return parent;
-  }
-
-  return findParent(parent, type);
 }

package/rules/utils/element.js

@@ -450,4 +450,24 @@ function addAllowedVersion(data, allowedVersion) {
     ...data,
     allowedVersion
   };
-}
+}
+
+function findParent(node, type) {
+  if (!node) {
+    return null;
+  }
+
+  const parent = node.$parent;
+
+  if (!parent) {
+    return node;
+  }
+
+  if (is(parent, type)) {
+    return parent;
+  }
+
+  return findParent(parent, type);
+}
+
+module.exports.findParent = findParent;

package/rules/utils/error-types.js

@@ -11,6 +11,7 @@ module.exports.ERROR_TYPES = Object.freeze({
   EXTENSION_ELEMENT_NOT_ALLOWED: 'camunda.extensionElementNotAllowed',
   EXTENSION_ELEMENT_REQUIRED: 'camunda.extensionElementRequired',
   FEEL_EXPRESSION_INVALID: 'camunda.feelExpressionInvalid',
+  LOOP_NOT_ALLOWED: 'camunda.loopNotAllowed',
   ATTACHED_TO_REF_ELEMENT_TYPE_NOT_ALLOWED: 'camunda.attachedToRefElementTypeNotAllowed',
   PROPERTY_DEPENDENT_REQUIRED: 'camunda.propertyDependentRequired',
   PROPERTY_NOT_ALLOWED: 'camunda.propertyNotAllowed',
@@ -19,5 +20,5 @@ module.exports.ERROR_TYPES = Object.freeze({
   PROPERTY_VALUE_DUPLICATED: 'camunda.propertyValueDuplicated',
   PROPERTY_VALUE_NOT_ALLOWED: 'camunda.propertyValueNotAllowed',
   PROPERTY_VALUE_REQUIRED: 'camunda.propertyValueRequired',
-  SECRET_EXPRESSION_INVALID: 'camunda.secretExpressionInvalid'
+  SECRET_EXPRESSION_FORMAT_DEPRECATED: 'camunda.secretExpressionFormatDeprecated'
 });