bpmn-elements 5.1.3 → 7.0.0

package/src/flows/Association.js

@@ -3,127 +3,112 @@ import {EventBroker} from '../EventBroker';
 import {FlowApi} from '../Api';
 import {getUniqueId} from '../shared';
 
-export default function Association(associationDef, {environment}) {
-  const {id, type = 'association', name, parent: originalParent, targetId, sourceId, behaviour = {}} = associationDef;
-  const parent = cloneParent(originalParent);
-  const logger = environment.Logger(type.toLowerCase());
+const countersSymbol = Symbol.for('counters');
 
-  const counters = {
+export default function Association(associationDef, {environment}) {
+  const {id, type = 'association', name, parent, targetId, sourceId, behaviour = {}} = associationDef;
+
+  this.id = id;
+  this.type = type;
+  this.name = name;
+  this.parent = cloneParent(parent);
+  this.behaviour = behaviour;
+  this.sourceId = sourceId;
+  this.targetId = targetId;
+  this.isAssociation = true;
+  this.environment = environment;
+  const logger = this.logger = environment.Logger(type.toLowerCase());
+
+  this[countersSymbol] = {
     complete: 0,
     take: 0,
     discard: 0,
   };
 
-  const associationApi = {
-    id,
-    type,
-    name,
-    parent,
-    behaviour,
-    sourceId,
-    targetId,
-    isAssociation: true,
-    environment,
-    get counters() {
-      return {...counters};
-    },
-    complete,
-    discard,
-    getApi,
-    getState,
-    recover,
-    stop,
-    take,
-  };
+  const {broker, on, once, waitFor} = new EventBroker(this, {prefix: 'association', durable: true, autoDelete: false});
+  this.broker = broker;
+  this.on = on;
+  this.once = once;
+  this.waitFor = waitFor;
 
-  const {broker, on, once, waitFor} = EventBroker(associationApi, {prefix: 'association', durable: true, autoDelete: false});
+  logger.debug(`<${id}> init, <${sourceId}> -> <${targetId}>`);
+}
 
-  associationApi.on = on;
-  associationApi.once = once;
-  associationApi.waitFor = waitFor;
+const proto = Association.prototype;
 
-  Object.defineProperty(associationApi, 'broker', {
-    enumerable: true,
-    get: () => broker,
-  });
+Object.defineProperty(proto, 'counters', {
+  enumerable: true,
+  get() {
+    return {...this[countersSymbol]};
+  },
+});
 
-  logger.debug(`<${id}> init, <${sourceId}> -> <${targetId}>`);
+proto.take = function take(content = {}) {
+  this.logger.debug(`<${this.id}> take target <${this.targetId}>`);
+  ++this[countersSymbol].take;
 
-  return associationApi;
-
-  function take(content = {}) {
-    logger.debug(`<${id}> take target <${targetId}>`);
-    ++counters.discard;
-
-    publishEvent('take', content);
-
-    return true;
-  }
-
-  function discard(content = {}) {
-    logger.debug(`<${id}> discard target <${targetId}>`);
-    ++counters.take;
-
-    publishEvent('discard', content);
-
-    return true;
-  }
-
-  function complete(content = {}) {
-    logger.debug(`<${id}> completed target <${targetId}>`);
-    ++counters.complete;
-
-    publishEvent('complete', content);
-
-    return true;
-  }
-
-  function publishEvent(action, content) {
-    const eventContent = createMessageContent({
-      action,
-      message: content,
-      sequenceId: getUniqueId(id),
-    });
-
-    broker.publish('event', `association.${action}`, eventContent, {type: action});
-  }
-
-  function createMessageContent(override = {}) {
-    return {
-      ...override,
-      id,
-      type,
-      name,
-      sourceId,
-      targetId,
-      isAssociation: true,
-      parent: cloneParent(parent),
-    };
-  }
-
-  function getState() {
-    const result = {
-      id,
-      type,
-      name,
-      sourceId,
-      targetId,
-      counters: {...counters},
-    };
-    result.broker = broker.getState();
-    return result;
-  }
-
-  function recover(state) {
-    Object.assign(counters, state.counters);
-    broker.recover(state.broker);
-  }
-
-  function getApi(message) {
-    return FlowApi(broker, message || {content: createMessageContent()});
-  }
-
-  function stop() {
-    broker.stop();
-  }
-}
+  this._publishEvent('take', content);
+
+  return true;
+};
+
+proto.discard = function discard(content = {}) {
+  this.logger.debug(`<${this.id}> discard target <${this.targetId}>`);
+  ++this[countersSymbol].discard;
+
+  this._publishEvent('discard', content);
+
+  return true;
+};
+
+proto.complete = function complete(content = {}) {
+  this.logger.debug(`<${this.id}> completed target <${this.targetId}>`);
+  ++this[countersSymbol].complete;
+
+  this._publishEvent('complete', content);
+
+  return true;
+};
+
+proto.getState = function getState() {
+  return this._createMessageContent({
+    counters: this.counters,
+    broker: this.broker.getState(true),
+  });
+};
+
+proto.recover = function recover(state) {
+  Object.assign(this[countersSymbol], state.counters);
+  this.broker.recover(state.broker);
+};
+
+proto.getApi = function getApi(message) {
+  return FlowApi(this.broker, message || {content: this._createMessageContent()});
+};
+
+proto.stop = function stop() {
+  this.broker.stop();
+};
+
+proto._publishEvent = function publishEvent(action, content) {
+  const eventContent = this._createMessageContent({
+    action,
+    message: content,
+    sequenceId: getUniqueId(this.id),
+  });
+
+  this.broker.publish('event', `association.${action}`, eventContent, {type: action});
+};
+
+proto._createMessageContent = function createMessageContent(override) {
+  return {
+    ...override,
+    id: this.id,
+    type: this.type,
+    name: this.name,
+    sourceId: this.sourceId,
+    targetId: this.targetId,
+    isAssociation: true,
+    parent: cloneParent(this.parent),
+  };
+};

package/src/flows/MessageFlow.js

@@ -2,108 +2,92 @@ import {brokerSafeId} from '../shared';
 import {cloneParent} from '../messageHelper';
 import {MessageFlowBroker} from '../EventBroker';
 
-export default function MessageFlow(flowDef, context) {
-  const {id, type = 'message', name, target, source, behaviour, parent} = flowDef;
-  const sourceElement = context.getActivityById(source.id) || context.getProcessById(source.processId);
-  const sourceEndConsumerTag = `_message-on-end-${brokerSafeId(id)}`;
-  const sourceMessageConsumerTag = `_message-on-message-${brokerSafeId(id)}`;
-  const {debug} = context.environment.Logger(type.toLowerCase());
-
-  if (!sourceElement) return;
+const countersSymbol = Symbol.for('counters');
+const sourceElementSymbol = Symbol.for('sourceElement');
 
-  const counters = {
+export default function MessageFlow(flowDef, context) {
+  const {id, type = 'messageflow', name, target, source, behaviour, parent} = flowDef;
+
+  this.id = id;
+  this.type = type;
+  this.name = name;
+  this.parent = cloneParent(parent);
+  this.source = source;
+  this.target = target;
+  this.behaviour = behaviour;
+  this.environment = context.environment;
+  this.context = context;
+
+  this[countersSymbol] = {
     messages: 0,
-    discard: 0,
-  };
-
-  const flowApi = {
-    id,
-    type,
-    name,
-    target,
-    source,
-    behaviour,
-    get counters() {
-      return {...counters};
-    },
-    activate,
-    deactivate,
-    getApi,
-    getState,
-    recover,
-    resume,
-    stop,
   };
 
-  const {broker, on, once, emit, waitFor} = MessageFlowBroker(flowApi);
-
-  flowApi.on = on;
-  flowApi.once = once;
-  flowApi.emit = emit;
-  flowApi.waitFor = waitFor;
-
-  Object.defineProperty(flowApi, 'broker', {
-    enumerable: true,
-    get: () => broker,
-  });
-
-  return flowApi;
-
-  function onSourceEnd({content}) {
-    ++counters.messages;
-    debug(`<${id}> sending message from <${source.processId}.${source.id}> to`, target.id ? `<${target.processId}.${target.id}>` : `<${target.processId}>`);
-    broker.publish('event', 'message.outbound', createMessage(content.message));
-  }
+  const {broker, on, once, emit, waitFor} = MessageFlowBroker(this);
+  this.broker = broker;
+  this.on = on;
+  this.once = once;
+  this.emit = emit;
+  this.waitFor = waitFor;
 
-  function onSourceMessage() {
-    deactivate();
-  }
-
-  function createMessage(message) {
-    return {
-      id,
-      type,
-      name,
-      source: {...source},
-      target: {...target},
-      parent: parent && cloneParent(parent),
-      message,
-    };
-  }
-
-  function stop() {
-    deactivate();
-    broker.stop();
-  }
-
-  function getState() {
-    return {
-      id,
-      type,
-      counters: {...counters},
-    };
-  }
-
-  function recover(state) {
-    Object.assign(counters, state.counters);
-    broker.recover(state.broker);
-  }
-
-  function resume() {
-    broker.resume();
-  }
+  this[sourceElementSymbol] = context.getActivityById(source.id) || context.getProcessById(source.processId);
+  this.logger = context.environment.Logger(type.toLowerCase());
+}
 
-  function getApi() {
-    return flowApi;
-  }
+const proto = MessageFlow.prototype;
 
-  function activate() {
-    sourceElement.on('message', onSourceMessage, {consumerTag: sourceMessageConsumerTag});
-    sourceElement.on('end', onSourceEnd, {consumerTag: sourceEndConsumerTag});
-  }
+Object.defineProperty(proto, 'counters', {
+  enumerable: true,
+  get() {
+    return {...this[countersSymbol]};
+  },
+});
 
-  function deactivate() {
-    sourceElement.broker.cancel(sourceMessageConsumerTag);
-    sourceElement.broker.cancel(sourceEndConsumerTag);
-  }
-}
+proto.getState = function getState() {
+  return {
+    id: this.id,
+    type: this.type,
+    counters: this.counters,
+  };
+};
+
+proto.recover = function recover(state) {
+  Object.assign(this[countersSymbol], state.counters);
+};
+
+proto.getApi = function getApi() {
+  return this;
+};
+
+proto.activate = function activate() {
+  const sourceElement = this[sourceElementSymbol];
+  const safeId = brokerSafeId(this.id);
+  sourceElement.on('message', this.deactivate.bind(this), {consumerTag: `_message-on-message-${safeId}`});
+  sourceElement.on('end', this._onSourceEnd.bind(this), {consumerTag: `_message-on-end-${safeId}`});
+};
+
+proto.deactivate = function deactivate() {
+  const sourceElement = this[sourceElementSymbol];
+  const safeId = brokerSafeId(this.id);
+  sourceElement.broker.cancel(`_message-on-end-${safeId}`);
+  sourceElement.broker.cancel(`_message-on-message-${safeId}`);
+};
+
+proto._onSourceEnd = function onSourceEnd({content}) {
+  ++this[countersSymbol].messages;
+  const source = this.source;
+  const target = this.target;
+  this.logger.debug(`<${this.id}> sending message from <${source.processId}.${source.id}> to <${target.id ? `${target.processId}.${target.id}` : target.processId}>`);
+  this.broker.publish('event', 'message.outbound', this._createMessage(content.message));
+};
+
+proto._createMessage = function createMessage(message) {
+  return {
+    id: this.id,
+    type: this.type,
+    name: this.name,
+    source: {...this.source},
+    target: {...this.target},
+    parent: cloneParent(this.parent),
+    message,
+  };
+};