bpmn-elements 6.0.1 → 8.0.1

package/dist/src/tasks/ServiceTask.js

@@ -3,8 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = ServiceTask;
 exports.ServiceTaskBehaviour = ServiceTaskBehaviour;
+exports.default = ServiceTask;
 
 var _Activity = _interopRequireDefault(require("../activity/Activity"));
 
@@ -15,101 +15,108 @@ var _messageHelper = require("../messageHelper");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function ServiceTask(activityDef, context) {
-  return (0, _Activity.default)(ServiceTaskBehaviour, activityDef, context);
+  return new _Activity.default(ServiceTaskBehaviour, activityDef, context);
 }
 
 function ServiceTaskBehaviour(activity) {
   const {
     id,
     type,
-    broker,
-    logger,
-    behaviour,
-    environment,
-    emitFatal
+    behaviour
   } = activity;
-  const loopCharacteristics = behaviour.loopCharacteristics && behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
-  const source = {
-    id,
-    type,
-    loopCharacteristics,
-    execute,
-    getService
-  };
-  return source;
+  this.id = id;
+  this.type = type;
+  this.loopCharacteristics = behaviour.loopCharacteristics && new behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
+  this.activity = activity;
+  this.environment = activity.environment;
+  this.broker = activity.broker;
+}
 
-  function execute(executeMessage) {
-    const content = executeMessage.content;
+const proto = ServiceTaskBehaviour.prototype;
 
-    if (loopCharacteristics && content.isRootScope) {
-      return loopCharacteristics.execute(executeMessage);
-    }
+proto.execute = function execute(executeMessage) {
+  const executeContent = executeMessage.content;
+  const loopCharacteristics = this.loopCharacteristics;
 
-    const {
-      executionId
-    } = content;
-    const service = getService(executeMessage);
-    if (!service) return emitFatal(new _Errors.ActivityError(`<${id}> service not defined`, executeMessage), content);
-    broker.subscribeTmp('api', `activity.#.${content.executionId}`, onApiMessage, {
-      consumerTag: `_api-${executionId}`
-    });
-    return service.execute(executeMessage, (err, output) => {
-      broker.cancel(`_api-${executionId}`);
-
-      if (err) {
-        logger.error(`<${content.executionId} (${id})>`, err);
-        return broker.publish('execution', 'execute.error', (0, _messageHelper.cloneContent)(content, {
-          error: new _Errors.ActivityError(err.message, executeMessage, err)
-        }, {
-          mandatory: true
-        }));
-      }
+  if (loopCharacteristics && executeContent.isRootScope) {
+    return loopCharacteristics.execute(executeMessage);
+  }
 
-      return broker.publish('execution', 'execute.completed', (0, _messageHelper.cloneContent)(content, {
-        output,
-        state: 'complete'
+  const executionId = executeContent.executionId;
+  const service = this.service = this.getService(executeMessage);
+  if (!service) return this.activity.emitFatal(new _Errors.ActivityError(`<${this.id}> service not defined`, executeMessage), executeContent);
+  const broker = this.broker;
+  broker.subscribeTmp('api', `activity.#.${executionId}`, (...args) => this._onApiMessage(executeMessage, ...args), {
+    consumerTag: `_api-${executionId}`
+  });
+  return service.execute(executeMessage, (err, output) => {
+    broker.cancel(`_api-${executionId}`);
+
+    if (err) {
+      this.activity.logger.error(`<${executionId} (${this.id})>`, err);
+      return broker.publish('execution', 'execute.error', (0, _messageHelper.cloneContent)(executeContent, {
+        error: new _Errors.ActivityError(err.message, executeMessage, err)
+      }, {
+        mandatory: true
       }));
-    });
+    }
+
+    return broker.publish('execution', 'execute.completed', (0, _messageHelper.cloneContent)(executeContent, {
+      output,
+      state: 'complete'
+    }));
+  });
+};
+
+proto.getService = function getService(message) {
+  let Service = this.activity.behaviour.Service;
+
+  if (!Service) {
+    Service = this.environment.settings.enableDummyService ? DummyService : null;
+  }
+
+  return Service && new Service(this.activity, (0, _messageHelper.cloneMessage)(message));
+};
 
-    function onApiMessage(_, message) {
-      if (message.properties.type === 'discard') {
+proto._onApiMessage = function onApiMessage(executeMessage, _, message) {
+  const broker = this.broker;
+
+  switch (message.properties.type) {
+    case 'discard':
+      {
+        const executionId = executeMessage.content.executionId;
         broker.cancel(`_api-${executionId}`);
-        if (service && service.discard) service.discard(message);
-        logger.debug(`<${content.executionId} (${id})> discarded`);
-        return broker.publish('execution', 'execute.discard', (0, _messageHelper.cloneContent)(content, {
+        const service = this.service;
+
+        if (service) {
+          if (service.discard) service.discard(message);else if (service.stop) service.stop(message);
+        }
+
+        this.activity.logger.debug(`<${executionId} (${this.id})> discarded`);
+        return broker.publish('execution', 'execute.discard', (0, _messageHelper.cloneContent)(executeMessage.content, {
           state: 'discard'
         }));
       }
 
-      if (message.properties.type === 'stop') {
+    case 'stop':
+      {
+        const executionId = executeMessage.content.executionId;
         broker.cancel(`_api-${executionId}`);
+        const service = this.service;
         if (service && service.stop) service.stop(message);
-        return logger.debug(`<${content.executionId} (${id})> stopped`);
+        return this.activity.logger.debug(`<${executionId} (${this.id})> stopped`);
       }
-    }
   }
+};
 
-  function getService(message) {
-    const Service = behaviour.Service;
-
-    if (!Service) {
-      return environment.settings.enableDummyService ? DummyService(activity) : null;
-    }
-
-    return Service(activity, (0, _messageHelper.cloneMessage)(message));
-  }
+function DummyService(activity) {
+  this.type = 'dummyservice';
+  this.activity = activity;
+}
 
-  function DummyService() {
-    logger.debug(`<${id}> returning dummy service`);
-    return {
-      type: 'dummyservice',
-      execute: executeDummyService
-    };
-
-    function executeDummyService(...args) {
-      logger.debug(`<${id}> executing dummy service`);
-      const next = args.pop();
-      next();
-    }
-  }
-}
+DummyService.prototype.execute = function executeDummyService(...args) {
+  const activity = this.activity;
+  activity.logger.debug(`<${activity.id}> executing dummy service`);
+  const next = args.pop();
+  next();
+};

package/dist/src/tasks/SignalTask.js

@@ -3,8 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = SignalTask;
 exports.SignalTaskBehaviour = SignalTaskBehaviour;
+exports.default = SignalTask;
 
 var _Activity = _interopRequireDefault(require("../activity/Activity"));
 
@@ -15,112 +15,116 @@ var _messageHelper = require("../messageHelper");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function SignalTask(activityDef, context) {
-  return (0, _Activity.default)(SignalTaskBehaviour, activityDef, context);
+  return new _Activity.default(SignalTaskBehaviour, activityDef, context);
 }
 
 function SignalTaskBehaviour(activity) {
   const {
     id,
     type,
-    behaviour,
-    broker
+    behaviour
   } = activity;
-  const loopCharacteristics = behaviour.loopCharacteristics && behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
-  const source = {
-    id,
-    type,
-    loopCharacteristics,
-    execute
-  };
-  return source;
+  this.id = id;
+  this.type = type;
+  this.loopCharacteristics = behaviour.loopCharacteristics && new behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
+  this.activity = activity;
+  this.broker = activity.broker;
+}
+
+const proto = SignalTaskBehaviour.prototype;
 
-  function execute(executeMessage) {
-    const content = executeMessage.content;
+proto.execute = function execute(executeMessage) {
+  const executeContent = executeMessage.content;
+  const loopCharacteristics = this.loopCharacteristics;
 
-    if (loopCharacteristics && content.isRootScope) {
-      return loopCharacteristics.execute(executeMessage);
+  if (loopCharacteristics && executeContent.isRootScope) {
+    return loopCharacteristics.execute(executeMessage);
+  }
+
+  const executionId = executeContent.executionId;
+  const broker = this.broker;
+  broker.subscribeTmp('api', `activity.#.${executionId}`, (...args) => this._onApiMessage(executeMessage, ...args), {
+    noAck: true,
+    consumerTag: `_api-${executionId}`
+  });
+  broker.subscribeTmp('api', '#.signal.*', (...args) => this._onDelegatedApiMessage(executeMessage, ...args), {
+    noAck: true,
+    consumerTag: `_api-delegated-${executionId}`
+  });
+  broker.publish('event', 'activity.wait', (0, _messageHelper.cloneContent)(executeContent, {
+    state: 'wait'
+  }));
+};
+
+proto._onDelegatedApiMessage = function onDelegatedApiMessage(executeMessage, routingKey, message) {
+  if (!message.properties.delegate) return;
+  const {
+    content: delegateContent
+  } = message;
+  if (!delegateContent || !delegateContent.message) return;
+  const executeContent = executeMessage.content;
+  const {
+    id: signalId,
+    executionId: signalExecutionId
+  } = delegateContent.message;
+  if (this.loopCharacteristics && signalExecutionId !== executeContent.executionId) return;
+  if (signalId !== this.id && signalExecutionId !== executeContent.executionId) return;
+  const {
+    type: messageType,
+    correlationId
+  } = message.properties;
+  this.broker.publish('event', 'activity.consumed', (0, _messageHelper.cloneContent)(executeContent, {
+    message: { ...delegateContent.message
     }
+  }), {
+    correlationId,
+    type: messageType
+  });
+  return this._onApiMessage(executeMessage, routingKey, message);
+};
+
+proto._onApiMessage = function onApiMessage(executeMessage, routingKey, message) {
+  const {
+    type: messageType,
+    correlationId
+  } = message.properties;
+  const executeContent = executeMessage.content;
 
-    const {
-      executionId
-    } = content;
-    broker.subscribeTmp('api', `activity.#.${executionId}`, onApiMessage, {
-      noAck: true,
-      consumerTag: `_api-${executionId}`
-    });
-    broker.subscribeTmp('api', '#.signal.*', onDelegatedApiMessage, {
-      noAck: true,
-      consumerTag: `_api-delegated-${executionId}`
-    });
-    broker.publish('event', 'activity.wait', (0, _messageHelper.cloneContent)(content, {
-      state: 'wait'
-    }));
-
-    function onDelegatedApiMessage(routingKey, message) {
-      if (!message.properties.delegate) return;
-      const {
-        content: delegateContent
-      } = message;
-      if (!delegateContent || !delegateContent.message) return;
-      const {
-        id: signalId,
-        executionId: signalExecutionId
-      } = delegateContent.message;
-      if (loopCharacteristics && signalExecutionId !== executionId) return;
-      if (signalId !== id && signalExecutionId !== executionId) return;
-      const {
-        type: messageType,
-        correlationId
-      } = message.properties;
-      broker.publish('event', 'activity.consumed', (0, _messageHelper.cloneContent)(content, {
-        message: { ...delegateContent.message
-        }
+  switch (messageType) {
+    case 'stop':
+      return this._stop(executeContent.executionId);
+
+    case 'signal':
+      this._stop(executeContent.executionId);
+
+      return this.broker.publish('execution', 'execute.completed', (0, _messageHelper.cloneContent)(executeContent, {
+        output: message.content.message,
+        state: 'signal'
       }), {
-        correlationId,
-        type: messageType
+        correlationId
       });
-      return onApiMessage(routingKey, message);
-    }
 
-    function onApiMessage(routingKey, message) {
-      const {
-        type: messageType,
+    case 'error':
+      this._stop(executeContent.executionId);
+
+      return this.broker.publish('execution', 'execute.error', (0, _messageHelper.cloneContent)(executeContent, {
+        error: new _Errors.ActivityError(message.content.message, executeMessage, message.content)
+      }, {
+        mandatory: true,
         correlationId
-      } = message.properties;
-
-      switch (messageType) {
-        case 'stop':
-          return stop();
-
-        case 'signal':
-          stop();
-          return broker.publish('execution', 'execute.completed', (0, _messageHelper.cloneContent)(content, {
-            output: message.content.message,
-            state: 'signal'
-          }), {
-            correlationId
-          });
-
-        case 'error':
-          stop();
-          return broker.publish('execution', 'execute.error', (0, _messageHelper.cloneContent)(content, {
-            error: new _Errors.ActivityError(message.content.message, executeMessage, message.content)
-          }, {
-            mandatory: true,
-            correlationId
-          }));
-
-        case 'discard':
-          stop();
-          return broker.publish('execution', 'execute.discard', (0, _messageHelper.cloneContent)(content), {
-            correlationId
-          });
-      }
-    }
+      }));
 
-    function stop() {
-      broker.cancel(`_api-${executionId}`);
-      broker.cancel(`_api-delegated-${executionId}`);
-    }
+    case 'discard':
+      this._stop(executeContent.executionId);
+
+      return this.broker.publish('execution', 'execute.discard', (0, _messageHelper.cloneContent)(executeContent), {
+        correlationId
+      });
   }
-}
+};
+
+proto._stop = function stop(executionId) {
+  const broker = this.broker;
+  broker.cancel(`_api-${executionId}`);
+  broker.cancel(`_api-delegated-${executionId}`);
+};

package/dist/src/tasks/StandardLoopCharacteristics.js

@@ -16,7 +16,7 @@ function StandardLoopCharacteristics(activity, loopCharacteristics) {
   behaviour = { ...behaviour,
     isSequential: true
   };
-  return (0, _LoopCharacteristics.default)(activity, { ...loopCharacteristics,
+  return new _LoopCharacteristics.default(activity, { ...loopCharacteristics,
     behaviour
   });
 }