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

package/dist/clean-arch/infra/http/controller.spec.js

@@ -1,60 +1,179 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
+const api_error_1 = require("../../../infra/http/errors/api-error");
+const application_error_1 = tslib_1.__importDefault(require("../../domain/errors/application-error"));
 const conflict_error_1 = tslib_1.__importDefault(require("../../domain/errors/conflict-error"));
+const domain_error_1 = tslib_1.__importDefault(require("../../domain/errors/domain-error"));
+const validation_error_1 = tslib_1.__importDefault(require("../../domain/errors/validation-error"));
+const not_allowed_1 = tslib_1.__importDefault(require("../authorizations/not-allowed"));
+const infra_error_1 = tslib_1.__importDefault(require("../errors/infra-error"));
 const controller_1 = tslib_1.__importDefault(require("./controller"));
-test('conflict error with one object', async () => {
-    class ControllerError extends controller_1.default {
-        async handle() {
-            try {
-                throw new conflict_error_1.default({ id: 'ID' });
-            }
-            catch (err) {
-                return this.throw(err);
-            }
-        }
+class TestController extends controller_1.default {
+    async handle() {
+        return this.success({ ok: true });
     }
-    const executeController = new ControllerError();
-    const responseError = await executeController.handle();
-    expect(responseError).toEqual(expect.objectContaining({
-        code: 409,
-        data: {
-            code: 409,
-            message: 'Entity already exists.',
-            items: [
-                {
-                    id: 'ID',
-                },
-            ],
-        },
-    }));
-});
-test('conflict error with array of objects', async () => {
-    class ControllerError extends controller_1.default {
-        async handle() {
-            try {
-                throw new conflict_error_1.default([{ id: 'ID 1' }, { id: 'ID 2' }]);
-            }
-            catch (err) {
-                return this.throw(err);
-            }
-        }
+    successResponse(dto) {
+        return this.success(dto);
+    }
+    noContentResponse() {
+        return this.noContent();
     }
-    const executeController = new ControllerError();
-    const responseError = await executeController.handle();
-    expect(responseError).toEqual(expect.objectContaining({
-        code: 409,
-        data: {
+    createdResponse(dto) {
+        return this.created(dto);
+    }
+    paginatedResponse(dto) {
+        return this.paginated(dto);
+    }
+}
+describe('Controller', () => {
+    it('should build success responses', () => {
+        const controller = new TestController();
+        expect(controller.successResponse({ id: '1' })).toEqual({
+            code: 200,
+            data: { data: { id: '1' } },
+        });
+        expect(controller.noContentResponse()).toEqual({
+            code: 204,
+            data: undefined,
+        });
+        expect(controller.createdResponse({ id: '1' })).toEqual({
+            code: 201,
+            data: { data: { id: '1' } },
+        });
+        expect(controller.createdResponse()).toEqual({
+            code: 201,
+            data: undefined,
+        });
+        expect(controller.paginatedResponse({ items: [1, 2] })).toEqual({
+            code: 200,
+            data: { items: [1, 2] },
+        });
+    });
+    it('should return conflict error response with one object', () => {
+        const controller = new TestController();
+        expect(controller.throw(new conflict_error_1.default({ id: 'ID' }))).toEqual({
+            code: 409,
+            data: {
+                code: 409,
+                message: 'Entity already exists.',
+                items: [{ id: 'ID' }],
+            },
+        });
+    });
+    it('should return conflict error response with array of objects', () => {
+        const controller = new TestController();
+        expect(controller.throw(new conflict_error_1.default([{ id: 'ID 1' }, { id: 'ID 2' }]))).toEqual({
             code: 409,
-            message: 'Entity already exists.',
-            items: [
-                {
-                    id: 'ID 1',
-                },
-                {
-                    id: 'ID 2',
-                },
-            ],
-        },
-    }));
+            data: {
+                code: 409,
+                message: 'Entity already exists.',
+                items: [{ id: 'ID 1' }, { id: 'ID 2' }],
+            },
+        });
+    });
+    it.each([
+        [new domain_error_1.default('domain failed', 422), 422, 'domain failed'],
+        [
+            new application_error_1.default('application failed', 401),
+            401,
+            'application failed',
+        ],
+        [new infra_error_1.default('infra failed', 503), 503, 'infra failed'],
+    ])('should map known error types with code and message', (error, code, message) => {
+        const controller = new TestController();
+        expect(controller.throw(error)).toEqual({
+            code,
+            data: {
+                code,
+                message,
+            },
+        });
+    });
+    it('should map api errors', () => {
+        const controller = new TestController();
+        const error = new api_error_1.ApiError({
+            status: 401,
+            body: {
+                code: 401,
+                message: 'Unauthorized',
+                timestamp: new Date('2024-01-01T00:00:00.000Z'),
+                errors: [
+                    {
+                        code_error: '401',
+                        location: 'authorization',
+                        msg: 'Unauthorized',
+                    },
+                ],
+            },
+            headers: {},
+        });
+        expect(controller.throw(error)).toEqual({
+            code: 401,
+            data: error.error,
+        });
+    });
+    it('should map validation errors', () => {
+        const controller = new TestController();
+        const error = new validation_error_1.default([
+            {
+                property: 'email',
+                message: 'Required field',
+            },
+        ]);
+        expect(controller.throw(error)).toEqual({
+            code: 400,
+            data: {
+                code: 400,
+                message: 'Validation Error',
+                errors: [
+                    {
+                        property: 'email',
+                        message: 'Required field',
+                    },
+                ],
+            },
+        });
+    });
+    it('should map not allowed errors', () => {
+        const controller = new TestController();
+        const error = new not_allowed_1.default({
+            status: 403,
+            body: {
+                code: 403,
+                message: 'Forbidden',
+                timestamp: new Date('2024-02-02T00:00:00.000Z'),
+                errors: [
+                    {
+                        code_error: '403',
+                        location: 'authorization',
+                        msg: 'Forbidden',
+                    },
+                ],
+            },
+            headers: {
+                'content-type': 'application/json',
+            },
+        });
+        expect(controller.throw(error)).toEqual({
+            code: 403,
+            data: error.error,
+        });
+    });
+    it('should map unexpected errors to internal server error', () => {
+        const controller = new TestController();
+        const unexpectedError = new Error('boom');
+        const consoleError = vi
+            .spyOn(console, 'error')
+            .mockImplementation(() => undefined);
+        expect(controller.throw(unexpectedError)).toEqual({
+            code: 500,
+            data: {
+                code: 500,
+                message: 'Server failed. Contact the administrator!',
+                reason: unexpectedError,
+            },
+        });
+        expect(consoleError).toHaveBeenCalledWith(unexpectedError);
+    });
 });

package/dist/clean-arch/infra/http/helpers.spec.d.ts

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

package/dist/clean-arch/infra/http/helpers.spec.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const health_connections_1 = tslib_1.__importDefault(require("./health-connections"));
+const handle_authorizer_headers_1 = require("./handle-authorizer-headers");
+const handle_bool_filter_1 = tslib_1.__importDefault(require("./handle-bool-filter"));
+const handle_is_active_query_1 = tslib_1.__importDefault(require("./handle-is-active-query"));
+const handle_sort_param_query_1 = require("./handle-sort-param-query");
+const handle_user_headers_1 = require("./handle-user-headers");
+const filter_1 = require("../../../infra/http/compression/filter");
+describe('HTTP helpers', () => {
+    it('should convert boolean filters', () => {
+        expect((0, handle_bool_filter_1.default)()).toBeUndefined();
+        expect((0, handle_bool_filter_1.default)('true')).toBe(true);
+        expect((0, handle_bool_filter_1.default)('false')).toBe(false);
+        expect((0, handle_is_active_query_1.default)()).toBeUndefined();
+        expect((0, handle_is_active_query_1.default)('true')).toBe(true);
+        expect((0, handle_is_active_query_1.default)('false')).toBe(false);
+    });
+    it('should map sort params to entity props', () => {
+        expect((0, handle_sort_param_query_1.handleSortParamQuery)('created_at')).toBe('createdAt');
+        expect((0, handle_sort_param_query_1.handleSortParamQuery)('updated_at')).toBe('updatedAt');
+        expect((0, handle_sort_param_query_1.handleSortParamQuery)('is_main')).toBe('isMain');
+        expect((0, handle_sort_param_query_1.handleSortParamQuery)('other')).toBe('createdAt');
+    });
+    it('should normalize authorizer headers and legacy headers', () => {
+        expect((0, handle_authorizer_headers_1.handleAuthorizerHeaders)({
+            username: 'John',
+            useremail: 'john@example.com',
+            userid: 'user-id',
+            ['app-id']: 'app-id',
+            ['app-name']: 'Portal',
+            tenantid: 'tenant-id',
+            ['x-trace-id']: 'trace-id',
+        })).toEqual({
+            userName: 'John',
+            userEmail: 'john@example.com',
+            appName: 'Portal',
+            entityId: 'user-id',
+            tenantId: 'tenant-id',
+            traceId: 'trace-id',
+        });
+        expect((0, handle_authorizer_headers_1.handleAuthorizerHeaders)({
+            username: 'John',
+            useremail: 'john@example.com',
+            ['app-id']: 'app-id',
+            tenantid: 'tenant-id',
+            ['x-trace-id']: 'trace-id',
+        })).toEqual({
+            userName: 'John',
+            userEmail: 'john@example.com',
+            appName: undefined,
+            entityId: 'app-id',
+            tenantId: 'tenant-id',
+            traceId: 'trace-id',
+        });
+        expect((0, handle_authorizer_headers_1.handleAuthorizerHeaders)({
+            username: 'John',
+            useremail: 'john@example.com',
+            tenantid: 'tenant-id',
+            ['x-trace-id']: 'trace-id',
+        })).toEqual({
+            userName: 'John',
+            userEmail: 'john@example.com',
+            appName: undefined,
+            entityId: 'john@example.com',
+            tenantId: 'tenant-id',
+            traceId: 'trace-id',
+        });
+        expect((0, handle_authorizer_headers_1.authorizerToLegacyDefaultHeaders)({
+            userName: 'John',
+            userEmail: 'john@example.com',
+            appName: 'Portal',
+            tenantId: 'tenant-id',
+            entityId: 'user-id',
+            traceId: 'trace-id',
+        })).toEqual({
+            createdByEmail: 'john@example.com',
+            createdByName: 'Portal',
+            updatedByEmail: 'john@example.com',
+            updatedByName: 'Portal',
+        });
+        expect((0, handle_authorizer_headers_1.authorizerToLegacyDefaultHeaders)({
+            userName: 'John',
+            userEmail: 'john@example.com',
+            tenantId: 'tenant-id',
+            entityId: 'user-id',
+        })).toEqual({
+            createdByEmail: 'john@example.com',
+            createdByName: 'John',
+            updatedByEmail: 'john@example.com',
+            updatedByName: 'John',
+        });
+    });
+    it('should normalize user headers', () => {
+        expect((0, handle_user_headers_1.handleUserHeaders)({
+            username: 'John',
+            useremail: 'john@example.com',
+            userid: 'user-id',
+            ['app-id']: 'app-id',
+            tenantid: 'tenant-id',
+        })).toEqual({
+            createdByName: 'John',
+            createdByEmail: 'john@example.com',
+            updatedByEmail: 'john@example.com',
+            updatedByName: 'John',
+            entityId: 'user-id',
+            tenantId: 'tenant-id',
+        });
+        expect((0, handle_user_headers_1.handleUserHeaders)({
+            username: 'John',
+            useremail: 'john@example.com',
+            ['app-id']: 'app-id',
+            tenantid: 'tenant-id',
+        })).toEqual({
+            createdByName: 'John',
+            createdByEmail: 'john@example.com',
+            updatedByEmail: 'john@example.com',
+            updatedByName: 'John',
+            entityId: 'app-id',
+            tenantId: 'tenant-id',
+        });
+    });
+    it('should delegate the health check to the database dependency', async () => {
+        const checkDB = {
+            dbIsOnline: vi.fn().mockResolvedValue(true),
+        };
+        const health = new health_connections_1.default(checkDB);
+        await expect(health.check()).resolves.toEqual({ dbIsOnline: true });
+        expect(checkDB.dbIsOnline).toHaveBeenCalledTimes(1);
+    });
+    it('should define if the payload must be compressed', () => {
+        expect((0, filter_1.isToCompress)({ 'accept-encoding': 'identity' })).toBe(true);
+        expect((0, filter_1.isToCompress)({ 'accept-encoding': 'gzip' })).toBe(false);
+    });
+});

package/dist/clean-arch/infra/http/net.spec.d.ts

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

package/dist/clean-arch/infra/http/net.spec.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const vitest_1 = require("vitest");
+vitest_1.vi.mock('axios', () => ({
+    default: {
+        get: vitest_1.vi.fn(),
+    },
+}));
+const axios_1 = tslib_1.__importDefault(require("axios"));
+const net_1 = require("./net");
+describe('Net', () => {
+    it('should return the current IP when the request succeeds', async () => {
+        vitest_1.vi.mocked(axios_1.default.get).mockResolvedValue({
+            data: '127.0.0.1\n',
+        });
+        const net = new net_1.Net();
+        await expect(net.getCurrentIP()).resolves.toBe('127.0.0.1');
+        expect(axios_1.default.get).toHaveBeenCalledWith('https://checkip.amazonaws.com/', {
+            timeout: 1000,
+        });
+    });
+    it('should return invalid when the request fails', async () => {
+        const consoleLog = vitest_1.vi
+            .spyOn(console, 'log')
+            .mockImplementation(() => undefined);
+        vitest_1.vi.mocked(axios_1.default.get).mockRejectedValue(new Error('fail'));
+        const net = new net_1.Net();
+        await expect(net.getCurrentIP()).resolves.toBe('invalid');
+        expect(consoleLog).toHaveBeenCalledWith(expect.any(Error));
+    });
+    it('should validate if the current IP is in the whitelist', async () => {
+        const net = new net_1.Net();
+        vitest_1.vi.spyOn(net, 'getCurrentIP').mockResolvedValue('127.0.0.1');
+        await expect(net.isCurrentIPInIPWhiteList(['127.0.0.1', '10.0.0.1'])).resolves.toBe(true);
+        await expect(net.isCurrentIPInIPWhiteList(['10.0.0.1', '10.0.0.2'])).resolves.toBe(false);
+    });
+    it('should ignore invalid IPs when configured', async () => {
+        const net = new net_1.Net();
+        vitest_1.vi.spyOn(net, 'getCurrentIP').mockResolvedValue('invalid');
+        await expect(net.isCurrentIPInIPWhiteList(['10.0.0.1'], true)).resolves.toBe(true);
+        await expect(net.isCurrentIPInIPWhiteList(['10.0.0.1'], false)).resolves.toBe(false);
+        expect(net.isIP('127.0.0.1')).toBe(4);
+        expect(net.isIP('invalid')).toBe(0);
+    });
+});

package/dist/clean-arch/infra/logger/logger-orbit.d.ts

@@ -22,6 +22,8 @@ export interface LogOrbitPropertiesInput extends LogPropertiesInput {
     id?: string;
     tenantId?: string;
     dateTime?: Date;
+    actorType?: ActorEnum;
+    category?: CategoryEnum;
     expirationHours?: number;
     trace?: {
         mainId?: string;

package/dist/clean-arch/infra/logger/logger-orbit.spec.d.ts

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

package/dist/clean-arch/infra/logger/logger-orbit.spec.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const vitest_1 = require("vitest");
+const logger_1 = require("../../application/logger");
+const log_error_1 = tslib_1.__importDefault(require("../../domain/errors/log-error"));
+const types_1 = require("../environment/types");
+const logger_orbit_1 = tslib_1.__importStar(require("./logger-orbit"));
+const createQueue = () => ({
+    on: vitest_1.vi.fn().mockResolvedValue(undefined),
+    publish: vitest_1.vi.fn().mockResolvedValue(undefined),
+});
+(0, vitest_1.describe)('LoggerOrbit', () => {
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.useRealTimers();
+        vitest_1.vi.restoreAllMocks();
+        logger_orbit_1.AuditOrbitLoggerGateway.instance = undefined;
+    });
+    (0, vitest_1.it)('should publish business logs even when the cached level would block them', async () => {
+        const queue = createQueue();
+        const cache = {
+            get: vitest_1.vi.fn().mockResolvedValue(types_1.LOG_LEVEL.error),
+            getKeys: vitest_1.vi.fn().mockResolvedValue(['LOG_LEVEL:*:*']),
+            set: vitest_1.vi.fn(),
+        };
+        const logger = new logger_orbit_1.LoggerOrbit(queue, {
+            cache: cache,
+            params: {
+                actor: 'system',
+                type: 'log',
+            },
+        });
+        await logger.log({
+            level: types_1.LOG_LEVEL.info,
+            category: logger_1.CategoryEnum.BUSINESS,
+            actorType: logger_1.ActorEnum.SYSTEM,
+            expirationHours: 1,
+        }, { id: 'business-log' });
+        await logger.log({
+            level: types_1.LOG_LEVEL.info,
+            category: logger_1.CategoryEnum.TECHNICAL,
+            actorType: logger_1.ActorEnum.SYSTEM,
+            expirationHours: 1,
+        }, { id: 'technical-log' });
+        (0, vitest_1.expect)(queue.publish).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(queue.publish).toHaveBeenCalledWith('log-service.direct', vitest_1.expect.any(logger_orbit_1.default));
+    });
+    (0, vitest_1.it)('should build default props and publish payloads with expiration dates', async () => {
+        vitest_1.vi.useFakeTimers();
+        vitest_1.vi.setSystemTime(new Date('2024-01-01T00:00:00.000Z'));
+        const queue = createQueue();
+        const logger = new logger_orbit_1.LoggerOrbit(queue, {
+            params: {
+                actor: 'system',
+                type: 'log',
+            },
+        });
+        const props = logger['buildDefaultProps']({
+            actor: 'system',
+            type: 'log',
+        });
+        await logger.register(props, { id: '1' });
+        const publishedEvent = queue.publish.mock.calls[0][1];
+        (0, vitest_1.expect)(props).toEqual(vitest_1.expect.objectContaining({
+            actor: 'system',
+            type: 'log',
+            level: types_1.LOG_LEVEL.info,
+            actorType: logger_1.ActorEnum.SYSTEM,
+            category: logger_1.CategoryEnum.TECHNICAL,
+            expirationHours: 672,
+        }));
+        (0, vitest_1.expect)(publishedEvent.name).toBe('log-service.log.created');
+        (0, vitest_1.expect)(publishedEvent.eventDate).toEqual(new Date('2024-01-01T00:00:00.000Z'));
+        (0, vitest_1.expect)(publishedEvent.input).toEqual(vitest_1.expect.objectContaining({
+            actor: 'system',
+            type: 'log',
+            level: types_1.LOG_LEVEL.info,
+            actorType: logger_1.ActorEnum.SYSTEM,
+            category: logger_1.CategoryEnum.TECHNICAL,
+            details: { id: '1' },
+            expirationDate: new Date('2024-01-29T00:00:00.000Z'),
+        }));
+    });
+    (0, vitest_1.it)('should execute retry strategies and throw LogError when configured', async () => {
+        const queue = createQueue();
+        const retryStrategy = vitest_1.vi.fn().mockResolvedValue(undefined);
+        const logger = new logger_orbit_1.LoggerOrbit(queue, {
+            options: {
+                retryStrategy,
+            },
+            params: {
+                actor: 'system',
+                type: 'log',
+            },
+        });
+        queue.publish.mockRejectedValueOnce(new Error('publish failed'));
+        await logger.register(logger['buildDefaultProps']({
+            actor: 'system',
+            type: 'log',
+        }), { id: '2' });
+        (0, vitest_1.expect)(retryStrategy).toHaveBeenCalledWith({ id: '2' }, vitest_1.expect.any(Object));
+        const failingLogger = new logger_orbit_1.LoggerOrbit(queue, {
+            options: {
+                throwOnError: true,
+            },
+        });
+        queue.publish.mockRejectedValueOnce(new Error('publish failed'));
+        await (0, vitest_1.expect)(failingLogger.register(failingLogger['buildDefaultProps'](), {
+            id: '3',
+        })).rejects.toThrow(log_error_1.default);
+    });
+    (0, vitest_1.it)('should reuse the singleton and apply default Orbit logger options', () => {
+        const queue = createQueue();
+        const first = logger_orbit_1.AuditOrbitLoggerGateway.getInstance(queue);
+        const second = logger_orbit_1.AuditOrbitLoggerGateway.getInstance(queue);
+        (0, vitest_1.expect)(first).toBe(second);
+        (0, vitest_1.expect)(first.options).toEqual({
+            throwOnError: false,
+            lastArgIsParams: true,
+        });
+    });
+});

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

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