bpmn-elements 5.1.3 → 7.0.0

package/src/getPropertyValue.js

@@ -9,53 +9,54 @@ function getPropertyValue(inputContext, propertyPath, fnScope) {
   if (!inputContext) return;
 
   let resultValue;
-  let next = iterateProps(inputContext, inputContext, propertyPath.trim());
+  let next = iterateProps(inputContext, inputContext, propertyPath.trim(), fnScope);
   while (next) {
     resultValue = next.getResult();
     next = next();
   }
   return resultValue;
+}
 
-  function iterateProps(base, iterateContext, iteratePropertyPath) {
-    let result;
-    const rest = iteratePropertyPath.replace(propertyPattern, (match, fnName, args, p, prop) => {
-      if (fnName) {
-        result = executeFn(getNamedValue(iterateContext, fnName), args, base);
-      } else {
-        result = getNamedValue(iterateContext, prop);
-      }
-      return '';
-    });
+function iterateProps(base, iterateContext, iteratePropertyPath, fnScope) {
+  let result;
+  const rest = iteratePropertyPath.replace(propertyPattern, (match, fnName, args, p, prop) => {
+    if (fnName) {
+      result = executeFn(getNamedValue(iterateContext, fnName), args, base, fnScope);
+    } else {
+      result = getNamedValue(iterateContext, prop);
+    }
+    return '';
+  });
 
-    if (rest === iteratePropertyPath) return;
-    if (result === undefined || result === null) return;
+  if (rest === iteratePropertyPath) return;
+  if (result === undefined || result === null) return;
 
-    const iterateNext = () => iterateProps(base, result, rest);
-    iterateNext.getResult = () => {
-      if (rest !== '') return;
-      return result;
-    };
+  const iterateNext = () => iterateProps(base, result, rest, fnScope);
+  iterateNext.getResult = () => {
+    if (rest !== '') return;
+    return result;
+  };
 
-    return iterateNext;
-  }
+  return iterateNext;
+}
 
-  function executeFn(fn, args, base) {
-    if (!fn) return;
+function executeFn(fn, args, base, fnScope) {
+  if (!fn) return;
 
-    let callArguments = [];
-    if (args) {
-      callArguments = splitArguments(args, base, fnScope);
-    } else {
-      callArguments.push(base);
-    }
+  let callArguments = [];
+  if (args) {
+    callArguments = splitArguments(args, base, fnScope);
+  } else {
+    callArguments.push(base);
+  }
 
-    if (!fnScope) return fn.apply(null, callArguments);
+  if (!fnScope) return fn.apply(null, callArguments);
 
-    return (function ScopedIIFE() { // eslint-disable-line no-extra-parens
-      return fn.apply(this, callArguments);
-    }).call(fnScope);
-  }
+  return (function ScopedIIFE() { // eslint-disable-line no-extra-parens
+    return fn.apply(this, callArguments);
+  }).call(fnScope);
 }
+
 function splitArguments(args, base, fnScope) {
   let insideString = false;
   let delimiter = '';

package/src/io/BpmnIO.js

@@ -0,0 +1,20 @@
+export default function BpmnIO(activity, context) {
+  this.activity = activity;
+  this.context = context;
+
+  const {ioSpecification: ioSpecificationDef, properties: propertiesDef} = activity.behaviour;
+  this.specification = ioSpecificationDef && new ioSpecificationDef.Behaviour(activity, ioSpecificationDef, context);
+  this.properties = propertiesDef && new propertiesDef.Behaviour(activity, propertiesDef, context);
+}
+
+BpmnIO.prototype.activate = function activate(message) {
+  const properties = this.properties, specification = this.specification;
+  if (properties) properties.activate(message);
+  if (specification) specification.activate(message);
+};
+
+BpmnIO.prototype.deactivate = function deactivate(message) {
+  const properties = this.properties, specification = this.specification;
+  if (properties) properties.deactivate(message);
+  if (specification) specification.deactivate(message);
+};

package/src/io/EnvironmentDataObject.js

@@ -1,22 +1,33 @@
 export default function EnvironmentDataObject(dataObjectDef, {environment}) {
   const {id, type, name, behaviour, parent} = dataObjectDef;
+  this.id = id;
+  this.type = type;
+  this.name = name;
+  this.behaviour = behaviour;
+  this.parent = parent;
+  this.environment = environment;
+}
 
-  const source = {
-    id,
-    name,
-    type,
-    behaviour,
-    parent,
-    read(broker, exchange, routingKeyPrefix, messageProperties) {
-      const value = environment.variables._data && environment.variables._data[id];
-      return broker.publish(exchange, `${routingKeyPrefix}response`, {id, name, type, value}, messageProperties);
-    },
-    write(broker, exchange, routingKeyPrefix, value, messageProperties) {
-      environment.variables._data = environment.variables._data || {};
-      environment.variables._data[id] = value;
-      return broker.publish(exchange, `${routingKeyPrefix}response`, {id, name, type, value}, messageProperties);
-    },
-  };
+EnvironmentDataObject.prototype.read = function read(broker, exchange, routingKeyPrefix, messageProperties) {
+  const environment = this.environment;
+  const value = environment.variables._data && environment.variables._data[this.id];
+  const content = this._createContent(value);
+  return broker.publish(exchange, `${routingKeyPrefix}response`, content, messageProperties);
+};
 
-  return source;
-}
+EnvironmentDataObject.prototype.write = function write(broker, exchange, routingKeyPrefix, value, messageProperties) {
+  const environment = this.environment;
+  environment.variables._data = environment.variables._data || {};
+  environment.variables._data[this.id] = value;
+  const content = this._createContent(value);
+  return broker.publish(exchange, `${routingKeyPrefix}response`, content, messageProperties);
+};
+
+EnvironmentDataObject.prototype._createContent = function createContent(value) {
+  return {
+    id: this.id,
+    type: this.type,
+    name: this.name,
+    value,
+  };
+};

package/src/io/EnvironmentDataStore.js

@@ -0,0 +1,33 @@
+export default function EnvironmentDataStore(dataStoreDef, {environment}) {
+  const {id, type, name, behaviour, parent} = dataStoreDef;
+  this.id = id;
+  this.type = type;
+  this.name = name;
+  this.behaviour = behaviour;
+  this.parent = parent;
+  this.environment = environment;
+}
+
+EnvironmentDataStore.prototype.read = function read(broker, exchange, routingKeyPrefix, messageProperties) {
+  const environment = this.environment;
+  const value = environment.variables._data && environment.variables._data[this.id];
+  const content = this._createContent(value);
+  return broker.publish(exchange, `${routingKeyPrefix}response`, content, messageProperties);
+};
+
+EnvironmentDataStore.prototype.write = function write(broker, exchange, routingKeyPrefix, value, messageProperties) {
+  const environment = this.environment;
+  environment.variables._data = environment.variables._data || {};
+  environment.variables._data[this.id] = value;
+  const content = this._createContent(value);
+  return broker.publish(exchange, `${routingKeyPrefix}response`, content, messageProperties);
+};
+
+EnvironmentDataStore.prototype._createContent = function createContent(value) {
+  return {
+    id: this.id,
+    type: this.type,
+    name: this.name,
+    value,
+  };
+};

package/src/io/EnvironmentDataStoreReference.js

@@ -0,0 +1,33 @@
+export default function EnvironmentDataStoreReference(dataObjectDef, {environment}) {
+  const {id, type, name, behaviour, parent} = dataObjectDef;
+  this.id = id;
+  this.type = type;
+  this.name = name;
+  this.behaviour = behaviour;
+  this.parent = parent;
+  this.environment = environment;
+}
+
+EnvironmentDataStoreReference.prototype.read = function read(broker, exchange, routingKeyPrefix, messageProperties) {
+  const environment = this.environment;
+  const value = environment.variables._data && environment.variables._data[this.id];
+  const content = this._createContent(value);
+  return broker.publish(exchange, `${routingKeyPrefix}response`, content, messageProperties);
+};
+
+EnvironmentDataStoreReference.prototype.write = function write(broker, exchange, routingKeyPrefix, value, messageProperties) {
+  const environment = this.environment;
+  environment.variables._data = environment.variables._data || {};
+  environment.variables._data[this.id] = value;
+  const content = this._createContent(value);
+  return broker.publish(exchange, `${routingKeyPrefix}response`, content, messageProperties);
+};
+
+EnvironmentDataStoreReference.prototype._createContent = function createContent(value) {
+  return {
+    id: this.id,
+    type: this.type,
+    name: this.name,
+    value,
+  };
+};

package/src/io/InputOutputSpecification.js

@@ -1,186 +1,184 @@
 import getPropertyValue from '../getPropertyValue';
 import {brokerSafeId} from '../shared';
 
+const consumingSymbol = Symbol.for('consuming');
+
 export default function IoSpecification(activity, ioSpecificationDef, context) {
   const {id, type = 'iospecification', behaviour = {}} = ioSpecificationDef;
-  const {broker} = activity;
-
-  const safeType = brokerSafeId(type).toLowerCase();
-  let activityConsumer;
-
-  const {dataInputs, dataOutputs} = behaviour;
+  this.id = id;
+  this.type = type;
+  this.behaviour = behaviour;
+  this.activity = activity;
+  this.broker = activity.broker;
+  this.context = context;
+}
 
-  const ioApi = {
-    id,
-    type,
-    behaviour,
-    activate,
-    deactivate,
-  };
+const proto = IoSpecification.prototype;
 
-  return ioApi;
+proto.activate = function activate() {
+  if (this[consumingSymbol]) return;
+  this[consumingSymbol] = this.broker.subscribeTmp('event', 'activity.#', this._onActivityEvent.bind(this), {noAck: true});
+};
 
-  function activate() {
-    if (activityConsumer) return;
-    activityConsumer = broker.subscribeTmp('event', 'activity.#', onActivityEvent, {noAck: true});
-  }
+proto.deactivate = function deactivate() {
+  if (this[consumingSymbol]) this[consumingSymbol] = this[consumingSymbol].cancel();
+};
 
-  function deactivate() {
-    if (activityConsumer) activityConsumer = activityConsumer.cancel();
+proto._onActivityEvent = function onActivityEvent(routingKey, message) {
+  const {dataInputs, dataOutputs} = this.behaviour;
+  if ((dataInputs || dataOutputs) && routingKey === 'activity.enter') {
+    return this._onFormatEnter();
   }
 
-  function onActivityEvent(routingKey, message) {
-    if ((dataInputs || dataOutputs) && routingKey === 'activity.enter') {
-      return formatOnEnter();
-    }
-
-    if (dataOutputs && routingKey === 'activity.execution.completed') {
-      formatOnComplete(message);
-    }
+  if (dataOutputs && routingKey === 'activity.execution.completed') {
+    this._onFormatComplete(message);
   }
-
-  function formatOnEnter() {
-    const startRoutingKey = `run.onstart.${safeType}`;
-    if (!dataInputs) {
-      return broker.publish('format', startRoutingKey, {
-        ioSpecification: {
-          dataOutputs: getDataOutputs(),
-        },
-      });
-    }
-
-    const {dataObjects, sources} = dataInputs.reduce((result, ioSource, index) => {
-      const source = {
-        id: ioSource.id,
-        type: ioSource.type,
-        name: ioSource.name,
-      };
-      result.sources.push(source);
-
-      const dataObjectId = getPropertyValue(ioSource, 'behaviour.association.source.dataObject.id');
-      if (!dataObjectId) return result;
-      const dataObject = context.getDataObjectById(dataObjectId);
-      if (!dataObject) return result;
-      result.dataObjects.push({index, dataObject});
-      return result;
-    }, {
-      dataObjects: [],
-      sources: [],
-    });
-
-    if (!dataObjects.length) {
-      return broker.publish('format', startRoutingKey, {
-        ioSpecification: {
-          dataInputs: sources,
-          dataOutputs: getDataOutputs(),
-        },
-      });
-    }
-
-    const endRoutingKey = `run.onstart.${safeType}.end`;
-    broker.publish('format', `${startRoutingKey}.begin`, {
-      endRoutingKey,
+};
+
+proto._onFormatEnter = function onFormatOnEnter() {
+  const safeType = brokerSafeId(this.type).toLowerCase();
+  const startRoutingKey = `run.onstart.${safeType}`;
+  const {dataInputs, dataOutputs} = this.behaviour;
+  const broker = this.broker;
+  if (!dataInputs) {
+    return broker.publish('format', startRoutingKey, {
       ioSpecification: {
-        dataInputs: sources.map((source) => {
-          return {...source};
-        }),
-        dataOutputs: getDataOutputs(),
+        dataOutputs: this._getDataOutputs(dataOutputs),
       },
     });
-
-    return read(broker, dataObjects, (_, responses) => {
-      responses.forEach((response) => {
-        sources[response.index].value = response.value;
-      });
-
-      broker.publish('format', endRoutingKey, {
-        ioSpecification: {
-          dataInputs: sources,
-          dataOutputs: getDataOutputs(),
-        },
-      });
-    });
   }
 
-  function formatOnComplete(message) {
-    const messageInputs = getPropertyValue(message, 'content.ioSpecification.dataInputs');
-    const messageOutputs = getPropertyValue(message, 'content.output.ioSpecification.dataOutputs') || [];
-
-    const {dataObjects, sources} = dataOutputs.reduce((result, ioSource, index) => {
-      const {value} = messageOutputs.find((output) => output.id === ioSource.id) || {};
-      const source = {
-        id: ioSource.id,
-        type: ioSource.type,
-        name: ioSource.name,
-        value,
-      };
-      result.sources.push(source);
-
-      const dataObjectId = getPropertyValue(ioSource, 'behaviour.association.target.dataObject.id');
-      if (!dataObjectId) return result;
-      const dataObject = context.getDataObjectById(dataObjectId);
-      if (!dataObject) return result;
-      result.dataObjects.push({index, dataObject, value});
-      return result;
-    }, {
-      dataObjects: [],
-      sources: [],
+  const {dataObjects, sources} = dataInputs.reduce((result, ioSource, index) => {
+    const source = {
+      id: ioSource.id,
+      type: ioSource.type,
+      name: ioSource.name,
+    };
+    result.sources.push(source);
+
+    const dataObjectId = getPropertyValue(ioSource, 'behaviour.association.source.dataObject.id');
+    if (!dataObjectId) return result;
+    const dataObject = this.context.getDataObjectById(dataObjectId);
+    if (!dataObject) return result;
+    result.dataObjects.push({index, dataObject});
+    return result;
+  }, {
+    dataObjects: [],
+    sources: [],
+  });
+
+  if (!dataObjects.length) {
+    return broker.publish('format', startRoutingKey, {
+      ioSpecification: {
+        dataInputs: sources,
+        dataOutputs: this._getDataOutputs(dataOutputs),
+      },
     });
+  }
 
-    const startRoutingKey = `run.onend.${safeType}`;
-    if (!dataObjects.length) {
-      return broker.publish('format', startRoutingKey, {
-        ioSpecification: {
-          dataInputs: messageInputs,
-          dataOutputs: sources,
-        },
-      });
-    }
-
-    const endRoutingKey = `run.onend.${safeType}.end`;
-    broker.publish('format', `${startRoutingKey}.begin`, {
-      endRoutingKey,
+  const endRoutingKey = `run.onstart.${safeType}.end`;
+  broker.publish('format', `${startRoutingKey}.begin`, {
+    endRoutingKey,
+    ioSpecification: {
+      dataInputs: sources.map((source) => {
+        return {...source};
+      }),
+      dataOutputs: this._getDataOutputs(dataOutputs),
+    },
+  });
+
+  return read(broker, dataObjects, (_, responses) => {
+    for (const response of responses) sources[response.index].value = response.value;
+
+    broker.publish('format', endRoutingKey, {
       ioSpecification: {
-        dataInputs: sources.map((input) => {
-          return {...input};
-        }),
-        dataOutputs: getDataOutputs(),
+        dataInputs: sources,
+        dataOutputs: this._getDataOutputs(dataOutputs),
       },
     });
-
-    return write(broker, dataObjects, (_, responses) => {
-      responses.forEach((response) => {
-        sources[response.index].value = response.value;
-      });
-
-      broker.publish('format', endRoutingKey, {
-        ioSpecification: {
-          dataInputs: sources,
-          dataOutputs: getDataOutputs(),
-        },
-      });
+  });
+};
+
+proto._onFormatComplete = function formatOnComplete(message) {
+  const safeType = brokerSafeId(this.type).toLowerCase();
+  const messageInputs = getPropertyValue(message, 'content.ioSpecification.dataInputs');
+  const messageOutputs = getPropertyValue(message, 'content.output.ioSpecification.dataOutputs') || [];
+  const dataOutputs = this.behaviour.dataOutputs;
+  const broker = this.broker;
+  const context = this.context;
+
+  const {dataObjects, sources} = dataOutputs.reduce((result, ioSource, index) => {
+    const {value} = messageOutputs.find((output) => output.id === ioSource.id) || {};
+    const source = {
+      id: ioSource.id,
+      type: ioSource.type,
+      name: ioSource.name,
+      value,
+    };
+    result.sources.push(source);
+
+
+    const dataObjectId = getPropertyValue(ioSource, 'behaviour.association.target.dataObject.id');
+    if (!dataObjectId) return result;
+    const dataObject = context.getDataObjectById(dataObjectId);
+    if (!dataObject) return result;
+    result.dataObjects.push({index, dataObject, value});
+    return result;
+  }, {
+    dataObjects: [],
+    sources: [],
+  });
+
+  const startRoutingKey = `run.onend.${safeType}`;
+  if (!dataObjects.length) {
+    return broker.publish('format', startRoutingKey, {
+      ioSpecification: {
+        dataInputs: messageInputs,
+        dataOutputs: sources,
+      },
     });
   }
 
-  function getDataOutputs() {
-    if (!dataOutputs) return;
-    return dataOutputs.map((dataOutput) => {
-      return {
-        id: dataOutput.id,
-        type: dataOutput.type,
-        name: dataOutput.name,
-      };
+  const endRoutingKey = `run.onend.${safeType}.end`;
+  broker.publish('format', `${startRoutingKey}.begin`, {
+    endRoutingKey,
+    ioSpecification: {
+      dataInputs: sources.map((input) => {
+        return {...input};
+      }),
+      dataOutputs: this._getDataOutputs(dataOutputs),
+    },
+  });
+
+  return write(broker, dataObjects, (_, responses) => {
+    for (const response of responses) sources[response.index].value = response.value;
+
+    broker.publish('format', endRoutingKey, {
+      ioSpecification: {
+        dataInputs: sources,
+        dataOutputs: this._getDataOutputs(dataOutputs),
+      },
     });
-  }
-}
+  });
+};
+
+proto._getDataOutputs = function getDataOutputs(dataOutputs) {
+  if (!dataOutputs) return;
+  return dataOutputs.map((dataOutput) => {
+    return {
+      id: dataOutput.id,
+      type: dataOutput.type,
+      name: dataOutput.name,
+    };
+  });
+};
 
 function read(broker, dataObjectRefs, callback) {
   const responses = [];
   let count = 0;
   const dataReadConsumer = broker.subscribeTmp('data', 'data.read.#', onDataObjectResponse, {noAck: true});
 
-  for (let i = 0; i < dataObjectRefs.length; i++) {
-    const {dataObject} = dataObjectRefs[i];
+  for (const {dataObject} of dataObjectRefs) {
     dataObject.read(broker, 'data', 'data.read.');
   }
 
@@ -200,22 +198,21 @@ function read(broker, dataObjectRefs, callback) {
 function write(broker, dataObjectRefs, callback) {
   const responses = [];
   let count = 0;
-  const dataWriteConsumer = broker.subscribeTmp('data', 'data.write.#', onDataObjectResponse, {noAck: true});
+  broker.subscribeTmp('data', 'data.write.#', onDataObjectResponse, {noAck: true});
 
-  for (let i = 0; i < dataObjectRefs.length; i++) {
-    const {dataObject, value} = dataObjectRefs[i];
+  for (const {dataObject, value} of dataObjectRefs) {
     dataObject.write(broker, 'data', 'data.write.', value);
   }
 
   function onDataObjectResponse(routingKey, message) {
-    const idx = dataObjectRefs.findIndex((dobj) => dobj.id === message.content.id);
-    responses[idx] = message.content;
+    const idx = dataObjectRefs.findIndex(({dataObject}) => dataObject.id === message.content.id);
+    responses[idx] = {index: idx, ...message.content};
 
     ++count;
 
     if (count < dataObjectRefs.length) return;
 
-    dataWriteConsumer.cancel();
+    broker.cancel(message.fields.consumerTag);
     return callback(null, responses);
   }
 }