bpmn-elements 6.0.1 → 7.0.0

package/dist/src/EventBroker.js

@@ -5,9 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.ActivityBroker = ActivityBroker;
 exports.DefinitionBroker = DefinitionBroker;
+exports.EventBroker = EventBroker;
 exports.MessageFlowBroker = MessageFlowBroker;
 exports.ProcessBroker = ProcessBroker;
-exports.EventBroker = EventBroker;
 
 var _smqp = require("smqp");
 
@@ -27,7 +27,7 @@ function DefinitionBroker(owner, onBrokerReturn) {
 }
 
 function MessageFlowBroker(owner) {
-  const eventBroker = EventBroker(owner, {
+  const eventBroker = new EventBroker(owner, {
     prefix: 'messageflow',
     autoDelete: false,
     durable: false
@@ -46,7 +46,7 @@ function MessageFlowBroker(owner) {
 }
 
 function ExecutionBroker(brokerOwner, prefix, onBrokerReturn) {
-  const eventBroker = EventBroker(brokerOwner, {
+  const eventBroker = new EventBroker(brokerOwner, {
     prefix,
     autoDelete: false,
     durable: false
@@ -84,104 +84,105 @@ function ExecutionBroker(brokerOwner, prefix, onBrokerReturn) {
 }
 
 function EventBroker(brokerOwner, options, onBrokerReturn) {
-  const broker = (0, _smqp.Broker)(brokerOwner);
-  const pfx = options.prefix;
+  this.options = options;
+  this.eventPrefix = options.prefix;
+  const broker = this.broker = (0, _smqp.Broker)(brokerOwner);
   broker.assertExchange('event', 'topic', options);
-  broker.on('return', onBrokerReturn || onBrokerReturnFn);
-  return {
-    eventPrefix: pfx,
-    broker,
-    on,
-    once,
-    waitFor,
-    emit,
-    emitFatal
-  };
-
-  function on(eventName, callback, eventOptions = {
-    once: false
-  }) {
-    const key = getEventRoutingKey(eventName);
-    if (eventOptions.once) return broker.subscribeOnce('event', key, eventCallback, eventOptions);
-    return broker.subscribeTmp('event', key, eventCallback, { ...eventOptions,
-      noAck: true
-    });
+  broker.on('return', onBrokerReturn ? onBrokerReturn.bind(brokerOwner) : this._onBrokerReturnFn.bind(this));
+  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 eventCallback(routingKey, message, owner) {
-      if (eventName === 'error') return callback((0, _Errors.makeErrorFromMessage)(message));
-      callback(owner.getApi(message));
-    }
-  }
+EventBroker.prototype.on = function on(eventName, callback, eventOptions = {
+  once: false
+}) {
+  const key = this._getEventRoutingKey(eventName);
+
+  if (eventOptions.once) return this.broker.subscribeOnce('event', key, eventCallback, eventOptions);
+  return this.broker.subscribeTmp('event', key, eventCallback, { ...eventOptions,
+    noAck: true
+  });
 
-  function once(eventName, callback, eventOptions = {}) {
-    return on(eventName, callback, { ...eventOptions,
-      once: true
-    });
+  function eventCallback(routingKey, message, owner) {
+    if (eventName === 'error') return callback((0, _Errors.makeErrorFromMessage)(message));
+    callback(owner.getApi(message));
   }
+};
 
-  function waitFor(eventName, onMessage) {
-    const key = getEventRoutingKey(eventName);
-    return new Promise((resolve, reject) => {
-      const consumers = [broker.subscribeTmp('event', key, eventCallback, {
-        noAck: true
-      }), 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));
-      }
+EventBroker.prototype.once = function once(eventName, callback, eventOptions = {}) {
+  return this.on(eventName, callback, { ...eventOptions,
+    once: true
+  });
+};
 
-      function errorCallback(routingKey, message, owner) {
-        if (!message.properties.mandatory) return;
-        unsubscribe();
-        return reject((0, _Errors.makeErrorFromMessage)(message, owner));
-      }
+EventBroker.prototype.waitFor = function waitFor(eventName, onMessage) {
+  const key = this._getEventRoutingKey(eventName);
 
-      function unsubscribe() {
-        consumers.forEach(consumer => consumer.cancel());
-      }
-    });
-  }
+  return new Promise((resolve, reject) => {
+    const consumers = [this.broker.subscribeTmp('event', key, eventCallback, {
+      noAck: true
+    }), this.broker.subscribeTmp('event', '*.error', errorCallback, {
+      noAck: true
+    })];
 
-  function onBrokerReturnFn(message) {
-    if (message.properties.type === 'error') {
-      const err = (0, _Errors.makeErrorFromMessage)(message);
-      throw err;
+    function eventCallback(routingKey, message, owner) {
+      if (onMessage && !onMessage(routingKey, message, owner)) return;
+      unsubscribe();
+      return resolve(owner.getApi(message));
     }
-  }
 
-  function getEventRoutingKey(eventName) {
-    if (eventName.indexOf('.') > -1) return eventName;
-
-    switch (eventName) {
-      case 'wait':
-        {
-          return `activity.${eventName}`;
-        }
+    function errorCallback(routingKey, message, owner) {
+      if (!message.properties.mandatory) return;
+      unsubscribe();
+      return reject((0, _Errors.makeErrorFromMessage)(message, owner));
+    }
 
-      default:
-        {
-          return `${pfx}.${eventName}`;
-        }
+    function unsubscribe() {
+      for (const consumer of consumers) {
+        consumer.cancel();
+      }
     }
-  }
+  });
+};
 
-  function emit(eventName, content = {}, props = {}) {
-    broker.publish('event', `${pfx}.${eventName}`, { ...content
-    }, {
-      type: eventName,
-      ...props
-    });
+EventBroker.prototype.emit = function emit(eventName, content, props) {
+  this.broker.publish('event', `${this.eventPrefix}.${eventName}`, { ...content
+  }, {
+    type: eventName,
+    ...props
+  });
+};
+
+EventBroker.prototype.emitFatal = function emitFatal(error, content) {
+  this.emit('error', { ...content,
+    error
+  }, {
+    mandatory: true
+  });
+};
+
+EventBroker.prototype._onBrokerReturnFn = function onBrokerReturnFn(message) {
+  if (message.properties.type === 'error') {
+    const err = (0, _Errors.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/dist/src/ExtensionsMapper.js

@@ -28,11 +28,11 @@ 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/dist/src/MessageFormatter.js

@@ -13,114 +13,183 @@ var _Errors = require("./error/Errors");
 
 var _smqp = require("smqp");
 
+const onMessageSymbol = Symbol.for('onMessage');
+const executionSymbol = Symbol.for('execution');
+
 function Formatter(element, formatQ) {
   const {
     id,
     broker,
     logger
   } = element;
-  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: (0, _messageHelper.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();
-    }
+  this.id = id;
+  this.broker = broker;
+  this.logger = logger;
+  this.formatQ = formatQ;
+  this.pendingFormats = [];
+  this[onMessageSymbol] = this._onMessage.bind(this);
+}
+
+Formatter.prototype.format = function format(message, callback) {
+  const correlationId = this._runId = (0, _shared.getUniqueId)(message.fields.routingKey);
+  const consumerTag = '_formatter-' + correlationId;
+  const formatQ = this.formatQ;
+  formatQ.queueMessage({
+    routingKey: '_formatting.exec'
+  }, {}, {
+    correlationId,
+    persistent: false
+  });
+  this[executionSymbol] = {
+    correlationId,
+    formatKey: message.fields.routingKey,
+    runMessage: (0, _messageHelper.cloneMessage)(message),
+    callback,
+    pending: [],
+    formatted: false,
+    executeMessage: null
+  };
+  formatQ.consume(this[onMessageSymbol], {
+    consumerTag,
+    prefetch: 100
+  });
+};
 
-    let formattingError;
-    let formattedContent = (0, _messageHelper.cloneContent)(content);
-    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, (0, _shared.filterUndefined)(formattedContent), true);
-    });
-    startFormatMsg.nack(false, true);
-    formatQ.assertConsumer(onFormatMessage, {
-      consumerTag: '_format-consumer',
-      prefetch: 100
-    });
-
-    function onFormatMessage(routingKey, message) {
-      const {
-        endRoutingKey,
-        error
-      } = message.content || {};
-
-      if (endRoutingKey) {
-        pendingFormats.push(message);
-        return logger.debug(`<${id}> start formatting ${fields.routingKey} message content with formatter ${routingKey}`);
+Formatter.prototype._onMessage = function onMessage(routingKey, message) {
+  const {
+    formatKey,
+    correlationId,
+    pending,
+    executeMessage
+  } = this[executionSymbol];
+  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);
       }
 
-      const {
-        isError,
-        message: formatStart
-      } = popFormattingStart(routingKey);
-      logger.debug(`<${id}> format ${fields.routingKey} message content with formatter ${routingKey}`);
-      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 _Errors.ActivityError(errMessage, (0, _messageHelper.cloneMessage)(runMessage, formattedContent), error);
-          pendingFormats.splice(0).forEach(({
-            nack
-          }) => nack(false, false));
+      this[executionSymbol].executeMessage = message;
+      break;
+
+    default:
+      {
+        message.ack();
+        const endRoutingKey = message.content && message.content.endRoutingKey;
+
+        if (endRoutingKey) {
+          this._decorate(message.content);
+
+          pending.push(message);
+          return this._debug(`start formatting ${formatKey} message content with formatter ${routingKey}`);
         }
 
-        formatStart.ack(isError);
-      }
-    }
+        if (asyncFormatting) {
+          const {
+            isError,
+            message: startMessage
+          } = this._popFormatStart(pending, routingKey);
+
+          if (startMessage) startMessage.ack();
+
+          if (isError) {
+            return this._complete(message, true);
+          }
+        }
+
+        this._decorate(message.content);
 
-    function popFormattingStart(routingKey) {
-      for (let i = 0; i < pendingFormats.length; i++) {
-        const pendingFormat = pendingFormats[i];
-        const {
-          endRoutingKey,
-          errorRoutingKey = '#.error'
-        } = pendingFormat.content;
-
-        if ((0, _smqp.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 ((0, _smqp.getRoutingKeyPattern)(errorRoutingKey).test(routingKey)) {
-          pendingFormats.splice(i, 1);
-          return {
-            isError: true,
-            message: pendingFormat
-          };
+        this._debug(`format ${message.fields.routingKey} message content with formatter ${routingKey}`);
+
+        if (executeMessage && asyncFormatting && !pending.length) {
+          this._complete(message);
         }
       }
+  }
+};
 
-      return {};
+Formatter.prototype._complete = function complete(message, isError) {
+  const {
+    runMessage,
+    formatKey,
+    callback,
+    formatted,
+    executeMessage
+  } = this[executionSymbol];
+  this[executionSymbol] = 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 _Errors.ActivityError(errMessage, (0, _messageHelper.cloneMessage)(runMessage), error));
+  }
+
+  return callback(null, runMessage.content, formatted);
+};
+
+Formatter.prototype._decorate = function decorate(withContent) {
+  const content = this[executionSymbol].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[executionSymbol].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 && (0, _smqp.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 ((0, _smqp.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}`);
+};

package/dist/src/Scripts.js

@@ -11,7 +11,11 @@ function Scripts() {
     register
   };
 
-  function getScript() {}
+  function
+    /*scriptType, activity*/
+  getScript() {}
 
-  function register() {}
+  function
+    /*activity*/
+  register() {}
 }