@friggframework/devtools 2.0.0--canary.546.74db90f.0 → 2.0.0--canary.545.e7becd9.0

package/frigg-cli/README.md

@@ -1281,7 +1281,7 @@ npm install @friggframework/frigg-cli@latest
 npm install -g @friggframework/frigg-cli
 
 # Local project dependencies
-npx create-frigg-app my-app
+frigg init my-app
 # (Will automatically include @friggframework/frigg-cli in package.json)
 ```
 

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

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

@@ -0,0 +1,337 @@
+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');
+        });
+    });
+});