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

package/integrations/tests/use-cases/update-integration.test.js

@@ -1,141 +0,0 @@
-jest.mock('../../../database/config', () => ({
-    DB_TYPE: 'mongodb',
-    getDatabaseType: jest.fn(() => 'mongodb'),
-    PRISMA_LOG_LEVEL: 'error,warn',
-    PRISMA_QUERY_LOGGING: false,
-}));
-
-const { UpdateIntegration } = require('../../use-cases/update-integration');
-const { TestIntegrationRepository } = require('../doubles/test-integration-repository');
-const { TestModuleFactory } = require('../../../modules/tests/doubles/test-module-factory');
-const { DummyIntegration } = require('../doubles/dummy-integration-class');
-
-describe('UpdateIntegration Use-Case', () => {
-    let integrationRepository;
-    let moduleFactory;
-    let useCase;
-
-    beforeEach(() => {
-        integrationRepository = new TestIntegrationRepository();
-        moduleFactory = new TestModuleFactory();
-        useCase = new UpdateIntegration({
-            integrationRepository,
-            integrationClasses: [DummyIntegration],
-            moduleFactory,
-        });
-    });
-
-    describe('happy path', () => {
-        it('calls on update and returns dto', async () => {
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy', foo: 'bar' });
-
-            const newConfig = { type: 'dummy', foo: 'baz' };
-            const dto = await useCase.execute(record.id, 'user-1', newConfig);
-
-            expect(dto.config.foo).toBe('baz');
-            expect(dto.id).toBe(record.id);
-            expect(dto.userId).toBe('user-1');
-        });
-
-        it('triggers ON_UPDATE event with correct payload', async () => {
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy', foo: 'bar' });
-            integrationRepository.clearHistory();
-
-            const newConfig = { type: 'dummy', foo: 'updated' };
-            await useCase.execute(record.id, 'user-1', newConfig);
-
-            const history = integrationRepository.getOperationHistory();
-            const findOperation = history.find(op => op.operation === 'findById');
-            expect(findOperation).toEqual({
-                operation: 'findById',
-                id: record.id,
-                found: true
-            });
-        });
-
-        it('updates integration with multiple entities', async () => {
-            const record = await integrationRepository.createIntegration(['e1', 'e2'], 'user-1', { type: 'dummy' });
-
-            const newConfig = { type: 'dummy', updated: true };
-            const dto = await useCase.execute(record.id, 'user-1', newConfig);
-
-            expect(dto.entities).toEqual(['e1', 'e2']);
-            expect(dto.config.updated).toBe(true);
-        });
-    });
-
-    describe('error cases', () => {
-        it('throws error when integration not found', async () => {
-            const nonExistentId = 'non-existent-id';
-            const newConfig = { type: 'dummy', foo: 'baz' };
-
-            await expect(useCase.execute(nonExistentId, 'user-1', newConfig))
-                .rejects
-                .toThrow(`No integration found by the ID of ${nonExistentId}`);
-        });
-
-        it('throws error when integration class not found', async () => {
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'unknown-type' });
-
-            const newConfig = { type: 'unknown-type', foo: 'baz' };
-
-            await expect(useCase.execute(record.id, 'user-1', newConfig))
-                .rejects
-                .toThrow('No integration class found for type: unknown-type');
-        });
-
-        it('throws error when user does not own integration', async () => {
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy' });
-
-            const newConfig = { type: 'dummy', foo: 'baz' };
-
-            await expect(useCase.execute(record.id, 'different-user', newConfig))
-                .rejects
-                .toThrow(`Integration ${record.id} does not belong to User different-user`);
-        });
-
-        it('throws error when no integration classes provided', async () => {
-            const useCaseWithoutClasses = new UpdateIntegration({
-                integrationRepository,
-                integrationClasses: [],
-                moduleFactory,
-            });
-
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy' });
-            const newConfig = { type: 'dummy', foo: 'baz' };
-
-            await expect(useCaseWithoutClasses.execute(record.id, 'user-1', newConfig))
-                .rejects
-                .toThrow('No integration class found for type: dummy');
-        });
-    });
-
-    describe('edge cases', () => {
-        it('handles config with null values', async () => {
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy', foo: 'bar' });
-
-            const newConfig = { type: 'dummy', foo: null, bar: undefined };
-            const dto = await useCase.execute(record.id, 'user-1', newConfig);
-
-            expect(dto.config.foo).toBeNull();
-            expect(dto.config.bar).toBeUndefined();
-        });
-
-        it('handles deeply nested config updates', async () => {
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy', nested: { old: 'value' } });
-
-            const newConfig = {
-                type: 'dummy',
-                nested: {
-                    new: 'value',
-                    deep: { level: 'test' }
-                }
-            };
-            const dto = await useCase.execute(record.id, 'user-1', newConfig);
-
-            expect(dto.config.nested.new).toBe('value');
-            expect(dto.config.nested.deep.level).toBe('test');
-            expect(dto.config.nested.old).toBeUndefined();
-        });
-    });
-}); 

package/integrations/use-cases/create-process.test.js

@@ -1,178 +0,0 @@
-/**
- * CreateProcess Use Case Tests
- * 
- * Tests process creation with validation and error handling.
- */
-
-const { CreateProcess } = require('./create-process');
-
-describe('CreateProcess', () => {
-    let createProcessUseCase;
-    let mockProcessRepository;
-
-    beforeEach(() => {
-        mockProcessRepository = {
-            create: jest.fn(),
-        };
-        createProcessUseCase = new CreateProcess({
-            processRepository: mockProcessRepository,
-        });
-    });
-
-    describe('constructor', () => {
-        it('should require processRepository', () => {
-            expect(() => new CreateProcess({})).toThrow('processRepository is required');
-        });
-
-        it('should initialize with processRepository', () => {
-            expect(createProcessUseCase.processRepository).toBe(mockProcessRepository);
-        });
-    });
-
-    describe('execute', () => {
-        const validProcessData = {
-            userId: 'user-123',
-            integrationId: 'integration-456',
-            name: 'test-crm-contact-sync',
-            type: 'CRM_SYNC',
-        };
-
-        it('should create a process with minimal required data', async () => {
-            const mockCreatedProcess = { id: 'process-789', ...validProcessData };
-            mockProcessRepository.create.mockResolvedValue(mockCreatedProcess);
-
-            const result = await createProcessUseCase.execute(validProcessData);
-
-            expect(mockProcessRepository.create).toHaveBeenCalledWith({
-                userId: 'user-123',
-                integrationId: 'integration-456',
-                name: 'test-crm-contact-sync',
-                type: 'CRM_SYNC',
-                state: 'INITIALIZING',
-                context: {},
-                results: {},
-                childProcesses: [],
-                parentProcessId: null,
-            });
-            expect(result).toEqual(mockCreatedProcess);
-        });
-
-        it('should create a process with all optional data', async () => {
-            const processDataWithOptions = {
-                ...validProcessData,
-                state: 'FETCHING_TOTAL',
-                context: { syncType: 'INITIAL', totalRecords: 100 },
-                results: { aggregateData: { totalSynced: 0 } },
-                childProcesses: ['child-1', 'child-2'],
-                parentProcessId: 'parent-123',
-            };
-
-            const mockCreatedProcess = { id: 'process-789', ...processDataWithOptions };
-            mockProcessRepository.create.mockResolvedValue(mockCreatedProcess);
-
-            const result = await createProcessUseCase.execute(processDataWithOptions);
-
-            expect(mockProcessRepository.create).toHaveBeenCalledWith(processDataWithOptions);
-            expect(result).toEqual(mockCreatedProcess);
-        });
-
-        it('should throw error if userId is missing', async () => {
-            const invalidData = { integrationId: 'int-123', name: 'test', type: 'CRM_SYNC' };
-
-            await expect(createProcessUseCase.execute(invalidData))
-                .rejects.toThrow('Missing required fields for process creation: userId');
-        });
-
-        it('should throw error if integrationId is missing', async () => {
-            const invalidData = { userId: 'user-123', name: 'test', type: 'CRM_SYNC' };
-
-            await expect(createProcessUseCase.execute(invalidData))
-                .rejects.toThrow('Missing required fields for process creation: integrationId');
-        });
-
-        it('should throw error if name is missing', async () => {
-            const invalidData = { userId: 'user-123', integrationId: 'int-123', type: 'CRM_SYNC' };
-
-            await expect(createProcessUseCase.execute(invalidData))
-                .rejects.toThrow('Missing required fields for process creation: name');
-        });
-
-        it('should throw error if type is missing', async () => {
-            const invalidData = { userId: 'user-123', integrationId: 'int-123', name: 'test' };
-
-            await expect(createProcessUseCase.execute(invalidData))
-                .rejects.toThrow('Missing required fields for process creation: type');
-        });
-
-        it('should throw error if userId is not a string', async () => {
-            const invalidData = { ...validProcessData, userId: 123 };
-
-            await expect(createProcessUseCase.execute(invalidData))
-                .rejects.toThrow('userId must be a string');
-        });
-
-        it('should throw error if integrationId is not a string', async () => {
-            const invalidData = { ...validProcessData, integrationId: 456 };
-
-            await expect(createProcessUseCase.execute(invalidData))
-                .rejects.toThrow('integrationId must be a string');
-        });
-
-        it('should throw error if name is not a string', async () => {
-            const invalidData = { ...validProcessData, name: 789 };
-
-            await expect(createProcessUseCase.execute(invalidData))
-                .rejects.toThrow('name must be a string');
-        });
-
-        it('should throw error if type is not a string', async () => {
-            const invalidData = { ...validProcessData, type: 999 };
-
-            await expect(createProcessUseCase.execute(invalidData))
-                .rejects.toThrow('type must be a string');
-        });
-
-        it('should throw error if state is provided but not a string', async () => {
-            const invalidData = { ...validProcessData, state: 123 };
-
-            await expect(createProcessUseCase.execute(invalidData))
-                .rejects.toThrow('state must be a string');
-        });
-
-        it('should throw error if context is provided but not an object', async () => {
-            const invalidData = { ...validProcessData, context: 'invalid' };
-
-            await expect(createProcessUseCase.execute(invalidData))
-                .rejects.toThrow('context must be an object');
-        });
-
-        it('should throw error if results is provided but not an object', async () => {
-            const invalidData = { ...validProcessData, results: 'invalid' };
-
-            await expect(createProcessUseCase.execute(invalidData))
-                .rejects.toThrow('results must be an object');
-        });
-
-        it('should throw error if childProcesses is provided but not an array', async () => {
-            const invalidData = { ...validProcessData, childProcesses: 'invalid' };
-
-            await expect(createProcessUseCase.execute(invalidData))
-                .rejects.toThrow('childProcesses must be an array');
-        });
-
-        it('should throw error if parentProcessId is provided but not a string', async () => {
-            const invalidData = { ...validProcessData, parentProcessId: 123 };
-
-            await expect(createProcessUseCase.execute(invalidData))
-                .rejects.toThrow('parentProcessId must be a string');
-        });
-
-        it('should handle repository errors', async () => {
-            const repositoryError = new Error('Database connection failed');
-            mockProcessRepository.create.mockRejectedValue(repositoryError);
-
-            await expect(createProcessUseCase.execute(validProcessData))
-                .rejects.toThrow('Failed to create process: Database connection failed');
-        });
-    });
-});

package/integrations/use-cases/get-process.test.js

@@ -1,190 +0,0 @@
-/**
- * GetProcess Use Case Tests
- * 
- * Tests process retrieval with error handling.
- */
-
-const { GetProcess } = require('./get-process');
-
-describe('GetProcess', () => {
-    let getProcessUseCase;
-    let mockProcessRepository;
-
-    beforeEach(() => {
-        mockProcessRepository = {
-            findById: jest.fn(),
-        };
-        getProcessUseCase = new GetProcess({
-            processRepository: mockProcessRepository,
-        });
-    });
-
-    describe('constructor', () => {
-        it('should require processRepository', () => {
-            expect(() => new GetProcess({})).toThrow('processRepository is required');
-        });
-
-        it('should initialize with processRepository', () => {
-            expect(getProcessUseCase.processRepository).toBe(mockProcessRepository);
-        });
-    });
-
-    describe('execute', () => {
-        const processId = 'process-123';
-        const mockProcess = {
-            id: processId,
-            userId: 'user-456',
-            integrationId: 'integration-789',
-            name: 'test-sync',
-            type: 'CRM_SYNC',
-            state: 'PROCESSING_BATCHES',
-            context: {
-                syncType: 'INITIAL',
-                totalRecords: 1000,
-                processedRecords: 500,
-            },
-            results: {
-                aggregateData: {
-                    totalSynced: 480,
-                    totalFailed: 20,
-                    duration: 120000,
-                    recordsPerSecond: 4.17,
-                },
-            },
-            createdAt: new Date('2024-01-01T10:00:00Z'),
-            updatedAt: new Date('2024-01-01T10:02:00Z'),
-        };
-
-        it('should retrieve a process by ID', async () => {
-            mockProcessRepository.findById.mockResolvedValue(mockProcess);
-
-            const result = await getProcessUseCase.execute(processId);
-
-            expect(mockProcessRepository.findById).toHaveBeenCalledWith(processId);
-            expect(result).toEqual(mockProcess);
-        });
-
-        it('should return null if process not found', async () => {
-            mockProcessRepository.findById.mockResolvedValue(null);
-
-            const result = await getProcessUseCase.execute(processId);
-
-            expect(mockProcessRepository.findById).toHaveBeenCalledWith(processId);
-            expect(result).toBeNull();
-        });
-
-        it('should throw error if processId is missing', async () => {
-            await expect(getProcessUseCase.execute(''))
-                .rejects.toThrow('processId must be a non-empty string');
-        });
-
-        it('should throw error if processId is not a string', async () => {
-            await expect(getProcessUseCase.execute(123))
-                .rejects.toThrow('processId must be a non-empty string');
-        });
-
-        it('should handle repository errors', async () => {
-            const repositoryError = new Error('Database connection failed');
-            mockProcessRepository.findById.mockRejectedValue(repositoryError);
-
-            await expect(getProcessUseCase.execute(processId))
-                .rejects.toThrow('Failed to retrieve process: Database connection failed');
-        });
-    });
-
-    describe('executeOrThrow', () => {
-        const processId = 'process-123';
-        const mockProcess = {
-            id: processId,
-            userId: 'user-456',
-            integrationId: 'integration-789',
-            name: 'test-sync',
-            type: 'CRM_SYNC',
-            state: 'COMPLETED',
-        };
-
-        it('should return process if found', async () => {
-            mockProcessRepository.findById.mockResolvedValue(mockProcess);
-
-            const result = await getProcessUseCase.executeOrThrow(processId);
-
-            expect(result).toEqual(mockProcess);
-        });
-
-        it('should throw error if process not found', async () => {
-            mockProcessRepository.findById.mockResolvedValue(null);
-
-            await expect(getProcessUseCase.executeOrThrow(processId))
-                .rejects.toThrow('Process not found: process-123');
-        });
-
-        it('should propagate repository errors', async () => {
-            const repositoryError = new Error('Database connection failed');
-            mockProcessRepository.findById.mockRejectedValue(repositoryError);
-
-            await expect(getProcessUseCase.executeOrThrow(processId))
-                .rejects.toThrow('Failed to retrieve process: Database connection failed');
-        });
-    });
-
-    describe('executeMany', () => {
-        const processIds = ['process-1', 'process-2', 'process-3'];
-        const mockProcesses = [
-            { id: 'process-1', name: 'sync-1', state: 'COMPLETED' },
-            { id: 'process-2', name: 'sync-2', state: 'PROCESSING' },
-            // process-3 will not be found
-        ];
-
-        it('should retrieve multiple processes', async () => {
-            mockProcessRepository.findById
-                .mockResolvedValueOnce(mockProcesses[0])  // process-1 found
-                .mockResolvedValueOnce(mockProcesses[1])  // process-2 found
-                .mockResolvedValueOnce(null);             // process-3 not found
-
-            const result = await getProcessUseCase.executeMany(processIds);
-
-            expect(mockProcessRepository.findById).toHaveBeenCalledTimes(3);
-            expect(mockProcessRepository.findById).toHaveBeenCalledWith('process-1');
-            expect(mockProcessRepository.findById).toHaveBeenCalledWith('process-2');
-            expect(mockProcessRepository.findById).toHaveBeenCalledWith('process-3');
-            
-            // Should return only found processes
-            expect(result).toEqual([mockProcesses[0], mockProcesses[1]]);
-        });
-
-        it('should return empty array if no processes found', async () => {
-            mockProcessRepository.findById
-                .mockResolvedValueOnce(null)
-                .mockResolvedValueOnce(null)
-                .mockResolvedValueOnce(null);
-
-            const result = await getProcessUseCase.executeMany(processIds);
-
-            expect(result).toEqual([]);
-        });
-
-        it('should throw error if processIds is not an array', async () => {
-            await expect(getProcessUseCase.executeMany('not-an-array'))
-                .rejects.toThrow('processIds must be an array');
-        });
-
-        it('should handle mixed success and failure', async () => {
-            const repositoryError = new Error('Database error');
-            mockProcessRepository.findById
-                .mockResolvedValueOnce(mockProcesses[0])  // process-1 found
-                .mockRejectedValueOnce(repositoryError)   // process-2 error
-                .mockResolvedValueOnce(null);             // process-3 not found
-
-            // Should propagate the repository error
-            await expect(getProcessUseCase.executeMany(processIds))
-                .rejects.toThrow('Failed to retrieve process: Database error');
-        });
-
-        it('should handle empty array', async () => {
-            const result = await getProcessUseCase.executeMany([]);
-
-            expect(mockProcessRepository.findById).not.toHaveBeenCalled();
-            expect(result).toEqual([]);
-        });
-    });
-});