@friggframework/devtools 2.0.0--canary.548.c8ae0ca.0 → 2.0.0--canary.545.c40eca4.0

package/frigg-cli/__tests__/infrastructure/repositories/FileSystemAppDefinitionRepository.test.js

@@ -0,0 +1,314 @@
+const {FileSystemAppDefinitionRepository} = require('../../../infrastructure/repositories/FileSystemAppDefinitionRepository');
+const {AppDefinition} = require('../../../domain/entities/AppDefinition');
+
+describe('FileSystemAppDefinitionRepository', () => {
+    let repository;
+    let mockFileSystemAdapter;
+    let mockSchemaValidator;
+    let projectRoot;
+
+    beforeEach(() => {
+        projectRoot = '/test/project/backend';
+
+        mockFileSystemAdapter = {
+            exists: jest.fn(),
+            ensureDirectory: jest.fn(),
+            writeFile: jest.fn(),
+            updateFile: jest.fn(),
+            readFile: jest.fn(),
+        };
+
+        mockSchemaValidator = {
+            validate: jest.fn(),
+        };
+
+        repository = new FileSystemAppDefinitionRepository(
+            mockFileSystemAdapter,
+            projectRoot,
+            mockSchemaValidator
+        );
+    });
+
+    describe('load', () => {
+        it('should load app definition from file', async () => {
+            const appDefJson = {
+                name: 'my-frigg-app',
+                version: '1.0.0',
+                description: 'Test app',
+                integrations: ['integration-1'],
+                apiModules: ['salesforce', 'stripe'],
+            };
+
+            mockFileSystemAdapter.exists.mockResolvedValue(true);
+            mockFileSystemAdapter.readFile.mockResolvedValue(JSON.stringify(appDefJson));
+
+            const result = await repository.load();
+
+            expect(result).toBeInstanceOf(AppDefinition);
+            expect(result.name).toBe('my-frigg-app');
+            expect(result.version.value).toBe('1.0.0');
+            expect(result.integrations).toEqual(['integration-1']);
+            expect(result.apiModules).toEqual(['salesforce', 'stripe']);
+        });
+
+        it('should return null if app definition does not exist', async () => {
+            mockFileSystemAdapter.exists.mockResolvedValue(false);
+
+            const result = await repository.load();
+
+            expect(result).toBeNull();
+        });
+
+        it('should handle missing integrations array', async () => {
+            const appDefJson = {
+                name: 'my-frigg-app',
+                version: '1.0.0',
+                // no integrations field
+            };
+
+            mockFileSystemAdapter.exists.mockResolvedValue(true);
+            mockFileSystemAdapter.readFile.mockResolvedValue(JSON.stringify(appDefJson));
+
+            const result = await repository.load();
+
+            expect(result).toBeInstanceOf(AppDefinition);
+            expect(result.integrations).toEqual([]);
+            expect(result.apiModules).toEqual([]);
+        });
+    });
+
+    describe('save', () => {
+        it('should save app definition to file', async () => {
+            const appDef = AppDefinition.create({
+                name: 'my-frigg-app',
+                version: '1.0.0',
+                description: 'Test app',
+            });
+
+            mockSchemaValidator.validate.mockResolvedValue({valid: true, errors: []});
+            mockFileSystemAdapter.exists.mockResolvedValue(false);
+
+            await repository.save(appDef);
+
+            expect(mockFileSystemAdapter.ensureDirectory).toHaveBeenCalledWith(
+                '/test/project/backend'
+            );
+            expect(mockFileSystemAdapter.writeFile).toHaveBeenCalledWith(
+                '/test/project/backend/app-definition.json',
+                expect.stringContaining('"name": "my-frigg-app"')
+            );
+        });
+
+        it('should update existing app definition file', async () => {
+            const appDef = AppDefinition.create({
+                name: 'my-frigg-app',
+                version: '1.0.0',
+                description: 'Test app',
+            });
+
+            mockSchemaValidator.validate.mockResolvedValue({valid: true, errors: []});
+            mockFileSystemAdapter.exists.mockResolvedValue(true);
+
+            await repository.save(appDef);
+
+            expect(mockFileSystemAdapter.updateFile).toHaveBeenCalled();
+            expect(mockFileSystemAdapter.writeFile).not.toHaveBeenCalled();
+        });
+
+        it('should throw error if validation fails', async () => {
+            const appDef = AppDefinition.create({
+                name: 'my-frigg-app',
+                version: '1.0.0',
+            });
+
+            // Mock validate to return invalid
+            jest.spyOn(appDef, 'validate').mockReturnValue({
+                isValid: false,
+                errors: ['Invalid configuration'],
+            });
+
+            await expect(repository.save(appDef)).rejects.toThrow(
+                'AppDefinition validation failed'
+            );
+        });
+
+        it('should throw error if schema validation fails', async () => {
+            const appDef = AppDefinition.create({
+                name: 'my-frigg-app',
+                version: '1.0.0',
+            });
+
+            mockSchemaValidator.validate.mockResolvedValue({
+                valid: false,
+                errors: ['Invalid schema'],
+            });
+
+            await expect(repository.save(appDef)).rejects.toThrow(
+                'Schema validation failed'
+            );
+        });
+
+        it('should save with integrations and API modules', async () => {
+            const appDef = AppDefinition.create({
+                name: 'my-frigg-app',
+                version: '1.0.0',
+            });
+
+            appDef.registerIntegration('test-integration', {
+                name: 'test-integration',
+                version: '1.0.0',
+                type: 'api',
+            });
+
+            appDef.registerApiModule('salesforce', {
+                name: 'salesforce',
+                version: '1.0.0',
+                authType: 'oauth2',
+            });
+
+            mockSchemaValidator.validate.mockResolvedValue({valid: true, errors: []});
+            mockFileSystemAdapter.exists.mockResolvedValue(false);
+
+            await repository.save(appDef);
+
+            const writeCall = mockFileSystemAdapter.writeFile.mock.calls[0];
+            const savedData = JSON.parse(writeCall[1]);
+
+            // AppDefinition stores integrations and apiModules as objects
+            expect(savedData.integrations).toEqual([{
+                name: 'test-integration',
+                enabled: true,
+            }]);
+            // apiModules include name, source, and version object
+            expect(savedData.apiModules).toHaveLength(1);
+            expect(savedData.apiModules[0].name).toBe('salesforce');
+            expect(savedData.apiModules[0].source).toBe('npm'); // default source
+        });
+
+        it('should format JSON with 2-space indentation', async () => {
+            const appDef = AppDefinition.create({
+                name: 'my-frigg-app',
+                version: '1.0.0',
+            });
+
+            mockSchemaValidator.validate.mockResolvedValue({valid: true, errors: []});
+            mockFileSystemAdapter.exists.mockResolvedValue(false);
+
+            await repository.save(appDef);
+
+            const writeCall = mockFileSystemAdapter.writeFile.mock.calls[0];
+            const content = writeCall[1];
+
+            // Check for 2-space indentation
+            expect(content).toMatch(/{\n  "name"/);
+        });
+    });
+
+    describe('exists', () => {
+        it('should return true if app definition exists', async () => {
+            mockFileSystemAdapter.exists.mockResolvedValue(true);
+
+            const result = await repository.exists();
+
+            expect(result).toBe(true);
+            expect(mockFileSystemAdapter.exists).toHaveBeenCalledWith(
+                '/test/project/backend/app-definition.json'
+            );
+        });
+
+        it('should return false if app definition does not exist', async () => {
+            mockFileSystemAdapter.exists.mockResolvedValue(false);
+
+            const result = await repository.exists();
+
+            expect(result).toBe(false);
+        });
+    });
+
+    describe('create', () => {
+        it('should create new app definition', async () => {
+            mockFileSystemAdapter.exists.mockResolvedValue(false);
+            mockSchemaValidator.validate.mockResolvedValue({valid: true, errors: []});
+
+            const result = await repository.create({
+                name: 'my-frigg-app',
+                version: '1.0.0',
+                description: 'Test app',
+            });
+
+            expect(result).toBeInstanceOf(AppDefinition);
+            expect(result.name).toBe('my-frigg-app');
+            expect(mockFileSystemAdapter.writeFile).toHaveBeenCalled();
+        });
+
+        it('should throw error if app definition already exists', async () => {
+            mockFileSystemAdapter.exists.mockResolvedValue(true);
+
+            await expect(
+                repository.create({
+                    name: 'my-frigg-app',
+                    version: '1.0.0',
+                })
+            ).rejects.toThrow('App definition already exists');
+        });
+
+        it('should validate and save created app definition', async () => {
+            mockFileSystemAdapter.exists.mockResolvedValue(false);
+            mockSchemaValidator.validate.mockResolvedValue({valid: true, errors: []});
+
+            await repository.create({
+                name: 'my-frigg-app',
+                version: '1.0.0',
+            });
+
+            expect(mockSchemaValidator.validate).toHaveBeenCalledWith(
+                'app-definition',
+                expect.any(Object)
+            );
+            expect(mockFileSystemAdapter.writeFile).toHaveBeenCalled();
+        });
+    });
+
+    describe('_toDomainEntity', () => {
+        it('should convert JSON to AppDefinition entity', () => {
+            const data = {
+                name: 'my-frigg-app',
+                version: '1.0.0',
+                description: 'Test app',
+                author: 'Test Author',
+                license: 'MIT',
+                repository: 'https://github.com/test/repo',
+                integrations: ['integration-1'],
+                apiModules: ['salesforce'],
+                config: {env: 'production'},
+            };
+
+            const result = repository._toDomainEntity(data);
+
+            expect(result).toBeInstanceOf(AppDefinition);
+            expect(result.name).toBe('my-frigg-app');
+            expect(result.version.value).toBe('1.0.0');
+            expect(result.description).toBe('Test app');
+            expect(result.author).toBe('Test Author');
+            expect(result.license).toBe('MIT');
+            expect(result.repository).toBe('https://github.com/test/repo');
+            expect(result.integrations).toEqual(['integration-1']);
+            expect(result.apiModules).toEqual(['salesforce']);
+            expect(result.config).toEqual({env: 'production'});
+        });
+
+        it('should handle minimal data', () => {
+            const data = {
+                name: 'my-frigg-app',
+                version: '1.0.0',
+            };
+
+            const result = repository._toDomainEntity(data);
+
+            expect(result).toBeInstanceOf(AppDefinition);
+            expect(result.integrations).toEqual([]);
+            expect(result.apiModules).toEqual([]);
+            expect(result.config).toEqual({});
+        });
+    });
+});

package/frigg-cli/__tests__/infrastructure/repositories/FileSystemIntegrationRepository.test.js

@@ -0,0 +1,383 @@
+const {FileSystemIntegrationRepository} = require('../../../infrastructure/repositories/FileSystemIntegrationRepository');
+const {Integration} = require('../../../domain/entities/Integration');
+const {IntegrationName} = require('../../../domain/value-objects/IntegrationName');
+
+describe('FileSystemIntegrationRepository', () => {
+    let repository;
+    let mockFileSystemAdapter;
+    let mockSchemaValidator;
+    let backendPath;
+
+    beforeEach(() => {
+        backendPath = '/test/project/backend';
+
+        mockFileSystemAdapter = {
+            exists: jest.fn(),
+            ensureDirectory: jest.fn(),
+            writeFile: jest.fn(),
+            readFile: jest.fn(),
+            listFiles: jest.fn(),
+        };
+
+        mockSchemaValidator = {
+            validate: jest.fn(),
+        };
+
+        repository = new FileSystemIntegrationRepository(
+            mockFileSystemAdapter,
+            backendPath,
+            mockSchemaValidator
+        );
+    });
+
+    describe('save', () => {
+        it('should save a new integration as a single file', async () => {
+            const integration = new Integration({
+                name: 'test-integration',
+                version: '1.0.0',
+                displayName: 'Test Integration',
+                description: 'Test description',
+                type: 'sync',
+                category: 'CRM',
+            });
+
+            mockSchemaValidator.validate.mockResolvedValue({valid: true, errors: []});
+            mockFileSystemAdapter.exists.mockResolvedValue(false); // Integration.js doesn't exist yet
+
+            await repository.save(integration);
+
+            // Verify integrations directory created
+            expect(mockFileSystemAdapter.ensureDirectory).toHaveBeenCalledWith(
+                '/test/project/backend/src/integrations'
+            );
+
+            // Verify schema validation
+            expect(mockSchemaValidator.validate).toHaveBeenCalledWith(
+                'integration-definition',
+                expect.any(Object)
+            );
+
+            // Verify only Integration.js written
+            expect(mockFileSystemAdapter.writeFile).toHaveBeenCalledTimes(1);
+
+            // Verify Integration.js content
+            const writeCall = mockFileSystemAdapter.writeFile.mock.calls[0];
+            expect(writeCall[0]).toBe('/test/project/backend/src/integrations/TestIntegrationIntegration.js');
+            expect(writeCall[1]).toContain('class TestIntegrationIntegration extends IntegrationBase');
+            expect(writeCall[1]).toContain('static Definition = {');
+            expect(writeCall[1]).toContain("name: 'test-integration'");
+        });
+
+        it('should NOT write Integration.js if it already exists', async () => {
+            const integration = new Integration({
+                name: 'test-integration',
+                version: '1.0.0',
+                displayName: 'Test Integration',
+                description: 'Test description',
+            });
+
+            mockSchemaValidator.validate.mockResolvedValue({valid: true, errors: []});
+            mockFileSystemAdapter.exists.mockResolvedValue(true); // Integration.js already exists
+
+            await repository.save(integration);
+
+            // Verify Integration.js NOT written
+            expect(mockFileSystemAdapter.writeFile).not.toHaveBeenCalled();
+        });
+
+        it('should throw error if integration is invalid', async () => {
+            // Create invalid integration (invalid type)
+            const integration = new Integration({
+                name: 'test-integration',
+                version: '1.0.0',
+                displayName: 'Test Integration',
+                type: 'invalid-type',
+            });
+
+            await expect(repository.save(integration)).rejects.toThrow('Invalid integration');
+        });
+
+        it('should throw error if schema validation fails', async () => {
+            const integration = new Integration({
+                name: 'test-integration',
+                version: '1.0.0',
+                displayName: 'Test Integration',
+            });
+
+            mockSchemaValidator.validate.mockResolvedValue({
+                valid: false,
+                errors: ['Invalid schema'],
+            });
+
+            await expect(repository.save(integration)).rejects.toThrow('Schema validation failed');
+        });
+
+        it('should handle kebab-case to PascalCase conversion correctly', async () => {
+            const integration = new Integration({
+                name: 'my-awesome-api',
+                version: '1.0.0',
+                displayName: 'My Awesome API',
+            });
+
+            mockSchemaValidator.validate.mockResolvedValue({valid: true, errors: []});
+            mockFileSystemAdapter.exists.mockResolvedValue(false);
+
+            await repository.save(integration);
+
+            const writeCall = mockFileSystemAdapter.writeFile.mock.calls[0];
+            expect(writeCall[0]).toBe('/test/project/backend/src/integrations/MyAwesomeApiIntegration.js');
+            expect(writeCall[1]).toContain('class MyAwesomeApiIntegration extends IntegrationBase');
+        });
+    });
+
+    describe('findByName', () => {
+        it('should find integration by name string', async () => {
+            const integrationJsContent = `
+                class TestIntegrationIntegration extends IntegrationBase {
+                    static Definition = {
+                        name: 'test-integration',
+                        version: '1.0.0',
+                        display: {
+                            label: 'Test Integration',
+                            description: 'Test description',
+                        },
+                    };
+                }
+                module.exports = TestIntegrationIntegration;
+            `;
+
+            mockFileSystemAdapter.exists.mockResolvedValue(true);
+            mockFileSystemAdapter.readFile.mockResolvedValue(integrationJsContent);
+
+            const result = await repository.findByName('test-integration');
+
+            expect(result).toBeInstanceOf(Integration);
+            expect(result.name.value).toBe('test-integration');
+            expect(result.version.value).toBe('1.0.0');
+        });
+
+        it('should find integration by IntegrationName value object', async () => {
+            const integrationJsContent = `
+                class TestIntegrationIntegration extends IntegrationBase {
+                    static Definition = {
+                        name: 'test-integration',
+                        version: '1.0.0',
+                        display: {},
+                    };
+                }
+            `;
+
+            mockFileSystemAdapter.exists.mockResolvedValue(true);
+            mockFileSystemAdapter.readFile.mockResolvedValue(integrationJsContent);
+
+            const name = new IntegrationName('test-integration');
+            const result = await repository.findByName(name);
+
+            expect(result).toBeInstanceOf(Integration);
+            expect(result.name.value).toBe('test-integration');
+        });
+
+        it('should return null if integration file does not exist', async () => {
+            mockFileSystemAdapter.exists.mockResolvedValue(false);
+
+            const result = await repository.findByName('nonexistent');
+
+            expect(result).toBeNull();
+        });
+    });
+
+    describe('exists', () => {
+        it('should return true if integration exists', async () => {
+            mockFileSystemAdapter.exists.mockResolvedValue(true);
+
+            const result = await repository.exists('test-integration');
+
+            expect(result).toBe(true);
+            expect(mockFileSystemAdapter.exists).toHaveBeenCalledWith(
+                '/test/project/backend/src/integrations/TestIntegrationIntegration.js'
+            );
+        });
+
+        it('should return false if integration does not exist', async () => {
+            mockFileSystemAdapter.exists.mockResolvedValue(false);
+
+            const result = await repository.exists('nonexistent');
+
+            expect(result).toBe(false);
+        });
+
+        it('should work with IntegrationName value object', async () => {
+            mockFileSystemAdapter.exists.mockResolvedValue(true);
+
+            const name = new IntegrationName('test-integration');
+            const result = await repository.exists(name);
+
+            expect(result).toBe(true);
+        });
+    });
+
+    describe('list', () => {
+        it('should return empty array if integrations directory does not exist', async () => {
+            mockFileSystemAdapter.exists.mockResolvedValue(false);
+
+            const result = await repository.list();
+
+            expect(result).toEqual([]);
+        });
+
+        it('should return list of all integrations', async () => {
+            mockFileSystemAdapter.exists.mockResolvedValue(true);
+            mockFileSystemAdapter.listFiles.mockResolvedValue([
+                'Integration1Integration.js',
+                'Integration2Integration.js',
+            ]);
+
+            const integration1Content = `
+                class Integration1Integration extends IntegrationBase {
+                    static Definition = {
+                        name: 'integration-1',
+                        version: '1.0.0',
+                        display: {},
+                    };
+                }
+            `;
+
+            const integration2Content = `
+                class Integration2Integration extends IntegrationBase {
+                    static Definition = {
+                        name: 'integration-2',
+                        version: '2.0.0',
+                        display: {},
+                    };
+                }
+            `;
+
+            mockFileSystemAdapter.readFile
+                .mockResolvedValueOnce(integration1Content)
+                .mockResolvedValueOnce(integration2Content);
+
+            const result = await repository.list();
+
+            expect(result).toHaveLength(2);
+            expect(result[0]).toBeInstanceOf(Integration);
+            expect(result[0].name.value).toBe('integration-1');
+            expect(result[1].name.value).toBe('integration-2');
+        });
+
+        it('should skip invalid integrations and log warning', async () => {
+            const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
+
+            mockFileSystemAdapter.exists.mockResolvedValue(true);
+            mockFileSystemAdapter.listFiles.mockResolvedValue([
+                'ValidIntegration.js',
+                'InvalidIntegration.js',
+            ]);
+
+            const validContent = `
+                class ValidIntegration extends IntegrationBase {
+                    static Definition = {
+                        name: 'valid-integration',
+                        version: '1.0.0',
+                        display: {},
+                    };
+                }
+            `;
+
+            mockFileSystemAdapter.readFile
+                .mockResolvedValueOnce(validContent)
+                .mockRejectedValueOnce(new Error('Read error'));
+
+            const result = await repository.list();
+
+            expect(result).toHaveLength(1);
+            expect(result[0].name.value).toBe('valid-integration');
+            expect(consoleWarnSpy).toHaveBeenCalledWith(
+                expect.stringContaining('Failed to load integration'),
+                expect.any(String)
+            );
+
+            consoleWarnSpy.mockRestore();
+        });
+
+        it('should filter out non-Integration files', async () => {
+            mockFileSystemAdapter.exists.mockResolvedValue(true);
+            mockFileSystemAdapter.listFiles.mockResolvedValue([
+                'TestIntegration.js',
+                'helper.js',
+                'utils.js',
+            ]);
+
+            const integrationContent = `
+                class TestIntegration extends IntegrationBase {
+                    static Definition = {
+                        name: 'test',
+                        version: '1.0.0',
+                        display: {},
+                    };
+                }
+            `;
+
+            mockFileSystemAdapter.readFile.mockResolvedValue(integrationContent);
+
+            const result = await repository.list();
+
+            // Should only process TestIntegration.js (ends with Integration.js)
+            expect(mockFileSystemAdapter.readFile).toHaveBeenCalledTimes(1);
+            expect(result).toHaveLength(1);
+        });
+    });
+
+    describe('_generateIntegrationClass', () => {
+        it('should generate valid Integration.js class file', () => {
+            const integration = new Integration({
+                name: 'my-test-integration',
+                version: '1.0.0',
+                displayName: 'My Test Integration',
+                description: 'Test description',
+                category: 'CRM',
+            });
+
+            const result = repository._generateIntegrationClass(integration);
+
+            expect(result).toContain("const { IntegrationBase } = require('@friggframework/core');");
+            expect(result).toContain('class MyTestIntegrationIntegration extends IntegrationBase');
+            expect(result).toContain('static Definition = {');
+            expect(result).toContain("name: 'my-test-integration'");
+            expect(result).toContain("version: '1.0.0'");
+            expect(result).toContain('modules: {');
+            expect(result).toContain('routes: [');
+            expect(result).toContain('module.exports = MyTestIntegrationIntegration');
+        });
+
+        it('should handle single-word integration names', () => {
+            const integration = new Integration({
+                name: 'salesforce',
+                version: '1.0.0',
+                displayName: 'Salesforce',
+                description: 'Salesforce integration',
+            });
+
+            const result = repository._generateIntegrationClass(integration);
+
+            expect(result).toContain('class SalesforceIntegration extends IntegrationBase');
+            expect(result).toContain('module.exports = SalesforceIntegration');
+        });
+
+        it('should include proper JSDoc comments', () => {
+            const integration = new Integration({
+                name: 'test-integration',
+                version: '1.0.0',
+                displayName: 'Test Integration',
+                description: 'Test description',
+            });
+
+            const result = repository._generateIntegrationClass(integration);
+
+            expect(result).toContain('/**');
+            expect(result).toContain('* Test Integration');
+            expect(result).toContain('* Test description');
+            expect(result).toContain('*/');
+        });
+    });
+
+});