bpmn-elements 6.0.0 → 8.0.0

package/src/Api.js

@@ -10,80 +10,86 @@ export {
 };
 
 function ActivityApi(broker, apiMessage, environment) {
-  return Api('activity', broker, apiMessage, environment);
+  return new Api('activity', broker, apiMessage, environment);
 }
 
 function DefinitionApi(broker, apiMessage, environment) {
-  return Api('definition', broker, apiMessage, environment);
+  return new Api('definition', broker, apiMessage, environment);
 }
 
 function ProcessApi(broker, apiMessage, environment) {
-  return Api('process', broker, apiMessage, environment);
+  return new Api('process', broker, apiMessage, environment);
 }
 
 function FlowApi(broker, apiMessage, environment) {
-  return Api('flow', broker, apiMessage, environment);
+  return new Api('flow', broker, apiMessage, environment);
 }
 
 function Api(pfx, broker, sourceMessage, environment) {
   if (!sourceMessage) throw new Error('Api requires message');
 
   const apiMessage = cloneMessage(sourceMessage);
-  const apiContent = apiMessage.content;
-  const {id, type, name} = apiContent;
-  const executionId = apiContent.executionId;
-  const owner = broker.owner;
-  environment = environment || broker.owner.environment;
 
+  const {id, type, name, executionId} = apiMessage.content;
+  this.id = id;
+  this.type = type;
+  this.name = name;
+  this.executionId = executionId;
+  this.environment = environment || broker.owner.environment;
+  this.content = apiMessage.content;
+  this.fields = apiMessage.fields;
+  this.messageProperties = apiMessage.properties;
+  this.broker = broker;
+  this.owner = broker.owner;
+  this.messagePrefix = pfx;
+}
+
+const proto = Api.prototype;
+
+proto.cancel = function cancel(message, options) {
+  this.sendApiMessage('cancel', {message}, options);
+};
+
+proto.discard = function discard() {
+  this.sendApiMessage('discard');
+};
+
+proto.fail = function fail(error) {
+  this.sendApiMessage('error', {error});
+};
+
+proto.signal = function signal(message, options) {
+  this.sendApiMessage('signal', {message}, options);
+};
+
+proto.stop = function stop() {
+  this.sendApiMessage('stop');
+};
+
+proto.resolveExpression = function resolveExpression(expression) {
+  return this.environment.resolveExpression(expression, {
+    fields: this.fields,
+    content: this.content,
+    properties: this.messageProperties,
+  }, this.owner);
+};
+
+proto.sendApiMessage = function sendApiMessage(action, content, options) {
+  const correlationId = (options && options.correlationId) || getUniqueId(`${this.id || this.messagePrefix}_signal`);
+  let key = `${this.messagePrefix}.${action}`;
+  if (this.executionId) key += `.${this.executionId}`;
+  this.broker.publish('api', key, this.createMessage(content), {...options, correlationId, type: action});
+};
+
+proto.getPostponed = function getPostponed(...args) {
+  if (this.owner.getPostponed) return this.owner.getPostponed(...args);
+  if (this.owner.isSubProcess && this.owner.execution) return this.owner.execution.getPostponed(...args);
+  return [];
+};
+
+proto.createMessage = function createMessage(content) {
   return {
-    id,
-    type,
-    name,
-    executionId,
-    environment,
-    fields: apiMessage.fields,
-    content: apiContent,
-    messageProperties: apiMessage.properties,
-    get owner() {
-      return owner;
-    },
-    cancel(message, options) {
-      sendApiMessage('cancel', {message}, options);
-    },
-    discard() {
-      sendApiMessage('discard');
-    },
-    signal(message, options) {
-      sendApiMessage('signal', {message}, options);
-    },
-    stop() {
-      sendApiMessage('stop');
-    },
-    resolveExpression(expression) {
-      return environment.resolveExpression(expression, apiMessage, broker.owner);
-    },
-    sendApiMessage,
-    createMessage,
-    getPostponed,
+    ...this.content,
+    ...content,
   };
-
-  function sendApiMessage(action, content, options = {}) {
-    if (!options.correlationId) options = {...options, correlationId: getUniqueId(`${id || pfx}_signal`)};
-    let key = `${pfx}.${action}`;
-    if (executionId) key += `.${executionId}`;
-    broker.publish('api', key, createMessage(content), {...options, type: action});
-  }
-
-  function getPostponed(...args) {
-    if (owner.getPostponed) return owner.getPostponed(...args);
-    if (owner.isSubProcess && owner.execution) return owner.execution.getPostponed(...args);
-    return [];
-  }
-
-  function createMessage(content = {}) {
-    return {
-      ...apiContent,
-      ...content,
-    };
-  }
-}
+};

package/src/Context.js

@@ -3,194 +3,199 @@ import ExtensionsMapper from './ExtensionsMapper';
 import {getUniqueId} from './shared';
 
 export default function Context(definitionContext, environment) {
-  environment = environment ? environment.clone() : Environment();
-  return ContextInstance(definitionContext, environment);
+  environment = environment ? environment.clone() : new Environment();
+  return new ContextInstance(definitionContext, environment);
 }
 
 function ContextInstance(definitionContext, environment) {
   const {id = 'Def', name, type = 'context'} = definitionContext;
   const sid = getUniqueId(id);
-
-  const activityRefs = {}, dataObjectRefs = {}, dataStoreRefs = {}, messageFlows = [], processes = [], processRefs = {}, sequenceFlowRefs = {}, sequenceFlows = [], associationRefs = [];
-
-  const context = {
-    id,
-    name,
-    type,
-    sid,
-    definitionContext,
-    environment,
-    clone,
-    getActivities,
-    getActivityById,
-    getAssociations,
-    getExecutableProcesses,
-    getDataObjectById,
-    getDataStoreById,
-    getInboundAssociations,
-    getInboundSequenceFlows,
-    getMessageFlows,
-    getOutboundSequenceFlows,
-    getOutboundAssociations,
-    getProcessById,
-    getProcesses,
-    getSequenceFlowById,
-    getSequenceFlows,
-    getStartActivities,
-    loadExtensions,
+  this.id = id;
+  this.name = name;
+  this.type = type;
+  this.sid = sid;
+  this.definitionContext = definitionContext;
+  this.environment = environment;
+  this.extensionsMapper = ExtensionsMapper(this);
+  this.refs = {
+    activityRefs: {},
+    associationRefs: [],
+    dataObjectRefs: {},
+    dataStoreRefs: {},
+    messageFlows: [],
+    processes: [],
+    processRefs: {},
+    sequenceFlowRefs: {},
+    sequenceFlows: [],
   };
+}
 
-  const extensionsMapper = ExtensionsMapper(context);
+const proto = ContextInstance.prototype;
 
-  return context;
+proto.getActivityById = function getActivityById(activityId) {
+  const activityInstance = this.refs.activityRefs[activityId];
+  if (activityInstance) return activityInstance;
+  const activity = this.definitionContext.getActivityById(activityId);
+  if (!activity) return null;
+  return this.upsertActivity(activity);
+};
 
-  function getActivityById(activityId) {
-    const activityInstance = activityRefs[activityId];
-    if (activityInstance) return activityInstance;
-    const activity = definitionContext.getActivityById(activityId);
-    if (!activity) return null;
-    return upsertActivity(activity);
-  }
+proto.upsertActivity = function upsertActivity(activityDef) {
+  let activityInstance = this.refs.activityRefs[activityDef.id];
+  if (activityInstance) return activityInstance;
 
-  function upsertActivity(activityDef) {
-    let activityInstance = activityRefs[activityDef.id];
-    if (activityInstance) return activityInstance;
+  activityInstance = this.refs.activityRefs[activityDef.id] = new activityDef.Behaviour(activityDef, this);
 
-    activityInstance = activityRefs[activityDef.id] = activityDef.Behaviour(activityDef, context);
+  return activityInstance;
+};
 
-    return activityInstance;
-  }
+proto.getSequenceFlowById = function getSequenceFlowById(sequenceFlowId) {
+  const flowInstance = this.refs.sequenceFlowRefs[sequenceFlowId];
+  if (flowInstance) return flowInstance;
 
-  function getSequenceFlowById(sequenceFlowId) {
-    const flowInstance = sequenceFlowRefs[sequenceFlowId];
-    if (flowInstance) return flowInstance;
+  const flowDef = this.definitionContext.getSequenceFlowById(sequenceFlowId);
+  if (!flowDef) return null;
+  return this.upsertSequenceFlow(flowDef);
+};
 
-    const flowDef = definitionContext.getSequenceFlowById(sequenceFlowId);
-    if (!flowDef) return null;
-    return upsertSequenceFlow(flowDef);
-  }
+proto.getInboundSequenceFlows = function getInboundSequenceFlows(activityId) {
+  return (this.definitionContext.getInboundSequenceFlows(activityId) || []).map((flow) => this.upsertSequenceFlow(flow));
+};
 
-  function getInboundSequenceFlows(activityId) {
-    return (definitionContext.getInboundSequenceFlows(activityId) || []).map((flow) => upsertSequenceFlow(flow));
-  }
+proto.getOutboundSequenceFlows = function getOutboundSequenceFlows(activityId) {
+  return (this.definitionContext.getOutboundSequenceFlows(activityId) || []).map((flow) => this.upsertSequenceFlow(flow));
+};
 
-  function getOutboundSequenceFlows(activityId) {
-    return (definitionContext.getOutboundSequenceFlows(activityId) || []).map((flow) => upsertSequenceFlow(flow));
-  }
+proto.getInboundAssociations = function getInboundAssociations(activityId) {
+  return (this.definitionContext.getInboundAssociations(activityId) || []).map((association) => this.upsertAssociation(association));
+};
 
-  function getInboundAssociations(activityId) {
-    return (definitionContext.getInboundAssociations(activityId) || []).map((association) => upsertAssociation(association));
-  }
+proto.getOutboundAssociations = function getOutboundAssociations(activityId) {
+  return (this.definitionContext.getOutboundAssociations(activityId) || []).map((association) => this.upsertAssociation(association));
+};
 
-  function getOutboundAssociations(activityId) {
-    return (definitionContext.getOutboundAssociations(activityId) || []).map((association) => upsertAssociation(association));
-  }
+proto.getActivities = function getActivities(scopeId) {
+  return (this.definitionContext.getActivities(scopeId) || []).map((activityDef) => this.upsertActivity(activityDef));
+};
 
-  function getActivities(scopeId) {
-    return (definitionContext.getActivities(scopeId) || []).map((activityDef) => upsertActivity(activityDef));
-  }
+proto.getSequenceFlows = function getSequenceFlows(scopeId) {
+  return (this.definitionContext.getSequenceFlows(scopeId) || []).map((flow) => this.upsertSequenceFlow(flow));
+};
 
-  function getSequenceFlows(scopeId) {
-    return (definitionContext.getSequenceFlows(scopeId) || []).map((flow) => upsertSequenceFlow(flow));
-  }
+proto.upsertSequenceFlow = function upsertSequenceFlow(flowDefinition) {
+  const refs = this.refs.sequenceFlowRefs;
+  let flowInstance = refs[flowDefinition.id];
+  if (flowInstance) return flowInstance;
 
-  function upsertSequenceFlow(flowDefinition) {
-    let flowInstance = sequenceFlowRefs[flowDefinition.id];
-    if (flowInstance) return flowInstance;
+  flowInstance = refs[flowDefinition.id] = new flowDefinition.Behaviour(flowDefinition, this);
+  this.refs.sequenceFlows.push(flowInstance);
 
-    flowInstance = sequenceFlowRefs[flowDefinition.id] = flowDefinition.Behaviour(flowDefinition, context);
-    sequenceFlows.push(flowInstance);
+  return flowInstance;
+};
 
-    return flowInstance;
-  }
+proto.getAssociations = function getAssociations(scopeId) {
+  return (this.definitionContext.getAssociations(scopeId) || []).map((association) => this.upsertAssociation(association));
+};
 
-  function getAssociations(scopeId) {
-    return (definitionContext.getAssociations(scopeId) || []).map((association) => upsertAssociation(association));
-  }
+proto.upsertAssociation = function upsertAssociation(associationDefinition) {
+  const refs = this.refs.associationRefs;
+  let instance = refs[associationDefinition.id];
+  if (instance) return instance;
 
-  function upsertAssociation(associationDefinition) {
-    let instance = associationRefs[associationDefinition.id];
-    if (instance) return instance;
+  instance = refs[associationDefinition.id] = new associationDefinition.Behaviour(associationDefinition, this);
 
-    instance = associationRefs[associationDefinition.id] = associationDefinition.Behaviour(associationDefinition, context);
+  return instance;
+};
 
-    return instance;
-  }
+proto.clone = function clone(newEnvironment) {
+  return new ContextInstance(this.definitionContext, newEnvironment || this.environment);
+};
 
-  function clone(newEnvironment) {
-    return ContextInstance(definitionContext, newEnvironment || environment);
-  }
+proto.getProcessById = function getProcessById(processId) {
+  const refs = this.refs.processRefs;
+  let bp = this.refs.processRefs[processId];
+  if (bp) return bp;
 
-  function getProcessById(processId) {
-    let processInstance = processRefs[processId];
-    if (processInstance) return processInstance;
+  const processDefinition = this.definitionContext.getProcessById(processId);
+  if (!processDefinition) return null;
 
-    const processDefinition = definitionContext.getProcessById(processId);
-    if (!processDefinition) return null;
-    processInstance = processRefs[processId] = processDefinition.Behaviour(processDefinition, context);
-    processes.push(processInstance);
+  const bpContext = this.clone(this.environment.clone());
+  bp = refs[processId] = new processDefinition.Behaviour(processDefinition, bpContext);
+  this.refs.processes.push(bp);
 
-    return processInstance;
-  }
+  return bp;
+};
 
-  function getProcesses() {
-    return definitionContext.getProcesses().map(({id: processId}) => getProcessById(processId));
-  }
+proto.getNewProcessById = function getNewProcessById(processId) {
+  if (!this.getProcessById(processId)) return null;
+  const bpDef = this.definitionContext.getProcessById(processId);
+  const bp = new bpDef.Behaviour(bpDef, this.clone(this.environment.clone()));
+  return bp;
+};
 
-  function getExecutableProcesses() {
-    return definitionContext.getExecutableProcesses().map(({id: processId}) => getProcessById(processId));
-  }
+proto.getProcesses = function getProcesses() {
+  return this.definitionContext.getProcesses().map(({id: processId}) => this.getProcessById(processId));
+};
 
-  function getMessageFlows(sourceId) {
-    if (!messageFlows.length) {
-      const flows = definitionContext.getMessageFlows() || [];
-      messageFlows.push(...flows.map((flow) => flow.Behaviour(flow, context)));
-    }
+proto.getExecutableProcesses = function getExecutableProcesses() {
+  return this.definitionContext.getExecutableProcesses().map(({id: processId}) => this.getProcessById(processId));
+};
 
-    return messageFlows.filter((flow) => flow.source.processId === sourceId);
+proto.getMessageFlows = function getMessageFlows(sourceId) {
+  if (!this.refs.messageFlows.length) {
+    const flows = this.definitionContext.getMessageFlows() || [];
+    this.refs.messageFlows.push(...flows.map((flow) => new flow.Behaviour(flow, this)));
   }
 
-  function getDataObjectById(referenceId) {
-    let dataObject;
-    if ((dataObject = dataObjectRefs[referenceId])) return dataObject;
+  return this.refs.messageFlows.filter((flow) => flow.source.processId === sourceId);
+};
 
-    const dataObjectDef = definitionContext.getDataObjectById(referenceId);
-    if (!dataObjectDef) return;
+proto.getDataObjectById = function getDataObjectById(referenceId) {
+  let dataObject;
+  if ((dataObject = this.refs.dataObjectRefs[referenceId])) return dataObject;
 
-    dataObject = dataObjectRefs[dataObjectDef.id] = dataObjectDef.Behaviour(dataObjectDef, context);
+  const dataObjectDef = this.definitionContext.getDataObjectById(referenceId);
+  if (!dataObjectDef) return;
 
-    return dataObject;
-  }
+  dataObject = this.refs.dataObjectRefs[dataObjectDef.id] = new dataObjectDef.Behaviour(dataObjectDef, this);
 
-  function getDataStoreById(referenceId) {
-    let dataStore;
-    if ((dataStore = dataStoreRefs[referenceId])) return dataStore;
+  return dataObject;
+};
 
-    const dataStoreDef = definitionContext.getDataStoreById(referenceId) || definitionContext.getDataStoreReferenceById(referenceId);
-    if (!dataStoreDef) return;
+proto.getDataStoreById = function getDataStoreById(referenceId) {
+  let dataStore;
+  if ((dataStore = this.refs.dataStoreRefs[referenceId])) return dataStore;
 
-    dataStore = dataStoreRefs[dataStoreDef.id] = dataStoreDef.Behaviour(dataStoreDef, context);
+  const dataStoreDef = this.definitionContext.getDataStoreById(referenceId) || this.definitionContext.getDataStoreReferenceById(referenceId);
+  if (!dataStoreDef) return;
 
-    return dataStore;
-  }
+  dataStore = this.refs.dataStoreRefs[dataStoreDef.id] = new dataStoreDef.Behaviour(dataStoreDef, this);
+
+  return dataStore;
+};
 
-  function getStartActivities(filterOptions, scopeId) {
-    const {referenceId, referenceType = 'unknown'} = filterOptions || {};
-    return getActivities().filter((activity) => {
-      if (!activity.isStart) return false;
-      if (scopeId && activity.parent.id !== scopeId) return false;
-      if (!filterOptions) return true;
+proto.getStartActivities = function getStartActivities(filterOptions, scopeId) {
+  const {referenceId, referenceType = 'unknown'} = filterOptions || {};
+  const result = [];
+  for (const activity of this.getActivities()) {
+    if (!activity.isStart) continue;
+    if (scopeId && activity.parent.id !== scopeId) continue;
+    if (!filterOptions) {
+      result.push(activity);
+      continue;
+    }
 
-      if (!activity.behaviour.eventDefinitions && !activity.behaviour.eventDefinitions) return false;
+    if (!activity.behaviour.eventDefinitions && !activity.behaviour.eventDefinitions) continue;
 
-      return activity.eventDefinitions.some((ed) => {
-        return ed.reference && ed.reference.id === referenceId && ed.reference.referenceType === referenceType;
-      });
+    const ref = activity.eventDefinitions.some((ed) => {
+      return ed.reference && ed.reference.id === referenceId && ed.reference.referenceType === referenceType;
     });
+    if (ref) result.push(activity);
   }
+  return result;
+};
 
-  function loadExtensions(activity) {
-    return extensionsMapper.get(activity);
-  }
-}
+proto.loadExtensions = function loadExtensions(activity) {
+  return this.extensionsMapper.get(activity);
+};