bpmnlint 10.2.2 → 10.3.0

package/config/all.js

@@ -3,6 +3,7 @@ const allRules = [
   'end-event-required',
   'event-sub-process-typed-start-event',
   'fake-join',
+  'global',
   'label-required',
   'link-event',
   'no-bpmndi',

package/config/recommended.js

@@ -4,6 +4,7 @@ module.exports = {
     'end-event-required': 'error',
     'event-sub-process-typed-start-event': 'error',
     'fake-join': 'warn',
+    'global': 'warn',
     'label-required': 'error',
     'link-event': 'error',
     'no-bpmndi': 'error',

package/lib/testers/rule-tester.d.ts

@@ -0,0 +1,37 @@
+export type TestFn = (...any) => any;
+
+export type ModdleElement = any;
+
+export type ValidRuleTest = {
+  config?: any,
+  it?: TestFn,
+  moddleElement: ModdleElement,
+  name?: string
+};
+
+export type InvalidReport = {
+  id: string,
+  message: string
+};
+
+export type InvalidRuleTest = {
+  config?: any,
+  it?: TestFn,
+  moddleElement: ModdleElement,
+  name?: string,
+  report: InvalidReport | InvalidReport[]
+};
+
+export type RuleTests = {
+  valid?: ValidRuleTest[],
+  invalid?: InvalidRuleTest[]
+};
+
+/**
+ * Verify a rule.
+ *
+ * @param ruleName
+ * @param rule the rule implementation
+ * @param tests the tests to verify
+ */
+export function verify(ruleName: string, rule: any, tests: RuleTests): void;

package/lib/traverse.js

@@ -1,9 +1,14 @@
+/**
+ * @typedef { import('./types.js').EnterFn } EnterFn
+ * @typedef { import('./types.js').LeaveFn } LeaveFn
+ */
+
 /**
  * Traverse a moddle tree, depth first from top to bottom
  * and call the passed visitor fn.
  *
  * @param {ModdleElement} element
- * @param {{ enter?: Function; leave?: Function }} options
+ * @param {{ enter?: EnterFn; leave?: LeaveFn }} options
  */
 module.exports = function traverse(element, options) {
 

package/lib/types.d.ts

@@ -0,0 +1,5 @@
+export type ModdleElement = any;
+
+export type EnterFn = (element: ModdleElement) => boolean | null;
+
+export type LeaveFn = (element: ModdleElement) => void;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bpmnlint",
   "description": "Validate your BPMN diagrams based on configurable lint rules",
-  "version": "10.2.2",
+  "version": "10.3.0",
   "main": "lib/index.js",
   "keywords": [
     "bpmnlint",
@@ -40,11 +40,11 @@
   "dependencies": {
     "@bpmn-io/moddle-utils": "^0.2.1",
     "ansi-colors": "^4.1.3",
-    "bpmn-moddle": "^8.0.1",
+    "bpmn-moddle": "^8.1.0",
     "bpmnlint-utils": "^1.1.1",
     "cli-table": "^0.3.11",
     "color-support": "^1.1.3",
-    "min-dash": "^4.1.1",
+    "min-dash": "^4.2.1",
     "mri": "^1.2.0",
     "pluralize": "^7.0.0",
     "tiny-glob": "^0.2.9"
@@ -52,12 +52,12 @@
   "devDependencies": {
     "@bpmn-io/bpmnlint-generate-docs-images": "^0.4.0",
     "bpmnlint": ".",
-    "chai": "^4.3.8",
-    "eslint": "^8.49.0",
+    "chai": "^4.4.1",
+    "eslint": "^8.57.0",
     "eslint-plugin-bpmn-io": "^1.0.0",
     "execa": "^8.0.1",
     "install-local": "^3.0.1",
-    "mocha": "^10.2.0",
+    "mocha": "^10.4.0",
     "npm-run-all": "^4.1.5",
     "nyc": "^15.1.0",
     "strip-indent": "^3.0.0"

package/rules/global.js

@@ -0,0 +1,117 @@
+const {
+  isAny, is
+} = require('bpmnlint-utils');
+
+
+/**
+ * A rule that verifies that global elements are properly used.
+ *
+ * Currently recognized global elements are:
+ *
+ *   * `bpmn:Error`
+ *   * `bpmn:Escalation`
+ *   * `bpmn:Signal`
+ *   * `bpmn:Message`
+ *
+ * For each of these elements proper usage implies:
+ *
+ *   * element must have a name
+ *   * element is used (referenced) from event definitions
+ *   * there exists only a single element per type with a given name
+ */
+module.exports = function() {
+
+  function check(node, reporter) {
+
+    if (!is(node, 'bpmn:Definitions')) {
+      return false;
+    }
+
+    const events = getEvents(node);
+    const eventDefinitions = getEventDefinitions(node);
+
+    events.forEach(event => {
+      if (!hasName(event)) {
+        reporter.report(event.id, 'Element is missing name');
+      }
+
+      if (!isReferenced(event, eventDefinitions)) {
+        reporter.report(event.id, 'Element is unused');
+      }
+
+      if (!isUnique(event, events)) {
+        reporter.report(event.id, 'Element name is not unique');
+      }
+    });
+
+  }
+
+  return {
+    check
+  };
+
+  // helpers /////////////////////////////
+
+  function getEvents(definition) {
+    return definition.rootElements.filter(node => isAny(node, [ 'bpmn:Error', 'bpmn:Escalation', 'bpmn:Message', 'bpmn:Signal' ]));
+  }
+
+  function getEventDefinitions(definition) {
+    const eventDefinitions = [];
+
+    function traverse(element) {
+      if (element.rootElements) {
+        element.rootElements.forEach(traverse);
+      }
+
+      if (element.flowElements) {
+        element.flowElements.forEach(traverse);
+      }
+
+      if (element.eventDefinitions) {
+        element.eventDefinitions.forEach(eventDefinition => eventDefinitions.push(eventDefinition));
+      }
+    }
+
+    traverse(definition);
+    return eventDefinitions;
+  }
+
+  function hasName(event) {
+    return (
+      event.name?.trim() !== ''
+    );
+  }
+
+  function isReferenced(event, eventDefinitions) {
+    if (is(event, 'bpmn:Error')) {
+      return (
+        eventDefinitions.some(node => is(node, 'bpmn:ErrorEventDefinition') && event.id === node.errorRef?.id)
+      );
+    }
+
+    if (is(event, 'bpmn:Escalation')) {
+      return (
+        eventDefinitions.some(node => is(node, 'bpmn:EscalationEventDefinition') && event.id === node.escalationRef?.id)
+      );
+    }
+
+    if (is(event, 'bpmn:Message')) {
+      return (
+        eventDefinitions.some(node => is(node, 'bpmn:MessageEventDefinition') && event.id === node.messageRef?.id)
+      );
+    }
+
+    if (is(event, 'bpmn:Signal')) {
+      return (
+        eventDefinitions.some(node => is(node, 'bpmn:SignalEventDefinition') && event.id === node.signalRef?.id)
+      );
+    }
+  }
+
+  function isUnique(event, events) {
+    return (
+      events.filter(node => is(node, event.$type) && event.name === node.name).length === 1
+    );
+  }
+};

package/rules/no-overlapping-elements.js

@@ -60,24 +60,29 @@ module.exports = function() {
  */
 function checkProcess(node, elementsToReport, elementsOutsideToReport, diObjects, parentDi) {
 
-  // check child elements for overlap
   const flowElements = node.flowElements || [];
-  checkElementsArray(flowElements, elementsToReport, diObjects);
 
-  // check child elements outside parent boundary
-  // TODO: Skipped DataSoreReferences for now
-  flowElements.filter(element => !is(element, 'bpmn:DataStoreReference')).forEach(element => {
+  const flowElementsWithDi = flowElements.filter(element => diObjects.has(element));
 
-    if (!diObjects.has(element)) {
-      return;
-    }
+  // check child elements for overlap
+  checkElementsArray(flowElementsWithDi, elementsToReport, diObjects);
 
-    if (isOutsideParentBoundary(diObjects.get(element).bounds, parentDi.bounds)) {
+  // check child elements outside parent boundary
+  //
+  //   * data objects do not have a visual representation
+  //   * for historical reasons data store references may be
+  //     outside of parent boundaries
+  //
+  flowElementsWithDi.forEach(element => {
+    if (
+      !is(element, 'bpmn:DataStoreReference') &&
+      isOutsideParentBoundary(diObjects.get(element).bounds, parentDi.bounds)
+    ) {
       elementsOutsideToReport.add(element);
     }
   });
 
-  // check subprocesses
+  // recurse into subprocesses
   const subProcesses = flowElements.filter(element => is(element, 'bpmn:SubProcess'));
   subProcesses.forEach(subProcess => {
     const subProcessDi = diObjects.get(subProcess) || {};
@@ -93,13 +98,10 @@ function checkProcess(node, elementsToReport, elementsOutsideToReport, diObjects
 function checkElementsArray(elements, elementsToReport, diObjects) {
   for (let i = 0; i < elements.length - 1; i++) {
     const element = elements[i];
+
     for (let j = i + 1; j < elements.length; j++) {
       const element2 = elements[j];
 
-      if (!diObjects.has(element) || !diObjects.has(element2)) {
-        continue;
-      }
-
       // ignore if Boundary events overlap their host
       // but still check if they overlap other elements
       if (element.attachedToRef === element2 || element2.attachedToRef === element) {