bpmn-elements 5.1.3 → 7.0.0

package/dist/src/io/InputOutputSpecification.js

@@ -11,196 +11,202 @@ var _shared = require("../shared");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+const consumingSymbol = Symbol.for('consuming');
+
 function IoSpecification(activity, ioSpecificationDef, context) {
   const {
     id,
     type = 'iospecification',
     behaviour = {}
   } = ioSpecificationDef;
-  const {
-    broker
-  } = activity;
-  const safeType = (0, _shared.brokerSafeId)(type).toLowerCase();
-  let activityConsumer;
+  this.id = id;
+  this.type = type;
+  this.behaviour = behaviour;
+  this.activity = activity;
+  this.broker = activity.broker;
+  this.context = context;
+}
+
+const proto = IoSpecification.prototype;
+
+proto.activate = function activate() {
+  if (this[consumingSymbol]) return;
+  this[consumingSymbol] = this.broker.subscribeTmp('event', 'activity.#', this._onActivityEvent.bind(this), {
+    noAck: true
+  });
+};
+
+proto.deactivate = function deactivate() {
+  if (this[consumingSymbol]) this[consumingSymbol] = this[consumingSymbol].cancel();
+};
+
+proto._onActivityEvent = function onActivityEvent(routingKey, message) {
   const {
     dataInputs,
     dataOutputs
-  } = behaviour;
-  const ioApi = {
-    id,
-    type,
-    behaviour,
-    activate,
-    deactivate
-  };
-  return ioApi;
+  } = this.behaviour;
 
-  function activate() {
-    if (activityConsumer) return;
-    activityConsumer = broker.subscribeTmp('event', 'activity.#', onActivityEvent, {
-      noAck: true
-    });
+  if ((dataInputs || dataOutputs) && routingKey === 'activity.enter') {
+    return this._onFormatEnter();
   }
 
-  function deactivate() {
-    if (activityConsumer) activityConsumer = activityConsumer.cancel();
+  if (dataOutputs && routingKey === 'activity.execution.completed') {
+    this._onFormatComplete(message);
   }
+};
 
-  function onActivityEvent(routingKey, message) {
-    if ((dataInputs || dataOutputs) && routingKey === 'activity.enter') {
-      return formatOnEnter();
-    }
+proto._onFormatEnter = function onFormatOnEnter() {
+  const safeType = (0, _shared.brokerSafeId)(this.type).toLowerCase();
+  const startRoutingKey = `run.onstart.${safeType}`;
+  const {
+    dataInputs,
+    dataOutputs
+  } = this.behaviour;
+  const broker = this.broker;
 
-    if (dataOutputs && routingKey === 'activity.execution.completed') {
-      formatOnComplete(message);
-    }
+  if (!dataInputs) {
+    return broker.publish('format', startRoutingKey, {
+      ioSpecification: {
+        dataOutputs: this._getDataOutputs(dataOutputs)
+      }
+    });
   }
 
-  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 = (0, _getPropertyValue.default)(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: []
+  });
 
-    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 = (0, _getPropertyValue.default)(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: this._getDataOutputs(dataOutputs)
+      }
     });
+  }
 
-    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,
+    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;
 
-    const endRoutingKey = `run.onstart.${safeType}.end`;
-    broker.publish('format', `${startRoutingKey}.begin`, {
-      endRoutingKey,
+    broker.publish('format', endRoutingKey, {
       ioSpecification: {
-        dataInputs: sources.map(source => {
-          return { ...source
-          };
-        }),
-        dataOutputs: getDataOutputs()
+        dataInputs: sources,
+        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 = (0, _getPropertyValue.default)(message, 'content.ioSpecification.dataInputs');
-    const messageOutputs = (0, _getPropertyValue.default)(message, 'content.output.ioSpecification.dataOutputs') || [];
+proto._onFormatComplete = function formatOnComplete(message) {
+  const safeType = (0, _shared.brokerSafeId)(this.type).toLowerCase();
+  const messageInputs = (0, _getPropertyValue.default)(message, 'content.ioSpecification.dataInputs');
+  const messageOutputs = (0, _getPropertyValue.default)(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 {
-      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 = (0, _getPropertyValue.default)(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: []
+      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 = (0, _getPropertyValue.default)(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
     });
-    const startRoutingKey = `run.onend.${safeType}`;
-
-    if (!dataObjects.length) {
-      return broker.publish('format', startRoutingKey, {
-        ioSpecification: {
-          dataInputs: messageInputs,
-          dataOutputs: sources
-        }
-      });
-    }
+    return result;
+  }, {
+    dataObjects: [],
+    sources: []
+  });
+  const startRoutingKey = `run.onend.${safeType}`;
 
-    const endRoutingKey = `run.onend.${safeType}.end`;
-    broker.publish('format', `${startRoutingKey}.begin`, {
-      endRoutingKey,
+  if (!dataObjects.length) {
+    return broker.publish('format', startRoutingKey, {
       ioSpecification: {
-        dataInputs: sources.map(input => {
-          return { ...input
-          };
-        }),
-        dataOutputs: getDataOutputs()
+        dataInputs: messageInputs,
+        dataOutputs: sources
       }
     });
-    return write(broker, dataObjects, (_, responses) => {
-      responses.forEach(response => {
-        sources[response.index].value = response.value;
-      });
-      broker.publish('format', endRoutingKey, {
-        ioSpecification: {
-          dataInputs: sources,
-          dataOutputs: getDataOutputs()
-        }
-      });
-    });
   }
 
-  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 = [];
@@ -209,10 +215,9 @@ function read(broker, dataObjectRefs, callback) {
     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.');
   }
 
@@ -235,24 +240,28 @@ function read(broker, dataObjectRefs, callback) {
 function write(broker, dataObjectRefs, callback) {
   const responses = [];
   let count = 0;
-  const dataWriteConsumer = broker.subscribeTmp('data', 'data.write.#', onDataObjectResponse, {
+  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);
   }
 }

package/dist/src/io/Properties.js

@@ -0,0 +1,252 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = Properties;
+
+var _getPropertyValue = _interopRequireDefault(require("../getPropertyValue"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const propertiesSymbol = Symbol.for('properties');
+const consumingSymbol = Symbol.for('consuming');
+
+function Properties(activity, propertiesDef, context) {
+  this.activity = activity;
+  this.broker = activity.broker;
+  const props = this[propertiesSymbol] = {
+    properties: [],
+    dataInputObjects: [],
+    dataOutputObjects: []
+  };
+
+  for (const {
+    id,
+    ...def
+  } of propertiesDef.values) {
+    const source = {
+      id,
+      type: def.type,
+      name: def.behaviour && def.behaviour.name
+    };
+    props.properties.push(source);
+    const inputDataObjectId = (0, _getPropertyValue.default)(def, 'behaviour.dataInput.association.source.dataObject.id');
+    const outputDataObjectId = (0, _getPropertyValue.default)(def, 'behaviour.dataOutput.association.target.dataObject.id');
+    const inputDataStoreId = (0, _getPropertyValue.default)(def, 'behaviour.dataInput.association.source.dataStore.id');
+    const outputDataStoreId = (0, _getPropertyValue.default)(def, 'behaviour.dataOutput.association.target.dataStore.id');
+
+    if (inputDataObjectId) {
+      const reference = context.getDataObjectById(inputDataObjectId);
+      props.dataInputObjects.push({
+        id,
+        reference
+      });
+      source.input = {
+        reference
+      };
+    }
+
+    if (outputDataObjectId) {
+      const reference = context.getDataObjectById(outputDataObjectId);
+      props.dataOutputObjects.push({
+        id,
+        reference: reference
+      });
+      source.output = {
+        reference
+      };
+    }
+
+    if (inputDataStoreId) {
+      const reference = context.getDataStoreById(inputDataStoreId);
+      props.dataInputObjects.push({
+        id,
+        reference
+      });
+      source.input = {
+        reference
+      };
+    }
+
+    if (outputDataStoreId) {
+      const reference = context.getDataStoreById(outputDataStoreId);
+      props.dataOutputObjects.push({
+        id,
+        reference
+      });
+      source.output = {
+        reference
+      };
+    }
+  }
+}
+
+const proto = Properties.prototype;
+
+proto.activate = function activate(message) {
+  if (this[consumingSymbol]) return;
+
+  if (message.fields.redelivered && message.content.properties) {
+    this._onActivityEvent('activity.extension.resume', message);
+  }
+
+  this[consumingSymbol] = this.broker.subscribeTmp('event', 'activity.#', this._onActivityEvent.bind(this), {
+    noAck: true
+  });
+};
+
+proto.deactivate = function deactivate() {
+  if (this[consumingSymbol]) this[consumingSymbol] = this[consumingSymbol].cancel();
+};
+
+proto._onActivityEvent = function onActivityEvent(routingKey, message) {
+  if (routingKey === 'activity.enter') {
+    return this._formatOnEnter(message);
+  }
+
+  if (routingKey === 'activity.extension.resume') {
+    return this._formatOnEnter(message);
+  }
+
+  if (routingKey === 'activity.execution.completed') {
+    return this._formatOnComplete(message);
+  }
+};
+
+proto._formatOnEnter = function formatOnEnter(message) {
+  const startRoutingKey = 'run.enter.bpmn-properties';
+  const dataInputObjects = this[propertiesSymbol].dataInputObjects;
+  const broker = this.broker;
+
+  if (!dataInputObjects.length) {
+    return broker.getQueue('format-run-q').queueMessage({
+      routingKey: startRoutingKey
+    }, {
+      properties: this._getProperties(message)
+    });
+  }
+
+  const endRoutingKey = 'run.enter.bpmn-properties.end';
+  broker.getQueue('format-run-q').queueMessage({
+    routingKey: startRoutingKey
+  }, {
+    endRoutingKey,
+    properties: this._getProperties(message)
+  });
+  return read(broker, dataInputObjects, (_, responses) => {
+    broker.publish('format', endRoutingKey, {
+      properties: this._getProperties(message, responses)
+    });
+  });
+};
+
+proto._formatOnComplete = function formatOnComplete(message) {
+  const startRoutingKey = 'run.end.bpmn-properties';
+  const messageOutput = (0, _getPropertyValue.default)(message, 'content.output.properties') || {};
+
+  const outputProperties = this._getProperties(message, messageOutput);
+
+  const dataOutputObjects = this[propertiesSymbol].dataOutputObjects;
+  const broker = this.broker;
+
+  if (!dataOutputObjects.length) {
+    return broker.getQueue('format-run-q').queueMessage({
+      routingKey: startRoutingKey
+    }, {
+      properties: outputProperties
+    });
+  }
+
+  const endRoutingKey = 'run.end.bpmn-properties.end';
+  broker.getQueue('format-run-q').queueMessage({
+    routingKey: startRoutingKey
+  }, {
+    endRoutingKey,
+    properties: outputProperties
+  });
+  return write(broker, dataOutputObjects, outputProperties, (_, responses) => {
+    broker.publish('format', endRoutingKey, {
+      properties: this._getProperties(message, responses)
+    });
+  });
+};
+
+proto._getProperties = function getProperties(message, values) {
+  let response = {};
+
+  if (message.content.properties) {
+    response = { ...message.content.properties
+    };
+  }
+
+  for (const {
+    id,
+    type,
+    name
+  } of this[propertiesSymbol].properties) {
+    if (!(id in response)) {
+      response[id] = {
+        id,
+        type,
+        name
+      };
+    }
+
+    if (!values || !(id in values)) continue;
+    response[id].value = values[id].value;
+  }
+
+  return response;
+};
+
+function read(broker, dataReferences, callback) {
+  const responses = {};
+  let count = 0;
+  const dataReadConsumer = broker.subscribeTmp('data', 'data.read.#', onDataReadResponse, {
+    noAck: true
+  });
+
+  for (const {
+    id: propertyId,
+    reference
+  } of dataReferences) {
+    reference.read(broker, 'data', 'data.read.', {
+      correlationId: propertyId
+    });
+  }
+
+  function onDataReadResponse(routingKey, message) {
+    responses[message.properties.correlationId] = { ...message.content
+    };
+    if (++count < dataReferences.length) return;
+    dataReadConsumer.cancel();
+    return callback(null, responses);
+  }
+}
+
+function write(broker, dataReferences, properties, callback) {
+  const responses = [];
+  let count = 0;
+  const dataWriteConsumer = broker.subscribeTmp('data', 'data.write.#', onDataWriteResponse, {
+    noAck: true
+  });
+
+  for (const {
+    id: propertyId,
+    reference
+  } of dataReferences) {
+    const value = propertyId in properties ? properties[propertyId].value : undefined;
+    reference.write(broker, 'data', 'data.write.', value, {
+      correlationId: propertyId
+    });
+  }
+
+  function onDataWriteResponse(routingKey, message) {
+    responses[message.properties.correlationId] = { ...message.content
+    };
+    if (++count < dataReferences.length) return;
+    dataWriteConsumer.cancel();
+    return callback(null, responses);
+  }
+}

package/dist/src/messageHelper.js

@@ -6,9 +6,9 @@ Object.defineProperty(exports, "__esModule", {
 exports.cloneContent = cloneContent;
 exports.cloneMessage = cloneMessage;
 exports.cloneParent = cloneParent;
+exports.pushParent = pushParent;
 exports.shiftParent = shiftParent;
 exports.unshiftParent = unshiftParent;
-exports.pushParent = pushParent;
 
 function cloneContent(content, extend) {
   const {