@friggframework/core 2.0.0-next.45 → 2.0.0-next.46

package/integrations/tests/use-cases/delete-integration-for-user.test.js

@@ -1,150 +0,0 @@
-jest.mock('../../../database/config', () => ({
-    DB_TYPE: 'mongodb',
-    getDatabaseType: jest.fn(() => 'mongodb'),
-    PRISMA_LOG_LEVEL: 'error,warn',
-    PRISMA_QUERY_LOGGING: false,
-}));
-
-const { DeleteIntegrationForUser } = require('../../use-cases/delete-integration-for-user');
-const { TestIntegrationRepository } = require('../doubles/test-integration-repository');
-const { DummyIntegration } = require('../doubles/dummy-integration-class');
-
-describe('DeleteIntegrationForUser Use-Case', () => {
-    let integrationRepository;
-    let useCase;
-
-    beforeEach(() => {
-        integrationRepository = new TestIntegrationRepository();
-        useCase = new DeleteIntegrationForUser({
-            integrationRepository,
-            integrationClasses: [DummyIntegration],
-        });
-    });
-
-    describe('happy path', () => {
-        it('deletes integration successfully', async () => {
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy' });
-
-            await useCase.execute(record.id, 'user-1');
-
-            const found = await integrationRepository.findIntegrationById(record.id);
-            expect(found).toBeNull();
-        });
-
-        it('tracks delete operation', async () => {
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy' });
-            integrationRepository.clearHistory();
-
-            await useCase.execute(record.id, 'user-1');
-
-            const history = integrationRepository.getOperationHistory();
-            const deleteOperation = history.find(op => op.operation === 'delete');
-            expect(deleteOperation).toEqual({
-                operation: 'delete',
-                id: record.id,
-                existed: true,
-                success: true
-            });
-        });
-
-        it('deletes integration with multiple entities', async () => {
-            const record = await integrationRepository.createIntegration(['e1', 'e2', 'e3'], 'user-1', { type: 'dummy' });
-
-            await useCase.execute(record.id, 'user-1');
-
-            const found = await integrationRepository.findIntegrationById(record.id);
-            expect(found).toBeNull();
-        });
-    });
-
-    describe('error cases', () => {
-        it('throws error when integration not found', async () => {
-            const nonExistentId = 'non-existent-id';
-
-            await expect(useCase.execute(nonExistentId, 'user-1'))
-                .rejects
-                .toThrow(`Integration with id of ${nonExistentId} does not exist`);
-        });
-
-        it('throws error when user does not own integration', async () => {
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy' });
-
-            await expect(useCase.execute(record.id, 'different-user'))
-                .rejects
-                .toThrow(`Integration ${record.id} does not belong to User different-user`);
-        });
-
-        it('throws error when integration class not found', async () => {
-            const useCaseWithoutClasses = new DeleteIntegrationForUser({
-                integrationRepository,
-                integrationClasses: [],
-            });
-
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy' });
-
-            await expect(useCaseWithoutClasses.execute(record.id, 'user-1'))
-                .rejects
-                .toThrow();
-        });
-
-        it('tracks failed delete operation for non-existent integration', async () => {
-            const nonExistentId = 'non-existent-id';
-            integrationRepository.clearHistory();
-
-            try {
-                await useCase.execute(nonExistentId, 'user-1');
-            } catch (error) {
-                const history = integrationRepository.getOperationHistory();
-                const findOperation = history.find(op => op.operation === 'findById');
-                expect(findOperation).toEqual({
-                    operation: 'findById',
-                    id: nonExistentId,
-                    found: false
-                });
-            }
-        });
-    });
-
-    describe('edge cases', () => {
-        it('handles deletion of already deleted integration', async () => {
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy' });
-
-            await useCase.execute(record.id, 'user-1');
-
-            await expect(useCase.execute(record.id, 'user-1'))
-                .rejects
-                .toThrow(`Integration with id of ${record.id} does not exist`);
-        });
-
-        it('handles integration with complex config during deletion', async () => {
-            const complexConfig = {
-                type: 'dummy',
-                settings: { nested: { deep: 'value' } },
-                credentials: { encrypted: true }
-            };
-
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', complexConfig);
-
-            await useCase.execute(record.id, 'user-1');
-
-            const found = await integrationRepository.findIntegrationById(record.id);
-            expect(found).toBeNull();
-        });
-
-        it('handles null userId gracefully', async () => {
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy' });
-
-            await expect(useCase.execute(record.id, null))
-                .rejects
-                .toThrow(`Integration ${record.id} does not belong to User null`);
-        });
-
-        it('handles undefined userId gracefully', async () => {
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy' });
-
-            await expect(useCase.execute(record.id, undefined))
-                .rejects
-                .toThrow(`Integration ${record.id} does not belong to User undefined`);
-        });
-    });
-}); 

package/integrations/tests/use-cases/find-integration-context-by-external-entity-id.test.js

@@ -1,92 +0,0 @@
-const { FindIntegrationContextByExternalEntityIdUseCase } = require('../../use-cases/find-integration-context-by-external-entity-id');
-const { TestModuleRepository } = require('../../../modules/tests/doubles/test-module-repository');
-const { TestIntegrationRepository } = require('../doubles/test-integration-repository');
-const { DummyIntegration } = require('../doubles/dummy-integration-class');
-
-describe('FindIntegrationContextByExternalEntityIdUseCase', () => {
-    let moduleRepository;
-    let integrationRepository;
-    let loadIntegrationContextUseCase;
-    let useCase;
-
-    beforeEach(() => {
-        moduleRepository = new TestModuleRepository();
-        integrationRepository = new TestIntegrationRepository();
-        loadIntegrationContextUseCase = {
-            execute: jest.fn(),
-        };
-        useCase = new FindIntegrationContextByExternalEntityIdUseCase({
-            moduleRepository,
-            integrationRepository,
-            loadIntegrationContextUseCase,
-        });
-    });
-
-    it('throws when externalEntityId is missing', async () => {
-        await expect(useCase.execute({})).rejects.toHaveProperty(
-            'code',
-            'EXTERNAL_ENTITY_ID_REQUIRED',
-        );
-    });
-
-    it('throws when entity is not found', async () => {
-        await expect(
-            useCase.execute({ externalEntityId: 'abc' }),
-        ).rejects.toHaveProperty('code', 'ENTITY_NOT_FOUND');
-    });
-
-    it('throws when entity user is missing', async () => {
-        moduleRepository.addEntity({
-            id: 'entity-1',
-            externalId: 'ext-1',
-        });
-
-        await expect(
-            useCase.execute({ externalEntityId: 'ext-1' }),
-        ).rejects.toHaveProperty('code', 'ENTITY_USER_NOT_FOUND');
-    });
-
-    it('throws when integration is not found for user', async () => {
-        moduleRepository.addEntity({
-            id: 'entity-1',
-            externalId: 'ext-1',
-            userId: 'user-1',
-        });
-
-        await expect(
-            useCase.execute({ externalEntityId: 'ext-1' }),
-        ).rejects.toHaveProperty('code', 'INTEGRATION_NOT_FOUND');
-    });
-
-    it('returns context, entity, and record on success', async () => {
-        const entity = {
-            id: 'entity-1',
-            externalId: 'ext-1',
-            userId: 'user-1',
-        };
-        moduleRepository.addEntity(entity);
-
-        const integrationRecord = await integrationRepository.createIntegration(
-            [entity.id],
-            entity.userId,
-            { type: 'dummy' },
-        );
-
-        const expectedContext = {
-            record: integrationRecord,
-            modules: [{ id: 'module-1' }],
-        };
-        loadIntegrationContextUseCase.execute.mockResolvedValue(
-            expectedContext,
-        );
-
-        const result = await useCase.execute({ externalEntityId: 'ext-1' });
-
-        expect(loadIntegrationContextUseCase.execute).toHaveBeenCalledWith({
-            integrationRecord,
-        });
-        expect(result.context).toEqual(expectedContext);
-        expect(result.entity).toEqual(entity);
-        expect(result.record).toEqual(integrationRecord);
-    });
-});

package/integrations/tests/use-cases/get-integration-for-user.test.js

@@ -1,150 +0,0 @@
-jest.mock('../../../database/config', () => ({
-    DB_TYPE: 'mongodb',
-    getDatabaseType: jest.fn(() => 'mongodb'),
-    PRISMA_LOG_LEVEL: 'error,warn',
-    PRISMA_QUERY_LOGGING: false,
-}));
-
-const { GetIntegrationForUser } = require('../../use-cases/get-integration-for-user');
-const { TestIntegrationRepository } = require('../doubles/test-integration-repository');
-const { TestModuleFactory } = require('../../../modules/tests/doubles/test-module-factory');
-const { TestModuleRepository } = require('../../../modules/tests/doubles/test-module-repository');
-const { DummyIntegration } = require('../doubles/dummy-integration-class');
-
-describe('GetIntegrationForUser Use-Case', () => {
-    let integrationRepository;
-    let moduleRepository;
-    let moduleFactory;
-    let useCase;
-
-    beforeEach(() => {
-        integrationRepository = new TestIntegrationRepository();
-        moduleRepository = new TestModuleRepository();
-        moduleFactory = new TestModuleFactory();
-        useCase = new GetIntegrationForUser({
-            integrationRepository,
-            integrationClasses: [DummyIntegration],
-            moduleFactory,
-            moduleRepository,
-        });
-    });
-
-    describe('happy path', () => {
-        it('returns integration dto', async () => {
-            const entity = { id: 'entity-1', _id: 'entity-1' };
-            moduleRepository.addEntity(entity);
-
-            const record = await integrationRepository.createIntegration([entity.id], 'user-1', { type: 'dummy' });
-
-            const dto = await useCase.execute(record.id, 'user-1');
-            expect(dto.id).toBe(record.id);
-            expect(dto.userId).toBe('user-1');
-            expect(dto.config.type).toBe('dummy');
-        });
-
-        it('returns integration with multiple entities', async () => {
-            const entity1 = { id: 'entity-1', _id: 'entity-1' };
-            const entity2 = { id: 'entity-2', _id: 'entity-2' };
-            moduleRepository.addEntity(entity1);
-            moduleRepository.addEntity(entity2);
-
-            const record = await integrationRepository.createIntegration([entity1.id, entity2.id], 'user-1', { type: 'dummy' });
-
-            const dto = await useCase.execute(record.id, 'user-1');
-            expect(dto.entities).toEqual([entity1, entity2]);
-        });
-
-        it('returns integration with complex config', async () => {
-            const entity = { id: 'entity-1', _id: 'entity-1' };
-            moduleRepository.addEntity(entity);
-
-            const complexConfig = {
-                type: 'dummy',
-                settings: { api: { timeout: 5000 }, debug: true },
-                features: ['webhooks', 'sync']
-            };
-
-            const record = await integrationRepository.createIntegration([entity.id], 'user-1', complexConfig);
-
-            const dto = await useCase.execute(record.id, 'user-1');
-            expect(dto.config).toEqual(complexConfig);
-        });
-    });
-
-    describe('error cases', () => {
-        it('throws error when integration not found', async () => {
-            const nonExistentId = 'non-existent-id';
-
-            await expect(useCase.execute(nonExistentId, 'user-1'))
-                .rejects
-                .toThrow();
-        });
-
-        it('throws error when user does not own integration', async () => {
-            const entity = { id: 'entity-1', _id: 'entity-1' };
-            moduleRepository.addEntity(entity);
-
-            const record = await integrationRepository.createIntegration([entity.id], 'user-1', { type: 'dummy' });
-
-            await expect(useCase.execute(record.id, 'different-user'))
-                .rejects
-                .toThrow();
-        });
-
-        it('throws error when integration class not found', async () => {
-            const useCaseWithoutClasses = new GetIntegrationForUser({
-                integrationRepository,
-                integrationClasses: [],
-                moduleFactory,
-                moduleRepository,
-            });
-
-            const entity = { id: 'entity-1', _id: 'entity-1' };
-            moduleRepository.addEntity(entity);
-
-            const record = await integrationRepository.createIntegration([entity.id], 'user-1', { type: 'dummy' });
-
-            await expect(useCaseWithoutClasses.execute(record.id, 'user-1'))
-                .rejects
-                .toThrow();
-        });
-
-        it('handles missing entities gracefully', async () => {
-            const record = await integrationRepository.createIntegration(['missing-entity'], 'user-1', { type: 'dummy' });
-
-            await expect(useCase.execute(record.id, 'user-1'))
-                .rejects
-                .toThrow();
-        });
-    });
-
-    describe('edge cases', () => {
-        it('handles userId as string vs number comparison', async () => {
-            const entity = { id: 'entity-1', _id: 'entity-1' };
-            moduleRepository.addEntity(entity);
-
-            const record = await integrationRepository.createIntegration([entity.id], 'user-1', { type: 'dummy' });
-
-            const dto1 = await useCase.execute(record.id, 'user-1');
-            const dto2 = await useCase.execute(record.id, 'user-1');
-
-            expect(dto1.userId).toBe(dto2.userId);
-        });
-
-        it('returns all integration properties', async () => {
-            const entity = { id: 'entity-1', _id: 'entity-1' };
-            moduleRepository.addEntity(entity);
-
-            const record = await integrationRepository.createIntegration([entity.id], 'user-1', { type: 'dummy' });
-
-            record.status = 'ACTIVE';
-            record.version = '1.0.0';
-            record.messages = { info: [{ title: 'Test', message: 'Message' }] };
-
-            const dto = await useCase.execute(record.id, 'user-1');
-            expect(dto.status).toBe('ACTIVE');
-            expect(dto.version).toBe('1.0.0');
-            expect(dto.messages).toEqual({ info: [{ title: 'Test', message: 'Message' }] });
-        });
-    });
-}); 

package/integrations/tests/use-cases/get-integration-instance.test.js

@@ -1,176 +0,0 @@
-jest.mock('../../../database/config', () => ({
-    DB_TYPE: 'mongodb',
-    getDatabaseType: jest.fn(() => 'mongodb'),
-    PRISMA_LOG_LEVEL: 'error,warn',
-    PRISMA_QUERY_LOGGING: false,
-}));
-
-const { GetIntegrationInstance } = require('../../use-cases/get-integration-instance');
-const { TestIntegrationRepository } = require('../doubles/test-integration-repository');
-const { TestModuleFactory } = require('../../../modules/tests/doubles/test-module-factory');
-const { DummyIntegration } = require('../doubles/dummy-integration-class');
-
-describe('GetIntegrationInstance Use-Case', () => {
-    let integrationRepository;
-    let moduleFactory;
-    let useCase;
-
-    beforeEach(() => {
-        integrationRepository = new TestIntegrationRepository();
-        moduleFactory = new TestModuleFactory();
-        useCase = new GetIntegrationInstance({
-            integrationRepository,
-            integrationClasses: [DummyIntegration],
-            moduleFactory,
-        });
-    });
-
-    describe('happy path', () => {
-        it('returns hydrated integration instance', async () => {
-            const record = await integrationRepository.createIntegration(['entity-1'], 'user-1', { type: 'dummy' });
-
-            const instance = await useCase.execute(record.id, 'user-1');
-
-            expect(instance.id).toBe(record.id);
-            expect(instance.getConfig().type).toBe('dummy');
-            expect(instance.entities).toEqual(record.entitiesIds);
-            expect(instance.userId).toBe('user-1');
-        });
-
-        it('returns instance with multiple modules', async () => {
-            const record = await integrationRepository.createIntegration(['entity-1', 'entity-2'], 'user-1', { type: 'dummy' });
-
-            const instance = await useCase.execute(record.id, 'user-1');
-
-            expect(instance.entities).toEqual(['entity-1', 'entity-2']);
-            expect(Object.keys(instance.modules)).toHaveLength(1);
-            expect(instance.modules['stubModule']).toBeDefined();
-        });
-
-        it('initializes integration instance properly', async () => {
-            const record = await integrationRepository.createIntegration(['entity-1'], 'user-1', { type: 'dummy' });
-
-            const instance = await useCase.execute(record.id, 'user-1');
-
-            expect(typeof instance.send).toBe('function');
-            expect(typeof instance.getConfig).toBe('function');
-            expect(typeof instance.initialize).toBe('function');
-        });
-
-        it('preserves all integration properties', async () => {
-            const record = await integrationRepository.createIntegration(['entity-1'], 'user-1', { type: 'dummy', custom: 'value' });
-
-            record.status = 'ACTIVE';
-            record.version = '2.0.0';
-            record.messages = { logs: [{ title: 'Test', message: 'Log entry' }] };
-
-            const instance = await useCase.execute(record.id, 'user-1');
-
-            expect(instance.status).toBe('ACTIVE');
-            expect(instance.version).toBe('2.0.0');
-            expect(instance.messages).toEqual({ logs: [{ title: 'Test', message: 'Log entry' }] });
-            expect(instance.getConfig().custom).toBe('value');
-        });
-    });
-
-    describe('error cases', () => {
-        it('throws error when integration not found', async () => {
-            const nonExistentId = 'non-existent-id';
-
-            await expect(useCase.execute(nonExistentId, 'user-1'))
-                .rejects
-                .toThrow(`No integration found by the ID of ${nonExistentId}`);
-        });
-
-        it('throws error when user does not own integration', async () => {
-            const record = await integrationRepository.createIntegration(['entity-1'], 'user-1', { type: 'dummy' });
-
-            await expect(useCase.execute(record.id, 'different-user'))
-                .rejects
-                .toThrow(`Integration ${record.id} does not belong to User different-user`);
-        });
-
-        it('throws error when integration class not found', async () => {
-            const useCaseWithoutClasses = new GetIntegrationInstance({
-                integrationRepository,
-                integrationClasses: [],
-                moduleFactory,
-            });
-
-            const record = await integrationRepository.createIntegration(['entity-1'], 'user-1', { type: 'dummy' });
-
-            await expect(useCaseWithoutClasses.execute(record.id, 'user-1'))
-                .rejects
-                .toThrow('No integration class found for type: dummy');
-        });
-
-        it('throws error when integration has unknown type', async () => {
-            const record = await integrationRepository.createIntegration(['entity-1'], 'user-1', { type: 'unknown-type' });
-
-            await expect(useCase.execute(record.id, 'user-1'))
-                .rejects
-                .toThrow('No integration class found for type: unknown-type');
-        });
-    });
-
-    describe('edge cases', () => {
-        it('handles integration with no entities', async () => {
-            const record = await integrationRepository.createIntegration([], 'user-1', { type: 'dummy' });
-
-            const instance = await useCase.execute(record.id, 'user-1');
-
-            expect(instance.entities).toEqual([]);
-            expect(Object.keys(instance.modules)).toHaveLength(0);
-        });
-
-        it('handles integration with null config values', async () => {
-            const record = await integrationRepository.createIntegration(['entity-1'], 'user-1', { type: 'dummy', nullValue: null });
-
-            const instance = await useCase.execute(record.id, 'user-1');
-
-            expect(instance.getConfig().nullValue).toBeNull();
-        });
-
-        it('handles userId comparison edge cases', async () => {
-            const record = await integrationRepository.createIntegration(['entity-1'], 'user-1', { type: 'dummy' });
-
-            const instance1 = await useCase.execute(record.id, 'user-1');
-            const instance2 = await useCase.execute(record.id, 'user-1');
-
-            expect(instance1.userId).toBe(instance2.userId);
-        });
-
-        it('returns fresh instance on each call', async () => {
-            const record = await integrationRepository.createIntegration(['entity-1'], 'user-1', { type: 'dummy' });
-
-            const instance1 = await useCase.execute(record.id, 'user-1');
-            const instance2 = await useCase.execute(record.id, 'user-1');
-
-            expect(instance1).not.toBe(instance2);
-            expect(instance1.id).toBe(instance2.id);
-        });
-
-        it('handles complex nested config structures', async () => {
-            const complexConfig = {
-                type: 'dummy',
-                settings: {
-                    api: {
-                        timeout: 5000,
-                        retries: 3,
-                        endpoints: ['users', 'orders']
-                    },
-                    features: {
-                        webhooks: true,
-                        sync: { interval: 300 }
-                    }
-                }
-            };
-
-            const record = await integrationRepository.createIntegration(['entity-1'], 'user-1', complexConfig);
-
-            const instance = await useCase.execute(record.id, 'user-1');
-
-            expect(instance.getConfig()).toEqual(complexConfig);
-        });
-    });
-});