@friggframework/core 2.0.0--canary.461.61382d8.0 → 2.0.0--canary.461.3d6d8ad.0

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([]);
-        });
-    });
-});

package/integrations/use-cases/load-integration-context-full.test.js

@@ -1,329 +0,0 @@
-jest.mock('../../database/config', () => ({
-    DB_TYPE: 'mongodb',
-    getDatabaseType: jest.fn(() => 'mongodb'),
-    PRISMA_LOG_LEVEL: 'error,warn',
-    PRISMA_QUERY_LOGGING: false,
-}));
-
-const { LoadIntegrationContextUseCase } = require('./load-integration-context');
-const { IntegrationBase } = require('../integration-base');
-const { createIntegrationRepository } = require('../repositories/integration-repository-factory');
-const { Module } = require('../../modules/module');
-const { ModuleFactory } = require('../../modules/module-factory');
-const { ModuleRepository } = require('../../modules/repositories/module-repository');
-
-// Mock OAuth2 API class that extends requester pattern
-class MockAsanaApi {
-    constructor(params) {
-        // Capture all injected params
-        this.client_id = params.client_id;
-        this.client_secret = params.client_secret;
-        this.redirect_uri = params.redirect_uri;
-        this.scope = params.scope;
-        this.access_token = params.access_token;
-        this.refresh_token = params.refresh_token;
-        this.delegate = params.delegate;
-    }
-
-    async getFolders() {
-        if (!this.access_token) {
-            throw new Error('No access token');
-        }
-        return {
-            folders: ['Marketing', 'Development', 'Design'],
-            usedToken: this.access_token
-        };
-    }
-
-    async listProjects() {
-        return {
-            projects: ['Q1 Launch', 'Website Redesign'],
-            clientId: this.client_id
-        };
-    }
-
-    getAuthorizationRequirements() {
-        return { type: 'oauth2', url: this.redirect_uri };
-    }
-}
-
-MockAsanaApi.requesterType = 'oauth2';
-
-class MockFrontifyApi {
-    constructor(params) {
-        this.client_id = params.client_id;
-        this.client_secret = params.client_secret;
-        this.redirect_uri = params.redirect_uri;
-        this.scope = params.scope;
-        this.access_token = params.access_token;
-        this.refresh_token = params.refresh_token;
-        this.domain = params.domain;
-    }
-
-    async listBrands() {
-        return {
-            brands: ['Main Brand', 'Sub Brand'],
-            domain: this.domain,
-            token: this.access_token
-        };
-    }
-
-    async searchAssets(query) {
-        return {
-            query,
-            assets: ['logo.svg', 'guidelines.pdf'],
-            clientSecret: this.client_secret ? 'hidden' : null
-        };
-    }
-
-    getAuthorizationRequirements() {
-        return { type: 'oauth2', url: this.redirect_uri };
-    }
-}
-
-MockFrontifyApi.requesterType = 'oauth2';
-
-// Module definitions with env variables
-const asanaDefinition = {
-    moduleName: 'asana',
-    modelName: 'Asana',
-    API: MockAsanaApi,
-    requiredAuthMethods: {
-        getToken: async () => {},
-        getEntityDetails: async () => {},
-        getCredentialDetails: async () => {},
-        apiPropertiesToPersist: {
-            credential: ['access_token', 'refresh_token'],
-            entity: [],
-        },
-        testAuthRequest: async () => true,
-    },
-    env: {
-        client_id: 'ASANA_CLIENT_ID_FROM_ENV',
-        client_secret: 'ASANA_SECRET_FROM_ENV',
-        redirect_uri: 'https://app.example.com/auth/asana',
-        scope: 'default',
-    },
-};
-
-const frontifyDefinition = {
-    moduleName: 'frontify',
-    modelName: 'Frontify',
-    API: MockFrontifyApi,
-    requiredAuthMethods: {
-        getToken: async () => {},
-        getEntityDetails: async () => {},
-        getCredentialDetails: async () => {},
-        apiPropertiesToPersist: {
-            credential: ['access_token', 'refresh_token'],
-            entity: ['domain'],
-        },
-        testAuthRequest: async () => true,
-    },
-    env: {
-        client_id: 'FRONTIFY_CLIENT_ID_FROM_ENV',
-        client_secret: 'FRONTIFY_SECRET_FROM_ENV',
-        redirect_uri: 'https://app.example.com/auth/frontify',
-        scope: 'read write',
-    },
-};
-
-// Integration class similar to AsanaIntegration
-class TestIntegration extends IntegrationBase {
-    static Definition = {
-        name: 'test-integration',
-        version: '1.0.0',
-        modules: {
-            asana: {
-                definition: asanaDefinition,
-            },
-            frontify: {
-                definition: frontifyDefinition,
-            },
-        },
-    };
-
-    async performBusinessLogic() {
-        // After hydration, this method can use API modules
-        const folders = await this.asana.api.getFolders();
-        const brands = await this.frontify.api.listBrands();
-        return { folders, brands };
-    }
-}
-
-describe('LoadIntegrationContextUseCase - Full Rounded Test', () => {
-    it('should load integration with working API modules that have env vars and credentials', async () => {
-        // Setup: Create entities with credentials (simulating DB records)
-        const entities = [
-            {
-                id: 'entity-asana-123',
-                moduleName: 'asana',
-                userId: 'user-789',
-                credential: {
-                    data: {
-                        access_token: 'asana_access_token_xyz',
-                        refresh_token: 'asana_refresh_token_abc',
-                    },
-                },
-            },
-            {
-                id: 'entity-frontify-456',
-                moduleName: 'frontify',
-                userId: 'user-789',
-                domain: 'customer.frontify.com',
-                credential: {
-                    data: {
-                        access_token: 'frontify_access_token_uvw',
-                        refresh_token: 'frontify_refresh_token_def',
-                    },
-                },
-            },
-        ];
-
-        // Mock repositories
-        const moduleRepository = {
-            findEntitiesByIds: jest.fn().mockResolvedValue(entities),
-            findEntityById: jest.fn().mockImplementation((id) =>
-                Promise.resolve(entities.find(e => e.id === id))
-            ),
-        };
-
-        // Create module factory with definitions
-        const moduleFactory = new ModuleFactory({
-            moduleRepository,
-            moduleDefinitions: [asanaDefinition, frontifyDefinition],
-        });
-
-        // Create the use case
-        const useCase = new LoadIntegrationContextUseCase({
-            integrationRepository: createIntegrationRepository(),
-            moduleRepository,
-            moduleFactory,
-        });
-
-        // Execute: Load integration context
-        const integrationRecord = {
-            id: 'integration-999',
-            userId: 'user-789',
-            entitiesIds: ['entity-asana-123', 'entity-frontify-456'],
-            status: 'active',
-            config: { someConfig: true },
-        };
-
-        const context = await useCase.execute({ integrationRecord });
-
-        // Verify: Context has modules
-        expect(context.modules).toHaveLength(2);
-
-        // Create integration instance and hydrate it
-        const integration = new TestIntegration();
-        integration.setIntegrationRecord(context);
-
-        // Verify: Integration has modules attached
-        expect(integration.asana).toBeDefined();
-        expect(integration.frontify).toBeDefined();
-        expect(integration.modules.asana).toBe(integration.asana);
-        expect(integration.modules.frontify).toBe(integration.frontify);
-
-        // CRITICAL TEST: Verify API instances have env vars from definition
-        expect(integration.asana.api.client_id).toBe('ASANA_CLIENT_ID_FROM_ENV');
-        expect(integration.asana.api.client_secret).toBe('ASANA_SECRET_FROM_ENV');
-        expect(integration.asana.api.redirect_uri).toBe('https://app.example.com/auth/asana');
-        expect(integration.asana.api.scope).toBe('default');
-
-        expect(integration.frontify.api.client_id).toBe('FRONTIFY_CLIENT_ID_FROM_ENV');
-        expect(integration.frontify.api.client_secret).toBe('FRONTIFY_SECRET_FROM_ENV');
-        expect(integration.frontify.api.redirect_uri).toBe('https://app.example.com/auth/frontify');
-        expect(integration.frontify.api.scope).toBe('read write');
-
-        // CRITICAL TEST: Verify API instances have credentials from entities
-        expect(integration.asana.api.access_token).toBe('asana_access_token_xyz');
-        expect(integration.asana.api.refresh_token).toBe('asana_refresh_token_abc');
-
-        expect(integration.frontify.api.access_token).toBe('frontify_access_token_uvw');
-        expect(integration.frontify.api.refresh_token).toBe('frontify_refresh_token_def');
-        expect(integration.frontify.api.domain).toBe('customer.frontify.com');
-
-        // CRITICAL TEST: Can call API methods successfully
-        const folders = await integration.asana.api.getFolders();
-        expect(folders.folders).toEqual(['Marketing', 'Development', 'Design']);
-        expect(folders.usedToken).toBe('asana_access_token_xyz');
-
-        const projects = await integration.asana.api.listProjects();
-        expect(projects.projects).toEqual(['Q1 Launch', 'Website Redesign']);
-        expect(projects.clientId).toBe('ASANA_CLIENT_ID_FROM_ENV');
-
-        const brands = await integration.frontify.api.listBrands();
-        expect(brands.brands).toEqual(['Main Brand', 'Sub Brand']);
-        expect(brands.domain).toBe('customer.frontify.com');
-        expect(brands.token).toBe('frontify_access_token_uvw');
-
-        const assets = await integration.frontify.api.searchAssets('logo');
-        expect(assets.query).toBe('logo');
-        expect(assets.assets).toEqual(['logo.svg', 'guidelines.pdf']);
-        expect(assets.clientSecret).toBe('hidden'); // Verifies secret exists
-
-        // CRITICAL TEST: Business logic methods can use hydrated APIs
-        const businessResult = await integration.performBusinessLogic();
-        expect(businessResult.folders.folders).toEqual(['Marketing', 'Development', 'Design']);
-        expect(businessResult.brands.brands).toEqual(['Main Brand', 'Sub Brand']);
-
-        // Verify the complete chain: env → Module → API → Integration
-        console.log('\n✅ Full Integration Test Results:');
-        console.log('  ENV vars injected: ✓');
-        console.log('  Credentials injected: ✓');
-        console.log('  API methods callable: ✓');
-        console.log('  Business logic works: ✓');
-    });
-
-    it('should handle missing credentials gracefully', async () => {
-        // Entity without credentials
-        const entities = [
-            {
-                id: 'entity-no-creds',
-                moduleName: 'asana',
-                userId: 'user-123',
-                credential: {
-                    data: {
-                        // Empty credential data - no access_token
-                    },
-                },
-            },
-        ];
-
-        const moduleRepository = {
-            findEntitiesByIds: jest.fn().mockResolvedValue(entities),
-            findEntityById: jest.fn().mockResolvedValue(entities[0]),
-        };
-
-        const moduleFactory = new ModuleFactory({
-            moduleRepository,
-            moduleDefinitions: [asanaDefinition],
-        });
-
-        const useCase = new LoadIntegrationContextUseCase({
-            integrationRepository: createIntegrationRepository(),
-            moduleRepository,
-            moduleFactory,
-        });
-
-        const context = await useCase.execute({
-            integrationRecord: {
-                id: 'integration-1',
-                userId: 'user-123',
-                entitiesIds: ['entity-no-creds'],
-            },
-        });
-
-        const integration = new TestIntegration();
-        integration.setIntegrationRecord(context);
-
-        // Should have module with env vars but no credentials
-        expect(integration.asana).toBeDefined();
-        expect(integration.asana.api.client_id).toBe('ASANA_CLIENT_ID_FROM_ENV');
-        expect(integration.asana.api.access_token).toBeUndefined();
-
-        // API method should fail without token
-        await expect(integration.asana.api.getFolders()).rejects.toThrow('No access token');
-    });
-});