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

package/dist/clean-arch/application/cache/cache.spec.d.ts

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

package/dist/clean-arch/application/cache/cache.spec.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cache_1 = require("./cache");
+const client_1 = require("./client");
+class MemoryCacheClient extends client_1.CacheClient {
+    startMock = vi.fn().mockResolvedValue(undefined);
+    closeMock = vi.fn().mockResolvedValue(undefined);
+    getMock = vi.fn();
+    setMock = vi.fn().mockResolvedValue(undefined);
+    delMock = vi.fn().mockResolvedValue(undefined);
+    delBatchMock = vi.fn().mockResolvedValue(undefined);
+    getKeysMock = vi.fn().mockResolvedValue([]);
+    flushMock = vi.fn().mockResolvedValue(undefined);
+    async start() {
+        await this.startMock();
+    }
+    async close() {
+        await this.closeMock();
+    }
+    async get(keyCache) {
+        return await this.getMock(keyCache);
+    }
+    async set(keyCache, data, expiration) {
+        await this.setMock(keyCache, data, expiration);
+    }
+    async del(keyCache) {
+        await this.delMock(keyCache);
+    }
+    async delBatch(keyCache) {
+        await this.delBatchMock(keyCache);
+    }
+    async getKeys(pattern) {
+        return await this.getKeysMock(pattern);
+    }
+    async flush() {
+        await this.flushMock();
+    }
+}
+class TestCache extends cache_1.Cache {
+    client = new MemoryCacheClient();
+    get currentClient() {
+        return this.client;
+    }
+}
+const createLogger = () => ({
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    debug: vi.fn(),
+});
+describe('Cache base', () => {
+    it('should perform the happy path operations', async () => {
+        const logger = createLogger();
+        const cache = new TestCache(undefined, logger);
+        cache.currentClient.getMock.mockResolvedValueOnce({ id: '1' });
+        cache.currentClient.getKeysMock.mockResolvedValueOnce(['cache:key']);
+        await cache.start();
+        await expect(cache.get('cache:key')).resolves.toEqual({ id: '1' });
+        await expect(cache.set('cache:key', { id: '1' }, 10)).resolves.toBeUndefined();
+        await expect(cache.del('cache:key')).resolves.toBeUndefined();
+        await expect(cache.getKeys('cache:*')).resolves.toEqual(['cache:key']);
+        await expect(cache.delBatch(['cache:key'])).resolves.toBeUndefined();
+        await expect(cache.flush()).resolves.toBeUndefined();
+        cache.currentClient.getMock.mockResolvedValueOnce({ ping: true });
+        await expect(cache.isRunning()).resolves.toBe(true);
+        await cache.close();
+        expect(cache.currentClient.startMock).toHaveBeenCalledTimes(1);
+        expect(cache.currentClient.setMock).toHaveBeenNthCalledWith(1, 'cache:key', JSON.stringify({ id: '1' }), 10);
+        expect(cache.currentClient.delMock).toHaveBeenCalledWith('cache:key');
+        expect(cache.currentClient.delBatchMock).toHaveBeenCalledWith([
+            'cache:key',
+        ]);
+        expect(cache.currentClient.flushMock).toHaveBeenCalledTimes(1);
+        expect(cache.currentClient.closeMock).toHaveBeenCalledTimes(1);
+        expect(logger.info).toHaveBeenCalledWith('💾 Cache Connected');
+        expect(logger.info).toHaveBeenCalledWith('💾 Cache closed');
+    });
+    it('should fetch, cache and reuse values', async () => {
+        const cache = new TestCache();
+        const promise = vi.fn().mockResolvedValue({ id: '1' });
+        cache.currentClient.getMock
+            .mockResolvedValueOnce(null)
+            .mockResolvedValueOnce({ id: '1' });
+        await expect(cache.getOrFetchAndCache('cache:key', 15, promise)).resolves.toEqual({ id: '1' });
+        await expect(cache.getOrFetchAndCache('cache:key', 15, promise)).resolves.toEqual({ id: '1' });
+        expect(promise).toHaveBeenCalledTimes(1);
+        expect(cache.currentClient.setMock).toHaveBeenCalledWith('cache:key', JSON.stringify({ id: '1' }), 15);
+    });
+    it('should return safe fallbacks when operations fail without throwOnError', async () => {
+        const cache = new TestCache();
+        cache.currentClient.getMock.mockRejectedValue(new Error('get failed'));
+        cache.currentClient.setMock.mockRejectedValue(new Error('set failed'));
+        cache.currentClient.delMock.mockRejectedValue(new Error('del failed'));
+        cache.currentClient.getKeysMock.mockRejectedValue(new Error('keys failed'));
+        cache.currentClient.delBatchMock.mockRejectedValue(new Error('batch failed'));
+        cache.currentClient.closeMock.mockRejectedValue(new Error('close failed'));
+        cache.currentClient.getMock.mockResolvedValueOnce(false);
+        await expect(cache.get('cache:key')).resolves.toBeNull();
+        await expect(cache.set('cache:key', { id: '1' })).resolves.toBeUndefined();
+        await expect(cache.del('cache:key')).resolves.toBeUndefined();
+        await expect(cache.getKeys('cache:*')).resolves.toBeNull();
+        await expect(cache.delBatch(['cache:key'])).resolves.toBeUndefined();
+        await expect(cache.close()).resolves.toBeUndefined();
+    });
+    it('should throw when throwOnError is enabled', async () => {
+        const logger = createLogger();
+        const cache = new TestCache(undefined, logger);
+        cache.currentClient.getMock.mockRejectedValue(new Error('get failed'));
+        await expect(cache.get('cache:key', { throwOnError: true })).rejects.toThrow('get failed');
+        expect(logger.error).toHaveBeenCalledWith(JSON.stringify(new Error('get failed')));
+    });
+    it('should switch to a running contingency client', async () => {
+        const logger = createLogger();
+        const cache = new TestCache(undefined, logger);
+        const primary = cache.currentClient;
+        const contingency = new MemoryCacheClient();
+        primary.getMock.mockResolvedValue(false);
+        contingency.getMock.mockResolvedValue({ ping: true });
+        cache.elegibleClients = [contingency, primary];
+        await expect(cache.isRunning()).resolves.toBe(true);
+        expect(primary.closeMock).toHaveBeenCalledTimes(1);
+        expect(logger.warn).toHaveBeenCalledWith('Changed cache client to MemoryCacheClient');
+        expect(cache.client).toBe(contingency);
+    });
+    it('should tolerate failed start with a single eligible client', async () => {
+        const logger = createLogger();
+        const cache = new TestCache(undefined, logger);
+        cache.options = { throwOnError: false };
+        cache.elegibleClients = [cache.currentClient];
+        cache.currentClient.startMock.mockRejectedValueOnce(new Error('start failed'));
+        await expect(cache.start()).resolves.toBeUndefined();
+        expect(logger.warn).not.toHaveBeenCalled();
+    });
+    it('should ignore contingency discovery errors while switching cache clients', async () => {
+        const logger = createLogger();
+        const cache = new TestCache(undefined, logger);
+        const primary = cache.currentClient;
+        const brokenContingency = new MemoryCacheClient();
+        const healthyContingency = new MemoryCacheClient();
+        cache.options = { throwOnError: false };
+        cache.elegibleClients = [
+            brokenContingency,
+            healthyContingency,
+            primary,
+        ];
+        primary.startMock.mockRejectedValueOnce(new Error('primary start failed'));
+        primary.closeMock.mockRejectedValueOnce(new Error('primary close failed'));
+        brokenContingency.startMock.mockRejectedValueOnce(new Error('contingency start failed'));
+        healthyContingency.getMock.mockResolvedValue({ ping: true });
+        await expect(cache.start()).resolves.toBeUndefined();
+        expect(cache.client).toBe(healthyContingency);
+        expect(brokenContingency.startMock).toHaveBeenCalledTimes(1);
+        expect(brokenContingency.closeMock).toHaveBeenCalledTimes(1);
+        expect(primary.closeMock).toHaveBeenCalledTimes(1);
+        expect(logger.warn).toHaveBeenCalledWith('Changed cache client to MemoryCacheClient');
+    });
+    it('should return false when health checks fail without throwOnError', async () => {
+        const logger = createLogger();
+        const cache = new TestCache(undefined, logger);
+        cache.options = { throwOnError: false };
+        cache.elegibleClients = [cache.currentClient];
+        cache.currentClient.setMock.mockRejectedValue(new Error('ping failed'));
+        await expect(cache.isRunning()).resolves.toBe(false);
+    });
+    it('should throw when close fails and throwOnError is enabled', async () => {
+        const logger = createLogger();
+        const cache = new TestCache(undefined, logger);
+        cache.currentClient.closeMock.mockRejectedValue(new Error('close failed'));
+        await expect(cache.close({ throwOnError: true })).rejects.toThrowError('close failed');
+        expect(logger.error).toHaveBeenCalledWith(JSON.stringify(new Error('close failed')));
+    });
+    it('should verify if a cache client is running with a ping key', async () => {
+        const client = new MemoryCacheClient({ timeout: 5 });
+        client.getMock.mockResolvedValue({ ping: true });
+        await expect(client.isRunning()).resolves.toBe(true);
+        expect(client.setMock).toHaveBeenCalledWith(expect.any(String), JSON.stringify({ ping: true }), 5);
+    });
+});

package/dist/clean-arch/application/consistency-event-dispatcher/consistency-event-dispatcher.d.ts

@@ -1,7 +1,7 @@
-import { AuthorizerHeaders } from '../../infra/http/handle-authorizer-headers';
 import { Entity } from '../../domain/entities/entity';
 import ConsistencyEvent from '../../domain/events/consistency-event/consistency-event';
 import { EventsName } from '../../domain/events/consistency-event/events-enum';
+import { AuthorizerHeaders } from '../../infra/http/handle-authorizer-headers';
 export declare abstract class ConsistencyEventDispatcher {
     dispatch(entity: Entity<any>, authorizerHeaders: AuthorizerHeaders, eventName: EventsName): Promise<void>;
     dispatchBatch(entities: Entity<any>[], authorizerHeaders: AuthorizerHeaders, eventName: EventsName): Promise<void>;

package/dist/clean-arch/application/logger/logger.spec.d.ts

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

package/dist/clean-arch/application/logger/logger.spec.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const types_1 = require("../../infra/environment/types");
+const logger_in_memory_1 = require("../../infra/logger/logger-in-memory");
+const base_audit_logger_1 = require("./base-audit-logger");
+const index_1 = tslib_1.__importStar(require("./index"));
+class TestLogger extends index_1.default {
+    registerMock = vi.fn().mockResolvedValue(undefined);
+    register(props, dataToLog) {
+        return this.registerMock(props, dataToLog);
+    }
+    async exposeIsToLog(props, dataToLog) {
+        return await this.isToLog(props, dataToLog);
+    }
+    exposeBuildProps(props, params) {
+        return this.buildProps(props, params);
+    }
+}
+class TestAuditLogger extends base_audit_logger_1.BaseAuditLogger {
+    exposeBuildParams(type, authorizerHeaders, trace) {
+        return this.buildParams(type, authorizerHeaders, trace);
+    }
+    async exposeInfo(payload, params) {
+        await this.info(payload, params);
+    }
+}
+describe('Logger base', () => {
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('should build props and split params from the last argument', async () => {
+        const logger = new TestLogger({
+            options: {
+                lastArgIsParams: true,
+            },
+            params: {
+                actor: 'default-actor',
+                type: 'default-type',
+            },
+        });
+        await logger.log({ level: types_1.LOG_LEVEL.warn }, [
+            'payload',
+            { actor: 'custom-actor', type: 'custom-type' },
+        ]);
+        expect(logger.registerMock).toHaveBeenCalledWith(expect.objectContaining({
+            level: types_1.LOG_LEVEL.warn,
+            actor: 'custom-actor',
+            type: 'custom-type',
+            dateTime: expect.any(Date),
+        }), 'payload');
+    });
+    it('should evaluate log levels using the cache filters', async () => {
+        const cache = {
+            getKeys: vi
+                .fn()
+                .mockResolvedValue(['LOG_LEVEL:test-type:*', 'LOG_LEVEL:*:*']),
+            get: vi.fn().mockResolvedValue(types_1.LOG_LEVEL.info),
+            set: vi.fn(),
+        };
+        const logger = new TestLogger({
+            cache: cache,
+            params: {
+                actor: 'test-actor',
+                type: 'test-type',
+            },
+        });
+        await expect(logger.exposeIsToLog({
+            level: types_1.LOG_LEVEL.warn,
+            actor: 'test-actor',
+            type: 'test-type',
+            dateTime: new Date(),
+        }, ['payload'])).resolves.toBe(true);
+        await expect(logger.exposeIsToLog({
+            level: types_1.LOG_LEVEL.debug,
+            actor: 'test-actor',
+            type: 'test-type',
+            dateTime: new Date(),
+        }, [])).resolves.toBe(false);
+        await logger.setLevel(types_1.LOG_LEVEL.debug, {
+            logActor: 'user',
+            logType: 'partner',
+        });
+        expect(cache.set).toHaveBeenCalledWith('LOG_LEVEL:partner:user', types_1.LOG_LEVEL.debug, 345600);
+    });
+    it('should fallback to default props and swallow logging errors', async () => {
+        const consoleError = vi
+            .spyOn(console, 'error')
+            .mockImplementation(() => undefined);
+        const consoleLog = vi
+            .spyOn(console, 'log')
+            .mockImplementation(() => undefined);
+        const logger = new TestLogger();
+        logger.registerMock.mockRejectedValue(new Error('register failed'));
+        expect(logger.exposeBuildProps(undefined, undefined)).toEqual(expect.objectContaining({
+            level: types_1.LOG_LEVEL.info,
+            actor: 'default',
+            type: 'default',
+            dateTime: expect.any(Date),
+        }));
+        await expect(logger.log({ level: types_1.LOG_LEVEL.info }, 'payload')).resolves.toBeUndefined();
+        expect(consoleError).toHaveBeenCalledWith('Error in log', expect.any(Error));
+        expect(consoleLog).toHaveBeenCalledWith('Input', { level: types_1.LOG_LEVEL.info }, 'payload');
+    });
+    it('should prefer exact cached filters and expose the level helpers', async () => {
+        const cache = {
+            getKeys: vi
+                .fn()
+                .mockResolvedValue(['LOG_LEVEL:*:*', 'LOG_LEVEL:test-type:test-actor']),
+            get: vi.fn().mockImplementation(async (key) => {
+                return key === 'LOG_LEVEL:test-type:test-actor'
+                    ? types_1.LOG_LEVEL.debug
+                    : types_1.LOG_LEVEL.error;
+            }),
+            set: vi.fn(),
+        };
+        const logger = new TestLogger({
+            cache: cache,
+            params: {
+                actor: 'test-actor',
+                type: 'test-type',
+            },
+        });
+        await logger.info('info-payload');
+        await logger.warn('warn-payload');
+        await logger.error('error-payload');
+        await logger.debug('debug-payload');
+        expect(cache.get).toHaveBeenCalledWith('LOG_LEVEL:test-type:test-actor');
+        expect(logger.registerMock).toHaveBeenCalledTimes(4);
+        expect(logger.registerMock).toHaveBeenNthCalledWith(1, expect.objectContaining({ level: types_1.LOG_LEVEL.info }), ['info-payload']);
+        expect(logger.registerMock).toHaveBeenNthCalledWith(4, expect.objectContaining({ level: types_1.LOG_LEVEL.debug }), ['debug-payload']);
+    });
+    it('should skip setLevel when no cache is configured', async () => {
+        const logger = new TestLogger();
+        await expect(logger.setLevel(types_1.LOG_LEVEL.warn, {
+            logActor: 'user',
+            logType: 'partner',
+        })).resolves.toBeUndefined();
+    });
+});
+describe('LoggerInMemory', () => {
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('should dispatch console calls according to the log level', () => {
+        const consoleInfo = vi
+            .spyOn(console, 'info')
+            .mockImplementation(() => undefined);
+        const consoleWarn = vi
+            .spyOn(console, 'warn')
+            .mockImplementation(() => undefined);
+        const consoleError = vi
+            .spyOn(console, 'error')
+            .mockImplementation(() => undefined);
+        const consoleDebug = vi
+            .spyOn(console, 'debug')
+            .mockImplementation(() => undefined);
+        const logger = new logger_in_memory_1.LoggerInMemory({
+            options: {
+                showProps: true,
+            },
+        });
+        logger['register']({ level: types_1.LOG_LEVEL.info }, 'payload');
+        logger['register']({ level: types_1.LOG_LEVEL.warn }, ['payload']);
+        logger['register']({ level: types_1.LOG_LEVEL.error }, 'payload');
+        logger['register']({ level: types_1.LOG_LEVEL.debug }, 'payload');
+        expect(consoleInfo).toHaveBeenCalledWith('payload', {
+            level: types_1.LOG_LEVEL.info,
+        });
+        expect(consoleWarn).toHaveBeenCalled();
+        expect(consoleError).toHaveBeenCalled();
+        expect(consoleDebug).toHaveBeenCalled();
+    });
+});
+describe('Audit loggers', () => {
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('should build audit params and delegate info logs', async () => {
+        const gateway = {
+            info: vi.fn().mockResolvedValue(undefined),
+        };
+        const logger = new TestAuditLogger(gateway);
+        const trace = { ids: [] };
+        const params = logger.exposeBuildParams('partner-created', {
+            entityId: 'user-id',
+            tenantId: 'tenant-id',
+            traceId: 'trace-id',
+        }, trace);
+        expect(params).toEqual({
+            type: 'partner-created',
+            trace: {
+                ids: ['trace-id'],
+            },
+            actor: 'user-id',
+            tenantId: 'tenant-id',
+            actorType: index_1.ActorEnum.USER,
+            category: index_1.CategoryEnum.BUSINESS,
+            expirationHours: 43800,
+        });
+        await logger.exposeInfo({ id: '1' }, params);
+        expect(gateway.info).toHaveBeenCalledWith({ payload: { id: '1' } }, params);
+    });
+});

package/dist/clean-arch/domain/entities/entity.spec.d.ts

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

package/dist/clean-arch/domain/entities/entity.spec.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const aggregate_root_1 = require("./aggregate-root");
+const entity_1 = require("./entity");
+const unique_entity_id_1 = require("./unique-entity-id");
+const value_object_1 = require("./value-object");
+const watched_list_1 = require("./watched-list");
+class StringWatchedList extends watched_list_1.WatchedList {
+    compareItems(a, b) {
+        return a === b;
+    }
+}
+class TestEntity extends entity_1.Entity {
+    constructor(props, id) {
+        super(props, id);
+    }
+}
+class TestAggregate extends aggregate_root_1.AggregateRoot {
+    constructor(props, id) {
+        super(props, id);
+    }
+}
+class TestValueObject extends value_object_1.ValueObject {
+    constructor(value) {
+        super({ value });
+    }
+    get value() {
+        return this.props.value;
+    }
+}
+describe('Entity', () => {
+    it('should compare entities by reference or shared id instance', () => {
+        const sharedId = new unique_entity_id_1.UniqueEntityId('shared-id');
+        const entity = new TestEntity({ name: 'primary' }, sharedId);
+        const sameReference = entity;
+        const sameId = new TestEntity({ name: 'secondary' }, sharedId);
+        const different = new TestEntity({ name: 'other' }, new unique_entity_id_1.UniqueEntityId('different-id'));
+        expect(entity.equals(sameReference)).toBe(true);
+        expect(entity.equals(sameId)).toBe(true);
+        expect(entity.equals(different)).toBe(false);
+    });
+    it('should serialize nested values to plain objects', () => {
+        const createdAt = new Date('2024-03-01T10:20:30.000Z');
+        const ownerId = new unique_entity_id_1.UniqueEntityId('owner-id');
+        const tags = new StringWatchedList(['finance', 'operations']);
+        const child = new TestEntity({
+            name: 'child',
+            createdAt,
+            ownerId,
+            tags,
+        }, new unique_entity_id_1.UniqueEntityId('child-id'));
+        const entity = new TestEntity({
+            name: 'parent',
+            createdAt,
+            ownerId,
+            child,
+            tags,
+            values: [ownerId, createdAt, { active: true }],
+            metadata: {
+                nestedDate: createdAt,
+                nestedId: ownerId,
+                nestedEntity: child,
+            },
+        }, new unique_entity_id_1.UniqueEntityId('parent-id'));
+        expect(entity.toObject()).toEqual({
+            name: 'parent',
+            createdAt: createdAt.toISOString(),
+            ownerId: 'owner-id',
+            child: {
+                name: 'child',
+                createdAt: createdAt.toISOString(),
+                ownerId: 'owner-id',
+                tags: ['finance', 'operations'],
+                id: 'child-id',
+            },
+            tags: ['finance', 'operations'],
+            values: ['owner-id', createdAt.toISOString(), { active: true }],
+            metadata: {
+                nestedDate: createdAt.toISOString(),
+                nestedId: 'owner-id',
+                nestedEntity: {
+                    name: 'child',
+                    createdAt: createdAt.toISOString(),
+                    ownerId: 'owner-id',
+                    tags: ['finance', 'operations'],
+                    id: 'child-id',
+                },
+            },
+            id: 'parent-id',
+        });
+        expect(entity.toEventDispatchObject()).toEqual(entity.toObject());
+    });
+    it('should allow replacing the id through the setter', () => {
+        const entity = new TestEntity({ name: 'test' });
+        const nextId = new unique_entity_id_1.UniqueEntityId('next-id');
+        entity.id = nextId;
+        expect(entity.id).toBe(nextId);
+        expect(entity.toObject()).toEqual({
+            name: 'test',
+            id: 'next-id',
+        });
+    });
+});
+describe('UniqueEntityId', () => {
+    it('should generate ids and compare them by value', () => {
+        const generatedId = new unique_entity_id_1.UniqueEntityId();
+        const copiedId = new unique_entity_id_1.UniqueEntityId(generatedId.toValue());
+        expect(generatedId.toString()).toBeTruthy();
+        expect(generatedId.equals(copiedId)).toBe(true);
+        expect(generatedId.toValue()).toBe(generatedId.toString());
+    });
+});
+describe('AggregateRoot and ValueObject', () => {
+    it('should manage aggregate timestamps and expose value object props', () => {
+        const createdAt = new Date('2024-03-01T10:20:30.000Z');
+        const nextCreatedAt = new Date('2024-03-02T10:20:30.000Z');
+        const aggregate = new TestAggregate({
+            name: 'aggregate',
+            createdAt,
+        });
+        const valueObject = new TestValueObject('payload');
+        expect(aggregate.createdAt).toBe(createdAt);
+        expect(aggregate.updatedAt).toBeUndefined();
+        aggregate.touch();
+        aggregate.createdAt = nextCreatedAt;
+        expect(aggregate.createdAt).toBe(nextCreatedAt);
+        expect(aggregate.updatedAt).toBeInstanceOf(Date);
+        expect(valueObject.value).toBe('payload');
+    });
+});

package/dist/clean-arch/domain/events/consistency-event/consistency-event.spec.d.ts

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

package/dist/clean-arch/domain/events/consistency-event/consistency-event.spec.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const entity_1 = require("../../entities/entity");
+const unique_entity_id_1 = require("../../entities/unique-entity-id");
+const events_enum_1 = require("./events-enum");
+const consistency_event_1 = tslib_1.__importDefault(require("./consistency-event"));
+const consistency_event_dispatcher_1 = require("../../../application/consistency-event-dispatcher/consistency-event-dispatcher");
+const in_memory_consistency_event_dispatcher_1 = require("../../../infra/consistency-event-dispatcher/in-memory-consistency-event-dispatcher");
+const amqp_consistency_event_dispatcher_1 = require("../../../infra/consistency-event-dispatcher/amqp-consistency-event-dispatcher");
+const exchanges_enum_1 = require("../../../infra/consistency-event-dispatcher/exchanges-enum");
+class TestEntity extends entity_1.Entity {
+    constructor(name, id) {
+        super({ name }, id);
+    }
+}
+class TestDispatcher extends consistency_event_dispatcher_1.ConsistencyEventDispatcher {
+    publishMock = vi.fn().mockResolvedValue(undefined);
+    async publish(event) {
+        await this.publishMock(event);
+    }
+}
+describe('Consistency events', () => {
+    const authorizerHeaders = {
+        userName: 'John',
+        userEmail: 'john@example.com',
+        appName: 'Portal',
+        entityId: 'user-id',
+        tenantId: 'tenant-id',
+        traceId: 'trace-id',
+    };
+    it('should create consistency events from entities', () => {
+        const entity = new TestEntity('entity-name', new unique_entity_id_1.UniqueEntityId('entity-id'));
+        const event = new consistency_event_1.default([entity], authorizerHeaders, events_enum_1.EventsName.PARTNER_CREATED);
+        expect(event.name).toBe('');
+        expect(event.eventDate).toBeInstanceOf(Date);
+        expect(event.input).toEqual({
+            eventName: events_enum_1.EventsName.PARTNER_CREATED,
+            origin: authorizerHeaders,
+            payload: [{ id: 'entity-id', name: 'entity-name' }],
+        });
+    });
+    it('should dispatch single and batch consistency events', async () => {
+        const dispatcher = new TestDispatcher();
+        const firstEntity = new TestEntity('first', new unique_entity_id_1.UniqueEntityId('first-id'));
+        const secondEntity = new TestEntity('second', new unique_entity_id_1.UniqueEntityId('second-id'));
+        await dispatcher.dispatch(firstEntity, authorizerHeaders, events_enum_1.EventsName.PARTNER_CREATED);
+        await dispatcher.dispatchBatch([firstEntity, secondEntity], authorizerHeaders, events_enum_1.EventsName.PARTNER_UPDATED);
+        expect(dispatcher.publishMock).toHaveBeenCalledTimes(2);
+        expect(dispatcher.publishMock.mock.calls[0][0].input).toEqual({
+            eventName: events_enum_1.EventsName.PARTNER_CREATED,
+            origin: authorizerHeaders,
+            payload: [{ id: 'first-id', name: 'first' }],
+        });
+        expect(dispatcher.publishMock.mock.calls[1][0].input).toEqual({
+            eventName: events_enum_1.EventsName.PARTNER_UPDATED,
+            origin: authorizerHeaders,
+            payload: [
+                { id: 'first-id', name: 'first' },
+                { id: 'second-id', name: 'second' },
+            ],
+        });
+    });
+    it('should swallow dispatch errors and log them', async () => {
+        const consoleError = vi
+            .spyOn(console, 'error')
+            .mockImplementation(() => undefined);
+        const dispatcher = new TestDispatcher();
+        const entity = new TestEntity('entity', new unique_entity_id_1.UniqueEntityId('entity-id'));
+        dispatcher.publishMock.mockRejectedValue(new Error('publish failed'));
+        await dispatcher.dispatch(entity, authorizerHeaders, events_enum_1.EventsName.PARTNER_CREATED);
+        await dispatcher.dispatchBatch([entity], authorizerHeaders, events_enum_1.EventsName.PARTNER_CREATED);
+        expect(consoleError).toHaveBeenCalledTimes(2);
+    });
+    it('should publish consistency events in memory', async () => {
+        const dispatcher = new in_memory_consistency_event_dispatcher_1.InMemoryConsistencyEventDispatcher();
+        const event = new consistency_event_1.default([new TestEntity('entity', new unique_entity_id_1.UniqueEntityId('entity-id'))], authorizerHeaders, events_enum_1.EventsName.PARTNER_CREATED);
+        await dispatcher.publish(event);
+        expect(dispatcher.events).toEqual([event]);
+    });
+    it('should publish consistency events through AMQP', async () => {
+        const amqp = {
+            publish: vi.fn().mockResolvedValue(undefined),
+        };
+        const dispatcher = new amqp_consistency_event_dispatcher_1.AmqpConsistencyEventDispatcher(amqp);
+        const event = new consistency_event_1.default([new TestEntity('entity', new unique_entity_id_1.UniqueEntityId('entity-id'))], authorizerHeaders, events_enum_1.EventsName.PARTNER_CREATED);
+        await dispatcher.publish(event);
+        expect(amqp.publish).toHaveBeenCalledWith(`${exchanges_enum_1.PREFIX}.${events_enum_1.EventsName.PARTNER_CREATED}.${exchanges_enum_1.TYPE}`, event, { storeMessageOnError: false });
+        expect(exchanges_enum_1.ExchangesEnum.CONSISTENCY_PARTNER_CREATED).toBe(`${exchanges_enum_1.PREFIX}.${events_enum_1.EventsName.PARTNER_CREATED}.${exchanges_enum_1.TYPE}`);
+    });
+});

package/dist/clean-arch/domain/value-objects/password.spec.d.ts

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