bpmn-engine 13.0.2 → 14.0.0

package/CHANGELOG.md

@@ -1,6 +1,13 @@
 Changelog
 =========
 
+# 14.0.0
+
+## Breaking
+- Engine is prototyped, can still be invoked without new
+- Bump [`bpmn-elements@8.0.0`](https://github.com/paed01/bpmn-elements/blob/master/CHANGELOG.md) with support for bpmn:CallActivity (#97)
+- Bump [`smqp@6.0.0`](https://github.com/paed01/smqp/blob/default/CHANGELOG.md) with support for bpmn:CallActivity (#97)
+
 # 13.0.2
 
 - fix for removing wrong listener on error by @allain

package/index.js

@@ -2,7 +2,7 @@
 
 const BpmnModdle = require('bpmn-moddle');
 const DebugLogger = require('./lib/Logger');
-const elements = require('bpmn-elements');
+const Elements = require('bpmn-elements');
 const getOptionsAndCallback = require('./lib/getOptionsAndCallback');
 const JavaScripts = require('./lib/JavaScripts');
 const ProcessOutputDataObject = require('./lib/extensions/ProcessOutputDataObject');
@@ -11,528 +11,556 @@ const {default: serializer, deserialize, TypeResolver} = require('moddle-context
 const {EventEmitter} = require('events');
 const {version: engineVersion} = require('./package.json');
 
-module.exports = {Engine};
+const kEngine = Symbol.for('engine');
+const kEnvironment = Symbol.for('environment');
+const kExecuting = Symbol.for('executing');
+const kExecution = Symbol.for('execution');
+const kLoadedDefinitions = Symbol.for('loaded definitions');
+const kOnBrokerReturn = Symbol.for('onBrokerReturn');
+const kPendingSources = Symbol.for('pending sources');
+const kSources = Symbol.for('sources');
+const kState = Symbol.for('state');
+const kStopped = Symbol.for('stopped');
+const kTypeResolver = Symbol.for('type resolver');
+
+module.exports = {Engine, Execution};
 
 function Engine(options = {}) {
-  options = {Logger: DebugLogger, scripts: JavaScripts(options.disableDummyScript), ...options};
+  if (!(this instanceof Engine)) return new Engine(options);
 
-  let {name, Logger, sourceContext} = options;
+  EventEmitter.call(this);
 
-  let loadedDefinitions, execution;
-  const logger = Logger('engine');
+  const opts = this.options = {
+    Logger: DebugLogger,
+    scripts: new JavaScripts(options.disableDummyScript),
+    ...options,
+  };
 
-  const sources = [];
-  const typeResolver = TypeResolver({
-    ...elements,
-    ...(options.elements || {})
-  }, defaultTypeResolver);
+  this.logger = opts.Logger('engine');
 
-  function defaultTypeResolver(elementTypes) {
-    if (options.typeResolver) return options.typeResolver(elementTypes);
-    elementTypes['bpmn:DataObject'] = ProcessOutputDataObject;
-  }
+  this[kTypeResolver] = TypeResolver({
+    ...Elements,
+    ...(opts.elements || {})
+  }, opts.typeResolver || defaultTypeResolver);
 
-  const pendingSources = [];
-  if (options.source) pendingSources.push(serializeSource(options.source));
-  if (options.moddleContext) pendingSources.push(serializeModdleContext(options.moddleContext));
-  if (sourceContext) pendingSources.push(sourceContext);
-
-  let environment = elements.Environment(options);
-  const emitter = new EventEmitter();
-
-  const engine = Object.assign(emitter, {
-    logger,
-    addSource,
-    execute,
-    getDefinitionById,
-    getDefinitions,
-    getState,
-    recover,
-    resume,
-    stop,
-    waitFor,
-  });
+  this[kEnvironment] = new Elements.Environment(opts);
 
-  const broker = Broker(engine);
+  const broker = this.broker = new Broker(this);
   broker.assertExchange('event', 'topic', {autoDelete: false});
 
-  Object.defineProperty(engine, 'broker', {
-    enumerable: true,
-    get() {
-      return broker;
-    }
-  });
+  this[kExecution] = null;
+  this[kLoadedDefinitions] = null;
+  this[kSources] = [];
 
-  Object.defineProperty(engine, 'name', {
-    enumerable: true,
-    get() {
-      return name;
-    },
-    set(value) {
-      name = value;
-    },
-  });
+  const pendingSources = this[kPendingSources] = [];
+  if (opts.source) pendingSources.push(this._serializeSource(opts.source));
+  if (opts.moddleContext) pendingSources.push(this._serializeModdleContext(opts.moddleContext));
+  if (opts.sourceContext) pendingSources.push(opts.sourceContext);
+}
 
-  Object.defineProperty(engine, 'environment', {
-    enumerable: true,
-    get() {
-      return environment;
-    },
-  });
+function defaultTypeResolver(elementTypes) {
+  elementTypes['bpmn:DataObject'] = ProcessOutputDataObject;
+  elementTypes['bpmn:DataStoreReference'] = ProcessOutputDataObject;
+}
 
-  Object.defineProperty(engine, 'state', {
-    enumerable: true,
-    get() {
-      if (execution) return execution.state;
-      return 'idle';
-    },
-  });
+Engine.prototype = Object.create(EventEmitter.prototype);
+
+Object.defineProperty(Engine.prototype, 'name', {
+  enumerable: true,
+  get() {
+    return this.options.name;
+  },
+  set(value) {
+    this.options.name = value;
+  },
+});
+
+Object.defineProperty(Engine.prototype, 'environment', {
+  enumerable: true,
+  get() {
+    return this[kEnvironment];
+  },
+});
+
+Object.defineProperty(Engine.prototype, 'state', {
+  enumerable: true,
+  get() {
+    const execution = this.execution;
+    if (execution) return execution.state;
+    return 'idle';
+  },
+});
+
+Object.defineProperty(Engine.prototype, 'stopped', {
+  enumerable: true,
+  get() {
+    const execution = this.execution;
+    if (execution) return execution.stopped;
+    return false;
+  },
+});
+
+Object.defineProperty(Engine.prototype, 'execution', {
+  enumerable: true,
+  get() {
+    return this[kExecution];
+  },
+});
+
+Engine.prototype.execute = async function execute(...args) {
+  const [executeOptions, callback] = getOptionsAndCallback(...args);
+  try {
+    var definitions = await this._loadDefinitions(executeOptions); // eslint-disable-line no-var
+  } catch (err) {
+    if (callback) return callback(err);
+    throw err;
+  }
 
-  Object.defineProperty(engine, 'stopped', {
-    enumerable: true,
-    get() {
-      if (execution) return execution.stopped;
-      return false;
-    },
-  });
+  const execution = this[kExecution] = new Execution(this, definitions, this.options);
+  return execution._execute(executeOptions, callback);
+};
 
-  Object.defineProperty(engine, 'execution', {
-    enumerable: true,
-    get() {
-      return execution;
-    },
-  });
+Engine.prototype.stop = function stop() {
+  const execution = this.execution;
+  if (!execution) return;
+  return execution.stop();
+};
 
-  return engine;
+Engine.prototype.recover = function recover(savedState, recoverOptions) {
+  if (!savedState) return this;
 
-  async function execute(...args) {
-    const [executeOptions, callback] = getOptionsAndCallback(...args);
-    try {
-      var definitions = await loadDefinitions(executeOptions); // eslint-disable-line no-var
-    } catch (err) {
-      if (callback) return callback(err);
-      throw err;
-    }
+  let name = this.name;
+  if (!name) name = this.name = savedState.name;
 
-    execution = Execution(engine, definitions, options);
-    return execution.execute(executeOptions, callback);
-  }
+  this.logger.debug(`<${name}> recover`);
 
-  function stop() {
-    if (!execution) return;
-    return execution.stop();
-  }
+  if (recoverOptions) this[kEnvironment] = new Elements.Environment(recoverOptions);
+  if (savedState.environment) this[kEnvironment] = this[kEnvironment].recover(savedState.environment);
 
-  function recover(savedState, recoverOptions) {
-    if (!savedState) return engine;
-    if (!name) name = savedState.name;
+  if (!savedState.definitions) return this;
 
-    logger.debug(`<${name}> recover`);
+  const pendingSources = this[kPendingSources];
+  const preSources = pendingSources.splice(0);
 
-    if (recoverOptions) environment = elements.Environment(recoverOptions);
-    if (savedState.environment) environment = environment.recover(savedState.environment);
+  const typeResolver = this[kTypeResolver];
+  const loadedDefinitions = this[kLoadedDefinitions] = savedState.definitions.map((dState) => {
+    let source;
+    if (dState.source) source = deserialize(JSON.parse(dState.source), typeResolver);
+    else source = preSources.find((s) => s.id === dState.id);
 
-    if (!savedState.definitions) return engine;
+    pendingSources.push(source);
 
-    const preSources = pendingSources.splice(0);
+    this.logger.debug(`<${name}> recover ${dState.type} <${dState.id}>`);
 
-    loadedDefinitions = savedState.definitions.map((dState) => {
-      let source;
-      if (dState.source) source = deserialize(JSON.parse(dState.source), typeResolver);
-      else source = preSources.find((s) => s.id === dState.id);
+    const definition = this._loadDefinition(source);
+    definition.recover(dState);
 
-      pendingSources.push(source);
+    return definition;
+  });
 
-      logger.debug(`<${name}> recover ${dState.type} <${dState.id}>`);
+  this[kExecution] = new Execution(this, loadedDefinitions, {}, true);
 
-      const definition = loadDefinition(source);
-      definition.recover(dState);
+  return this;
+};
 
-      return definition;
-    });
+Engine.prototype.resume = async function resume(...args) {
+  const [resumeOptions, callback] = getOptionsAndCallback(...args);
 
-    execution = Execution(engine, loadedDefinitions, {}, true);
-
-    return engine;
+  let execution = this.execution;
+  if (!execution) {
+    const definitions = await this.getDefinitions();
+    if (!definitions.length) {
+      const err = new Error('nothing to resume');
+      if (callback) return callback(err);
+      throw err;
+    }
+    execution = this[kExecution] = new Execution(this, definitions, this.options);
   }
 
-  async function resume(...args) {
-    const [resumeOptions, callback] = getOptionsAndCallback(...args);
-
-    if (!execution) {
-      const definitions = await getDefinitions();
-      if (!definitions.length) {
-        const err = new Error('nothing to resume');
-        if (callback) return callback(err);
-        throw err;
-      }
-      execution = Execution(engine, definitions, options);
+  return execution._resume(resumeOptions, callback);
+};
+
+Engine.prototype.addSource = function addSource({sourceContext: addContext} = {}) {
+  if (!addContext) return;
+  const loadedDefinitions = this[kLoadedDefinitions];
+  if (loadedDefinitions) loadedDefinitions.splice(0);
+  this[kPendingSources].push(addContext);
+};
+
+Engine.prototype.getDefinitions = async function getDefinitions(executeOptions) {
+  const loadedDefinitions = this[kLoadedDefinitions];
+  if (loadedDefinitions && loadedDefinitions.length) return loadedDefinitions;
+  return this._loadDefinitions(executeOptions);
+};
+
+Engine.prototype.getDefinitionById = async function getDefinitionById(id) {
+  return (await this.getDefinitions()).find((d) => d.id === id);
+};
+
+Engine.prototype.getState = async function getState() {
+  const execution = this.execution;
+  if (execution) return execution.getState();
+
+  const definitions = await this.getDefinitions();
+  return new Execution(this, definitions, this.options).getState();
+};
+
+Engine.prototype.waitFor = function waitFor(eventName) {
+  const self = this;
+  return new Promise((resolve, reject) => {
+    self.once(eventName, onEvent);
+    self.once('error', onError);
+
+    function onEvent(api) {
+      self.removeListener('error', onError);
+      resolve(api);
     }
+    function onError(err) {
+      self.removeListener(eventName, onEvent);
+      reject(err);
+    }
+  });
+};
+
+Engine.prototype._loadDefinitions = async function loadDefinitions(executeOptions) {
+  const runSources = await Promise.all(this[kPendingSources]);
+  const loadedDefinitions = this[kLoadedDefinitions] = runSources.map((source) => this._loadDefinition(source, executeOptions));
+  return loadedDefinitions;
+};
+
+Engine.prototype._loadDefinition = function loadDefinition(serializedContext, executeOptions = {}) {
+  const {settings, variables} = executeOptions;
+
+  const environment = this.environment;
+  const context = new Elements.Context(serializedContext, environment.clone({
+    listener: environment.options.listener,
+    ...executeOptions,
+    settings: {
+      ...environment.settings,
+      ...settings,
+    },
+    variables: {
+      ...environment.variables,
+      ...variables,
+    },
+    source: serializedContext,
+  }));
 
-    return execution.resume(resumeOptions, callback);
-  }
+  return new Elements.Definition(context);
+};
 
-  function addSource({sourceContext: addContext} = {}) {
-    if (!addContext) return;
-    if (loadedDefinitions) loadedDefinitions.splice(0);
-    pendingSources.push(addContext);
-  }
+Engine.prototype._serializeSource = async function serializeSource(source) {
+  const moddleContext = await this._getModdleContext(source);
+  return this._serializeModdleContext(moddleContext);
+};
 
-  async function getDefinitions(executeOptions) {
-    if (loadedDefinitions && loadedDefinitions.length) return loadedDefinitions;
-    return loadDefinitions(executeOptions);
-  }
+Engine.prototype._serializeModdleContext = function serializeModdleContext(moddleContext) {
+  const serialized = serializer(moddleContext, this[kTypeResolver]);
+  this[kSources].push(serialized);
+  return serialized;
+};
 
-  async function getDefinitionById(id) {
-    return (await getDefinitions()).find((d) => d.id === id);
-  }
+Engine.prototype._getModdleContext = function getModdleContext(source) {
+  const bpmnModdle = new BpmnModdle(this.options.moddleOptions);
+  return bpmnModdle.fromXML(Buffer.isBuffer(source) ? source.toString() : source.trim());
+};
 
-  async function getState() {
-    if (execution) return execution.getState();
+function Execution(engine, definitions, options, isRecovered = false) {
+  this.name = engine.name;
+  this.options = options;
+  this.definitions = definitions;
+  this[kState] = 'idle';
+  this[kStopped] = isRecovered;
+  this[kEnvironment] = engine.environment;
+  this[kEngine] = engine;
+  this[kExecuting] = [];
+  const onBrokerReturn = this[kOnBrokerReturn] = this._onBrokerReturn.bind(this);
+  engine.broker.on('return', onBrokerReturn);
+}
 
-    const definitions = await getDefinitions();
-    return Execution(engine, definitions, options).getState();
-  }
+Object.defineProperty(Execution.prototype, 'state', {
+  enumerable: true,
+  get() {
+    return this[kState];
+  },
+});
+
+Object.defineProperty(Execution.prototype, 'stopped', {
+  enumerable: true,
+  get() {
+    return this[kStopped];
+  },
+});
+
+Object.defineProperty(Execution.prototype, 'broker', {
+  enumerable: true,
+  get() {
+    return this[kEngine].broker;
+  },
+});
+
+Object.defineProperty(Execution.prototype, 'environment', {
+  enumerable: true,
+  get() {
+    return this[kEnvironment];
+  },
+});
+
+Execution.prototype._execute = function execute(executeOptions, callback) {
+  this._setup(executeOptions);
+  this[kStopped] = false;
+  this._debug('execute');
+
+  this._addConsumerCallbacks(callback);
+  const definitionExecutions = this.definitions.reduce((result, definition) => {
+    if (!definition.getExecutableProcesses().length) return result;
+    result.push(definition.run());
+    return result;
+  }, []);
 
-  async function loadDefinitions(executeOptions) {
-    const runSources = await Promise.all(pendingSources);
-    loadedDefinitions = runSources.map((source) => loadDefinition(source, executeOptions));
-    return loadedDefinitions;
-  }
 
-  function loadDefinition(serializedContext, executeOptions = {}) {
-    const {settings, variables} = executeOptions;
-
-    const context = elements.Context(serializedContext, environment.clone({
-      listener: environment.options.listener,
-      ...executeOptions,
-      settings: {
-        ...environment.settings,
-        ...settings,
-      },
-      variables: {
-        ...environment.variables,
-        ...variables,
-      },
-      source: serializedContext,
-    }));
-
-    return elements.Definition(context);
+  if (!definitionExecutions.length) {
+    const error = new Error('No executable processes');
+    if (!callback) return this[kEngine].emit('error', error);
+    return callback(error);
   }
 
-  async function serializeSource(source) {
-    const moddleContext = await getModdleContext(source);
-    return serializeModdleContext(moddleContext);
-  }
+  return this;
+};
 
-  function serializeModdleContext(moddleContext) {
-    const serialized = serializer(moddleContext, typeResolver);
-    sources.push(serialized);
-    return serialized;
-  }
+Execution.prototype._resume = function resume(resumeOptions, callback) {
+  this._setup(resumeOptions);
 
-  function getModdleContext(source) {
-    const bpmnModdle = new BpmnModdle(options.moddleOptions);
-    return bpmnModdle.fromXML(Buffer.isBuffer(source) ? source.toString() : source.trim());
-  }
+  this[kStopped] = false;
+  this._debug('resume');
+  this._addConsumerCallbacks(callback);
 
-  async function waitFor(eventName) {
-    return new Promise((resolve, reject) => {
-      engine.once(eventName, onEvent);
-      engine.once('error', onError);
+  this[kExecuting].splice(0);
+  this.definitions.forEach((definition) => definition.resume());
 
-      function onEvent(api) {
-        engine.removeListener('error', onError);
-        resolve(api);
-      }
-      function onError(err) {
-        engine.removeListener(eventName, onEvent);
-        reject(err);
-      }
-    });
-  }
-}
+  return this;
+};
 
-function Execution(engine, definitions, options, isRecovered = false) {
-  const {environment, logger, waitFor, broker} = engine;
-  broker.on('return', onBrokerReturn);
+Execution.prototype._addConsumerCallbacks = function addConsumerCallbacks(callback) {
+  if (!callback) return;
 
-  let state = 'idle';
-  let stopped = isRecovered;
-  const executing = [];
+  const broker = this.broker;
+  const onBrokerReturn = this[kOnBrokerReturn];
 
-  return {
-    ...Api(),
-    get state() {
-      return state;
-    },
-    get stopped() {
-      return stopped;
-    },
-    execute,
-    resume,
-  };
+  broker.off('return', onBrokerReturn);
 
-  function execute(executeOptions, callback) {
-    setup(executeOptions);
-    stopped = false;
-    logger.debug(`<${engine.name}> execute`);
-
-    addConsumerCallbacks(callback);
-    const definitionExecutions = definitions.reduce((result, definition) => {
-      if (!definition.getExecutableProcesses().length) return result;
-      result.push(definition.run());
-      return result;
-    }, []);
-
-    if (!definitionExecutions.length) {
-      const error = new Error('No executable processes');
-      if (!callback) return engine.emit('error', error);
-      return callback(error);
-    }
+  clearConsumers();
 
-    return Api();
-  }
+  broker.subscribeOnce('event', 'engine.stop', () => {
+    clearConsumers();
+    return callback(null, this);
+  }, {consumerTag: 'ctag-cb-stop'});
 
-  function resume(resumeOptions, callback) {
-    setup(resumeOptions);
+  broker.subscribeOnce('event', 'engine.end', () => {
+    clearConsumers();
+    return callback(null, this);
+  }, {consumerTag: 'ctag-cb-end'});
 
-    stopped = false;
-    logger.debug(`<${engine.name}> resume`);
-    addConsumerCallbacks(callback);
+  broker.subscribeOnce('event', 'engine.error', (_, message) => {
+    clearConsumers();
+    return callback(message.content);
+  }, {consumerTag: 'ctag-cb-error'});
 
-    executing.splice(0);
-    definitions.forEach((definition) => definition.resume());
+  return callback;
 
-    return Api();
+  function clearConsumers() {
+    broker.cancel('ctag-cb-stop');
+    broker.cancel('ctag-cb-end');
+    broker.cancel('ctag-cb-error');
+    broker.on('return', onBrokerReturn);
   }
+};
 
-  function addConsumerCallbacks(callback) {
-    if (!callback) return;
+Execution.prototype.stop = async function stop() {
+  const engine = this[kEngine];
+  const prom = engine.waitFor('stop');
+  this[kStopped] = true;
+  const timers = engine.environment.timers;
 
-    broker.off('return', onBrokerReturn);
+  timers.executing.slice().forEach((ref) => timers.clearTimeout(ref));
 
-    clearConsumers();
+  this[kExecuting].splice(0).forEach((d) => d.stop());
 
-    broker.subscribeOnce('event', 'engine.stop', cbLeave, {consumerTag: 'ctag-cb-stop'});
-    broker.subscribeOnce('event', 'engine.end', cbLeave, {consumerTag: 'ctag-cb-end'});
-    broker.subscribeOnce('event', 'engine.error', cbError, {consumerTag: 'ctag-cb-error'});
+  const result = await prom;
+  this[kState] = 'stopped';
+  return result;
+};
 
-    return callback;
+Execution.prototype._setup = function setup(setupOptions = {}) {
+  const listener = setupOptions.listener || this.options.listener;
+  if (listener && typeof listener.emit !== 'function') throw new Error('listener.emit is not a function');
 
-    function cbLeave() {
-      clearConsumers();
-      return callback(null, Api());
-    }
-    function cbError(_, message) {
-      clearConsumers();
-      return callback(message.content);
-    }
+  const onChildMessage = this._onChildMessage.bind(this);
 
-    function clearConsumers() {
-      broker.cancel('ctag-cb-stop');
-      broker.cancel('ctag-cb-end');
-      broker.cancel('ctag-cb-error');
-      broker.on('return', onBrokerReturn);
-    }
-  }
+  for (const definition of this.definitions) {
+    if (listener) definition.environment.options.listener = listener;
 
-  async function stop() {
-    const prom = waitFor('stop');
-    stopped = true;
-    const timers = environment.timers;
-    timers.executing.slice().forEach((ref) => timers.clearTimeout(ref));
-    executing.splice(0).forEach((d) => d.stop());
-    const result = await prom;
-    state = 'stopped';
-    return result;
+    definition.broker.subscribeTmp('event', 'definition.#', onChildMessage, {noAck: true, consumerTag: '_engine_definition'});
+    definition.broker.subscribeTmp('event', 'process.#', onChildMessage, {noAck: true, consumerTag: '_engine_process'});
+    definition.broker.subscribeTmp('event', 'activity.#', onChildMessage, {noAck: true, consumerTag: '_engine_activity'});
+    definition.broker.subscribeTmp('event', 'flow.#', onChildMessage, {noAck: true, consumerTag: '_engine_flow'});
   }
+};
+
+Execution.prototype._onChildMessage = function onChildMessage(routingKey, message, owner) {
+  const {environment: ownerEnvironment} = owner;
+  const listener = ownerEnvironment.options && ownerEnvironment.options.listener;
+  this[kState] = 'running';
+
+  let newState;
+  const elementApi = owner.getApi && owner.getApi(message);
+
+  switch (routingKey) {
+    case 'definition.resume':
+    case 'definition.enter': {
+      const executing = this[kExecuting];
+      const idx = executing.indexOf(owner);
+      if (idx > -1) break;
+      executing.push(owner);
+      break;
+    }
+    case 'definition.stop': {
+      this._teardownDefinition(owner);
 
-  function setup(setupOptions = {}) {
-    const listener = setupOptions.listener || options.listener;
-    if (listener && typeof listener.emit !== 'function') throw new Error('listener.emit is not a function');
-
-    definitions.forEach(setupDefinition);
-
-    function setupDefinition(definition) {
-      if (listener) definition.environment.options.listener = listener;
+      const executing = this[kExecuting];
+      if (executing.some((d) => d.isRunning)) break;
 
-      definition.broker.subscribeTmp('event', 'definition.#', onChildMessage, {noAck: true, consumerTag: '_engine_definition'});
-      definition.broker.subscribeTmp('event', 'process.#', onChildMessage, {noAck: true, consumerTag: '_engine_process'});
-      definition.broker.subscribeTmp('event', 'activity.#', onChildMessage, {noAck: true, consumerTag: '_engine_activity'});
-      definition.broker.subscribeTmp('event', 'flow.#', onChildMessage, {noAck: true, consumerTag: '_engine_flow'});
+      newState = 'stopped';
+      this[kStopped] = true;
+      break;
     }
-  }
-
-  function onChildMessage(routingKey, message, owner) {
-    const {environment: ownerEnvironment} = owner;
-    const listener = ownerEnvironment.options && ownerEnvironment.options.listener;
-    state = 'running';
-
-    let executionStopped, executionCompleted, executionErrored;
-    const elementApi = owner.getApi && owner.getApi(message);
-
-    switch (routingKey) {
-      case 'definition.resume':
-      case 'definition.enter': {
-        const idx = executing.indexOf(owner);
-        if (idx > -1) break;
-        executing.push(owner);
-        break;
-      }
-      case 'definition.stop':
-        teardownDefinition(owner);
-        if (executing.some((d) => d.isRunning)) break;
-
-        executionStopped = true;
-        stopped = true;
-        break;
-      case 'definition.leave':
-        teardownDefinition(owner);
-
-        if (executing.some((d) => d.isRunning)) break;
-
-        executionCompleted = true;
-        break;
-      case 'definition.error':
-        teardownDefinition(owner);
-        executionErrored = true;
-        break;
-      case 'activity.wait': {
-        emitListenerEvent('wait', owner.getApi(message), Api());
-        break;
-      }
-      case 'process.end': {
-        if (!message.content.output) break;
-        for (const key in message.content.output) {
-          switch (key) {
-            case 'data': {
-              environment.output.data = environment.output.data || {};
-              environment.output.data = {...environment.output.data, ...message.content.output.data};
-              break;
-            }
-            default: {
-              environment.output[key] = message.content.output[key];
-            }
+    case 'definition.leave':
+      this._teardownDefinition(owner);
+
+      if (this[kExecuting].some((d) => d.isRunning)) break;
+
+      newState = 'idle';
+      break;
+    case 'definition.error':
+      this._teardownDefinition(owner);
+      newState = 'error';
+      break;
+    case 'activity.wait': {
+      if (listener) listener.emit('wait', owner.getApi(message), this);
+      break;
+    }
+    case 'process.end': {
+      if (!message.content.output) break;
+      const environment = this.environment;
+
+      for (const key in message.content.output) {
+        switch (key) {
+          case 'data': {
+            environment.output.data = environment.output.data || {};
+            environment.output.data = {...environment.output.data, ...message.content.output.data};
+            break;
+          }
+          default: {
+            environment.output[key] = message.content.output[key];
           }
         }
-        break;
       }
+      break;
     }
+  }
 
-    emitListenerEvent(routingKey, elementApi, Api());
-    broker.publish('event', routingKey, {...message.content}, {...message.properties, mandatory: false});
-
-    if (executionStopped) {
-      state = 'stopped';
-      logger.debug(`<${engine.name}> stopped`);
-      onComplete('stop');
-    } else if (executionCompleted) {
-      state = 'idle';
-      logger.debug(`<${engine.name}> completed`);
-      onComplete('end');
-    } else if (executionErrored) {
-      state = 'error';
-      logger.debug(`<${engine.name}> error`);
-      onError(message.content.error);
-    }
+  if (listener) listener.emit(routingKey, elementApi, this);
 
-    function onComplete(eventName) {
-      broker.publish('event', `engine.${eventName}`, {}, {type: eventName});
-      engine.emit(eventName, Api());
-    }
+  const broker = this.broker;
+  broker.publish('event', routingKey, {...message.content}, {...message.properties, mandatory: false});
 
-    function onError(err) {
-      broker.publish('event', 'engine.error', err, {type: 'error', mandatory: true});
-    }
+  if (!newState) return;
 
-    function emitListenerEvent(...args) {
-      if (!listener) return;
-      listener.emit(...args);
-    }
-  }
+  this[kState] = newState;
 
-  function teardownDefinition(definition) {
-    const idx = executing.indexOf(definition);
-    if (idx > -1) executing.splice(idx, 1);
-
-    definition.broker.cancel('_engine_definition');
-    definition.broker.cancel('_engine_process');
-    definition.broker.cancel('_engine_activity');
-    definition.broker.cancel('_engine_flow');
+  switch (newState) {
+    case 'stopped':
+      this._debug('stopped');
+      broker.publish('event', 'engine.stop', {}, {type: 'stop'});
+      return this[kEngine].emit('stop', this);
+    case 'idle':
+      this._debug('completed');
+      broker.publish('event', 'engine.end', {}, {type: 'end'});
+      return this[kEngine].emit('end', this);
+    case 'error':
+      this._debug('error');
+      return broker.publish('event', 'engine.error', message.content.error, {type: 'error', mandatory: true});
   }
-
-  function getState() {
-    return {
-      name: engine.name,
-      state,
-      stopped,
-      engineVersion,
-      environment: environment.getState(),
-      definitions: definitions.map(getDefinitionState),
-    };
+};
+
+Execution.prototype._teardownDefinition = function teardownDefinition(definition) {
+  const executing = this[kExecuting];
+  const idx = executing.indexOf(definition);
+  if (idx > -1) executing.splice(idx, 1);
+
+  definition.broker.cancel('_engine_definition');
+  definition.broker.cancel('_engine_process');
+  definition.broker.cancel('_engine_activity');
+  definition.broker.cancel('_engine_flow');
+};
+
+Execution.prototype.getState = function getState() {
+  const definitions = [];
+  for (const definition of this.definitions) {
+    definitions.push({
+      ...definition.getState(),
+      source: definition.environment.options.source.serialize(),
+    });
   }
 
-  function getActivityById(activityId) {
-    for (const definition of definitions) {
-      const activity = definition.getActivityById(activityId);
-      if (activity) return activity;
-    }
-  }
+  return {
+    name: this[kEngine].name,
+    state: this.state,
+    stopped: this.stopped,
+    engineVersion,
+    environment: this.environment.getState(),
+    definitions,
+  };
+};
 
-  function getPostponed() {
-    const defs = stopped ? definitions : executing;
-    return defs.reduce((result, definition) => {
-      result = result.concat(definition.getPostponed());
-      return result;
-    }, []);
+Execution.prototype.getActivityById = function getActivityById(activityId) {
+  for (const definition of this.definitions) {
+    const activity = definition.getActivityById(activityId);
+    if (activity) return activity;
   }
+};
 
-  function signal(payload, {ignoreSameDefinition} = {}) {
-    for (const definition of executing) {
-      if (ignoreSameDefinition && payload && payload.parent && payload.parent.id === definition.id) continue;
-      definition.signal(payload);
-    }
-  }
+Execution.prototype.getPostponed = function getPostponed() {
+  const defs = this.stopped ? this.definitions : this[kExecuting];
+  return defs.reduce((result, definition) => {
+    result = result.concat(definition.getPostponed());
+    return result;
+  }, []);
+};
 
-  function cancelActivity(payload) {
-    for (const definition of executing) {
-      definition.cancelActivity(payload);
-    }
+Execution.prototype.signal = function signal(payload, {ignoreSameDefinition} = {}) {
+  for (const definition of this[kExecuting]) {
+    if (ignoreSameDefinition && payload && payload.parent && payload.parent.id === definition.id) continue;
+    definition.signal(payload);
   }
+};
 
-  function getDefinitionState(definition) {
-    return {
-      ...definition.getState(),
-      source: definition.environment.options.source.serialize(),
-    };
+Execution.prototype.cancelActivity = function cancelActivity(payload) {
+  for (const definition of this[kExecuting]) {
+    definition.cancelActivity(payload);
   }
+};
 
-  function onBrokerReturn(message) {
-    if (message.properties.type === 'error') {
-      engine.emit('error', message.content);
-    }
-  }
+Execution.prototype.waitFor = function waitFor(...args) {
+  return this[kEngine].waitFor(...args);
+};
 
-  function Api() {
-    return {
-      name: engine.name,
-      get state() {
-        return state;
-      },
-      get stopped() {
-        return stopped;
-      },
-      broker,
-      environment,
-      definitions,
-      getActivityById,
-      getState,
-      getPostponed,
-      signal,
-      cancelActivity,
-      stop,
-      waitFor,
-    };
+Execution.prototype._onBrokerReturn = function onBrokerReturn(message) {
+  if (message.properties.type === 'error') {
+    this[kEngine].emit('error', message.content);
   }
-}
+};
+
+Execution.prototype._debug = function debug(msg) {
+  this[kEngine].logger.debug(`<${this.name}> ${msg}`);
+};

package/lib/JavaScripts.js

@@ -2,50 +2,49 @@
 
 const {Script} = require('vm');
 
-module.exports = function Scripts(disableDummy) {
-  const scripts = {};
+module.exports = Scripts;
 
-  return {
-    getScript,
-    register,
-  };
+function Scripts(disableDummy) {
+  if (!(this instanceof Scripts)) return new Scripts(disableDummy);
+  this.scripts = {};
+  this.disableDummy = disableDummy;
+}
 
-  function register({id, type, behaviour, logger, environment}) {
-    let scriptBody, language;
+Scripts.prototype.register = function register({id, type, behaviour, logger, environment}) {
+  let scriptBody, language;
 
-    switch (type) {
-      case 'bpmn:SequenceFlow': {
-        if (!behaviour.conditionExpression) return;
-        language = behaviour.conditionExpression.language;
-        if (!language) return;
-        scriptBody = behaviour.conditionExpression.body;
-        break;
-      }
-      default: {
-        language = behaviour.scriptFormat;
-        scriptBody = behaviour.script;
-      }
+  switch (type) {
+    case 'bpmn:SequenceFlow': {
+      if (!behaviour.conditionExpression) return;
+      language = behaviour.conditionExpression.language;
+      if (!language) return;
+      scriptBody = behaviour.conditionExpression.body;
+      break;
     }
-
-    const filename = `${type}/${id}`;
-    if (!language || !scriptBody) {
-      if (disableDummy) return;
-      const script = new DummyScript(language, filename, logger);
-      scripts[id] = script;
-      return script;
+    default: {
+      language = behaviour.scriptFormat;
+      scriptBody = behaviour.script;
     }
+  }
 
-    if (!/^javascript$/i.test(language)) return;
-
-    const script = new JavaScript(language, filename, scriptBody, environment);
-    scripts[id] = script;
-
+  const filename = `${type}/${id}`;
+  if (!language || !scriptBody) {
+    if (this.disableDummy) return;
+    const script = new DummyScript(language, filename, logger);
+    this.scripts[id] = script;
     return script;
   }
 
-  function getScript(language, {id}) {
-    return scripts[id];
-  }
+  if (!/^javascript$/i.test(language)) return;
+
+  const script = new JavaScript(language, filename, scriptBody, environment);
+  this.scripts[id] = script;
+
+  return script;
+};
+
+Scripts.prototype.getScript = function getScript(language, {id}) {
+  return this.scripts[id];
 };
 
 function JavaScript(language, filename, scriptBody, environment) {

package/lib/extensions/ProcessOutputDataObject.js

@@ -19,7 +19,6 @@ module.exports = function ProcessOutputDataObject(dataObjectDef, {environment})
 
       environment.output.data = environment.output.data || {};
       environment.output.data[id] = value;
-
       return broker.publish(exchange, `${routingKeyPrefix}response`, {id, name, type, value}, messageProperties);
     },
   };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bpmn-engine",
   "description": "BPMN 2.0 execution engine. Open source javascript workflow engine.",
-  "version": "13.0.2",
+  "version": "14.0.0",
   "main": "index.js",
   "types": "types/bpmn-engine.d.ts",
   "repository": {
@@ -51,21 +51,21 @@
   },
   "devDependencies": {
     "bent": "^7.3.12",
-    "camunda-bpmn-moddle": "^6.1.0",
-    "chai": "^4.3.0",
+    "camunda-bpmn-moddle": "^6.1.2",
+    "chai": "^4.3.6",
     "chronokinesis": "^3.0.0",
     "eslint": "^7.23.0",
     "markdown-toc": "^1.2.0",
-    "mocha": "^9.1.2",
+    "mocha": "^9.2.2",
     "mocha-cakes-2": "^3.3.0",
-    "nock": "^13.0.7",
+    "nock": "^13.2.4",
     "nyc": "^15.1.0"
   },
   "dependencies": {
-    "bpmn-elements": "^6.0.1",
+    "bpmn-elements": "^8.0.0",
     "bpmn-moddle": "^7.0.4",
-    "debug": "^4.3.1",
-    "moddle-context-serializer": "^1.1.1",
-    "smqp": "^5.1.0"
+    "debug": "^4.3.4",
+    "moddle-context-serializer": "^2.0.0",
+    "smqp": "^6.0.0"
   }
 }