@friggframework/devtools 2.0.0--canary.545.ae2019f.0 → 2.0.0--canary.549.a579cca.0

package/frigg-cli/__tests__/application/use-cases/AddApiModuleToIntegrationUseCase.test.js

@@ -1,326 +0,0 @@
-const {AddApiModuleToIntegrationUseCase} = require('../../../application/use-cases/AddApiModuleToIntegrationUseCase');
-const {Integration} = require('../../../domain/entities/Integration');
-const {IntegrationName} = require('../../../domain/value-objects/IntegrationName');
-const {SemanticVersion} = require('../../../domain/value-objects/SemanticVersion');
-const {ValidationException} = require('../../../domain/exceptions/DomainException');
-
-// Mock dependencies
-class MockIntegrationRepository {
-    constructor() {
-        this.integrations = new Map();
-        this.saveCalled = false;
-    }
-
-    async save(integration) {
-        this.saveCalled = true;
-        this.integrations.set(integration.name.value, integration);
-        return integration;
-    }
-
-    async findByName(name) {
-        return this.integrations.get(name) || null;
-    }
-
-    async exists(name) {
-        return this.integrations.has(name);
-    }
-}
-
-class MockApiModuleRepository {
-    constructor() {
-        this.modules = new Set(['salesforce', 'stripe', 'hubspot']);
-    }
-
-    async exists(name) {
-        return this.modules.has(name);
-    }
-}
-
-class MockUnitOfWork {
-    constructor() {
-        this.committed = false;
-        this.rolledBack = false;
-    }
-
-    async commit() {
-        this.committed = true;
-    }
-
-    async rollback() {
-        this.rolledBack = true;
-    }
-}
-
-class MockIntegrationValidator {
-    constructor() {
-        this.validateCalled = false;
-        this.shouldFail = false;
-        this.errors = [];
-    }
-
-    validateApiModuleAddition(integration, moduleName, moduleVersion) {
-        this.validateCalled = true;
-        if (this.shouldFail) {
-            return {
-                isValid: false,
-                errors: this.errors
-            };
-        }
-        return {
-            isValid: true,
-            errors: []
-        };
-    }
-}
-
-describe('AddApiModuleToIntegrationUseCase', () => {
-    let useCase;
-    let mockIntegrationRepository;
-    let mockApiModuleRepository;
-    let mockUnitOfWork;
-    let mockValidator;
-
-    beforeEach(() => {
-        mockIntegrationRepository = new MockIntegrationRepository();
-        mockApiModuleRepository = new MockApiModuleRepository();
-        mockUnitOfWork = new MockUnitOfWork();
-        mockValidator = new MockIntegrationValidator();
-
-        useCase = new AddApiModuleToIntegrationUseCase(
-            mockIntegrationRepository,
-            mockApiModuleRepository,
-            mockUnitOfWork,
-            mockValidator
-        );
-
-        // Add a test integration
-        const integration = Integration.create({
-            name: 'test-integration',
-            type: 'api',
-            displayName: 'Test Integration',
-            description: 'Test',
-            category: 'CRM'
-        });
-        mockIntegrationRepository.integrations.set('test-integration', integration);
-    });
-
-    describe('execute()', () => {
-        test('successfully adds API module to integration', async () => {
-            const request = {
-                integrationName: 'test-integration',
-                moduleName: 'salesforce',
-                moduleVersion: '1.0.0',
-                source: 'local'
-            };
-
-            const result = await useCase.execute(request);
-
-            expect(result.success).toBe(true);
-            expect(result.message).toContain("API module 'salesforce' added");
-            expect(result.integration.apiModules).toHaveLength(1);
-            expect(result.integration.apiModules[0].name).toBe('salesforce');
-            expect(mockIntegrationRepository.saveCalled).toBe(true);
-            expect(mockUnitOfWork.committed).toBe(true);
-        });
-
-        test('adds module with correct version', async () => {
-            const request = {
-                integrationName: 'test-integration',
-                moduleName: 'salesforce',
-                moduleVersion: '2.3.0'
-            };
-
-            const result = await useCase.execute(request);
-
-            expect(result.success).toBe(true);
-            expect(result.integration.apiModules[0].version).toBe('2.3.0');
-        });
-
-        test('defaults version to 1.0.0 when not provided', async () => {
-            const request = {
-                integrationName: 'test-integration',
-                moduleName: 'salesforce'
-            };
-
-            const result = await useCase.execute(request);
-
-            expect(result.success).toBe(true);
-            expect(result.integration.apiModules[0].version).toBe('1.0.0');
-        });
-
-        test('defaults source to local when not provided', async () => {
-            const request = {
-                integrationName: 'test-integration',
-                moduleName: 'salesforce'
-            };
-
-            const result = await useCase.execute(request);
-
-            expect(result.success).toBe(true);
-            expect(result.integration.apiModules[0].source).toBe('local');
-        });
-
-        test('allows custom source', async () => {
-            const request = {
-                integrationName: 'test-integration',
-                moduleName: 'salesforce',
-                source: 'npm'
-            };
-
-            const result = await useCase.execute(request);
-
-            expect(result.success).toBe(true);
-            expect(result.integration.apiModules[0].source).toBe('npm');
-        });
-
-        test('throws error when integration not found', async () => {
-            const request = {
-                integrationName: 'non-existent',
-                moduleName: 'salesforce'
-            };
-
-            await expect(useCase.execute(request)).rejects.toThrow(ValidationException);
-            await expect(useCase.execute(request)).rejects.toThrow("Integration 'non-existent' not found");
-            expect(mockUnitOfWork.rolledBack).toBe(true);
-        });
-
-        test('throws error when API module does not exist', async () => {
-            const request = {
-                integrationName: 'test-integration',
-                moduleName: 'non-existent-module'
-            };
-
-            await expect(useCase.execute(request)).rejects.toThrow(ValidationException);
-            await expect(useCase.execute(request)).rejects.toThrow("API module 'non-existent-module' not found");
-            await expect(useCase.execute(request)).rejects.toThrow('Create it first');
-            expect(mockUnitOfWork.rolledBack).toBe(true);
-        });
-
-        test('throws error when API module already added', async () => {
-            // First add
-            await useCase.execute({
-                integrationName: 'test-integration',
-                moduleName: 'salesforce'
-            });
-
-            // Try to add again
-            const request = {
-                integrationName: 'test-integration',
-                moduleName: 'salesforce'
-            };
-
-            await expect(useCase.execute(request)).rejects.toThrow();
-            await expect(useCase.execute(request)).rejects.toThrow('already added');
-            expect(mockUnitOfWork.rolledBack).toBe(true);
-        });
-
-        test('calls validator with correct parameters', async () => {
-            const request = {
-                integrationName: 'test-integration',
-                moduleName: 'salesforce',
-                moduleVersion: '1.5.0'
-            };
-
-            await useCase.execute(request);
-
-            expect(mockValidator.validateCalled).toBe(true);
-        });
-
-        test('throws error when validation fails', async () => {
-            mockValidator.shouldFail = true;
-            mockValidator.errors = ['Some validation error'];
-
-            const request = {
-                integrationName: 'test-integration',
-                moduleName: 'salesforce'
-            };
-
-            await expect(useCase.execute(request)).rejects.toThrow(ValidationException);
-            expect(mockUnitOfWork.rolledBack).toBe(true);
-        });
-
-        test('commits transaction only after all operations succeed', async () => {
-            const request = {
-                integrationName: 'test-integration',
-                moduleName: 'salesforce'
-            };
-
-            await useCase.execute(request);
-
-            expect(mockIntegrationRepository.saveCalled).toBe(true);
-            expect(mockUnitOfWork.committed).toBe(true);
-            expect(mockUnitOfWork.rolledBack).toBe(false);
-        });
-
-        test('rollsback on repository save error', async () => {
-            mockIntegrationRepository.save = async () => {
-                throw new Error('Database error');
-            };
-
-            const request = {
-                integrationName: 'test-integration',
-                moduleName: 'salesforce'
-            };
-
-            await expect(useCase.execute(request)).rejects.toThrow('Database error');
-            expect(mockUnitOfWork.rolledBack).toBe(true);
-        });
-
-        test('allows adding multiple different API modules', async () => {
-            await useCase.execute({
-                integrationName: 'test-integration',
-                moduleName: 'salesforce'
-            });
-
-            const result = await useCase.execute({
-                integrationName: 'test-integration',
-                moduleName: 'stripe'
-            });
-
-            expect(result.success).toBe(true);
-            expect(result.integration.apiModules).toHaveLength(2);
-            expect(result.integration.apiModules.map(m => m.name)).toContain('salesforce');
-            expect(result.integration.apiModules.map(m => m.name)).toContain('stripe');
-        });
-
-        test('returns integration object with updated apiModules', async () => {
-            const request = {
-                integrationName: 'test-integration',
-                moduleName: 'salesforce',
-                moduleVersion: '1.0.0',
-                source: 'local'
-            };
-
-            const result = await useCase.execute(request);
-
-            expect(result.integration).toHaveProperty('id');
-            expect(result.integration).toHaveProperty('name');
-            expect(result.integration).toHaveProperty('version');
-            expect(result.integration).toHaveProperty('apiModules');
-            expect(result.integration.apiModules).toBeInstanceOf(Array);
-        });
-
-        test('preserves existing integration data', async () => {
-            const integration = Integration.create({
-                name: 'salesforce-sync',
-                type: 'sync',
-                displayName: 'Salesforce Sync',
-                description: 'Sync data with Salesforce',
-                category: 'CRM'
-            });
-            mockIntegrationRepository.integrations.set('salesforce-sync', integration);
-
-            const request = {
-                integrationName: 'salesforce-sync',
-                moduleName: 'salesforce'
-            };
-
-            const result = await useCase.execute(request);
-
-            expect(result.integration.name).toBe('salesforce-sync');
-            expect(result.integration.type).toBe('sync');
-            expect(result.integration.displayName).toBe('Salesforce Sync');
-            expect(result.integration.description).toBe('Sync data with Salesforce');
-        });
-    });
-});

package/frigg-cli/__tests__/application/use-cases/CreateApiModuleUseCase.test.js

@@ -1,337 +0,0 @@
-const {CreateApiModuleUseCase} = require('../../../application/use-cases/CreateApiModuleUseCase');
-const {ApiModule} = require('../../../domain/entities/ApiModule');
-const {DomainException, ValidationException} = require('../../../domain/exceptions/DomainException');
-
-// Mock dependencies
-class MockApiModuleRepository {
-    constructor() {
-        this.modules = new Map();
-        this.saveCalled = false;
-    }
-
-    async save(apiModule) {
-        this.saveCalled = true;
-        this.modules.set(apiModule.name, apiModule);
-        return apiModule;
-    }
-
-    async findByName(name) {
-        return this.modules.get(name) || null;
-    }
-
-    async exists(name) {
-        return this.modules.has(name);
-    }
-
-    async list() {
-        return Array.from(this.modules.values());
-    }
-}
-
-class MockAppDefinitionRepository {
-    constructor() {
-        this.appDef = null;
-        this.loadCalled = false;
-        this.saveCalled = false;
-    }
-
-    async load() {
-        this.loadCalled = true;
-        return this.appDef;
-    }
-
-    async save(appDef) {
-        this.saveCalled = true;
-        this.appDef = appDef;
-        return appDef;
-    }
-
-    async exists() {
-        return this.appDef !== null;
-    }
-}
-
-class MockUnitOfWork {
-    constructor() {
-        this.committed = false;
-        this.rolledBack = false;
-        this.operations = [];
-    }
-
-    addOperation(operation) {
-        this.operations.push(operation);
-    }
-
-    async commit() {
-        this.committed = true;
-    }
-
-    async rollback() {
-        this.rolledBack = true;
-    }
-}
-
-describe('CreateApiModuleUseCase', () => {
-    let useCase;
-    let mockApiModuleRepository;
-    let mockAppDefinitionRepository;
-    let mockUnitOfWork;
-
-    beforeEach(() => {
-        mockApiModuleRepository = new MockApiModuleRepository();
-        mockAppDefinitionRepository = new MockAppDefinitionRepository();
-        mockUnitOfWork = new MockUnitOfWork();
-
-        useCase = new CreateApiModuleUseCase(
-            mockApiModuleRepository,
-            mockUnitOfWork,
-            mockAppDefinitionRepository
-        );
-    });
-
-    describe('execute()', () => {
-        test('successfully creates a new API module with required fields', async () => {
-            const request = {
-                name: 'salesforce',
-                displayName: 'Salesforce',
-                description: 'Salesforce CRM API',
-                baseUrl: 'https://api.salesforce.com',
-                authType: 'oauth2',
-                apiVersion: 'v1'
-            };
-
-            const result = await useCase.execute(request);
-
-            expect(result.success).toBe(true);
-            expect(result.apiModule.name).toBe('salesforce');
-            expect(result.apiModule.displayName).toBe('Salesforce');
-            expect(mockApiModuleRepository.saveCalled).toBe(true);
-            expect(mockUnitOfWork.committed).toBe(true);
-        });
-
-        test('creates module with minimal required fields', async () => {
-            const request = {
-                name: 'stripe-api',
-                authType: 'api-key'
-            };
-
-            const result = await useCase.execute(request);
-
-            expect(result.success).toBe(true);
-            expect(result.apiModule.name).toBe('stripe-api');
-            expect(result.apiModule.displayName).toBe('Stripe Api');
-            expect(result.apiModule.apiConfig.authType).toBe('api-key');
-        });
-
-        test('creates module with entities', async () => {
-            const request = {
-                name: 'salesforce',
-                authType: 'oauth2',
-                entities: {
-                    account: {
-                        label: 'Salesforce Account',
-                        required: true,
-                        fields: ['id', 'name']
-                    }
-                }
-            };
-
-            const result = await useCase.execute(request);
-
-            expect(result.success).toBe(true);
-            expect(result.apiModule.entities).toHaveProperty('account');
-            expect(result.apiModule.entities.account.label).toBe('Salesforce Account');
-        });
-
-        test('creates module with OAuth scopes', async () => {
-            const request = {
-                name: 'salesforce',
-                authType: 'oauth2',
-                scopes: ['read:accounts', 'write:accounts']
-            };
-
-            const result = await useCase.execute(request);
-
-            expect(result.success).toBe(true);
-            expect(result.apiModule.scopes).toEqual(['read:accounts', 'write:accounts']);
-        });
-
-        test('creates module with credentials', async () => {
-            const request = {
-                name: 'salesforce',
-                authType: 'oauth2',
-                credentials: [
-                    {
-                        name: 'clientId',
-                        type: 'string',
-                        required: true,
-                        description: 'OAuth client ID'
-                    }
-                ]
-            };
-
-            const result = await useCase.execute(request);
-
-            expect(result.success).toBe(true);
-            expect(result.apiModule.credentials).toHaveLength(1);
-            expect(result.apiModule.credentials[0].name).toBe('clientId');
-        });
-
-        test('registers API module in app definition if available', async () => {
-            // Setup app definition
-            const AppDefinition = require('../../../domain/entities/AppDefinition').AppDefinition;
-            mockAppDefinitionRepository.appDef = AppDefinition.create({
-                name: 'test-app',
-                version: '1.0.0'
-            });
-
-            const request = {
-                name: 'salesforce',
-                authType: 'oauth2'
-            };
-
-            const result = await useCase.execute(request);
-
-            expect(result.success).toBe(true);
-            expect(mockAppDefinitionRepository.loadCalled).toBe(true);
-            expect(mockAppDefinitionRepository.saveCalled).toBe(true);
-            expect(mockAppDefinitionRepository.appDef.hasApiModule('salesforce')).toBe(true);
-        });
-
-        test('succeeds even if app definition does not exist', async () => {
-            mockAppDefinitionRepository.appDef = null;
-
-            const request = {
-                name: 'salesforce',
-                authType: 'oauth2'
-            };
-
-            const result = await useCase.execute(request);
-
-            expect(result.success).toBe(true);
-            expect(mockAppDefinitionRepository.loadCalled).toBe(true);
-            expect(mockAppDefinitionRepository.saveCalled).toBe(false);
-        });
-
-        test('throws validation error when name is missing', async () => {
-            const request = {
-                authType: 'oauth2'
-            };
-
-            await expect(useCase.execute(request)).rejects.toThrow(DomainException);
-            expect(mockUnitOfWork.rolledBack).toBe(true);
-        });
-
-        test('throws validation error when name is invalid', async () => {
-            const request = {
-                name: 'Invalid Name!',
-                authType: 'oauth2'
-            };
-
-            await expect(useCase.execute(request)).rejects.toThrow();
-            expect(mockUnitOfWork.rolledBack).toBe(true);
-        });
-
-        test('defaults authType to oauth2 when missing', async () => {
-            const request = {
-                name: 'salesforce'
-            };
-
-            const result = await useCase.execute(request);
-
-            expect(result.success).toBe(true);
-            expect(result.apiModule.apiConfig.authType).toBe('oauth2');
-        });
-
-        test('rollsback on repository error', async () => {
-            mockApiModuleRepository.save = async () => {
-                throw new Error('Database error');
-            };
-
-            const request = {
-                name: 'salesforce',
-                authType: 'oauth2'
-            };
-
-            await expect(useCase.execute(request)).rejects.toThrow('Database error');
-            expect(mockUnitOfWork.rolledBack).toBe(true);
-        });
-
-        test('succeeds even if app definition registration fails', async () => {
-            // Setup app definition that will fail
-            const AppDefinition = require('../../../domain/entities/AppDefinition').AppDefinition;
-            mockAppDefinitionRepository.appDef = AppDefinition.create({
-                name: 'test-app',
-                version: '1.0.0'
-            });
-
-            // Make save throw error
-            const consoleSpy = jest.spyOn(console, 'warn').mockImplementation();
-            mockAppDefinitionRepository.save = async () => {
-                throw new Error('Failed to update app definition');
-            };
-
-            const request = {
-                name: 'salesforce',
-                authType: 'oauth2'
-            };
-
-            const result = await useCase.execute(request);
-
-            expect(result.success).toBe(true);
-            expect(consoleSpy).toHaveBeenCalledWith(
-                expect.stringContaining('Could not register API module'),
-                expect.any(String)
-            );
-            expect(mockUnitOfWork.committed).toBe(true);
-            expect(mockUnitOfWork.rolledBack).toBe(false);
-
-            consoleSpy.mockRestore();
-        });
-
-        test('commits transaction only after all operations succeed', async () => {
-            const AppDefinition = require('../../../domain/entities/AppDefinition').AppDefinition;
-            mockAppDefinitionRepository.appDef = AppDefinition.create({
-                name: 'test-app',
-                version: '1.0.0'
-            });
-
-            const request = {
-                name: 'salesforce',
-                authType: 'oauth2'
-            };
-
-            const result = await useCase.execute(request);
-
-            expect(result.success).toBe(true);
-            expect(mockApiModuleRepository.saveCalled).toBe(true);
-            expect(mockAppDefinitionRepository.saveCalled).toBe(true);
-            expect(mockUnitOfWork.committed).toBe(true);
-            expect(mockUnitOfWork.rolledBack).toBe(false);
-        });
-
-        test('returns full API module object', async () => {
-            const request = {
-                name: 'salesforce',
-                displayName: 'Salesforce',
-                description: 'Salesforce CRM API',
-                authType: 'oauth2',
-                baseUrl: 'https://api.salesforce.com',
-                version: '2.0.0'
-            };
-
-            const result = await useCase.execute(request);
-
-            expect(result.apiModule).toHaveProperty('name');
-            expect(result.apiModule).toHaveProperty('version');
-            expect(result.apiModule).toHaveProperty('displayName');
-            expect(result.apiModule).toHaveProperty('description');
-            expect(result.apiModule).toHaveProperty('apiConfig');
-            expect(result.apiModule).toHaveProperty('entities');
-            expect(result.apiModule).toHaveProperty('scopes');
-            expect(result.apiModule).toHaveProperty('credentials');
-            expect(result.apiModule).toHaveProperty('createdAt');
-            expect(result.apiModule).toHaveProperty('updatedAt');
-        });
-    });
-});