npm - @candlerip/shared3 - Versions diffs - 0.0.101 → 0.0.102 - Mend

@@ -0,0 +1,70 @@
+import amqp from 'amqplib';
+import { consoleCustomError, customErrorWorker } from '../../../error/index.js';
+export const MessageBrokerSingleton = (() => {
+    let _channel;
+    let _connection;
+    let _errorMessage = 'Initializing MessageBroker';
+    let _url;
+    let _customErrorWorker;
+    const checkErrorStatus = () => {
+        if (_errorMessage) {
+            return _customErrorWorker.composeCustomError(_errorMessage);
+        }
+        return;
+    };
+    const connect = async () => {
+        try {
+            _connection = await amqp.connect(_url);
+            _connection.on('error', (_err) => {
+                handleError(_err);
+            });
+            _channel = await _connection.createChannel();
+            _errorMessage = null;
+        }
+        catch (err) {
+            handleError(err);
+        }
+    };
+    const handleError = (err) => {
+        _customErrorWorker.addInfo({ err });
+        _errorMessage = 'Error connect Rabbitmq';
+        setTimeout(connect, 10000);
+    };
+    const init = (url) => {
+        _url = url;
+        _customErrorWorker = customErrorWorker({ url });
+        connect();
+    };
+    const listenQueue = async (queue, onMessage) => {
+        const resp = checkErrorStatus();
+        if (resp) {
+            consoleCustomError(resp.customError);
+            console.error('QUEUE:', queue);
+            setTimeout(() => listenQueue(queue, onMessage), 10000);
+            return;
+        }
+        await _channel.assertQueue(queue, { durable: true });
+        _channel.consume(queue, (msg) => {
+            if (msg) {
+                onMessage(JSON.parse(msg.content.toString()));
+                _channel.ack(msg);
+            }
+        });
+    };
+    const sendMessage = async (queueName, message) => {
+        const resp = checkErrorStatus();
+        if (resp) {
+            consoleCustomError(resp.customError);
+            console.error('QUEUE:', queueName);
+            console.error('MESSAGE:', message);
+            return;
+        }
+        await _channel.assertQueue(queueName, { durable: true });
+        _channel.sendToQueue(queueName, Buffer.from(JSON.stringify(message)));
+    };
+    return {
+        init,
+        listenQueue,
+        sendMessage,
+    };
+})();

@@ -0,0 +1,12 @@
+import { MessageBrokerRefreshCache } from '../message-broker-refresh-cache/index.js';
+import { MessageBrokerQueueName } from '../message-broker-queue-name/index.js';
+import { MESSAGE_BROKER_CONFIG } from './config.js';
+import { CustomError } from '../../../error/index.js';
+export type MessageBroker = {
+    [key in MessageBrokerQueueName]: TypeMap[(typeof MESSAGE_BROKER_CONFIG)[key]];
+};
+interface TypeMap {
+    'MessageBrokerRefreshCache | null': MessageBrokerRefreshCache | null;
+    CustomError: CustomError;
+}
+export {};

@@ -0,0 +1,6 @@
+import { MessageBrokerSingleton } from '../../message-broker/index.js';
+export const refreshCache = (cacheKeys) => MessageBrokerSingleton.sendMessage('cache-service:refresh-cache', cacheKeys
+    ? {
+        cacheKeys,
+    }
+    : null);

@@ -0,0 +1,4 @@
+import { CacheKey } from '../../cache/index.js';
+export type MessageBrokerRefreshCache = {
+    cacheKeys: CacheKey[];
+};

	@@ -0,0 +1,2 @@
1	+ import { MESSAGE_BROKER_CONFIG } from '../message-broker/config.js';
2	+ export type MessageBrokerQueueName = keyof typeof MESSAGE_BROKER_CONFIG;

	@@ -0,0 +1,2 @@
1	+ export * from './type.js';
2	+ export * from './refresh-cache/index.js';

	@@ -0,0 +1,2 @@
1	+ import { CacheKey } from '../../../cache/index.js';
2	+ export type RefreshCache = (cacheKeys?: CacheKey[]) => Promise<void>;

	@@ -0,0 +1,2 @@
1	+ import { RefreshCache } from './type.js';
2	+ export declare const refreshCache: RefreshCache;

@candlerip/shared3 0.0.101 → 0.0.102