Nominating Presidential Muppets


    2.0.2 • Public • Published


    NPM version Build Status Coverage Status Davis Dependency Status


    Use argosy instead. This module is no longer maintained as a separate entity.

    Easily create micro-services.

    Part of the Argosy family.


    var service = require('argosy-service')(),
        match   = require('argosy-pattern/match'),
        client  = require('argosy-client')
    // connect the client to the service
    // create the service
    service.message({ greet: match.string }).process(function (msg, cb) {
        cb(null, 'Hello ' + msg.greet)
    // use the service
    client.invoke({ greet: 'Jason' }, function (err, result) {

    or with promises...

    // create the service
    service.message({ greet: match.string }).process(function (msg) {
        return Promise.resolve('Hello ' + msg.greet)
    // use the service
    client.invoke({ greet: 'Jason' }).then(console.log)


    var argosyService = require('argosy-service')

    service = argosyService()

    Create a new service object. The service object is a stream intended to be connected (piped) to Argosy clients through any number of intermediary streams.

    queue = service.message(pattern)

    Create a concurrent-queue that will be pushed messages that match the pattern object provided (see argosy-pattern for details on defining patterns). These messages should be processed and responded to using the process function of the queue. Responses will be sent to the connected/requesting client.

    It is advised not to match the key argosy as this is reserved for internal use.

    built-in message handlers

    {argosy: 'info'}

    All services created will respond to messages that match {argosy: 'info'}. The response payload will be:

        role: 'service',
        implemented: [
            'encoded argosy pattern 1',
            'encoded argosy pattern 2',

    The implemented array will contain encoded argosy-pattern's for which the service will respond.

    service stream messages

    service request

    Incoming requests are structured like so:

        type: 'request',
        headers: { client: { id: 'uuid', seq: 0 } },
        body: {}


    • headers can be anything you want to send, the service will send them back exactly as they were. This is useful for correlating responses with requests. The argosy-client sends a client UUID and a request sequence number in the headers to correlate responses.
    • body contains the message that the service will match against

    service response

    Outbound responses are structured like so:

        type: 'response',
        headers: { client: { id: 'uuid', seq: 0 } },
        body: {},
        error: { message: '', stack: '' }


    • headers matches whatever headers object was supplied by the client to allow the client to correlate responses with requests on it's end
    • body contains the response from the service message implementation
    • error will be undefined unless an error occured in which case it will contain an object with the error message and stack

    new service message implementation

    When a new message pattern for the service is defined, a notify-implemented message object will be emitted from the service stream. This allows connected listers to be made aware of new message implementations. The structure of this message is:

        type: 'notify-implemented',
        body: 'encoded argosy pattern'


    npm test [--dot | --spec] [--grep=pattern]

    Specifying --dot or --spec will change the output from the default TAP style. Specifying --grep will only run the test files that match the given pattern.


    npm run coverage [--html]

    This will output a textual coverage report. Including --html will also open an HTML coverage report in the default browser.


    npm i argosy-service

    DownloadsWeekly Downloads






    Last publish


    • jasonpincin