@friggframework/devtools 2.0.0--canary.545.e256e95.0 → 2.0.0--canary.553.dc5f898.0

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

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

@@ -1,383 +0,0 @@
-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('*/');
-        });
-    });
-
-});