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

package/frigg-cli/validate-command/__tests__/adapters/validate-command.test.js

@@ -0,0 +1,205 @@
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const {
+    createValidateCommand,
+    formatConsoleOutput,
+    autoDetectFriggApp,
+    findBackendPathInDir,
+    findBackendPath
+} = require('../../adapters/cli/validate-command');
+const { ValidationResult } = require('../../domain/entities/validation-result');
+const { ValidationError } = require('../../domain/value-objects/validation-error');
+const { FixSuggestion } = require('../../domain/value-objects/fix-suggestion');
+const { Command } = require('commander');
+
+describe('validateCommand', () => {
+    let mockOutput;
+
+    beforeEach(() => {
+        mockOutput = {
+            info: jest.fn(),
+            success: jest.fn(),
+            error: jest.fn(),
+            warn: jest.fn(),
+            log: jest.fn()
+        };
+    });
+
+    describe('createValidateCommand', () => {
+        it('registers validate command on program', () => {
+            const program = new Command();
+            createValidateCommand(program);
+            const validateCmd = program.commands.find(c => c.name() === 'validate');
+            expect(validateCmd).toBeDefined();
+        });
+
+        it('has required options', () => {
+            const program = new Command();
+            createValidateCommand(program);
+            const validateCmd = program.commands.find(c => c.name() === 'validate');
+            const options = validateCmd.options.map(o => o.long);
+            expect(options).toContain('--format');
+            expect(options).toContain('--verbose');
+        });
+    });
+
+    describe('formatConsoleOutput', () => {
+        it('outputs success for valid result', () => {
+            const result = ValidationResult.create();
+            formatConsoleOutput(result, {}, mockOutput);
+            expect(mockOutput.success).toHaveBeenCalled();
+        });
+
+        it('outputs errors for invalid result', () => {
+            const error = ValidationError.create({
+                path: 'integrations',
+                message: 'Missing integrations',
+                severity: 'error'
+            });
+            const result = ValidationResult.create({ errors: [error] });
+            formatConsoleOutput(result, {}, mockOutput);
+            const logCalls = mockOutput.log.mock.calls.flat().join(' ');
+            expect(logCalls).toContain('Missing integrations');
+        });
+
+        it('outputs warnings', () => {
+            const warning = ValidationError.create({
+                path: 'database',
+                message: 'No database configured',
+                severity: 'warning'
+            });
+            const result = ValidationResult.create({ errors: [warning] });
+            formatConsoleOutput(result, {}, mockOutput);
+            expect(mockOutput.warn).toHaveBeenCalled();
+        });
+
+        it('shows fix suggestions in verbose mode', () => {
+            const fix = FixSuggestion.create({ action: 'add', description: 'Add database configuration' });
+            const error = ValidationError.create({
+                path: 'database',
+                message: 'Missing config',
+                severity: 'error',
+                fix
+            });
+            const result = ValidationResult.create({ errors: [error] });
+            formatConsoleOutput(result, { verbose: true }, mockOutput);
+            const logCalls = mockOutput.log.mock.calls.flat().join(' ');
+            expect(logCalls).toContain('Add database configuration');
+        });
+    });
+
+    describe('findBackendPathInDir', () => {
+        let tmpDir;
+
+        beforeEach(() => {
+            tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'frigg-test-'));
+        });
+
+        afterEach(() => {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        });
+
+        it('finds backend/index.js', () => {
+            const backendDir = path.join(tmpDir, 'backend');
+            fs.mkdirSync(backendDir);
+            fs.writeFileSync(path.join(backendDir, 'index.js'), 'module.exports = {}');
+            expect(findBackendPathInDir(tmpDir)).toBe(backendDir);
+        });
+
+        it('finds index.js with integrations keyword', () => {
+            fs.writeFileSync(path.join(tmpDir, 'index.js'), 'module.exports = { integrations: [] }');
+            expect(findBackendPathInDir(tmpDir)).toBe(tmpDir);
+        });
+
+        it('finds index.js with Definition keyword', () => {
+            fs.writeFileSync(path.join(tmpDir, 'index.js'), 'module.exports = { Definition: {} }');
+            expect(findBackendPathInDir(tmpDir)).toBe(tmpDir);
+        });
+
+        it('returns null for non-frigg directory', () => {
+            fs.writeFileSync(path.join(tmpDir, 'index.js'), 'console.log("hello")');
+            expect(findBackendPathInDir(tmpDir)).toBeNull();
+        });
+
+        it('returns null for empty directory', () => {
+            expect(findBackendPathInDir(tmpDir)).toBeNull();
+        });
+    });
+
+    describe('findBackendPath', () => {
+        let tmpDir;
+
+        beforeEach(() => {
+            tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'frigg-test-'));
+        });
+
+        afterEach(() => {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        });
+
+        it('finds backend subdirectory with package.json', () => {
+            const backendDir = path.join(tmpDir, 'backend');
+            fs.mkdirSync(backendDir);
+            fs.writeFileSync(path.join(backendDir, 'package.json'), '{}');
+            expect(findBackendPath(tmpDir)).toBe(backendDir);
+        });
+
+        it('finds backend subdirectory with index.js', () => {
+            const backendDir = path.join(tmpDir, 'backend');
+            fs.mkdirSync(backendDir);
+            fs.writeFileSync(path.join(backendDir, 'index.js'), 'module.exports = {}');
+            expect(findBackendPath(tmpDir)).toBe(backendDir);
+        });
+
+        it('returns path itself if it has package.json', () => {
+            fs.writeFileSync(path.join(tmpDir, 'package.json'), '{}');
+            expect(findBackendPath(tmpDir)).toBe(tmpDir);
+        });
+
+        it('returns null for non-backend directory', () => {
+            expect(findBackendPath(tmpDir)).toBeNull();
+        });
+    });
+
+    describe('autoDetectFriggApp', () => {
+        let tmpDir;
+
+        beforeEach(() => {
+            tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'frigg-test-'));
+        });
+
+        afterEach(() => {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        });
+
+        it('detects frigg app in current directory', () => {
+            const backendDir = path.join(tmpDir, 'backend');
+            fs.mkdirSync(backendDir);
+            fs.writeFileSync(path.join(backendDir, 'index.js'), 'module.exports = {}');
+            const result = autoDetectFriggApp(tmpDir);
+            expect(result).toEqual({
+                appRoot: tmpDir,
+                backendPath: backendDir
+            });
+        });
+
+        it('detects frigg app in parent directory', () => {
+            const backendDir = path.join(tmpDir, 'backend');
+            const subDir = path.join(tmpDir, 'src', 'components');
+            fs.mkdirSync(backendDir);
+            fs.mkdirSync(subDir, { recursive: true });
+            fs.writeFileSync(path.join(backendDir, 'index.js'), 'module.exports = {}');
+            const result = autoDetectFriggApp(subDir);
+            expect(result).toEqual({
+                appRoot: tmpDir,
+                backendPath: backendDir
+            });
+        });
+
+        it('returns null when no frigg app found', () => {
+            const result = autoDetectFriggApp(tmpDir);
+            expect(result).toBeNull();
+        });
+    });
+});

package/frigg-cli/validate-command/__tests__/application/validate-app-use-case.test.js

@@ -0,0 +1,104 @@
+const { ValidateAppUseCase } = require('../../application/use-cases/validate-app-use-case');
+
+describe('ValidateAppUseCase', () => {
+    let useCase;
+    let mockAppDefinitionValidator;
+    let mockIntegrationClassValidator;
+
+    beforeEach(() => {
+        mockAppDefinitionValidator = {
+            validate: jest.fn()
+        };
+        mockIntegrationClassValidator = {
+            validate: jest.fn()
+        };
+        useCase = new ValidateAppUseCase({
+            appDefinitionValidator: mockAppDefinitionValidator,
+            integrationClassValidator: mockIntegrationClassValidator
+        });
+    });
+
+    describe('execute', () => {
+        it('validates app definition structure', async () => {
+            const { ValidationResult } = require('../../domain/entities/validation-result');
+            mockAppDefinitionValidator.validate.mockReturnValue(ValidationResult.create());
+            mockIntegrationClassValidator.validate.mockReturnValue(ValidationResult.create());
+
+            const definition = { integrations: [] };
+            await useCase.execute({ definition });
+
+            expect(mockAppDefinitionValidator.validate).toHaveBeenCalledWith(definition);
+        });
+
+        it('validates each integration class', async () => {
+            const { ValidationResult } = require('../../domain/entities/validation-result');
+            mockAppDefinitionValidator.validate.mockReturnValue(ValidationResult.create());
+            mockIntegrationClassValidator.validate.mockReturnValue(ValidationResult.create());
+
+            class Int1 { static Definition = { name: 'int1' }; }
+            class Int2 { static Definition = { name: 'int2' }; }
+            const definition = { integrations: [Int1, Int2] };
+
+            await useCase.execute({ definition });
+
+            expect(mockIntegrationClassValidator.validate).toHaveBeenCalledWith(Int1, 0);
+            expect(mockIntegrationClassValidator.validate).toHaveBeenCalledWith(Int2, 1);
+        });
+
+        it('merges all validation results', async () => {
+            const { ValidationResult } = require('../../domain/entities/validation-result');
+            const { ValidationError } = require('../../domain/value-objects/validation-error');
+
+            const appError = ValidationError.create({ path: 'database', message: 'missing', severity: 'error' });
+            const intError = ValidationError.create({ path: 'integrations[0]', message: 'invalid', severity: 'error' });
+
+            mockAppDefinitionValidator.validate.mockReturnValue(
+                ValidationResult.create({ errors: [appError] })
+            );
+            mockIntegrationClassValidator.validate.mockReturnValue(
+                ValidationResult.create({ errors: [intError] })
+            );
+
+            class Int1 { static Definition = { name: 'int1' }; }
+            const definition = { integrations: [Int1] };
+
+            const result = await useCase.execute({ definition });
+
+            expect(result.getErrors()).toHaveLength(2);
+        });
+
+        it('returns valid result when no errors', async () => {
+            const { ValidationResult } = require('../../domain/entities/validation-result');
+            mockAppDefinitionValidator.validate.mockReturnValue(ValidationResult.create());
+            mockIntegrationClassValidator.validate.mockReturnValue(ValidationResult.create());
+
+            const definition = { integrations: [] };
+            const result = await useCase.execute({ definition });
+
+            expect(result.isValid()).toBe(true);
+        });
+
+        it('adds context with definition metadata', async () => {
+            const { ValidationResult } = require('../../domain/entities/validation-result');
+            mockAppDefinitionValidator.validate.mockReturnValue(ValidationResult.create());
+
+            const definition = { integrations: [] };
+            const result = await useCase.execute({ definition, appPath: '/app/backend' });
+
+            expect(result.getContext()).toMatchObject({ appPath: '/app/backend' });
+        });
+    });
+
+    describe('error handling', () => {
+        it('handles validator throwing error', async () => {
+            mockAppDefinitionValidator.validate.mockImplementation(() => {
+                throw new Error('Validator crashed');
+            });
+
+            const definition = { integrations: [] };
+
+            await expect(useCase.execute({ definition }))
+                .rejects.toThrow('Validator crashed');
+        });
+    });
+});

package/frigg-cli/validate-command/__tests__/domain/fix-suggestion.test.js

@@ -0,0 +1,153 @@
+const { FixSuggestion } = require('../../domain/value-objects/fix-suggestion');
+
+describe('FixSuggestion', () => {
+    describe('creation', () => {
+        it('creates fix with action and description', () => {
+            const fix = FixSuggestion.create({
+                action: 'add',
+                description: 'Add the name field to the configuration'
+            });
+            expect(fix.action).toBe('add');
+            expect(fix.description).toBe('Add the name field to the configuration');
+        });
+
+        it('creates fix with template', () => {
+            const fix = FixSuggestion.create({
+                action: 'add',
+                description: 'Add database configuration',
+                template: { database: { mongoDB: { enable: true } } }
+            });
+            expect(fix.template).toEqual({ database: { mongoDB: { enable: true } } });
+        });
+
+        it('creates fix with code snippet', () => {
+            const fix = FixSuggestion.create({
+                action: 'replace',
+                description: 'Update the export',
+                codeSnippet: 'module.exports = { Definition };'
+            });
+            expect(fix.codeSnippet).toBe('module.exports = { Definition };');
+        });
+
+        it('throws for missing action', () => {
+            expect(() => FixSuggestion.create({ description: 'Fix it' }))
+                .toThrow('action is required');
+        });
+
+        it('throws for missing description', () => {
+            expect(() => FixSuggestion.create({ action: 'add' }))
+                .toThrow('description is required');
+        });
+
+        it('throws for invalid action', () => {
+            expect(() => FixSuggestion.create({ action: 'destroy', description: 'd' }))
+                .toThrow('Invalid action');
+        });
+    });
+
+    describe('actions', () => {
+        it('supports add action', () => {
+            const fix = FixSuggestion.create({ action: 'add', description: 'd' });
+            expect(fix.isAdd()).toBe(true);
+            expect(fix.isRemove()).toBe(false);
+        });
+
+        it('supports remove action', () => {
+            const fix = FixSuggestion.create({ action: 'remove', description: 'd' });
+            expect(fix.isRemove()).toBe(true);
+        });
+
+        it('supports replace action', () => {
+            const fix = FixSuggestion.create({ action: 'replace', description: 'd' });
+            expect(fix.isReplace()).toBe(true);
+        });
+
+        it('supports rename action', () => {
+            const fix = FixSuggestion.create({ action: 'rename', description: 'd' });
+            expect(fix.isRename()).toBe(true);
+        });
+
+        it('supports update action', () => {
+            const fix = FixSuggestion.create({ action: 'update', description: 'd' });
+            expect(fix.isUpdate()).toBe(true);
+        });
+    });
+
+    describe('applicability', () => {
+        it('is auto-applicable with template', () => {
+            const fix = FixSuggestion.create({
+                action: 'add',
+                description: 'd',
+                template: { key: 'value' }
+            });
+            expect(fix.isAutoApplicable()).toBe(true);
+        });
+
+        it('is auto-applicable with code snippet', () => {
+            const fix = FixSuggestion.create({
+                action: 'replace',
+                description: 'd',
+                codeSnippet: 'const x = 1;'
+            });
+            expect(fix.isAutoApplicable()).toBe(true);
+        });
+
+        it('is not auto-applicable without template or snippet', () => {
+            const fix = FixSuggestion.create({ action: 'add', description: 'd' });
+            expect(fix.isAutoApplicable()).toBe(false);
+        });
+    });
+
+    describe('target', () => {
+        it('sets target path', () => {
+            const fix = FixSuggestion.create({
+                action: 'add',
+                description: 'd',
+                targetPath: 'config.database'
+            });
+            expect(fix.targetPath).toBe('config.database');
+        });
+
+        it('sets target file', () => {
+            const fix = FixSuggestion.create({
+                action: 'update',
+                description: 'd',
+                targetFile: 'backend/index.js'
+            });
+            expect(fix.targetFile).toBe('backend/index.js');
+        });
+    });
+
+    describe('serialization', () => {
+        it('converts to JSON', () => {
+            const fix = FixSuggestion.create({
+                action: 'add',
+                description: 'Add config',
+                template: { key: 'value' },
+                targetPath: 'config'
+            });
+            const json = fix.toJSON();
+            expect(json).toEqual({
+                action: 'add',
+                description: 'Add config',
+                template: { key: 'value' },
+                codeSnippet: null,
+                targetPath: 'config',
+                targetFile: null
+            });
+        });
+    });
+
+    describe('formatting', () => {
+        it('formats for console display', () => {
+            const fix = FixSuggestion.create({
+                action: 'add',
+                description: 'Add the name field',
+                template: { name: 'my-app' }
+            });
+            const formatted = fix.format();
+            expect(formatted).toContain('add');
+            expect(formatted).toContain('Add the name field');
+        });
+    });
+});

package/frigg-cli/validate-command/__tests__/domain/validation-error.test.js

@@ -0,0 +1,162 @@
+const { ValidationError } = require('../../domain/value-objects/validation-error');
+const { FixSuggestion } = require('../../domain/value-objects/fix-suggestion');
+
+describe('ValidationError', () => {
+    describe('creation', () => {
+        it('creates error with required fields', () => {
+            const error = ValidationError.create({
+                path: 'integrations[0].name',
+                message: 'Integration name is required'
+            });
+            expect(error.path).toBe('integrations[0].name');
+            expect(error.message).toBe('Integration name is required');
+            expect(error.severity).toBe('error');
+        });
+
+        it('creates error with custom severity', () => {
+            const warning = ValidationError.create({
+                path: 'config.timeout',
+                message: 'Timeout value seems high',
+                severity: 'warning'
+            });
+            expect(warning.severity).toBe('warning');
+            expect(warning.isWarning()).toBe(true);
+            expect(warning.isError()).toBe(false);
+        });
+
+        it('creates error with fix suggestion', () => {
+            const fix = FixSuggestion.create({
+                action: 'add',
+                description: 'Add the name field to integration'
+            });
+            const error = ValidationError.create({
+                path: 'integrations[0].name',
+                message: 'Required field missing',
+                fix
+            });
+            expect(error.fix).toBe(fix);
+            expect(error.hasFix()).toBe(true);
+        });
+
+        it('throws for missing path', () => {
+            expect(() => ValidationError.create({ message: 'error' }))
+                .toThrow('path is required');
+        });
+
+        it('throws for missing message', () => {
+            expect(() => ValidationError.create({ path: 'a.b' }))
+                .toThrow('message is required');
+        });
+
+        it('throws for invalid severity', () => {
+            expect(() => ValidationError.create({
+                path: 'a',
+                message: 'b',
+                severity: 'critical'
+            })).toThrow('Invalid severity');
+        });
+    });
+
+    describe('path parsing', () => {
+        it('parses simple path', () => {
+            const error = ValidationError.create({ path: 'name', message: 'm' });
+            expect(error.getPathSegments()).toEqual(['name']);
+        });
+
+        it('parses nested path', () => {
+            const error = ValidationError.create({ path: 'config.database.uri', message: 'm' });
+            expect(error.getPathSegments()).toEqual(['config', 'database', 'uri']);
+        });
+
+        it('parses array path', () => {
+            const error = ValidationError.create({ path: 'integrations[0].modules[1].name', message: 'm' });
+            expect(error.getPathSegments()).toEqual(['integrations', '0', 'modules', '1', 'name']);
+        });
+
+        it('gets root path', () => {
+            const error = ValidationError.create({ path: 'integrations[0].config.timeout', message: 'm' });
+            expect(error.getRootPath()).toBe('integrations');
+        });
+    });
+
+    describe('severity helpers', () => {
+        it('identifies error severity', () => {
+            const error = ValidationError.create({ path: 'a', message: 'm', severity: 'error' });
+            expect(error.isError()).toBe(true);
+            expect(error.isWarning()).toBe(false);
+            expect(error.isInfo()).toBe(false);
+        });
+
+        it('identifies warning severity', () => {
+            const error = ValidationError.create({ path: 'a', message: 'm', severity: 'warning' });
+            expect(error.isError()).toBe(false);
+            expect(error.isWarning()).toBe(true);
+        });
+
+        it('identifies info severity', () => {
+            const error = ValidationError.create({ path: 'a', message: 'm', severity: 'info' });
+            expect(error.isError()).toBe(false);
+            expect(error.isInfo()).toBe(true);
+        });
+    });
+
+    describe('code', () => {
+        it('assigns error code', () => {
+            const error = ValidationError.create({
+                path: 'name',
+                message: 'Required',
+                code: 'REQUIRED_FIELD'
+            });
+            expect(error.code).toBe('REQUIRED_FIELD');
+        });
+
+        it('defaults to null code', () => {
+            const error = ValidationError.create({ path: 'a', message: 'm' });
+            expect(error.code).toBeNull();
+        });
+    });
+
+    describe('serialization', () => {
+        it('converts to JSON', () => {
+            const error = ValidationError.create({
+                path: 'config.name',
+                message: 'Name required',
+                severity: 'error',
+                code: 'REQUIRED'
+            });
+            const json = error.toJSON();
+            expect(json).toEqual({
+                path: 'config.name',
+                message: 'Name required',
+                severity: 'error',
+                code: 'REQUIRED',
+                fix: null
+            });
+        });
+
+        it('includes fix in JSON', () => {
+            const fix = FixSuggestion.create({ action: 'add', description: 'Add field' });
+            const error = ValidationError.create({
+                path: 'a',
+                message: 'm',
+                fix
+            });
+            const json = error.toJSON();
+            expect(json.fix).toMatchObject({ action: 'add', description: 'Add field' });
+        });
+    });
+
+    describe('equality', () => {
+        it('considers errors equal by path and message', () => {
+            const error1 = ValidationError.create({ path: 'a.b', message: 'Required' });
+            const error2 = ValidationError.create({ path: 'a.b', message: 'Required' });
+            expect(error1.equals(error2)).toBe(true);
+        });
+
+        it('considers errors different by path', () => {
+            const error1 = ValidationError.create({ path: 'a.b', message: 'Required' });
+            const error2 = ValidationError.create({ path: 'a.c', message: 'Required' });
+            expect(error1.equals(error2)).toBe(false);
+        });
+    });
+});