bpmnlint-plugin-camunda-compat 2.35.0 → 2.36.0

package/rules/camunda-cloud/error-reference.js

@@ -1,73 +1,73 @@
-const {
-  is,
-  isAny
-} = require('bpmnlint-utils');
-
-const {
-  getEventDefinition,
-  hasProperties
-} = require('../utils/element');
-
-const { reportErrors } = require('../utils/reporter');
-
-const { skipInNonExecutableProcess } = require('../utils/rule');
-
-const { greaterOrEqual } = require('../utils/version');
-const { annotateRule } = require('../helper');
-
-const NO_ERROR_REF_ALLOWED_VERSION = '8.2';
-
-module.exports = skipInNonExecutableProcess(function({ version }) {
-  function check(node, reporter) {
-    if (!isAny(node, [ 'bpmn:CatchEvent', 'bpmn:ThrowEvent' ])) {
-      return;
-    }
-
-    const eventDefinition = getEventDefinition(node);
-
-    if (!eventDefinition || !is(eventDefinition, 'bpmn:ErrorEventDefinition')) {
-      return;
-    }
-
-    let errors = [];
-
-    if (!isNoErrorRefAllowed(node, version)) {
-      errors = hasProperties(eventDefinition, {
-        errorRef: {
-          required: true,
-          allowedVersion: '8.2'
-        }
-      }, node);
-
-      if (errors.length) {
-        reportErrors(node, reporter, errors);
-
-        return;
-      }
-    }
-
-    const errorRef = eventDefinition.get('errorRef');
-
-    if (!errorRef) {
-      return;
-    }
-
-    errors = hasProperties(errorRef, {
-      errorCode: {
-        required: true
-      }
-    }, node);
-
-    if (errors.length) {
-      reportErrors(node, reporter, errors);
-    }
-  }
-
-  return annotateRule('error-reference', {
-    check
-  });
-});
-
-function isNoErrorRefAllowed(node, version) {
-  return is(node, 'bpmn:CatchEvent') && greaterOrEqual(version, NO_ERROR_REF_ALLOWED_VERSION);
+const {
+  is,
+  isAny
+} = require('bpmnlint-utils');
+
+const {
+  getEventDefinition,
+  hasProperties
+} = require('../utils/element');
+
+const { reportErrors } = require('../utils/reporter');
+
+const { skipInNonExecutableProcess } = require('../utils/rule');
+
+const { greaterOrEqual } = require('../utils/version');
+const { annotateRule } = require('../helper');
+
+const NO_ERROR_REF_ALLOWED_VERSION = '8.2';
+
+module.exports = skipInNonExecutableProcess(function({ version }) {
+  function check(node, reporter) {
+    if (!isAny(node, [ 'bpmn:CatchEvent', 'bpmn:ThrowEvent' ])) {
+      return;
+    }
+
+    const eventDefinition = getEventDefinition(node);
+
+    if (!eventDefinition || !is(eventDefinition, 'bpmn:ErrorEventDefinition')) {
+      return;
+    }
+
+    let errors = [];
+
+    if (!isNoErrorRefAllowed(node, version)) {
+      errors = hasProperties(eventDefinition, {
+        errorRef: {
+          required: true,
+          allowedVersion: '8.2'
+        }
+      }, node);
+
+      if (errors.length) {
+        reportErrors(node, reporter, errors);
+
+        return;
+      }
+    }
+
+    const errorRef = eventDefinition.get('errorRef');
+
+    if (!errorRef) {
+      return;
+    }
+
+    errors = hasProperties(errorRef, {
+      errorCode: {
+        required: true
+      }
+    }, node);
+
+    if (errors.length) {
+      reportErrors(node, reporter, errors);
+    }
+  }
+
+  return annotateRule('error-reference', {
+    check
+  });
+});
+
+function isNoErrorRefAllowed(node, version) {
+  return is(node, 'bpmn:CatchEvent') && greaterOrEqual(version, NO_ERROR_REF_ALLOWED_VERSION);
 }

package/rules/camunda-cloud/escalation-boundary-event-attached-to-ref.js

@@ -1,47 +1,47 @@
-const {
-  is,
-  isAny
-} = require('bpmnlint-utils');
-
-const {
-  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) {
-    if (!isAny(node, [ 'bpmn:CatchEvent', 'bpmn:ThrowEvent' ])) {
-      return;
-    }
-
-    const eventDefinition = getEventDefinition(node);
-
-    if (!eventDefinition || !is(eventDefinition, 'bpmn:EscalationEventDefinition')) {
-      return;
-    }
-
-    const attachedToRef = node.get('attachedToRef');
-
-    if (attachedToRef && is(attachedToRef, 'bpmn:Task')) {
-      reportErrors(node, reporter, {
-        message: `Element of type <bpmn:BoundaryEvent> with event definition of type <bpmn:EscalationEventDefinition> is not allowed to be attached to element of type <${ attachedToRef.$type }>`,
-        path: null,
-        data: {
-          type: ERROR_TYPES.ATTACHED_TO_REF_ELEMENT_TYPE_NOT_ALLOWED,
-          node,
-          parentNode: null,
-          attachedToRef
-        }
-      });
-    }
-  }
-
-  return {
-    check
-  };
-});
+const {
+  is,
+  isAny
+} = require('bpmnlint-utils');
+
+const {
+  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) {
+    if (!isAny(node, [ 'bpmn:CatchEvent', 'bpmn:ThrowEvent' ])) {
+      return;
+    }
+
+    const eventDefinition = getEventDefinition(node);
+
+    if (!eventDefinition || !is(eventDefinition, 'bpmn:EscalationEventDefinition')) {
+      return;
+    }
+
+    const attachedToRef = node.get('attachedToRef');
+
+    if (attachedToRef && is(attachedToRef, 'bpmn:Task')) {
+      reportErrors(node, reporter, {
+        message: `Element of type <bpmn:BoundaryEvent> with event definition of type <bpmn:EscalationEventDefinition> is not allowed to be attached to element of type <${ attachedToRef.$type }>`,
+        path: null,
+        data: {
+          type: ERROR_TYPES.ATTACHED_TO_REF_ELEMENT_TYPE_NOT_ALLOWED,
+          node,
+          parentNode: null,
+          attachedToRef
+        }
+      });
+    }
+  }
+
+  return {
+    check
+  };
+});

package/rules/camunda-cloud/escalation-reference.js

@@ -1,68 +1,68 @@
-const {
-  is,
-  isAny
-} = require('bpmnlint-utils');
-
-const {
-  getEventDefinition,
-  hasProperties
-} = require('../utils/element');
-
-const { reportErrors } = require('../utils/reporter');
-
-const { skipInNonExecutableProcess } = require('../utils/rule');
-const { annotateRule } = require('../helper');
-
-module.exports = skipInNonExecutableProcess(function() {
-  function check(node, reporter) {
-    if (!isAny(node, [ 'bpmn:CatchEvent', 'bpmn:ThrowEvent' ])) {
-      return;
-    }
-
-    const eventDefinition = getEventDefinition(node);
-
-    if (!eventDefinition || !is(eventDefinition, 'bpmn:EscalationEventDefinition')) {
-      return;
-    }
-
-    let errors = [];
-
-    if (!isNoEscalationRefAllowed(node)) {
-      errors = hasProperties(eventDefinition, {
-        escalationRef: {
-          required: true
-        }
-      }, node);
-
-      if (errors.length) {
-        reportErrors(node, reporter, errors);
-
-        return;
-      }
-    }
-
-    const escalationRef = eventDefinition.get('escalationRef');
-
-    if (!escalationRef) {
-      return;
-    }
-
-    errors = hasProperties(escalationRef, {
-      escalationCode: {
-        required: true
-      }
-    }, node);
-
-    if (errors.length) {
-      reportErrors(node, reporter, errors);
-    }
-  }
-
-  return annotateRule('escalation-reference', {
-    check
-  });
-});
-
-function isNoEscalationRefAllowed(node) {
-  return isAny(node, [ 'bpmn:CatchEvent', 'bpmn:BoundaryEvent' ]);
+const {
+  is,
+  isAny
+} = require('bpmnlint-utils');
+
+const {
+  getEventDefinition,
+  hasProperties
+} = require('../utils/element');
+
+const { reportErrors } = require('../utils/reporter');
+
+const { skipInNonExecutableProcess } = require('../utils/rule');
+const { annotateRule } = require('../helper');
+
+module.exports = skipInNonExecutableProcess(function() {
+  function check(node, reporter) {
+    if (!isAny(node, [ 'bpmn:CatchEvent', 'bpmn:ThrowEvent' ])) {
+      return;
+    }
+
+    const eventDefinition = getEventDefinition(node);
+
+    if (!eventDefinition || !is(eventDefinition, 'bpmn:EscalationEventDefinition')) {
+      return;
+    }
+
+    let errors = [];
+
+    if (!isNoEscalationRefAllowed(node)) {
+      errors = hasProperties(eventDefinition, {
+        escalationRef: {
+          required: true
+        }
+      }, node);
+
+      if (errors.length) {
+        reportErrors(node, reporter, errors);
+
+        return;
+      }
+    }
+
+    const escalationRef = eventDefinition.get('escalationRef');
+
+    if (!escalationRef) {
+      return;
+    }
+
+    errors = hasProperties(escalationRef, {
+      escalationCode: {
+        required: true
+      }
+    }, node);
+
+    if (errors.length) {
+      reportErrors(node, reporter, errors);
+    }
+  }
+
+  return annotateRule('escalation-reference', {
+    check
+  });
+});
+
+function isNoEscalationRefAllowed(node) {
+  return isAny(node, [ 'bpmn:CatchEvent', 'bpmn:BoundaryEvent' ]);
 }

package/rules/camunda-cloud/event-based-gateway-target.js

@@ -1,39 +1,39 @@
-const { is } = require('bpmnlint-utils');
-
-const { ERROR_TYPES } = 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:ReceiveTask')) {
-      return;
-    }
-
-    // receive task as event-based gateway target is allowed by BPMN 2.0 but not
-    // supported by Zeebe
-    const error = node.get('incoming').some((sequenceFlow) => {
-      const source = sequenceFlow.get('sourceRef');
-
-      return is(source, 'bpmn:EventBasedGateway');
-    });
-
-    if (error) {
-      reportErrors(node, reporter, {
-        message: 'Element of type <bpmn:ReceiveTask> not allowed as event-based gateway target',
-        path: null,
-        data: {
-          type: ERROR_TYPES.EVENT_BASED_GATEWAY_TARGET_NOT_ALLOWED,
-          node,
-          parentNode: null
-        }
-      });
-    }
-  }
-
-  return {
-    check
-  };
+const { is } = require('bpmnlint-utils');
+
+const { ERROR_TYPES } = 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:ReceiveTask')) {
+      return;
+    }
+
+    // receive task as event-based gateway target is allowed by BPMN 2.0 but not
+    // supported by Zeebe
+    const error = node.get('incoming').some((sequenceFlow) => {
+      const source = sequenceFlow.get('sourceRef');
+
+      return is(source, 'bpmn:EventBasedGateway');
+    });
+
+    if (error) {
+      reportErrors(node, reporter, {
+        message: 'Element of type <bpmn:ReceiveTask> not allowed as event-based gateway target',
+        path: null,
+        data: {
+          type: ERROR_TYPES.EVENT_BASED_GATEWAY_TARGET_NOT_ALLOWED,
+          node,
+          parentNode: null
+        }
+      });
+    }
+  }
+
+  return {
+    check
+  };
 });

package/rules/camunda-cloud/executable-process.js

@@ -1,62 +1,62 @@
-const { is } = require('bpmnlint-utils');
-
-const { hasProperties } = require('../utils/element');
-
-const { reportErrors } = require('../utils/reporter');
-
-module.exports = function() {
-  function check(node, reporter) {
-    if (!is(node, 'bpmn:Definitions')) {
-      return;
-    }
-
-    const rootElements = node.get('rootElements'),
-          collaboration = rootElements.find(rootElement => is(rootElement, 'bpmn:Collaboration')),
-          processes = rootElements.filter(rootElement => is(rootElement, 'bpmn:Process'));
-
-    let errors = [];
-
-    for (const process of processes) {
-      const parentNode = getParentNode(process, collaboration);
-
-      errors = [
-        ...errors,
-        ...hasProperties(process, {
-          isExecutable: {
-            value: true
-          }
-        }, parentNode)
-      ];
-    }
-
-    if (errors.length > processes.length - 1) {
-      errors.forEach(error => {
-        const { data } = error;
-
-        const { node: process } = data;
-
-        reportErrors(getParentNode(process, collaboration), reporter, error);
-      });
-    }
-  }
-
-  return {
-    check
-  };
-};
-
-function getParentNode(process, collaboration) {
-  if (!collaboration) {
-    return process;
-  }
-
-  const participants = collaboration.get('participants');
-
-  const participant = participants.find(participant => participant.get('processRef') === process);
-
-  if (participant) {
-    return participant;
-  }
-
-  return process;
+const { is } = require('bpmnlint-utils');
+
+const { hasProperties } = require('../utils/element');
+
+const { reportErrors } = require('../utils/reporter');
+
+module.exports = function() {
+  function check(node, reporter) {
+    if (!is(node, 'bpmn:Definitions')) {
+      return;
+    }
+
+    const rootElements = node.get('rootElements'),
+          collaboration = rootElements.find(rootElement => is(rootElement, 'bpmn:Collaboration')),
+          processes = rootElements.filter(rootElement => is(rootElement, 'bpmn:Process'));
+
+    let errors = [];
+
+    for (const process of processes) {
+      const parentNode = getParentNode(process, collaboration);
+
+      errors = [
+        ...errors,
+        ...hasProperties(process, {
+          isExecutable: {
+            value: true
+          }
+        }, parentNode)
+      ];
+    }
+
+    if (errors.length > processes.length - 1) {
+      errors.forEach(error => {
+        const { data } = error;
+
+        const { node: process } = data;
+
+        reportErrors(getParentNode(process, collaboration), reporter, error);
+      });
+    }
+  }
+
+  return {
+    check
+  };
+};
+
+function getParentNode(process, collaboration) {
+  if (!collaboration) {
+    return process;
+  }
+
+  const participants = collaboration.get('participants');
+
+  const participant = participants.find(participant => participant.get('processRef') === process);
+
+  if (participant) {
+    return participant;
+  }
+
+  return process;
 }

package/rules/camunda-cloud/execution-listener.js

@@ -1,33 +1,33 @@
-const {
-  findExtensionElement,
-  hasProperties
-} = require('../utils/element');
-
-const { reportErrors } = require('../utils/reporter');
-
-const { skipInNonExecutableProcess } = require('../utils/rule');
-
-module.exports = skipInNonExecutableProcess(function() {
-  function check(node, reporter) {
-    const executionListeners = findExtensionElement(node, 'zeebe:ExecutionListeners');
-
-    if (!executionListeners) {
-      return;
-    }
-
-    const listeners = executionListeners.get('listeners');
-    const errors = listeners.flatMap(listener => hasProperties(listener, {
-      type: {
-        required: true
-      }
-    }, node));
-
-    if (errors.length) {
-      reportErrors(node, reporter, errors);
-    }
-  }
-
-  return {
-    check
-  };
-});
+const {
+  findExtensionElement,
+  hasProperties
+} = require('../utils/element');
+
+const { reportErrors } = require('../utils/reporter');
+
+const { skipInNonExecutableProcess } = require('../utils/rule');
+
+module.exports = skipInNonExecutableProcess(function() {
+  function check(node, reporter) {
+    const executionListeners = findExtensionElement(node, 'zeebe:ExecutionListeners');
+
+    if (!executionListeners) {
+      return;
+    }
+
+    const listeners = executionListeners.get('listeners');
+    const errors = listeners.flatMap(listener => hasProperties(listener, {
+      type: {
+        required: true
+      }
+    }, node));
+
+    if (errors.length) {
+      reportErrors(node, reporter, errors);
+    }
+  }
+
+  return {
+    check
+  };
+});