rxjs-rabbitmq 2.2.0 → 2.2.1

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/src/types.ts CHANGED
@@ -11,10 +11,11 @@ import {
11
11
 
12
12
  export type MapType<T = any> = { [key:string]: T };
13
13
 
14
- export type RmqMessageTypeHandler = (event: RmqEventMessage) => Promise<void>;
14
+ export type RmqMessageTypeHandler = (event: RmqEventMessage) => Promise<void> | void;
15
15
  export type RmqHandleMessageTypeConfig = { messageName: string, callbackHandler: RmqMessageTypeHandler };
16
16
  export type RmqHandleMessageTypeConfigs = string[] | RmqHandleMessageTypeConfig[];
17
17
  export type ExchangeType = 'direct' | 'topic' | 'headers' | 'fanout';
18
+ export type RmqPayload = unknown;
18
19
 
19
20
 
20
21
  export interface QueueConfig {
@@ -100,38 +101,62 @@ export interface QueueExchangeBindingConfig {
100
101
 
101
102
  export type RmqEventRequestResponse <T = any> = Promise<RmqEventMessage<T>>;
102
103
 
103
- export type RmqSendMessageParams = {
104
+ export type RmqSendMessageParams<T = unknown> = {
104
105
  queue: string,
105
- data: any,
106
+ data: T,
106
107
  publishOptions: Options.Publish
107
108
  }
108
109
 
109
- export type RmqSendRequestParams = {
110
+ export type RmqSendRequestParams<T = unknown> = {
110
111
  queue: string,
111
- data: any,
112
+ data: T,
112
113
  publishOptions: Options.Publish,
113
114
  }
114
115
 
115
- export type RmqPublishEventParams<T = any> = {
116
+ export type RmqPublishEventParams<T = unknown> = {
116
117
  exchange: string,
117
118
  data: T,
118
119
  routingKey?: string,
119
120
  publishOptions: Options.Publish
120
121
  }
121
122
 
122
- export type RmqEventMessage<T = any> = {
123
+ export type RmqEventMessage<T = unknown> = {
123
124
  data: T,
124
125
  message: ConsumeMessage,
125
126
  ack: () => void;
126
127
  publishEvent: (options: RmqPublishEventParams) => void,
127
- sendMessage: (options: RmqSendMessageParams) => void,
128
- sendRequest: <T = any> (options: RmqSendRequestParams) => Promise<RmqEventMessage<T>>,
128
+ sendMessage: <U = unknown>(options: RmqSendMessageParams<U>) => void,
129
+ sendRequest: <U = unknown>(options: RmqSendRequestParams<U>) => Promise<RmqEventMessage<U>>,
129
130
  };
130
131
 
131
- export type RmqEventHandler = (event: RmqEventMessage) => any;
132
+ export type RmqEventHandler = (event: RmqEventMessage) => unknown;
132
133
 
133
134
  export type AckFn = (message: Message) => void;
134
135
 
136
+ export type RabbitMqLogger = {
137
+ debug: (...args: any[]) => void;
138
+ info: (...args: any[]) => void;
139
+ warn: (...args: any[]) => void;
140
+ error: (...args: any[]) => void;
141
+ };
142
+
143
+ export type RabbitMqMetrics = {
144
+ messagesReceived: number;
145
+ messagesPublished: number;
146
+ messagesAcked: number;
147
+ messagesNacked: number;
148
+ messagesRetried: number;
149
+ rpcRequests: number;
150
+ rpcResponses: number;
151
+ reconnects: number;
152
+ };
153
+
154
+ export type RabbitMqSerializer = {
155
+ serialize: (value: unknown) => Buffer;
156
+ deserialize: (value: Buffer, encoding?: BufferEncoding) => unknown;
157
+ };
158
+
159
+ export type RabbitMqSerializerMap = Record<string, RabbitMqSerializer>;
135
160
 
136
161
  /**
137
162
 
@@ -145,6 +170,9 @@ export type RabbitMqInitConfig = {
145
170
  dontSendToReplyQueueOnPublish?: boolean,
146
171
  autoAckUnhandledMessageTypes?: boolean,
147
172
  pushUnhandledMessageTypesToDefaultHandler?: boolean,
173
+ logger?: Partial<RabbitMqLogger>,
174
+ metrics?: boolean,
175
+ rpcRequestTimeoutMs?: number,
148
176
  delayStart?: number,
149
177
  connection_url: string,
150
178
  retryAttempts: number,
package/src/utils.ts CHANGED
@@ -1,7 +1,7 @@
1
- import { MapType } from "./types";
1
+ import { MapType, RabbitMqSerializer, RabbitMqSerializerMap } from "./types";
2
2
 
3
3
  // https://github.com/Foo-Foo-MQ/foo-foo-mq/blob/main/src/index.js
4
- export const SERIALIZERS = {
4
+ export const SERIALIZERS: RabbitMqSerializerMap = {
5
5
  'application/json': {
6
6
  deserialize: (bytes: any, encoding: any) => {
7
7
  return JSON.parse(bytes.toString(encoding || 'utf8'));
@@ -31,12 +31,21 @@ export const SERIALIZERS = {
31
31
  deserialize: (bytes: any, encoding: any) => {
32
32
  return bytes.toString(encoding || 'utf8');
33
33
  },
34
- serialize: (str: string) => {
35
- return Buffer.from(str, 'utf8');
34
+ serialize: (value: unknown) => {
35
+ return Buffer.from(String(value), 'utf8');
36
36
  }
37
37
  }
38
38
  };
39
39
 
40
+ export const registerSerializer = (contentType: string, serializer: RabbitMqSerializer) => {
41
+ SERIALIZERS[contentType] = serializer;
42
+ return SERIALIZERS[contentType];
43
+ };
44
+
45
+ export const getSerializer = (contentType: string) => {
46
+ return SERIALIZERS[contentType] || null;
47
+ };
48
+
40
49
  export const mapify = <T> (list: T[], key: string | number): MapType<T> => {
41
50
  return list.reduce((map: MapType<T>, item: T) => {
42
51
  map[ item[key] ] = item;
@@ -0,0 +1,49 @@
1
+ const test = require('node:test');
2
+ const assert = require('node:assert/strict');
3
+ const { RabbitMQClient, registerSerializer } = require('../dist');
4
+
5
+ test('client supports clean shutdown and metrics inspection without a live connection', async () => {
6
+ const client = new RabbitMQClient({
7
+ stopAutoInit: true,
8
+ metrics: true,
9
+ connection_url: 'amqp://localhost',
10
+ retryAttempts: 1,
11
+ retryDelay: 50,
12
+ queues: [],
13
+ exchanges: [],
14
+ bindings: []
15
+ });
16
+
17
+ assert.deepEqual(client.getMetrics(), {
18
+ messagesReceived: 0,
19
+ messagesPublished: 0,
20
+ messagesAcked: 0,
21
+ messagesNacked: 0,
22
+ messagesRetried: 0,
23
+ rpcRequests: 0,
24
+ rpcResponses: 0,
25
+ reconnects: 0
26
+ });
27
+
28
+ await assert.doesNotReject(() => client.close());
29
+ });
30
+
31
+ test('custom serializers can be registered and used', () => {
32
+ const contentType = 'application/test+json';
33
+
34
+ const serializer = {
35
+ serialize: (value) => Buffer.from(JSON.stringify(value)),
36
+ deserialize: (bytes) => JSON.parse(bytes.toString('utf8'))
37
+ };
38
+
39
+ assert.doesNotThrow(() => {
40
+ registerSerializer(contentType, serializer);
41
+ RabbitMQClient.registerSerializer(contentType, serializer);
42
+ });
43
+
44
+ const payload = { ok: true, count: 2 };
45
+ assert.deepEqual(
46
+ registerSerializer(contentType, serializer).deserialize(registerSerializer(contentType, serializer).serialize(payload)),
47
+ payload
48
+ );
49
+ });