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

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

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

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

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

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

@@ -1,152 +0,0 @@
-const { ValidationResult } = require('../../domain/entities/validation-result');
-const { ValidationError } = require('../../domain/value-objects/validation-error');
-const { FixSuggestion } = require('../../domain/value-objects/fix-suggestion');
-
-describe('ValidationResult', () => {
-    describe('creation', () => {
-        it('creates empty result with no errors', () => {
-            const result = ValidationResult.create();
-            expect(result.isValid()).toBe(true);
-            expect(result.getErrors()).toHaveLength(0);
-            expect(result.getWarnings()).toHaveLength(0);
-        });
-
-        it('creates result with errors', () => {
-            const error = ValidationError.create({
-                path: 'integrations[0].name',
-                message: 'Integration name is required',
-                severity: 'error'
-            });
-            const result = ValidationResult.create({ errors: [error] });
-            expect(result.isValid()).toBe(false);
-            expect(result.getErrors()).toHaveLength(1);
-        });
-
-        it('creates result with warnings', () => {
-            const warning = ValidationError.create({
-                path: 'config.timeout',
-                message: 'Timeout value is unusually high',
-                severity: 'warning'
-            });
-            const result = ValidationResult.create({ errors: [warning] });
-            expect(result.isValid()).toBe(true);
-            expect(result.getWarnings()).toHaveLength(1);
-        });
-    });
-
-    describe('addError', () => {
-        it('adds error to result', () => {
-            const result = ValidationResult.create();
-            const error = ValidationError.create({
-                path: 'name',
-                message: 'Name is required',
-                severity: 'error'
-            });
-            result.addError(error);
-            expect(result.isValid()).toBe(false);
-            expect(result.getErrors()).toContain(error);
-        });
-
-        it('adds warning without affecting validity', () => {
-            const result = ValidationResult.create();
-            const warning = ValidationError.create({
-                path: 'description',
-                message: 'Description is recommended',
-                severity: 'warning'
-            });
-            result.addError(warning);
-            expect(result.isValid()).toBe(true);
-            expect(result.getWarnings()).toContain(warning);
-        });
-    });
-
-    describe('merge', () => {
-        it('merges two valid results', () => {
-            const result1 = ValidationResult.create();
-            const result2 = ValidationResult.create();
-            const merged = result1.merge(result2);
-            expect(merged.isValid()).toBe(true);
-        });
-
-        it('merges results with errors', () => {
-            const error1 = ValidationError.create({
-                path: 'name',
-                message: 'Name required',
-                severity: 'error'
-            });
-            const error2 = ValidationError.create({
-                path: 'version',
-                message: 'Version required',
-                severity: 'error'
-            });
-            const result1 = ValidationResult.create({ errors: [error1] });
-            const result2 = ValidationResult.create({ errors: [error2] });
-            const merged = result1.merge(result2);
-            expect(merged.isValid()).toBe(false);
-            expect(merged.getErrors()).toHaveLength(2);
-        });
-
-        it('preserves context from both results', () => {
-            const result1 = ValidationResult.create({ context: { file: 'index.js' } });
-            const result2 = ValidationResult.create({ context: { integration: 'oauth' } });
-            const merged = result1.merge(result2);
-            expect(merged.getContext()).toMatchObject({ file: 'index.js', integration: 'oauth' });
-        });
-    });
-
-    describe('filtering', () => {
-        it('filters errors by path prefix', () => {
-            const errors = [
-                ValidationError.create({ path: 'integrations[0].name', message: 'a', severity: 'error' }),
-                ValidationError.create({ path: 'integrations[1].config', message: 'b', severity: 'error' }),
-                ValidationError.create({ path: 'database.uri', message: 'c', severity: 'error' })
-            ];
-            const result = ValidationResult.create({ errors });
-            const filtered = result.filterByPath('integrations');
-            expect(filtered.getErrors()).toHaveLength(2);
-        });
-
-        it('filters by severity', () => {
-            const errors = [
-                ValidationError.create({ path: 'a', message: 'error1', severity: 'error' }),
-                ValidationError.create({ path: 'b', message: 'warning1', severity: 'warning' }),
-                ValidationError.create({ path: 'c', message: 'info1', severity: 'info' })
-            ];
-            const result = ValidationResult.create({ errors });
-            expect(result.getBySeverity('error')).toHaveLength(1);
-            expect(result.getBySeverity('warning')).toHaveLength(1);
-            expect(result.getBySeverity('info')).toHaveLength(1);
-        });
-    });
-
-    describe('summary', () => {
-        it('generates summary statistics', () => {
-            const errors = [
-                ValidationError.create({ path: 'a', message: 'm1', severity: 'error' }),
-                ValidationError.create({ path: 'b', message: 'm2', severity: 'error' }),
-                ValidationError.create({ path: 'c', message: 'm3', severity: 'warning' })
-            ];
-            const result = ValidationResult.create({ errors });
-            const summary = result.getSummary();
-            expect(summary.errorCount).toBe(2);
-            expect(summary.warningCount).toBe(1);
-            expect(summary.isValid).toBe(false);
-        });
-    });
-
-    describe('serialization', () => {
-        it('converts to JSON', () => {
-            const error = ValidationError.create({
-                path: 'name',
-                message: 'Required',
-                severity: 'error',
-                fix: FixSuggestion.create({ action: 'add', description: 'Add name field' })
-            });
-            const result = ValidationResult.create({ errors: [error] });
-            const json = result.toJSON();
-            expect(json).toHaveProperty('valid', false);
-            expect(json).toHaveProperty('errors');
-            expect(json.errors[0]).toHaveProperty('path', 'name');
-        });
-    });
-});