Appolo Bus Module

bus module for appolo built with rabbot

Installation

npm i @appolo/bus

Options

key	Description	Type	Default
id	injection id	string	busProvider
connection	AMQP connection string	string	null
auto	true to auto initialize busProvider and start listen to events	boolean	true
listener	true to register queue event handlers	boolean	true
exchangeName	name of the exchange	string
queueName	name of the queue	string
appendEnv	append env name to queueName and exchangeName	boolean	true
exchange	exchange options	object	{}
queue	queue options	object	{}
requestQueue	request queue options	object	{}
replayQueue	request queue options or false to disable	object	{}

Exchange Options

key	Description	Type	Default
type	request queue options or false to disable	string	topic
autoDelete	delete when consumer count goes to 0	boolean	false
durable	survive broker restarts	boolean	true
persistent	persistent delivery, messages saved to disk	boolean	true
alternate	define an alternate exchange	string
publishTimeout	timeout in milliseconds for publish calls to this exchange	2^32
replyTimeout	timeout in milliseconds to wait for a reply	2^32
limit	the number of unpublished messages to cache while waiting on connection	2^16
noConfirm	prevents rabbot from creating the exchange in confirm mode	boolean	false

Queue Options

key	Description	Type	Default
autoDelete	delete when consumer count goes to 0	boolean	false
durable	survive broker restarts	boolean	true
subscribe	auto-start the subscription	boolean	false
limit	max number of unacked messages allowed for consumer	2^16	1
noAck	the server will remove messages from the queue as soon as they are delivered	boolean	false
noBatch	causes ack, nack & reject to take place immediately	boolean	false
noCacheKeys	disable cache of matched routing keys to prevent unbounded memory growth	boolean	false
queueLimit	max number of ready messages a queue can hold	2^32
messageTt	time in ms before a message expires on the queue	2^32
expires	time in ms before a queue with 0 consumers expires	2^32
in config/modules/all.ts

import {PubSubModule} from '@appolo/pubsub';

export = async function (app: App) {
   await app.module(new BusModule({redis:"amqp://connection-string"}));
}

Usage

Publisher

import {define, singleton} from 'appolo'
import {publisher} from "@appolo/bus";

@define()
@singleton()
export class SomePublisher {

    @publisher("test")
    async publish(data: any): Promise<any> {
        return data
    }
}

Or with BusProvider

@define()
@singleton()
export class SomePublisher {

    inject() busProvider:BusProvider

    publish(data:any): Promise<any> {
        return this.busProvider.publish("test",data)
    }
}

Handler

if you don not call msg ack or nack it will be called on handler return msg.ack() or msg.nack() on error

import {define, singleton} from 'appolo'
import {handler} from "@appolo/bus";

@define()
@singleton()
export class SomeHandler {

    @handler("test")
    handle(msg: IMessage<data>) {
       //do something
    }

    @handler("someName")
    handle(msg: IMessage<data>) {

        try{
           //do some thing

           msg.ack();
        }
        catch(){
            msg.nack();
        }
    }
}

Request

import {define, singleton} from 'appolo'
import {request} from "@appolo/bus";

@define()
@singleton()
export class SomePublisher {

    @request("test")
    async getData(data: any): Promise<any> {
        return data
    }

    public async handleData(){
        let data = await this.getData({userId:1})
    }


}

Or with BusProvider

@define()
@singleton()
export class SomePublisher {

    inject() busProvider:busProvider

    publish(data:any): Promise<any> {
        let data = await  this.busProvider.request("test",data)

        return data;
    }
}

Reply

import {define, singleton} from 'appolo'
import {handler} from "@appolo/bus";

@define()
@singleton()
export class SomeHandler {

    inject() busProvider:busProvider


    @reply("test")
    handle(msg: IMessage<data>) {
        return {userId:1}
    }

    // or reply methods
    @reply("someName")
    handle(msg: IMessage<data>) {

        try{
            //get some data
         msg.replySuccess(msg,{userId:1})
        }
        catch(){
            msg.replyError(msg,e)
        }
    }
}

IMessage

each handler and reply handler called with message object

{
  // metadata specific to routing & delivery
  fields: {
    consumerTag: "", // identifies the consumer to rabbit
    deliveryTag: #, // identifies the message delivered for rabbit
    redelivered: true|false, // indicates if the message was previously nacked or returned to the queue
    exchange: "" // name of exchange the message was published to,
    routingKey: "" // the routing key (if any) used when published
  },
  properties:{
    contentType: "application/json", // see serialization for how defaults are determined
    contentEncoding: "utf8", // rabbot's default
    headers: {}, // any user provided headers
    correlationId: "", // the correlation id if provided
    replyTo: "", // the reply queue would go here
    messageId: "", // message id if provided
    type: "", // the type of the message published
    appId: "" // not used by rabbot
  },
  content: { "type": "Buffer", "data": [ ... ] }, // raw buffer of message body
  body: , // this could be an object, string, etc - whatever was published
  type: "" // this also contains the type of the message published
}

message.ack()

Enqueues the message for acknowledgement.

message.nack()

Enqueues the message for rejection. This will re-enqueue the message.

message.reject()

Rejects the message without re-queueing it. Please use with caution and consider having a dead-letter-exchange assigned to the queue before using this feature.

message.reply( data:any )

Acknowledges the messages and sends the message back to the requestor.

message.replySuccess( data:T )

reply the message with json object {success: true,data}

message.replyError( e: RequestError<T> )

reply the message with json object {success: false,message: e.message, data:e.data}

BusProvider

initialize()

initialize busProvider and start listen to events if not in in auto mode

publish(type: string, data: any, expire?: number): Promise<void>

publish event

• type - event name
• data - any data
• expire - timeout until the message is expired in the queue

request<T>(type: string, data: any, expire?: number): Promise<T>

request data by event return promise with event response

• type - event name
• data - any data
• expire - timeout until the request is rejected

close<T>(): Promise<void>

close the connection and clean all handlers

getQueueMessagesCount(): Promise<number>

return number of pending events in the queue