scatter-gather

Package that provides a scatter/gather pattern to pass messages to multiple client modules and aggregate the results.

Usage

Basic Usage

You can create a new instance of this module in the following manner:

const scather = new ScatterGather({
  timeout: 5000,
  modules: {
      myModule
  }
})

Note that you specify an object of named modules, each of which must conform to a simple contract to process the messages sent to it. Here is a very simple example module to illustrate the contract they need to implement:

function getResponseMessage (inputMessage, response, error) {
  const message = {
    id: inputMessage.id,
    type: inputMessage.type,
    key: inputMessage.key
  }
  if (response) {
    message.response = response
  }
  if (error) {
    message.error = error
  }
  return message
}

exports.processMessage = async function (message) {
    try {
        const item = "DoSomethingHere"
        return getResponseMessage(message, item, undefined)
    } catch (err) {
        console.log(err)
        return getResponseMessage(message, undefined, err)
    }
}

Note that each scatter-gather module must implement the processMessage function, which is an async function that returns a Promise.

Request Message Format

Request messages sent to the scatter-gather module must follow this contract:

{
    id: 'FakeId',
    type: 'MessageType',
    key: 'ByuId',
    body: { // Any object can be included in this parameter 
        anything: 'here'
    }
}

Response Message Format

Scatter-gather modules must return messages of the following type:

{
    id: 'FakeId',
    type: 'MessageType',
    key: 'ByuId',
    response: { // Any object can be optionally returned here
        some: 'data'
    },
    error: new Error() // Any Error object can be optionally returned here
}

You should either specify the response property if your call suceeds, or the error property if it fails.

You should not throw errors from the scatter/gather modules. Instead, you should return a message with the error field populated.