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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seidor-cloud-produtos/orbit-backend-lib",
-  "version": "2.0.136",
+  "version": "2.0.138",
   "description": "Internal lib for backend components",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -81,10 +81,6 @@
     "@aws-sdk/client-sqs": "3.940.0",
     "@fastify/cors": "8.3.0",
     "@nestjs/common": "8.4.7",
-    "@opentelemetry/auto-instrumentations-node": "^0.69.0",
-    "@opentelemetry/resources": "^2.5.0",
-    "@opentelemetry/sdk-node": "^0.211.0",
-    "@opentelemetry/semantic-conventions": "^1.39.0",
     "amqplib": "0.10.9",
     "axios": "1.8.2",
     "compression": "1.7.4",

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

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

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

@@ -1,178 +0,0 @@
-"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,9 +0,0 @@
-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>;
-    abstract publish(event: ConsistencyEvent): Promise<void>;
-}

package/dist/clean-arch/application/consistency-event-dispatcher/consistency-event-dispatcher.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConsistencyEventDispatcher = void 0;
-const tslib_1 = require("tslib");
-const consistency_event_1 = tslib_1.__importDefault(require("../../domain/events/consistency-event/consistency-event"));
-class ConsistencyEventDispatcher {
-    async dispatch(entity, authorizerHeaders, eventName) {
-        try {
-            const event = new consistency_event_1.default([entity], authorizerHeaders, eventName);
-            await this.publish(event);
-        }
-        catch (error) {
-            console.error(`Failed to dispatch consistency event: ${error}`);
-        }
-    }
-    async dispatchBatch(entities, authorizerHeaders, eventName) {
-        try {
-            const event = new consistency_event_1.default(entities, authorizerHeaders, eventName);
-            await this.publish(event);
-        }
-        catch (error) {
-            console.error(`Failed to dispatch batch consistency events: ${error}`);
-        }
-    }
-}
-exports.ConsistencyEventDispatcher = ConsistencyEventDispatcher;

package/dist/clean-arch/application/logger/base-audit-logger.d.ts

@@ -1,10 +0,0 @@
-import { AuthorizerHeaders } from '../../infra/http/handle-authorizer-headers';
-import LoggerGateway, { Trace } from '.';
-import { LogOrbitParams } from '../../infra/logger/logger-orbit';
-export declare abstract class BaseAuditLogger {
-    protected readonly gateway: LoggerGateway;
-    protected defaultExpirationHours: number;
-    constructor(gateway: LoggerGateway);
-    protected buildParams(type: string, authorizerHeaders: AuthorizerHeaders, trace: Trace): LogOrbitParams;
-    protected info(payload: any, params: LogOrbitParams): Promise<void>;
-}

package/dist/clean-arch/application/logger/base-audit-logger.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseAuditLogger = void 0;
-const _1 = require(".");
-const FIVE_YEARS_IN_HOURS = 24 * 365 * 5;
-class BaseAuditLogger {
-    gateway;
-    defaultExpirationHours = FIVE_YEARS_IN_HOURS;
-    constructor(gateway) {
-        this.gateway = gateway;
-    }
-    buildParams(type, authorizerHeaders, trace) {
-        trace.ids.push(authorizerHeaders.traceId);
-        return {
-            type,
-            trace,
-            actor: authorizerHeaders.entityId,
-            tenantId: authorizerHeaders.tenantId,
-            actorType: _1.ActorEnum.USER,
-            category: _1.CategoryEnum.BUSINESS,
-            expirationHours: this.defaultExpirationHours,
-        };
-    }
-    async info(payload, params) {
-        return await this.gateway.info({ payload }, params);
-    }
-}
-exports.BaseAuditLogger = BaseAuditLogger;

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

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

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

@@ -1,204 +0,0 @@
-"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

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

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

@@ -1,130 +0,0 @@
-"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.d.ts

@@ -1,15 +0,0 @@
-import { AuthorizerHeaders } from '../../../infra/http/handle-authorizer-headers';
-import { Entity } from '../../entities/entity';
-import DomainEvent from '../domain-event';
-import { EventsName } from './events-enum';
-export interface ConsistencyEventMessage {
-    eventName: EventsName;
-    origin: AuthorizerHeaders;
-    payload: Record<string, any>[];
-}
-export default class ConsistencyEvent implements DomainEvent {
-    readonly eventDate: Date;
-    readonly name: string;
-    readonly input: ConsistencyEventMessage;
-    constructor(entities: Entity<any>[], authorizerHeaders: AuthorizerHeaders, eventName: EventsName);
-}

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

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class ConsistencyEvent {
-    eventDate = new Date();
-    name = '';
-    input;
-    constructor(entities, authorizerHeaders, eventName) {
-        this.input = {
-            eventName,
-            origin: authorizerHeaders,
-            payload: entities.map(entity => entity.toEventDispatchObject()),
-        };
-    }
-}
-exports.default = ConsistencyEvent;

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

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