rxjs-rabbitmq 2.1.9 → 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/README.md +416 -65
- package/dist/rabbitmq-client.helper.d.ts +34 -2
- package/dist/rabbitmq-client.helper.js +262 -81
- package/dist/rabbitmq-client.helper.js.map +1 -1
- package/dist/types.d.ts +36 -10
- package/dist/utils.d.ts +4 -16
- package/dist/utils.js +12 -3
- package/dist/utils.js.map +1 -1
- package/package.json +2 -2
- package/src/rabbitmq-client.helper.ts +309 -95
- package/src/types.ts +38 -10
- package/src/utils.ts +13 -4
- package/test/rabbitmq-client.test.js +49 -0
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:
|
|
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:
|
|
112
|
+
data: T,
|
|
112
113
|
publishOptions: Options.Publish,
|
|
113
114
|
}
|
|
114
115
|
|
|
115
|
-
export type RmqPublishEventParams<T =
|
|
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 =
|
|
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: <
|
|
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) =>
|
|
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: (
|
|
35
|
-
return Buffer.from(
|
|
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
|
+
});
|