bpmn-elements 18.0.2 → 18.0.4

package/dist/process/Process.js

@@ -8,10 +8,12 @@ var _ProcessExecution = require("./ProcessExecution.js");
 var _shared = require("../shared.js");
 var _Api = require("../Api.js");
 var _EventBroker = require("../EventBroker.js");
+var _MessageFormatter = require("../MessageFormatter.js");
 var _messageHelper = require("../messageHelper.js");
 var _Errors = require("../error/Errors.js");
 var _constants = require("../constants.js");
 const K_LANES = Symbol.for('lanes');
+const K_FORMATTER = Symbol.for('formatter');
 
 /**
  * Owns one `<bpmn:process>`. Wraps the structural definition and orchestrates flow traversal,
@@ -49,12 +51,14 @@ function Process(processDef, context) {
     broker,
     on,
     once,
-    waitFor
+    waitFor,
+    emitFatal
   } = (0, _EventBroker.ProcessBroker)(this);
   this.broker = broker;
   this.on = on;
   this.once = once;
   this.waitFor = waitFor;
+  this.emitFatal = emitFatal;
   this[_constants.K_MESSAGE_HANDLERS] = {
     onApiMessage: this._onApiMessage.bind(this),
     onRunMessage: this._onRunMessage.bind(this),
@@ -84,6 +88,14 @@ Object.defineProperties(Process.prototype, {
       return this[_constants.K_EXTENSIONS];
     }
   },
+  formatter: {
+    get() {
+      let formatter = this[K_FORMATTER];
+      if (formatter) return formatter;
+      formatter = this[K_FORMATTER] = new _MessageFormatter.Formatter(this);
+      return formatter;
+    }
+  },
   stopped: {
     get() {
       return this[_constants.K_STOPPED];
@@ -292,14 +304,28 @@ Process.prototype._deactivateRunConsumers = function deactivateRunConsumers() {
 };
 
 /** @internal */
-Process.prototype._onRunMessage = function onRunMessage(routingKey, message) {
+Process.prototype._onRunMessage = function onRunMessage(routingKey, message, messageProperties) {
+  if (routingKey === 'run.resume') {
+    return this._onResumeMessage(message);
+  }
+  const preStatus = this[_constants.K_STATUS];
+  this[_constants.K_STATUS] = 'formatting';
+  return this.formatter.format(message, (err, formattedContent, formatted) => {
+    this[_constants.K_STATUS] = preStatus;
+    if (err) {
+      return this.emitFatal(err, message.content);
+    }
+    if (formatted) message.content = formattedContent;
+    this._continueRunMessage(routingKey, message, messageProperties);
+  });
+};
+
+/** @internal */
+Process.prototype._continueRunMessage = function continueRunMessage(routingKey, message) {
   const {
     content,
     fields
   } = message;
-  if (routingKey === 'run.resume') {
-    return this._onResumeMessage(message);
-  }
   this[_constants.K_STATE_MESSAGE] = message;
   switch (routingKey) {
     case 'run.enter':
@@ -308,6 +334,7 @@ Process.prototype._onRunMessage = function onRunMessage(routingKey, message) {
         this[_constants.K_STATUS] = 'entered';
         if (fields.redelivered) break;
         this[_constants.K_EXECUTION].delete('execution');
+        if (this.extensions) this.extensions.activate((0, _messageHelper.cloneMessage)(message));
         this._publishEvent('enter', content);
         break;
       }
@@ -322,6 +349,7 @@ Process.prototype._onRunMessage = function onRunMessage(routingKey, message) {
       {
         const exec = this[_constants.K_EXECUTION];
         this[_constants.K_STATUS] = 'executing';
+        if (fields.redelivered && this.extensions) this.extensions.activate((0, _messageHelper.cloneMessage)(message));
         const executeMessage = (0, _messageHelper.cloneMessage)(message);
         let execution = exec.get('execution');
         if (fields.redelivered && !execution) {
@@ -366,6 +394,7 @@ Process.prototype._onRunMessage = function onRunMessage(routingKey, message) {
     case 'run.leave':
       {
         this[_constants.K_STATUS] = undefined;
+        if (this.extensions) this.extensions.deactivate((0, _messageHelper.cloneMessage)(message));
         message.ack();
         this._deactivateRunConsumers();
         const {
@@ -394,6 +423,7 @@ Process.prototype._onResumeMessage = function onResumeMessage(message) {
       return;
   }
   if (!stateMessage.fields.redelivered) return;
+  if (this.extensions) this.extensions.activate((0, _messageHelper.cloneMessage)(stateMessage));
   this._debug(`resume from ${this.status}`);
   return this.broker.publish('run', stateMessage.fields.routingKey, (0, _messageHelper.cloneContent)(stateMessage.content), stateMessage.properties);
 };
@@ -530,6 +560,7 @@ Process.prototype._onApiMessage = function onApiMessage(routingKey, message) {
 Process.prototype._onStop = function onStop() {
   this[_constants.K_STOPPED] = true;
   this._deactivateRunConsumers();
+  if (this.extensions) this.extensions.deactivate((0, _messageHelper.cloneMessage)(this[_constants.K_STATE_MESSAGE]));
   return this._publishEvent('stop');
 };
 

package/dist/process/ProcessExecution.js

@@ -116,6 +116,16 @@ ProcessExecution.prototype.execute = function execute(executeMessage) {
   });
   this[_constants.K_STOPPED] = false;
   this.environment.assignVariables(executeMessage);
+
+  // Seed input from the execute content (sub process) or a single inbound trigger (call activity forwarding its formatted input).
+  const content = executeMessage.content;
+  const inbound = content.inbound;
+  const input = content.input ?? (inbound?.length === 1 && inbound[0].input);
+  if (input) {
+    this.environment.assignVariables({
+      input
+    });
+  }
   this[K_ACTIVITY_Q] = this.broker.assertQueue(`execute-${executionId}-q`, {
     durable: true,
     autoDelete: false

package/dist/tasks/CallActivity.js

@@ -73,10 +73,25 @@ CallActivityBehaviour.prototype.execute = function execute(executeMessage) {
     noAck: true,
     consumerTag: `_api-delegated-cancel-${executionId}`
   });
-  broker.publish('event', 'activity.call', (0, _messageHelper.cloneContent)(executeContent, {
+  const callContent = {
     state: 'wait',
     calledElement
-  }), {
+  };
+
+  // Forward the multi-instance loop context as input to the called process; any current content input takes precedence.
+  if (executeContent.isMultiInstance) {
+    const input = {
+      isSequential: executeContent.isSequential,
+      index: executeContent.index,
+      cardinality: executeContent.loopCardinality
+    };
+    const elementVariable = loopCharacteristics?.elementVariable;
+    if (elementVariable && elementVariable in executeContent) {
+      input[elementVariable] = executeContent[elementVariable];
+    }
+    callContent.input = Object.assign(input, executeContent.input);
+  }
+  broker.publish('event', 'activity.call', (0, _messageHelper.cloneContent)(executeContent, callContent), {
     type: 'call'
   });
 };

package/dist/tasks/SubProcess.js

@@ -96,8 +96,29 @@ SubProcessBehaviour.prototype.execute = function execute(executeMessage) {
   if (loopCharacteristics && isRootScope) {
     return loopCharacteristics.execute(executeMessage);
   }
-  const processExecution = this._upsertExecution(executeMessage);
-  return processExecution.execute(executeMessage);
+
+  // Forward the multi-instance loop context as input to the sub process execution; any current content input takes precedence.
+  let message = executeMessage;
+  const content = executeMessage.content;
+  if (content.isMultiInstance) {
+    const input = {
+      isSequential: content.isSequential,
+      index: content.index,
+      cardinality: content.loopCardinality
+    };
+    const elementVariable = loopCharacteristics?.elementVariable;
+    if (elementVariable && elementVariable in content) {
+      input[elementVariable] = content[elementVariable];
+    }
+    message = (0, _messageHelper.cloneMessage)(executeMessage, {
+      input: {
+        ...input,
+        ...content.input
+      }
+    });
+  }
+  const processExecution = this._upsertExecution(message);
+  return processExecution.execute(message);
 };
 SubProcessBehaviour.prototype.getState = function getState() {
   const states = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bpmn-elements",
-  "version": "18.0.2",
+  "version": "18.0.4",
   "description": "Executable workflow elements based on BPMN 2.0",
   "type": "module",
   "main": "./dist/index.js",

package/src/process/Process.js

@@ -2,6 +2,7 @@ import { ProcessExecution } from './ProcessExecution.js';
 import { getUniqueId } from '../shared.js';
 import { ProcessApi } from '../Api.js';
 import { ProcessBroker } from '../EventBroker.js';
+import { Formatter } from '../MessageFormatter.js';
 import { cloneMessage, cloneContent, cloneParent } from '../messageHelper.js';
 import { makeErrorFromMessage } from '../error/Errors.js';
 import {
@@ -17,6 +18,7 @@ import {
 } from '../constants.js';
 
 const K_LANES = Symbol.for('lanes');
+const K_FORMATTER = Symbol.for('formatter');
 
 /**
  * Owns one `<bpmn:process>`. Wraps the structural definition and orchestrates flow traversal,
@@ -47,11 +49,12 @@ export function Process(processDef, context) {
   this[K_STATUS] = undefined;
   this[K_STOPPED] = false;
 
-  const { broker, on, once, waitFor } = ProcessBroker(this);
+  const { broker, on, once, waitFor, emitFatal } = ProcessBroker(this);
   this.broker = broker;
   this.on = on;
   this.once = once;
   this.waitFor = waitFor;
+  this.emitFatal = emitFatal;
 
   this[K_MESSAGE_HANDLERS] = {
     onApiMessage: this._onApiMessage.bind(this),
@@ -83,6 +86,14 @@ Object.defineProperties(Process.prototype, {
       return this[K_EXTENSIONS];
     },
   },
+  formatter: {
+    get() {
+      let formatter = this[K_FORMATTER];
+      if (formatter) return formatter;
+      formatter = this[K_FORMATTER] = new Formatter(this);
+      return formatter;
+    },
+  },
   stopped: {
     get() {
       return this[K_STOPPED];
@@ -278,13 +289,28 @@ Process.prototype._deactivateRunConsumers = function deactivateRunConsumers() {
 };
 
 /** @internal */
-Process.prototype._onRunMessage = function onRunMessage(routingKey, message) {
-  const { content, fields } = message;
-
+Process.prototype._onRunMessage = function onRunMessage(routingKey, message, messageProperties) {
   if (routingKey === 'run.resume') {
     return this._onResumeMessage(message);
   }
 
+  const preStatus = this[K_STATUS];
+  this[K_STATUS] = 'formatting';
+
+  return this.formatter.format(message, (err, formattedContent, formatted) => {
+    this[K_STATUS] = preStatus;
+    if (err) {
+      return this.emitFatal(err, message.content);
+    }
+    if (formatted) message.content = formattedContent;
+    this._continueRunMessage(routingKey, message, messageProperties);
+  });
+};
+
+/** @internal */
+Process.prototype._continueRunMessage = function continueRunMessage(routingKey, message) {
+  const { content, fields } = message;
+
   this[K_STATE_MESSAGE] = message;
 
   switch (routingKey) {
@@ -295,6 +321,7 @@ Process.prototype._onRunMessage = function onRunMessage(routingKey, message) {
       if (fields.redelivered) break;
 
       this[K_EXECUTION].delete('execution');
+      if (this.extensions) this.extensions.activate(cloneMessage(message));
       this._publishEvent('enter', content);
 
       break;
@@ -308,6 +335,7 @@ Process.prototype._onRunMessage = function onRunMessage(routingKey, message) {
     case 'run.execute': {
       const exec = this[K_EXECUTION];
       this[K_STATUS] = 'executing';
+      if (fields.redelivered && this.extensions) this.extensions.activate(cloneMessage(message));
       const executeMessage = cloneMessage(message);
       let execution = exec.get('execution');
       if (fields.redelivered && !execution) {
@@ -360,6 +388,7 @@ Process.prototype._onRunMessage = function onRunMessage(routingKey, message) {
     }
     case 'run.leave': {
       this[K_STATUS] = undefined;
+      if (this.extensions) this.extensions.deactivate(cloneMessage(message));
       message.ack();
       this._deactivateRunConsumers();
       const { output, ...rest } = content;
@@ -389,6 +418,8 @@ Process.prototype._onResumeMessage = function onResumeMessage(message) {
 
   if (!stateMessage.fields.redelivered) return;
 
+  if (this.extensions) this.extensions.activate(cloneMessage(stateMessage));
+
   this._debug(`resume from ${this.status}`);
 
   return this.broker.publish('run', stateMessage.fields.routingKey, cloneContent(stateMessage.content), stateMessage.properties);
@@ -518,6 +549,7 @@ Process.prototype._onApiMessage = function onApiMessage(routingKey, message) {
 Process.prototype._onStop = function onStop() {
   this[K_STOPPED] = true;
   this._deactivateRunConsumers();
+  if (this.extensions) this.extensions.deactivate(cloneMessage(this[K_STATE_MESSAGE]));
   return this._publishEvent('stop');
 };
 

package/src/process/ProcessExecution.js

@@ -112,6 +112,15 @@ ProcessExecution.prototype.execute = function execute(executeMessage) {
   this[K_STOPPED] = false;
 
   this.environment.assignVariables(executeMessage);
+
+  // Seed input from the execute content (sub process) or a single inbound trigger (call activity forwarding its formatted input).
+  const content = executeMessage.content;
+  const inbound = content.inbound;
+  const input = content.input ?? (inbound?.length === 1 && inbound[0].input);
+  if (input) {
+    this.environment.assignVariables({ input });
+  }
+
   this[K_ACTIVITY_Q] = this.broker.assertQueue(`execute-${executionId}-q`, { durable: true, autoDelete: false });
 
   if (executeMessage.fields.redelivered) {

package/src/tasks/CallActivity.js

@@ -80,17 +80,28 @@ CallActivityBehaviour.prototype.execute = function execute(executeMessage) {
     consumerTag: `_api-delegated-cancel-${executionId}`,
   });
 
-  broker.publish(
-    'event',
-    'activity.call',
-    cloneContent(executeContent, {
-      state: 'wait',
-      calledElement,
-    }),
-    {
-      type: 'call',
+  const callContent = {
+    state: 'wait',
+    calledElement,
+  };
+
+  // Forward the multi-instance loop context as input to the called process; any current content input takes precedence.
+  if (executeContent.isMultiInstance) {
+    const input = {
+      isSequential: executeContent.isSequential,
+      index: executeContent.index,
+      cardinality: executeContent.loopCardinality,
+    };
+    const elementVariable = loopCharacteristics?.elementVariable;
+    if (elementVariable && elementVariable in executeContent) {
+      input[elementVariable] = executeContent[elementVariable];
     }
-  );
+    callContent.input = Object.assign(input, executeContent.input);
+  }
+
+  broker.publish('event', 'activity.call', cloneContent(executeContent, callContent), {
+    type: 'call',
+  });
 };
 
 CallActivityBehaviour.prototype._onDelegatedApiMessage = function onDelegatedApiMessage(

package/src/tasks/SubProcess.js

@@ -1,6 +1,6 @@
 import { Activity } from '../activity/Activity.js';
 import { ProcessExecution } from '../process/ProcessExecution.js';
-import { cloneContent } from '../messageHelper.js';
+import { cloneContent, cloneMessage } from '../messageHelper.js';
 
 const K_EXECUTIONS = Symbol.for('executions');
 const K_ON_EXECUTION_COMPLETED = Symbol.for('execution completed handler');
@@ -81,8 +81,24 @@ SubProcessBehaviour.prototype.execute = function execute(executeMessage) {
     return loopCharacteristics.execute(executeMessage);
   }
 
-  const processExecution = this._upsertExecution(executeMessage);
-  return processExecution.execute(executeMessage);
+  // Forward the multi-instance loop context as input to the sub process execution; any current content input takes precedence.
+  let message = executeMessage;
+  const content = executeMessage.content;
+  if (content.isMultiInstance) {
+    const input = {
+      isSequential: content.isSequential,
+      index: content.index,
+      cardinality: content.loopCardinality,
+    };
+    const elementVariable = loopCharacteristics?.elementVariable;
+    if (elementVariable && elementVariable in content) {
+      input[elementVariable] = content[elementVariable];
+    }
+    message = cloneMessage(executeMessage, { input: { ...input, ...content.input } });
+  }
+
+  const processExecution = this._upsertExecution(message);
+  return processExecution.execute(message);
 };
 
 SubProcessBehaviour.prototype.getState = function getState() {

package/types/index.d.ts

@@ -261,6 +261,8 @@ declare module 'bpmn-elements' {
   export enum ProcessStatusValue {
 	/** ProcessExecution constructed, not yet started */
 	Init = 'init',
+	/** Formatting next run message */
+	Formatting = 'formatting',
 	/** Process run entered */
 	Entered = 'entered',
 	/** Process run started */
@@ -1458,6 +1460,7 @@ declare module 'bpmn-elements' {
 			[x: string]: any;
 		}) => import("smqp").Consumer;
 		waitFor: (eventName: string, onMessage?: ((routingKey: string, message: ElementBrokerMessage, owner: Process) => boolean) | undefined) => Promise<IApi<Process>>;
+		emitFatal: (error: Error, content?: Record<string, any>) => void;
 		logger: ILogger;
 		/**
 		 * Allocate an executionId and emit init event without starting the run.

package/types/interfaces.d.ts

@@ -359,6 +359,8 @@ export type DefinitionStatus = DefinitionStatusValue | `${DefinitionStatusValue}
 export const enum ProcessStatusValue {
   /** ProcessExecution constructed, not yet started */
   Init = 'init',
+  /** Formatting next run message */
+  Formatting = 'formatting',
   /** Process run entered */
   Entered = 'entered',
   /** Process run started */