rxjs-rabbitmq 1.1.1 → 2.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -1,4 +1,4 @@
1
- # RxJS Rabbit MQ Client
1
+ # RxJS RabbitMQ Client
2
2
 
3
3
 
4
4
 
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "rxjs-rabbitmq",
3
- "version": "1.1.1",
3
+ "version": "2.0.0",
4
4
  "description": "RxJS powered RabbitMQ event handling",
5
5
  "main": "dist/index.js",
6
6
  "types": "dist/index.d.ts",
@@ -61,16 +61,18 @@ export class RabbitMQClient {
61
61
  private connectionErrorStream: Subject<any> = new Subject<any>();
62
62
  private connectionCloseStream: Subject<any> = new Subject<any>();
63
63
 
64
+ /*
65
+ Handle all messages from all queues on this client
66
+ */
64
67
  private messagesStream: Subject<RmqEventMessage> = new Subject<RmqEventMessage>();
68
+ private messagesStreamsByQueue: MapType<Subject<RmqEventMessage>> = {};
65
69
 
66
70
  private queues: MapType<Replies.AssertQueue> = {};
67
71
  private exchanges:MapType<Replies.AssertExchange> = {};
68
72
  private bindings: QueueExchangeBindingConfig[] = [];
69
73
 
70
74
  private DEFAULT_LISTENER_TYPE = '__default';
71
-
72
75
  private EXCLUSIVE_QUEUE: string = uuidv1();
73
-
74
76
  private queueListeners: MapType<Subscription> = {};
75
77
 
76
78
  private queueToEventHandleMapping: MapType<
@@ -100,7 +102,7 @@ export class RabbitMQClient {
100
102
  }
101
103
 
102
104
  constructor(clientInitConfig: RabbitMqInitConfig) {
103
- this.init(clientInitConfig);
105
+ !clientInitConfig.stopAutoInit && this.init(clientInitConfig);
104
106
  }
105
107
 
106
108
  init(clientInitConfig: RabbitMqInitConfig) {
@@ -120,20 +122,23 @@ export class RabbitMQClient {
120
122
  const retryDelay = clientInitConfig.retryDelay || 0;
121
123
 
122
124
  const init = () => {
125
+ // creating connection
123
126
  console.log(`Attempting connection to Rabbit MQ...`);
124
127
  return connect(connection_url)
125
128
  .then((connection) => {
126
129
  this.connection = connection;
127
- console.log(`connected to message server`);
130
+ console.log(`Connected to message server`);
128
131
  return this.connection.createChannel();
129
132
  })
133
+ // creating channel
130
134
  .then((channel) => {
131
135
  this.channel = channel;
132
136
  if (prefetch) {
133
137
  this.channel.prefetch(prefetch || 1);
134
138
  }
135
- console.log(`channel created on message server`);
139
+ console.log(`Channel created on message server`);
136
140
  })
141
+ // creating exclusive queue
137
142
  .then(() => {
138
143
  // create an exclusive queue for this channel connection
139
144
  console.log(`Creating exclusive queue ${this.EXCLUSIVE_QUEUE}`);
@@ -141,26 +146,29 @@ export class RabbitMQClient {
141
146
  console.log(`Created exclusive queue ${this.EXCLUSIVE_QUEUE}`);
142
147
  });
143
148
  })
149
+ // assert to queues
144
150
  .then(() => {
145
151
  const promises: Promise<Replies.AssertQueue>[] = [];
146
- // by default, create an observable stream on the queue for unidentified/null routing keys
152
+
147
153
  for (const queueConfig of queues) {
148
154
  this.queueToEventHandleMapping[queueConfig.name] = {};
149
155
  this.queueToEventCallbackMapping[queueConfig.name] = {};
150
-
156
+
151
157
  const queueListenersMap = this.queueToEventHandleMapping[queueConfig.name];
152
158
  const queueCallbacksMap = this.queueToEventCallbackMapping[queueConfig.name];
153
-
159
+
160
+ // by default, create an observable stream on the queue for unidentified/null routing keys
154
161
  queueListenersMap[this.DEFAULT_LISTENER_TYPE] = new ReplaySubject();
155
162
 
156
- for (const messageType of queueConfig.handleMessageTypes) {
163
+ const useHandleMessageTypes = queueConfig.handleMessageTypes || [];
164
+ for (const messageType of useHandleMessageTypes) {
157
165
  const isStringList = typeof messageType === 'string';
158
-
159
166
  if (isStringList) {
160
167
  queueListenersMap[messageType as string] = new ReplaySubject();
161
168
  }
162
169
  else {
163
- queueCallbacksMap[messageType.messageName] = messageType.callbackHandler;
170
+ const config: RmqHandleMessageTypeConfig = messageType;
171
+ queueCallbacksMap[config.messageName] = config.callbackHandler;
164
172
  }
165
173
  }
166
174
 
@@ -172,6 +180,7 @@ export class RabbitMQClient {
172
180
  console.log(`queues created on channel`);
173
181
  })
174
182
  })
183
+ // assert exchanges
175
184
  .then(() => {
176
185
  const promises = exchanges.map((config) => this.channel.assertExchange(config.name, config.type, config.options));
177
186
  return Promise.all(promises).then(values => {
@@ -179,6 +188,7 @@ export class RabbitMQClient {
179
188
  console.log(`exchanges created on channel`);
180
189
  });
181
190
  })
191
+ // apply bindings
182
192
  .then(() => {
183
193
  const promises = bindings.map((config) => this.channel.bindQueue(config.queue, config.exchange, config.routingKey));
184
194
  // bind the exclusive queue to all the exchanges
@@ -263,8 +273,10 @@ export class RabbitMQClient {
263
273
  publishEvent: this.publishEvent.bind(this),
264
274
  };
265
275
 
266
- // send message to stream
276
+ // send message to general stream
267
277
  this.messagesStream.next(messageObj);
278
+ // send message to queue stream
279
+ this.messagesStreamsByQueue[queue]?.next(messageObj);
268
280
 
269
281
  // console.log(`Message on queue ${queue}:`, messageObj);
270
282
 
@@ -304,29 +316,35 @@ export class RabbitMQClient {
304
316
  }
305
317
  };
306
318
 
307
- const consumerTag = Date.now().toString();
319
+ this.channel.consume(queue, handleCallback, { ...(options || {}) });
320
+ }
321
+ }
308
322
 
309
- this.channel.consume(queue, handleCallback, { ...(options || {}), consumerTag: options?.consumerTag || consumerTag });
323
+ private listenToQueue(queue: string, options?: Options.Consume) {
324
+ if (this.queueListeners[queue]) {
325
+ console.log(`Already Registered messages/events listener for queue: ${queue}`);
326
+ return;
310
327
  }
328
+
329
+ console.log(`Registering messages/events listener for queue: ${queue}`);
330
+ const startQueueListener = this.getQueueListener(queue, options);
331
+
332
+ this.messagesStreamsByQueue[queue] = new Subject<RmqEventMessage>();
333
+ this.queueListeners[queue] = this.onReady.pipe(
334
+ tap((readyState) => {
335
+ startQueueListener()
336
+ })
337
+ )
338
+ .subscribe({
339
+ next: (readyState) => {
340
+ console.log(`Registered: Now listening to messages/events on queue ${queue}...`);
341
+ }
342
+ });
311
343
  }
312
344
 
313
345
  onQueue(queue: string, options?: Options.Consume) {
314
346
  // listen for messages on the queue
315
- if (!this.queueListeners[queue]) {
316
- console.log(`Registering messages/events listener for queue ${queue}:`);
317
- const startQueueListener = this.getQueueListener(queue, options);
318
-
319
- this.queueListeners[queue] = this.onReady.pipe(
320
- tap((readyState) => {
321
- startQueueListener()
322
- })
323
- )
324
- .subscribe({
325
- next: (readyState) => {
326
- console.log(`Registered: Now listening to messages/events on queue ${queue}...`);
327
- }
328
- });
329
- }
347
+ this.listenToQueue(queue, options);
330
348
 
331
349
  const handle = (messageType: string) => {
332
350
  return this.onReady.pipe(
@@ -367,6 +385,11 @@ export class RabbitMQClient {
367
385
  };
368
386
  }
369
387
 
388
+ forQueue(queue: string, options?: Options.Consume) {
389
+ this.listenToQueue(queue, options);
390
+ return this.messagesStreamsByQueue[queue].asObservable();
391
+ }
392
+
370
393
  ack(message: ConsumeMessage) {
371
394
  this.channel.ack(message);
372
395
  console.log(`Acknoledged rmq message.`);
package/src/types.ts CHANGED
@@ -11,7 +11,6 @@ import {
11
11
 
12
12
  export type MapType<T = any> = { [key:string]: T };
13
13
 
14
-
15
14
  export type RmqMessageTypeHandler = (event: RmqEventMessage) => Promise<void>;
16
15
  export type RmqHandleMessageTypeConfig = { messageName: string, callbackHandler: RmqMessageTypeHandler };
17
16
  export type RmqHandleMessageTypeConfigs = string[] | RmqHandleMessageTypeConfig[];
@@ -25,15 +24,25 @@ export interface QueueConfig {
25
24
  /*
26
25
  the event names
27
26
  */
28
- handleMessageTypes: RmqHandleMessageTypeConfigs,
27
+ handleMessageTypes?: RmqHandleMessageTypeConfigs,
29
28
 
30
29
  /*
31
30
 
32
31
  */
33
32
  options?: Options.AssertQueue
34
33
  }
35
- export interface ExchangeConfig { name: string, type: string, options?: Options.AssertExchange }
36
- export interface QueueExchangeBindingConfig { queue: string, exchange: string, routingKey: string }
34
+
35
+ export interface ExchangeConfig {
36
+ name: string,
37
+ type: string,
38
+ options?: Options.AssertExchange
39
+ }
40
+
41
+ export interface QueueExchangeBindingConfig {
42
+ queue: string,
43
+ exchange: string,
44
+ routingKey: string
45
+ }
37
46
 
38
47
  export type RmqEventRequestResponse <T = any> = Promise<RmqEventMessage<T>>;
39
48
 
@@ -68,6 +77,7 @@ export type RmqEventMessage<T = any> = {
68
77
  export type AckFn = (message: Message) => void;
69
78
 
70
79
  export type RabbitMqInitConfig = {
80
+ stopAutoInit: boolean,
71
81
  dontSendToReplyQueueOnPublish?: boolean,
72
82
  autoAckUnhandledMessageTypes?: boolean,
73
83
  pushUnhandledMessageTypesToDefaultHandler?: boolean,