@seidor-cloud-produtos/orbit-backend-lib 2.0.110 → 2.0.112

package/dist/clean-arch/infra/orbit-http-client/orbit-axios-client/orbit-axios-client.spec.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const vitest_1 = require("vitest");
+const httpClient = {
+    get: vitest_1.vi.fn(),
+    post: vitest_1.vi.fn(),
+};
+vitest_1.vi.mock('axios', () => ({
+    default: {
+        create: vitest_1.vi.fn(() => httpClient),
+    },
+}));
+const axios_1 = tslib_1.__importDefault(require("axios"));
+const http_error_1 = tslib_1.__importDefault(require("../../../domain/errors/http-error"));
+const orbit_axios_client_1 = require("./orbit-axios-client");
+class TestOrbitAxiosClient extends orbit_axios_client_1.OrbitAxiosClient {
+    getTarget() {
+        return 'target-service';
+    }
+    getBaseUrl() {
+        return 'https://example.com';
+    }
+    async sendPost() {
+        return await this.post({
+            endpoint: '/partners',
+            body: { id: '1' },
+            config: {
+                headers: {
+                    authorization: 'token',
+                },
+            },
+        });
+    }
+    async sendGet() {
+        return await this.get({
+            endpoint: '/partners',
+            config: {
+                headers: {
+                    authorization: 'token',
+                },
+                query: {
+                    page: '1',
+                },
+            },
+        });
+    }
+}
+describe('OrbitAxiosClient', () => {
+    afterEach(() => {
+        vitest_1.vi.clearAllMocks();
+    });
+    it('should create the axios instance with the target header', () => {
+        new TestOrbitAxiosClient();
+        expect(axios_1.default.create).toHaveBeenCalledWith({
+            baseURL: 'https://example.com',
+            headers: {
+                target: 'target-service',
+            },
+        });
+    });
+    it('should map successful POST and GET responses', async () => {
+        const client = new TestOrbitAxiosClient();
+        httpClient.post.mockResolvedValue({
+            data: { id: '1' },
+            status: 201,
+            headers: {
+                'content-type': 'application/json',
+            },
+        });
+        httpClient.get.mockResolvedValue({
+            data: [{ id: '1' }],
+            status: 200,
+            headers: {
+                'content-type': 'application/json',
+            },
+        });
+        await expect(client.sendPost()).resolves.toEqual({
+            body: { id: '1' },
+            code: 201,
+            headers: {
+                'content-type': 'application/json',
+            },
+        });
+        await expect(client.sendGet()).resolves.toEqual({
+            body: [{ id: '1' }],
+            code: 200,
+            headers: {
+                'content-type': 'application/json',
+            },
+        });
+        expect(httpClient.post).toHaveBeenCalledWith('/partners', { id: '1' }, {
+            headers: {
+                authorization: 'token',
+            },
+        });
+        expect(httpClient.get).toHaveBeenCalledWith('/partners', {
+            headers: {
+                authorization: 'token',
+            },
+            params: {
+                page: '1',
+            },
+        });
+    });
+    it('should convert axios errors into HttpError', async () => {
+        const client = new TestOrbitAxiosClient();
+        httpClient.post.mockRejectedValue({
+            response: {
+                data: {
+                    message: 'Integration failed',
+                },
+                headers: {
+                    'x-request-id': 'request-id',
+                },
+                status: 502,
+            },
+        });
+        await expect(client.sendPost()).rejects.toBeInstanceOf(http_error_1.default);
+        await expect(client.sendPost()).rejects.toEqual(expect.objectContaining({
+            message: 'Integration failed',
+            code: 502,
+            response: {
+                body: {
+                    message: 'Integration failed',
+                },
+                headers: {
+                    'x-request-id': 'request-id',
+                },
+                code: 502,
+            },
+        }));
+    });
+    it('should use the default HttpError message and code when axios error is incomplete', async () => {
+        const client = new TestOrbitAxiosClient();
+        httpClient.get.mockRejectedValue({});
+        await expect(client.sendGet()).rejects.toBeInstanceOf(http_error_1.default);
+        await expect(client.sendGet()).rejects.toEqual(expect.objectContaining({
+            message: 'Integration error',
+            code: 400,
+        }));
+    });
+});

package/dist/clean-arch/infra/orbit-notification-client/discord-client.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clean-arch/infra/orbit-notification-client/discord-client.spec.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const sendMock = vitest_1.vi.fn().mockResolvedValue(undefined);
+const destroyMock = vitest_1.vi.fn();
+const setAuthorMock = vitest_1.vi.fn().mockReturnThis();
+const setColorMock = vitest_1.vi.fn().mockReturnThis();
+const setTitleMock = vitest_1.vi.fn().mockReturnThis();
+const setDescriptionMock = vitest_1.vi.fn().mockReturnThis();
+vitest_1.vi.mock('discord.js', () => ({
+    EmbedBuilder: vitest_1.vi.fn().mockImplementation(() => ({
+        setAuthor: setAuthorMock,
+        setColor: setColorMock,
+        setTitle: setTitleMock,
+        setDescription: setDescriptionMock,
+    })),
+    WebhookClient: vitest_1.vi.fn().mockImplementation(() => ({
+        send: sendMock,
+        destroy: destroyMock,
+    })),
+}));
+const discord_js_1 = require("discord.js");
+const discord_client_1 = require("./discord-client");
+class TestDiscordClient extends discord_client_1.OrbitDiscordNotificationClient {
+    getId() {
+        return 'discord-id';
+    }
+    getToken() {
+        return 'discord-token';
+    }
+}
+describe('OrbitDiscordNotificationClient', () => {
+    afterEach(() => {
+        vitest_1.vi.clearAllMocks();
+    });
+    it('should send error notifications through the webhook client', async () => {
+        const client = new TestDiscordClient();
+        await client.sendErrorNotification('API', 'Failure', 'Stacktrace');
+        expect(discord_js_1.WebhookClient).toHaveBeenCalledWith({
+            id: 'discord-id',
+            token: 'discord-token',
+        });
+        expect(discord_js_1.EmbedBuilder).toHaveBeenCalledTimes(1);
+        expect(setAuthorMock).toHaveBeenCalledWith({ name: 'API' });
+        expect(setTitleMock).toHaveBeenCalledWith('Failure');
+        expect(setDescriptionMock).toHaveBeenCalledWith('```Stacktrace```');
+        expect(sendMock).toHaveBeenCalledWith({
+            embeds: [expect.any(Object)],
+        });
+        expect(destroyMock).toHaveBeenCalledTimes(1);
+    });
+    it('should swallow webhook errors', async () => {
+        const client = new TestDiscordClient();
+        sendMock.mockRejectedValueOnce(new Error('failed'));
+        await expect(client.sendErrorNotification('API', 'Failure', 'Stacktrace')).resolves.toBeUndefined();
+        expect(destroyMock).not.toHaveBeenCalled();
+    });
+});

package/dist/clean-arch/infra/queue/queue-utils.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clean-arch/infra/queue/queue-utils.spec.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const vitest_1 = require("vitest");
+vitest_1.vi.mock('child_process', () => ({
+    fork: vitest_1.vi.fn(),
+}));
+const child_process_1 = require("child_process");
+const handler_1 = tslib_1.__importDefault(require("../../application/queue/handler"));
+const create_consumers_1 = tslib_1.__importDefault(require("./create-consumers"));
+const create_queues_1 = tslib_1.__importDefault(require("./create-queues"));
+const in_memory_queue_1 = tslib_1.__importDefault(require("./in-memory/in-memory-queue"));
+const queue_controller_1 = tslib_1.__importDefault(require("./queue-controller"));
+const worker_1 = tslib_1.__importDefault(require("./worker"));
+class TestHandler extends handler_1.default {
+    handleMock = vitest_1.vi.fn().mockResolvedValue(undefined);
+    constructor(simultaneity = 1, timeoutPerMessageSeconds) {
+        super();
+        this.simultaneity = simultaneity;
+        this.timeoutPerMessageSeconds = timeoutPerMessageSeconds;
+    }
+    async handle(message) {
+        await this.handleMock(message);
+    }
+}
+class TestQueueController extends queue_controller_1.default {
+    eventHandlers = [
+        {
+            queueName: 'queue-1',
+            callback: Promise.resolve(new TestHandler()),
+        },
+        {
+            queueName: 'queue-2',
+            callback: Promise.resolve(new TestHandler()),
+        },
+    ];
+}
+class TestCreateConsumers extends create_consumers_1.default {
+    consumers = [
+        {
+            queueName: 'queue-1',
+            configs: { durable: true },
+        },
+        {
+            queueName: 'queue-2',
+            configs: { durable: false },
+        },
+    ];
+}
+class TestCreateQueues extends create_queues_1.default {
+}
+(0, vitest_1.describe)('Queue helpers', () => {
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.useFakeTimers();
+    });
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.useRealTimers();
+        vitest_1.vi.restoreAllMocks();
+    });
+    (0, vitest_1.it)('should expose simultaneity and timeout from handlers', () => {
+        const handler = new TestHandler(3, 10);
+        (0, vitest_1.expect)(handler.getSimultaneity()).toBe(3);
+        (0, vitest_1.expect)(handler.getTimeoutPerMessageSeconds()).toBe(10);
+    });
+    (0, vitest_1.it)('should publish and consume matching in-memory queue messages', async () => {
+        const queue = new in_memory_queue_1.default();
+        const event = {
+            name: 'queue-1',
+            eventDate: new Date(),
+        };
+        const otherEvent = {
+            name: 'queue-2',
+            eventDate: new Date(),
+        };
+        const handler = new TestHandler();
+        await queue.publish('exchange', event);
+        await queue.publish('exchange', otherEvent);
+        await queue.on('queue-1', handler);
+        (0, vitest_1.expect)(handler.handleMock).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(handler.handleMock).toHaveBeenCalledWith({
+            exchangeName: 'exchange',
+            domainEvent: event,
+        });
+    });
+    (0, vitest_1.it)('should register all queue consumers', async () => {
+        const queue = {
+            on: vitest_1.vi.fn().mockResolvedValue(undefined),
+        };
+        const controller = new TestQueueController(queue);
+        await controller.runConsumers();
+        (0, vitest_1.expect)(queue.on).toHaveBeenCalledTimes(2);
+        (0, vitest_1.expect)(queue.on).toHaveBeenNthCalledWith(1, 'queue-1', vitest_1.expect.any(TestHandler));
+        (0, vitest_1.expect)(queue.on).toHaveBeenNthCalledWith(2, 'queue-2', vitest_1.expect.any(TestHandler));
+    });
+    (0, vitest_1.it)('should create consumer topology when supported', async () => {
+        const queue = {
+            createConsumers: vitest_1.vi.fn().mockResolvedValue(undefined),
+        };
+        const controller = new TestCreateConsumers(queue);
+        await controller.createConsumers();
+        (0, vitest_1.expect)(queue.createConsumers).toHaveBeenCalledTimes(2);
+        (0, vitest_1.expect)(queue.createConsumers).toHaveBeenNthCalledWith(1, 'queue-1', {
+            durable: true,
+        });
+        (0, vitest_1.expect)(queue.createConsumers).toHaveBeenNthCalledWith(2, 'queue-2', {
+            durable: false,
+        });
+    });
+    (0, vitest_1.it)('should skip consumer topology when not supported', async () => {
+        const queue = {};
+        const controller = new TestCreateConsumers(queue);
+        await (0, vitest_1.expect)(controller.createConsumers()).resolves.toBeUndefined();
+    });
+    (0, vitest_1.it)('should create queues when supported', async () => {
+        const queue = {
+            createQueues: vitest_1.vi.fn().mockResolvedValue(undefined),
+        };
+        const controller = new TestCreateQueues(queue, [
+            { name: 'queue-1', configs: { durable: true } },
+            { name: 'queue-2', configs: { durable: false } },
+        ]);
+        await controller.createQueues();
+        (0, vitest_1.expect)(queue.createQueues).toHaveBeenCalledTimes(2);
+        (0, vitest_1.expect)(queue.createQueues).toHaveBeenNthCalledWith(1, 'queue-1', {
+            durable: true,
+        });
+        (0, vitest_1.expect)(queue.createQueues).toHaveBeenNthCalledWith(2, 'queue-2', {
+            durable: false,
+        });
+    });
+    (0, vitest_1.it)('should skip queue creation when not supported', async () => {
+        const queue = {};
+        const controller = new TestCreateQueues(queue, [
+            { name: 'queue-1', configs: { durable: true } },
+        ]);
+        await (0, vitest_1.expect)(controller.createQueues()).resolves.toBeUndefined();
+    });
+    (0, vitest_1.it)('should restart forked workers until the retry limit', async () => {
+        const on = vitest_1.vi.fn();
+        const child = {
+            on,
+            pid: 321,
+        };
+        const consoleLog = vitest_1.vi
+            .spyOn(console, 'log')
+            .mockImplementation(() => undefined);
+        const consoleError = vitest_1.vi
+            .spyOn(console, 'error')
+            .mockImplementation(() => undefined);
+        vitest_1.vi.mocked(child_process_1.fork).mockReturnValue(child);
+        const worker = new worker_1.default('/tmp/worker.js');
+        worker.fWorker();
+        (0, vitest_1.expect)(child_process_1.fork).toHaveBeenCalledWith('/tmp/worker.js');
+        const onError = on.mock.calls.find(([event]) => event === 'error')?.[1];
+        const onExit = on.mock.calls.find(([event]) => event === 'exit')?.[1];
+        onError?.(new Error('boom'));
+        (0, vitest_1.expect)(consoleError).toHaveBeenCalledWith('⛔ Child process 321 error :', vitest_1.expect.any(Error));
+        onExit?.(1);
+        await vitest_1.vi.runOnlyPendingTimersAsync();
+        (0, vitest_1.expect)(child_process_1.fork).toHaveBeenCalledTimes(2);
+        for (let attempt = 2; attempt <= 6; attempt++) {
+            const currentChild = vitest_1.vi.mocked(child_process_1.fork).mock.results[attempt - 2]?.value || child;
+            const exitHandler = currentChild.on.mock.calls.find(([event]) => event === 'exit')?.[1];
+            exitHandler?.(1);
+            await vitest_1.vi.runOnlyPendingTimersAsync();
+        }
+        (0, vitest_1.expect)(consoleLog).toHaveBeenCalledWith('🔄 Restarting worker process... Attempt 1 of 5');
+        (0, vitest_1.expect)(consoleError).toHaveBeenCalledWith('⛔ Max restart attempts reached. Not restarting worker process 321. Container restart required!');
+    });
+});

package/dist/clean-arch/infra/queue/rabbitmq/amqp-lib.js

@@ -33,8 +33,8 @@ class AmqpQueue {
      */
     setSocketOptions(socketOptions) {
         this.socketOptions = {
-            ...(socketOptions || {}),
             maxStoredMessagesOnError: 500,
+            ...(socketOptions || {}),
         };
         return this;
     }
@@ -76,7 +76,7 @@ class AmqpQueue {
             }
             this.logger.info(`Retrying connection in... ${this.socketOptions.retry.intervalMs || 0}ms`);
             await (0, timeout_1.sleep)(this.socketOptions.retry.intervalMs);
-            return await this.connect(vHost, retryCount++);
+            return await this.connect(vHost, retryCount + 1);
         }
     }
     /**
@@ -202,7 +202,7 @@ class AmqpQueue {
                 error: err,
             });
             if (buildedConfigs.storeMessageOnError === false ||
-                (this.socketOptions?.maxStoredMessagesOnError || 0) <
+                (this.socketOptions?.maxStoredMessagesOnError || 0) <=
                     this.messagesInMemory.length) {
                 return;
             }
@@ -280,7 +280,7 @@ class AmqpQueue {
                 TTLms: sevenDaysInMs,
             };
         }
-        return await this.createConsumers(queueName, configs);
+        return await this.createConsumers(queueName, buildedConfigs);
     }
     /**
      * Retorna uma instância singleton conectada ao vHost informado.