@seidor-cloud-produtos/orbit-backend-lib 2.0.138 → 2.1.0

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-in-memory.d.ts

@@ -1,11 +1,40 @@
-import LoggerGateway, { LogOptions, LogParams, LogPropertiesInput } from '../../application/logger';
 import { Cache } from '../../../clean-arch/application/cache/cache';
+import LoggerGateway, { LogOptions, LogPropertiesInput } from '../../application/logger';
+import { LogOrbitParamsInput } from './logger-orbit';
 export interface LoggerInMemoryOptions extends LogOptions {
+    /**
+     * Quando `true`, inclui as propriedades do log na saída do console.
+     * Útil para depuração local.
+     */
     showProps?: boolean;
 }
+export type LoggerInMemoryProps = {
+    cache?: Cache;
+    options?: LoggerInMemoryOptions;
+    params?: LogOrbitParamsInput;
+};
+/**
+ * Logger simples que escreve no console.
+ *
+ * Observação: esta implementação NÃO persiste logs em memória.
+ * O nome "InMemory" refere-se ao uso local/leve, sem dependências externas.
+ */
 export declare class LoggerInMemory extends LoggerGateway {
     protected options: LoggerInMemoryOptions;
-    constructor(cache?: Cache, options?: LoggerInMemoryOptions, params?: LogParams);
+    /**
+     * @param cache Cache opcional para filtro de nível (pode ser em memória ou Redis).
+     * @param options Opções de comportamento do logger.
+     * @param params Parâmetros padrão de log (actor/type).
+     */
+    constructor(props?: LoggerInMemoryProps);
+    /**
+     * Delegado para o fluxo comum de LoggerGateway.
+     * Mantido como atalho para compatibilidade com outros loggers.
+     */
     log(props: LogPropertiesInput, dataToLog: any): Promise<void>;
+    /**
+     * Escreve no console usando o nível de log.
+     * Quando `showProps` é true, adiciona as props como último argumento.
+     */
     protected register(props: LogPropertiesInput, dataToLog: any): void;
 }

package/dist/clean-arch/infra/logger/logger-in-memory.js

@@ -4,13 +4,32 @@ exports.LoggerInMemory = void 0;
 const tslib_1 = require("tslib");
 const logger_1 = tslib_1.__importDefault(require("../../application/logger"));
 const types_1 = require("../environment/types");
+/**
+ * Logger simples que escreve no console.
+ *
+ * Observação: esta implementação NÃO persiste logs em memória.
+ * O nome "InMemory" refere-se ao uso local/leve, sem dependências externas.
+ */
 class LoggerInMemory extends logger_1.default {
-    constructor(cache, options, params) {
-        super(cache, options, params);
+    /**
+     * @param cache Cache opcional para filtro de nível (pode ser em memória ou Redis).
+     * @param options Opções de comportamento do logger.
+     * @param params Parâmetros padrão de log (actor/type).
+     */
+    constructor(props) {
+        super(props);
     }
+    /**
+     * Delegado para o fluxo comum de LoggerGateway.
+     * Mantido como atalho para compatibilidade com outros loggers.
+     */
     async log(props, dataToLog) {
         return await super.log(props, dataToLog);
     }
+    /**
+     * Escreve no console usando o nível de log.
+     * Quando `showProps` é true, adiciona as props como último argumento.
+     */
     register(props, dataToLog) {
         const args = dataToLog instanceof Array ? [...dataToLog] : [dataToLog];
         if (this.options?.showProps) {

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

@@ -1,21 +1,38 @@
-import Queue from '../../application/queue/queue';
+import { Cache } from '../../../clean-arch/application/cache/cache';
 import LoggerGateway, { ActorEnum, CategoryEnum, LogOptions, LogParams, LogProperties, LogPropertiesInput } from '../../application/logger';
+import Queue from '../../application/queue/queue';
 import DomainEvent from '../../domain/events/domain-event';
-import { Cache } from '../../../clean-arch/application/cache/cache';
+/**
+ * Opções adicionais do LoggerOrbit.
+ */
 export interface LoggerOrbitOptions extends LogOptions {
+    /**
+     * Quando `true`, falhas ao publicar o log geram exceção (`LogError`).
+     */
     throwOnError?: boolean;
+    /**
+     * Estratégia de retry executada quando a publicação falha.
+     */
     retryStrategy?: (data: any, props?: LogOrbitPropertiesInput, options?: LoggerOrbitOptions) => Promise<void>;
 }
+/**
+ * Propriedades de log aceitas pelo LoggerOrbit (entrada).
+ */
 export interface LogOrbitPropertiesInput extends LogPropertiesInput {
     id?: string;
     tenantId?: string;
     dateTime?: Date;
+    actorType?: ActorEnum;
+    category?: CategoryEnum;
     expirationHours?: number;
     trace?: {
         mainId?: string;
         ids: string[];
     };
 }
+/**
+ * Propriedades finais de log geradas pelo LoggerOrbit.
+ */
 export interface LogOrbitProperties extends LogProperties {
     id?: string;
     tenantId?: string;
@@ -27,29 +44,88 @@ export interface LogOrbitProperties extends LogProperties {
         ids: string[];
     };
 }
+/**
+ * Parâmetros padrão suportados pelo LoggerOrbit.
+ */
 export interface LogOrbitParams extends LogParams {
     actorType: ActorEnum;
     category: CategoryEnum;
     expirationHours: number;
 }
+export type LogOrbitParamsInput = Partial<LogOrbitParams>;
+/**
+ * Payload enviado para o serviço de logs.
+ *
+ * `expirationDate` é calculada a partir de `expirationHours`.
+ */
 export type LogPayload = Omit<LogProperties, 'expirationHours'> & {
     expirationDate: Date;
     details: any;
 };
+export type LoggerOrbitProps = {
+    cache?: Cache;
+    options?: LoggerOrbitOptions;
+    params?: LogOrbitParamsInput;
+};
+/**
+ * Evento de domínio enviado para o serviço de logs.
+ */
 export default class LogEvent implements DomainEvent {
     readonly input: LogPayload;
     readonly name = "log-service.log.created";
     readonly eventDate: Date;
     constructor(input: LogPayload);
 }
+/**
+ * Implementação de logger que publica logs em fila (AMQP).
+ *
+ * - Publica em exchange `log-service.direct`.
+ * - Força logging para categoria BUSINESS.
+ * - Permite retry e opção de falhar com exceção.
+ */
 export declare class LoggerOrbit extends LoggerGateway {
     private queue;
     protected options: LoggerOrbitOptions;
-    protected params?: LogOrbitParams;
-    constructor(queue: Queue, cache?: Cache, options?: LoggerOrbitOptions, params?: LogOrbitParams);
+    protected params?: LogOrbitParamsInput;
+    constructor(queue: Queue, props?: LoggerOrbitProps);
+    /**
+     * Loga um evento (atalho para `super.log`).
+     */
     log(props: LogOrbitPropertiesInput, dataToLog: any): Promise<void>;
+    /**
+     * Determina se deve logar.
+     *
+     * - Usa o filtro padrão do LoggerGateway.
+     * - Força logging se a categoria for BUSINESS.
+     */
     protected isToLog(props: LogOrbitProperties, dataToLog: any): Promise<boolean>;
+    /**
+     * Registra o log publicando na fila.
+     *
+     * Em caso de falha:
+     * - Executa `retryStrategy` se existir.
+     * - Lança `LogError` se `throwOnError` estiver habilitado.
+     */
     register(props: LogOrbitProperties, data: any): Promise<void>;
+    /**
+     * Monta o payload final para publicação.
+     *
+     * Converte `expirationHours` em `expirationDate` e coloca o conteúdo
+     * original em `details`.
+     */
     private buildPayload;
-    protected buildDefaultProps(params?: LogOrbitParams): LogOrbitProperties;
+    /**
+     * Propriedades padrão do LoggerOrbit.
+     *
+     * - category: TECHNICAL
+     * - actorType: SYSTEM
+     * - expirationHours: 4 * 7 dias
+     */
+    protected buildDefaultProps(params?: LogOrbitParamsInput): LogOrbitProperties;
+}
+export declare class AuditOrbitLoggerGateway {
+    private static instance;
+    protected constructor();
+    static getInstance(queue: Queue, props?: LoggerOrbitProps): LoggerOrbit;
+    private static buildProps;
 }

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

@@ -1,9 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LoggerOrbit = void 0;
+exports.AuditOrbitLoggerGateway = exports.LoggerOrbit = void 0;
 const tslib_1 = require("tslib");
 const logger_1 = tslib_1.__importStar(require("../../application/logger"));
 const log_error_1 = tslib_1.__importDefault(require("../../domain/errors/log-error"));
+/**
+ * Evento de domínio enviado para o serviço de logs.
+ */
 class LogEvent {
     input;
     name = 'log-service.log.created';
@@ -13,23 +16,46 @@ class LogEvent {
     }
 }
 exports.default = LogEvent;
+/**
+ * Implementação de logger que publica logs em fila (AMQP).
+ *
+ * - Publica em exchange `log-service.direct`.
+ * - Força logging para categoria BUSINESS.
+ * - Permite retry e opção de falhar com exceção.
+ */
 class LoggerOrbit extends logger_1.default {
     queue;
-    constructor(queue, cache, options, params) {
-        super(cache, options, params);
+    constructor(queue, props) {
+        super(props);
         this.queue = queue;
     }
+    /**
+     * Loga um evento (atalho para `super.log`).
+     */
     async log(props, dataToLog) {
         return await super.log(props, dataToLog);
     }
+    /**
+     * Determina se deve logar.
+     *
+     * - Usa o filtro padrão do LoggerGateway.
+     * - Força logging se a categoria for BUSINESS.
+     */
     async isToLog(props, dataToLog) {
         return ((await super.isToLog(props, dataToLog)) ||
             props.category === logger_1.CategoryEnum.BUSINESS);
     }
+    /**
+     * Registra o log publicando na fila.
+     *
+     * Em caso de falha:
+     * - Executa `retryStrategy` se existir.
+     * - Lança `LogError` se `throwOnError` estiver habilitado.
+     */
     async register(props, data) {
         try {
             const payload = this.buildPayload(props, data);
-            await this.queue.publish('logservice.common.direct', new LogEvent(payload));
+            await this.queue.publish('log-service.direct', new LogEvent(payload));
         }
         catch (error) {
             if (this.options?.retryStrategy) {
@@ -40,6 +66,12 @@ class LoggerOrbit extends logger_1.default {
             }
         }
     }
+    /**
+     * Monta o payload final para publicação.
+     *
+     * Converte `expirationHours` em `expirationDate` e coloca o conteúdo
+     * original em `details`.
+     */
     buildPayload(props, dataToLog) {
         const { expirationHours, ...buildedProperties } = props;
         const now = new Date();
@@ -50,14 +82,39 @@ class LoggerOrbit extends logger_1.default {
             details: dataToLog,
         };
     }
+    /**
+     * Propriedades padrão do LoggerOrbit.
+     *
+     * - category: TECHNICAL
+     * - actorType: SYSTEM
+     * - expirationHours: 4 * 7 dias
+     */
     buildDefaultProps(params) {
         const sevenDaysInHours = 168;
         return {
-            ...super.buildDefaultProps(),
-            category: params?.category || logger_1.CategoryEnum.TECHNICAL,
+            category: logger_1.CategoryEnum.TECHNICAL,
             actorType: logger_1.ActorEnum.SYSTEM,
             expirationHours: sevenDaysInHours * 4,
+            ...super.buildDefaultProps(params),
         };
     }
 }
 exports.LoggerOrbit = LoggerOrbit;
+class AuditOrbitLoggerGateway {
+    static instance;
+    constructor() { }
+    static getInstance(queue, props) {
+        if (!this.instance) {
+            this.instance = new LoggerOrbit(queue, this.buildProps(props));
+        }
+        return this.instance;
+    }
+    static buildProps(props = {}) {
+        props.options = props.options || {
+            throwOnError: false,
+            lastArgIsParams: true,
+        };
+        return props;
+    }
+}
+exports.AuditOrbitLoggerGateway = AuditOrbitLoggerGateway;

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 {};