bpmn-elements 6.0.1 → 8.0.1

package/src/Environment.js

@@ -2,122 +2,138 @@ import Expressions from './Expressions';
 import {Scripts as IScripts} from './Scripts';
 import {Timers} from './Timers';
 
-const defaultOptions = ['extensions', 'output', 'services', 'scripts', 'settings', 'variables', 'Logger'];
+const kServices = Symbol.for('services');
+const kVariables = Symbol.for('variables');
+
+const defaultOptions = [
+  'expressions',
+  'extensions',
+  'Logger',
+  'output',
+  'scripts',
+  'services',
+  'settings',
+  'timers',
+  'variables',
+];
 
 export default function Environment(options = {}) {
-  const initialOptions = validateOptions(options);
-
-  let variables = options.variables || {};
-  const settings = {...options.settings};
-  const output = options.output || {};
-  const services = options.services || {};
-  const scripts = options.scripts || IScripts();
-  const timers = options.timers || Timers();
-  const expressions = options.expressions || Expressions();
-  const Logger = options.Logger || DummyLogger;
-  const extensions = options.extensions;
-
-  const environmentApi = {
-    options: initialOptions,
-    expressions,
-    extensions,
-    output,
-    scripts,
-    services,
-    settings,
-    timers,
-    get variables() {
-      return variables;
-    },
-    addService,
-    assignVariables,
-    clone,
-    getScript,
-    getServiceByName,
-    getState,
-    registerScript,
-    resolveExpression,
-    recover,
-    Logger,
-  };
-
-  return environmentApi;
+  this.options = validateOptions(options);
+
+  this.expressions = options.expressions || Expressions();
+  this.extensions = options.extensions;
+  this.output = options.output || {};
+  this.scripts = options.scripts || IScripts();
+  this.timers = options.timers || Timers();
+  this.settings = {...options.settings};
+  this.Logger = options.Logger || DummyLogger;
+  this[kServices] = options.services || {};
+  this[kVariables] = options.variables || {};
+}
 
-  function getState() {
-    return {
-      settings: {...settings},
-      variables: {...variables},
-      output: {...output},
-    };
-  }
+const proto = Environment.prototype;
+
+Object.defineProperty(proto, 'variables', {
+  enumerable: true,
+  get() {
+    return this[kVariables];
+  },
+});
+
+Object.defineProperty(proto, 'services', {
+  enumerable: true,
+  get() {
+    return this[kServices];
+  },
+  set(value) {
+    const services = this[kServices];
+    for (const name in services) {
+      if (!(name in value)) delete services[name];
+    }
+    Object.assign(services, value);
+  },
+});
 
-  function recover(state) {
-    if (!state) return environmentApi;
+proto.getState = function getState() {
+  return {
+    settings: {...this.settings},
+    variables: {...this[kVariables]},
+    output: {...this.output},
+  };
+};
+
+proto.recover = function recover(state) {
+  if (!state) return this;
+
+  if (state.settings) Object.assign(this.settings, state.settings);
+  if (state.variables) Object.assign(this[kVariables], state.variables);
+  if (state.output) Object.assign(this.output, state.output);
+
+  return this;
+};
+
+proto.clone = function clone(overrideOptions = {}) {
+  const services = this[kServices];
+  const newOptions = {
+    settings: {...this.settings},
+    variables: {...this[kVariables]},
+    Logger: this.Logger,
+    extensions: this.extensions,
+    scripts: this.scripts,
+    timers: this.timers,
+    expressions: this.expressions,
+    ...this.options,
+    ...overrideOptions,
+    services,
+  };
 
-    const recoverOptions = validateOptions(state);
-    Object.assign(options, recoverOptions);
+  if (overrideOptions.services) newOptions.services = {...services, ...overrideOptions.services};
 
-    if (state.settings) Object.assign(settings, state.settings);
-    if (state.variables) Object.assign(variables, state.variables);
-    if (state.output) Object.assign(output, state.output);
+  return new this.constructor(newOptions);
+};
 
-    return environmentApi;
-  }
+proto.assignVariables = function assignVariables(newVars) {
+  if (!newVars || typeof newVars !== 'object') return;
 
-  function clone(overrideOptions = {}) {
-    const newOptions = {
-      settings: {...settings},
-      variables: {...variables},
-      output: {...output},
-      Logger,
-      extensions,
-      scripts,
-      timers,
-      expressions,
-      ...initialOptions,
-      ...overrideOptions,
-      services,
-    };
-
-    if (overrideOptions.services) newOptions.services = {...services, ...overrideOptions.services};
-
-    return Environment(newOptions);
-  }
+  this[kVariables] = {
+    ...this.variables,
+    ...newVars,
+  };
+};
 
-  function assignVariables(newVars) {
-    if (!newVars || typeof newVars !== 'object') return;
+proto.assignSettings = function assignVariables(newSettings) {
+  if (!newSettings || typeof newSettings !== 'object') return;
 
-    variables = {
-      ...variables,
-      ...newVars,
-    };
-  }
+  this.settings = {
+    ...this.settings,
+    ...newSettings,
+  };
+};
 
-  function getScript(...args) {
-    return scripts.getScript(...args);
-  }
+proto.getScript = function getScript(...args) {
+  return this.scripts.getScript(...args);
+};
 
-  function registerScript(...args) {
-    return scripts.register(...args);
-  }
+proto.registerScript = function registerScript(...args) {
+  return this.scripts.register(...args);
+};
 
-  function getServiceByName(serviceName) {
-    return services[serviceName];
-  }
+proto.getServiceByName = function getServiceByName(serviceName) {
+  return this[kServices][serviceName];
+};
 
-  function resolveExpression(expression, message = {}, expressionFnContext) {
-    const from = {
-      environment: environmentApi,
-      ...message,
-    };
+proto.resolveExpression = function resolveExpression(expression, message = {}, expressionFnContext) {
+  const from = {
+    environment: this,
+    ...message,
+  };
 
-    return expressions.resolveExpression(expression, from, expressionFnContext);
-  }
+  return this.expressions.resolveExpression(expression, from, expressionFnContext);
+};
 
-  function addService(name, fn) {
-    services[name] = fn;
-  }
-}
+proto.addService = function addService(name, fn) {
+  this[kServices][name] = fn;
+};
 
 function validateOptions(input) {
   const options = {};

package/src/EventBroker.js

@@ -23,7 +23,7 @@ function DefinitionBroker(owner, onBrokerReturn) {
 }
 
 function MessageFlowBroker(owner) {
-  const eventBroker = EventBroker(owner, {prefix: 'messageflow', autoDelete: false, durable: false});
+  const eventBroker = new EventBroker(owner, {prefix: 'messageflow', autoDelete: false, durable: false});
   const broker = eventBroker.broker;
 
   broker.assertExchange('message', 'topic', {durable: true, autoDelete: false});
@@ -34,7 +34,7 @@ function MessageFlowBroker(owner) {
 }
 
 function ExecutionBroker(brokerOwner, prefix, onBrokerReturn) {
-  const eventBroker = EventBroker(brokerOwner, {prefix, autoDelete: false, durable: false}, onBrokerReturn);
+  const eventBroker = new EventBroker(brokerOwner, {prefix, autoDelete: false, durable: false}, onBrokerReturn);
   const broker = eventBroker.broker;
 
   broker.assertExchange('api', 'topic', {autoDelete: false, durable: false});
@@ -54,90 +54,89 @@ function ExecutionBroker(brokerOwner, prefix, onBrokerReturn) {
 }
 
 function EventBroker(brokerOwner, options, onBrokerReturn) {
-  const broker = Broker(brokerOwner);
-  const pfx = options.prefix;
+  this.options = options;
+  this.eventPrefix = options.prefix;
 
+  const broker = this.broker = Broker(brokerOwner);
   broker.assertExchange('event', 'topic', options);
-  broker.on('return', onBrokerReturn || onBrokerReturnFn);
+  broker.on('return', onBrokerReturn ? onBrokerReturn.bind(brokerOwner) : this._onBrokerReturnFn.bind(this));
 
-  return {
-    eventPrefix: pfx,
-    broker,
-    on,
-    once,
-    waitFor,
-    emit,
-    emitFatal,
-  };
+  this.on = this.on.bind(this);
+  this.once = this.once.bind(this);
+  this.waitFor = this.waitFor.bind(this);
+  this.emit = this.emit.bind(this);
+  this.emitFatal = this.emitFatal.bind(this);
+}
 
-  function on(eventName, callback, eventOptions = { once: false }) {
-    const key = getEventRoutingKey(eventName);
+EventBroker.prototype.on = function on(eventName, callback, eventOptions = { once: false }) {
+  const key = this._getEventRoutingKey(eventName);
 
-    if (eventOptions.once) return broker.subscribeOnce('event', key, eventCallback, eventOptions);
-    return broker.subscribeTmp('event', key, eventCallback, {...eventOptions, noAck: true});
+  if (eventOptions.once) return this.broker.subscribeOnce('event', key, eventCallback, eventOptions);
+  return this.broker.subscribeTmp('event', key, eventCallback, {...eventOptions, noAck: true});
 
-    function eventCallback(routingKey, message, owner) {
-      if (eventName === 'error') return callback(makeErrorFromMessage(message));
-      callback(owner.getApi(message));
-    }
+  function eventCallback(routingKey, message, owner) {
+    if (eventName === 'error') return callback(makeErrorFromMessage(message));
+    callback(owner.getApi(message));
   }
+};
 
-  function once(eventName, callback, eventOptions = {}) {
-    return on(eventName, callback, {...eventOptions, once: true});
-  }
+EventBroker.prototype.once = function once(eventName, callback, eventOptions = {}) {
+  return this.on(eventName, callback, {...eventOptions, once: true});
+};
 
-  function waitFor(eventName, onMessage) {
-    const key = getEventRoutingKey(eventName);
+EventBroker.prototype.waitFor = function waitFor(eventName, onMessage) {
+  const key = this._getEventRoutingKey(eventName);
 
-    return new Promise((resolve, reject) => {
-      const consumers = [
-        broker.subscribeTmp('event', key, eventCallback, {noAck: true}),
-        broker.subscribeTmp('event', '*.error', errorCallback, {noAck: true})
-      ];
+  return new Promise((resolve, reject) => {
+    const consumers = [
+      this.broker.subscribeTmp('event', key, eventCallback, {noAck: true}),
+      this.broker.subscribeTmp('event', '*.error', errorCallback, {noAck: true}),
+    ];
 
-      function eventCallback(routingKey, message, owner) {
-        if (onMessage && !onMessage(routingKey, message, owner)) return;
-        unsubscribe();
-        return resolve(owner.getApi(message));
-      }
+    function eventCallback(routingKey, message, owner) {
+      if (onMessage && !onMessage(routingKey, message, owner)) return;
+      unsubscribe();
+      return resolve(owner.getApi(message));
+    }
 
-      function errorCallback(routingKey, message, owner) {
-        if (!message.properties.mandatory) return;
-        unsubscribe();
-        return reject(makeErrorFromMessage(message, owner));
-      }
+    function errorCallback(routingKey, message, owner) {
+      if (!message.properties.mandatory) return;
+      unsubscribe();
+      return reject(makeErrorFromMessage(message, owner));
+    }
 
-      function unsubscribe() {
-        consumers.forEach((consumer) => consumer.cancel());
+    function unsubscribe() {
+      for (const consumer of consumers) {
+        consumer.cancel();
       }
-    });
-  }
-
-  function onBrokerReturnFn(message) {
-    if (message.properties.type === 'error') {
-      const err = makeErrorFromMessage(message);
-      throw err;
     }
-  }
+  });
+};
 
-  function getEventRoutingKey(eventName) {
-    if (eventName.indexOf('.') > -1) return eventName;
+EventBroker.prototype.emit = function emit(eventName, content, props) {
+  this.broker.publish('event', `${this.eventPrefix}.${eventName}`, {...content}, {type: eventName, ...props});
+};
 
-    switch (eventName) {
-      case 'wait': {
-        return `activity.${eventName}`;
-      }
-      default: {
-        return `${pfx}.${eventName}`;
-      }
-    }
-  }
+EventBroker.prototype.emitFatal = function emitFatal(error, content) {
+  this.emit('error', {...content, error}, {mandatory: true});
+};
 
-  function emit(eventName, content = {}, props = {}) {
-    broker.publish('event', `${pfx}.${eventName}`, {...content}, {type: eventName, ...props});
+EventBroker.prototype._onBrokerReturnFn = function onBrokerReturnFn(message) {
+  if (message.properties.type === 'error') {
+    const err = makeErrorFromMessage(message);
+    throw err;
   }
+};
+
+EventBroker.prototype._getEventRoutingKey = function getEventRoutingKey(eventName) {
+  if (eventName.indexOf('.') > -1) return eventName;
 
-  function emitFatal(error, content = {}) {
-    emit('error', {...content, error}, {mandatory: true});
+  switch (eventName) {
+    case 'wait': {
+      return `activity.${eventName}`;
+    }
+    default: {
+      return `${this.eventPrefix}.${eventName}`;
+    }
   }
-}
+};

package/src/ExtensionsMapper.js

@@ -20,10 +20,10 @@ export default function ExtensionsMapper(context) {
     }
 
     function activate(message) {
-      activityExtensions.forEach((extension) => extension.activate(message));
+      for (const extension of activityExtensions) extension.activate(message);
     }
     function deactivate(message) {
-      activityExtensions.forEach((extension) => extension.deactivate(message));
+      for (const extension of activityExtensions) extension.deactivate(message);
     }
   }
 

package/src/MessageFormatter.js

@@ -1,96 +1,154 @@
-import {cloneMessage, cloneParent, cloneContent} from './messageHelper';
-import {filterUndefined} from './shared';
+import {cloneMessage} from './messageHelper';
+import {getUniqueId} from './shared';
 import {ActivityError} from './error/Errors';
 import {getRoutingKeyPattern} from 'smqp';
 
+const kOnMessage = Symbol.for('onMessage');
+const kExecution = Symbol.for('execution');
+
 export {Formatter};
 
 function Formatter(element, formatQ) {
   const {id, broker, logger} = element;
+  this.id = id;
+  this.broker = broker;
+  this.logger = logger;
+  this.formatQ = formatQ;
 
-  return function formatRunMessage(runMessage, callback) {
-    const startFormatMsg = formatQ.get();
-    if (!startFormatMsg) return callback(null, runMessage.content, false);
-
-    const pendingFormats = [];
-    const {fields, content} = runMessage;
-    const fundamentals = {
-      id: content.id,
-      type: content.type,
-      parent: cloneParent(content.parent),
-      attachedTo: content.attachedTo,
-      executionId: content.executionId,
-      isSubProcess: content.isSubProcess,
-      isMultiInstance: content.isMultiInstance,
-    };
-    if (content.inbound) {
-      fundamentals.inbound = content.inbound.slice();
-    }
-    if (content.outbound) {
-      fundamentals.outbound = content.outbound.slice();
-    }
-
-    let formattingError;
-    let formattedContent = cloneContent(content);
+  this.pendingFormats = [];
 
-    const depleted = formatQ.on('depleted', () => {
-      if (pendingFormats.length) return;
-      depleted.cancel();
-      logger.debug(`<${id}> completed formatting ${fields.routingKey}`);
-      broker.cancel('_format-consumer');
-      if (formattingError) return callback(formattingError);
-      return callback(null, filterUndefined(formattedContent), true);
-    });
+  this[kOnMessage] = this._onMessage.bind(this);
+}
 
-    startFormatMsg.nack(false, true);
-    formatQ.assertConsumer(onFormatMessage, { consumerTag: '_format-consumer', prefetch: 100 });
+Formatter.prototype.format = function format(message, callback) {
+  const correlationId = this._runId = getUniqueId(message.fields.routingKey);
+  const consumerTag = '_formatter-' + correlationId;
+  const formatQ = this.formatQ;
+
+  formatQ.queueMessage({
+    routingKey: '_formatting.exec',
+  }, {}, {
+    correlationId,
+    persistent: false,
+  });
+
+  this[kExecution] = {
+    correlationId,
+    formatKey: message.fields.routingKey,
+    runMessage: cloneMessage(message),
+    callback,
+    pending: [],
+    formatted: false,
+    executeMessage: null,
+  };
 
-    function onFormatMessage(routingKey, message) {
-      const {endRoutingKey, error} = message.content || {};
+  formatQ.consume(this[kOnMessage], {
+    consumerTag,
+    prefetch: 100,
+  });
+};
+
+Formatter.prototype._onMessage = function onMessage(routingKey, message) {
+  const {formatKey, correlationId, pending, executeMessage} = this[kExecution];
+  const asyncFormatting = pending.length;
+
+  switch (routingKey) {
+    case '_formatting.exec':
+      if (message.properties.correlationId !== correlationId) return message.ack();
+      if (!asyncFormatting) {
+        message.ack();
+        return this._complete(message);
+      }
+      this[kExecution].executeMessage = message;
+      break;
+    default: {
+      message.ack();
 
+      const endRoutingKey = message.content && message.content.endRoutingKey;
       if (endRoutingKey) {
-        pendingFormats.push(message);
-        return logger.debug(`<${id}> start formatting ${fields.routingKey} message content with formatter ${routingKey}`);
+        this._decorate(message.content);
+        pending.push(message);
+        return this._debug(`start formatting ${formatKey} message content with formatter ${routingKey}`);
       }
 
-      const {isError, message: formatStart} = popFormattingStart(routingKey);
-
-      logger.debug(`<${id}> format ${fields.routingKey} message content with formatter ${routingKey}`);
+      if (asyncFormatting) {
+        const {isError, message: startMessage} = this._popFormatStart(pending, routingKey);
+        if (startMessage) startMessage.ack();
 
-      formattedContent = {
-        ...formattedContent,
-        ...message.content,
-        ...fundamentals,
-      };
-
-      message.ack();
-      if (formatStart) {
         if (isError) {
-          const errMessage = error && error.message || 'formatting failed';
-          logger.debug(`<${id}> formatting of ${fields.routingKey} failed with ${routingKey}: ${errMessage}`);
-          formattingError = new ActivityError(errMessage, cloneMessage(runMessage, formattedContent), error);
-          pendingFormats.splice(0).forEach(({nack}) => nack(false, false));
+          return this._complete(message, true);
         }
-        formatStart.ack(isError);
       }
-    }
 
-    function popFormattingStart(routingKey) {
-      for (let i = 0; i < pendingFormats.length; i++) {
-        const pendingFormat = pendingFormats[i];
-        const {endRoutingKey, errorRoutingKey = '#.error'} = pendingFormat.content;
-
-        if (getRoutingKeyPattern(endRoutingKey).test(routingKey)) {
-          logger.debug(`<${id}> completed formatting ${fields.routingKey} message content with formatter ${routingKey}`);
-          pendingFormats.splice(i, 1);
-          return {message: pendingFormat};
-        } else if (getRoutingKeyPattern(errorRoutingKey).test(routingKey)) {
-          pendingFormats.splice(i, 1);
-          return {isError: true, message: pendingFormat};
-        }
-      }
+      this._decorate(message.content);
+      this._debug(`format ${message.fields.routingKey} message content with formatter ${routingKey}`);
 
-      return {};
+      if (executeMessage && asyncFormatting && !pending.length) {
+        this._complete(message);
+      }
     }
-  };
-}
+  }
+};
+
+Formatter.prototype._complete = function complete(message, isError) {
+  const {runMessage, formatKey, callback, formatted, executeMessage} = this[kExecution];
+  this[kExecution] = null;
+  if (executeMessage) executeMessage.ack();
+
+  this.broker.cancel(message.fields.consumerTag);
+
+  if (isError) {
+    const error = (message.content && message.content.error) || new Error('formatting failed');
+    const errMessage = error.message || 'formatting failed';
+    this._debug(`formatting of ${formatKey} failed with ${message.fields.routingKey}: ${errMessage}`);
+    return callback(new ActivityError(errMessage, cloneMessage(runMessage), error));
+  }
+
+  return callback(null, runMessage.content, formatted);
+};
+
+Formatter.prototype._decorate = function decorate(withContent) {
+  const content = this[kExecution].runMessage.content;
+  for (const key in withContent) {
+    switch (key) {
+      case 'id':
+      case 'type':
+      case 'parent':
+      case 'attachedTo':
+      case 'executionId':
+      case 'isSubProcess':
+      case 'isMultiInstance':
+      case 'inbound':
+      case 'outbound':
+      case 'endRoutingKey':
+      case 'errorRoutingKey':
+        break;
+      default: {
+        content[key] = withContent[key];
+        this[kExecution].formatted = true;
+      }
+    }
+  }
+};
+
+Formatter.prototype._popFormatStart = function popFormattingStart(pending, routingKey) {
+  for (let idx = 0; idx < pending.length; idx++) {
+    const msg = pending[idx];
+    const {endRoutingKey, errorRoutingKey = '#.error'} = msg.content;
+
+    if (endRoutingKey && getRoutingKeyPattern(endRoutingKey).test(routingKey)) {
+      this._debug(`completed formatting ${msg.fields.routingKey} message content with formatter ${routingKey}`);
+      pending.splice(idx, 1);
+      return {message: msg};
+    } else if (getRoutingKeyPattern(errorRoutingKey).test(routingKey)) {
+      pending.splice(idx, 1);
+      return {isError: true, message: msg};
+    }
+  }
+
+  return {};
+};
+
+Formatter.prototype._debug = function debug(msg) {
+  this.logger.debug(`<${this.id}> ${msg}`);
+};