bpmnlint 11.9.0 → 11.11.0

package/config/all.js

@@ -1,5 +1,6 @@
 const allRules = [
   'ad-hoc-sub-process',
+  'conditional-event',
   'conditional-flows',
   'end-event-required',
   'event-based-gateway',

package/config/correctness.js

@@ -1,6 +1,7 @@
 module.exports = {
   rules: {
     'ad-hoc-sub-process': 'error',
+    'conditional-event': 'error',
     'event-based-gateway': 'error',
     'event-sub-process-typed-start-event': 'error',
     'link-event': 'error',

package/lib/testers/helper.js

@@ -3,16 +3,37 @@ const { BpmnModdle } = require('bpmn-moddle');
 
 const { readFileSync } = require('node:fs');
 
+/**
+ * @typedef { any } ModdleElement
+ *
+ * @typedef { {
+ *   root: ModdleElement,
+ *   moddle: BpmnModdle,
+ *   warnings: any[]
+ * } } CreatedModdle
+ */
 
 /**
  * Create moddle instance.
  *
- * @param {String} xml the XML string
+ * @param {string} xml the XML string
+ * @param {string} [elementType]
+ * @param {Object} [moddleExtensions]
  *
- * @return {Promise<Object>}
+ * @return {Promise<CreatedModdle>}
  */
-async function createModdle(xml, elementType = 'bpmn:Definitions') {
-  const moddle = new BpmnModdle();
+async function createModdle(xml, elementType = 'bpmn:Definitions', moddleExtensions) {
+
+  if (typeof elementType !== 'string') {
+    moddleExtensions = elementType;
+    elementType = undefined;
+  }
+
+  if (typeof elementType === 'undefined') {
+    elementType = 'bpmn:Definitions';
+  }
+
+  const moddle = new BpmnModdle(moddleExtensions);
 
   const {
     rootElement: root,
@@ -22,6 +43,8 @@ async function createModdle(xml, elementType = 'bpmn:Definitions') {
   return {
     root,
     moddle,
+
+    // @ts-ignore-next-line "legacy"
     context: {
       warnings
     },
@@ -35,14 +58,16 @@ module.exports.createModdle = createModdle;
 /**
  * Return moddle instance, read from the given file.
  *
- * @param {String} filePath
+ * @param {string|URL} filePath
+ * @param {string} [elementType]
+ * @param {Object} [moddleExtensions]
  *
- * @return {Promise<Object>}
+ * @return {Promise<CreatedModdle>}
  */
-function readModdle(filePath) {
+function readModdle(filePath, elementType, moddleExtensions) {
   const contents = readFileSync(filePath, 'utf8');
 
-  return createModdle(contents);
+  return createModdle(contents, elementType, moddleExtensions);
 }
 
 module.exports.readModdle = readModdle;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bpmnlint",
   "description": "Validate your BPMN diagrams based on configurable lint rules",
-  "version": "11.9.0",
+  "version": "11.11.0",
   "main": "lib/index.js",
   "keywords": [
     "bpmnlint",
@@ -31,7 +31,7 @@
     "lint": "eslint .",
     "lint:types": "tsc",
     "dev": "npm test -- --watch",
-    "test": "mocha --exclude 'test/integration/*/**' 'test/**/*.*js'",
+    "test": "mocha --exclude \"test/integration/*/**\" \"test/**/*.*js\"",
     "test-coverage": "nyc --reporter=lcov --reporter=html npm test",
     "generate-docs-images": "npx @bpmn-io/bpmnlint-generate-docs-images ."
   },
@@ -51,7 +51,7 @@
     "tiny-glob": "^0.2.9"
   },
   "devDependencies": {
-    "@bpmn-io/bpmnlint-generate-docs-images": "^1.1.0",
+    "@bpmn-io/bpmnlint-generate-docs-images": "^1.2.0",
     "@types/mocha": "^10.0.10",
     "chai": "^6.2.2",
     "eslint": "^9.39.2",

package/rules/ad-hoc-sub-process.js

@@ -11,7 +11,6 @@ const {
  * A rule that ensures that an Ad Hoc Sub Process is valid according to the BPMN spec:
  *
  * - No start or end events
- * - Every intermediate event has an outgoing sequence flow
  *
  * @type { import('../lib/types.js').RuleFactory }
  */

package/rules/conditional-event.js

@@ -0,0 +1,52 @@
+const {
+  is
+} = require('bpmnlint-utils');
+
+const {
+  annotateRule,
+  isInExecutableProcess
+} = require('./helper');
+
+
+/**
+ * Ensures that a conditional event has a condition specified.
+ *
+ * @type { import('../lib/types.js').RuleFactory }
+ */
+module.exports = function() {
+
+  function check(node, reporter) {
+
+    if (!isInExecutableProcess(node)) {
+      return;
+    }
+
+    const eventDefinition = getConditionalEventDefinition(node);
+
+    if (!eventDefinition) {
+      return;
+    }
+
+    if (!hasCondition(eventDefinition)) {
+      reporter.report(node.id, 'Conditional event is missing a condition', [ 'condition' ]);
+    }
+  }
+
+  return annotateRule('conditional-event', {
+    check
+  });
+
+};
+
+function getConditionalEventDefinition(node) {
+  if (!is(node, 'bpmn:Event')) {
+    return;
+  }
+
+  const eventDefinitions = node.eventDefinitions || [];
+  return eventDefinitions.find(def => is(def, 'bpmn:ConditionalEventDefinition'));
+}
+
+function hasCondition(eventDefinition) {
+  return !!eventDefinition.condition?.body;
+}

package/rules/helper.js

@@ -71,6 +71,22 @@ function findParent(node, type) {
 module.exports.findParent = findParent;
 
 
+/**
+ * Check if the node is inside of an executable process.
+ *
+ * @param { ModdleElement } node
+ *
+ * @return { boolean }
+ */
+function isInExecutableProcess(node) {
+  const process = findParent(node, 'bpmn:Process');
+
+  return process && process.isExecutable;
+}
+
+module.exports.isInExecutableProcess = isInExecutableProcess;
+
+
 const documentationBaseUrl = 'https://github.com/bpmn-io/bpmnlint/blob/main/docs/rules';
 
 /**