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

package/frigg-cli/validate-command/__tests__/infrastructure/template-validation.test.js

@@ -1,155 +0,0 @@
-/**
- * Template Validation Tests
- *
- * Validates that the frigg init templates produce valid configurations
- * when run through the validator.
- */
-
-const path = require('path');
-const { AppDefinitionValidator } = require('../../infrastructure/validators/app-definition-validator');
-const { IntegrationClassValidator } = require('../../infrastructure/validators/integration-class-validator');
-const { ApiModuleValidator } = require('../../infrastructure/validators/api-module-validator');
-
-// Resolve template paths relative to frigg-cli package root
-const FRIGG_CLI_ROOT = path.resolve(__dirname, '../../..');
-const TEMPLATES_DIR = path.join(FRIGG_CLI_ROOT, 'templates');
-
-describe('Template Validation', () => {
-    let appDefinitionValidator;
-    let integrationClassValidator;
-    let apiModuleValidator;
-
-    beforeEach(() => {
-        appDefinitionValidator = new AppDefinitionValidator();
-        integrationClassValidator = new IntegrationClassValidator();
-        apiModuleValidator = new ApiModuleValidator();
-    });
-
-    describe('backend/index.js template', () => {
-        // Load the actual template
-        const templatePath = path.join(TEMPLATES_DIR, 'backend/index.js');
-        let templateModule;
-
-        beforeAll(() => {
-            // Clear require cache to ensure fresh load
-            delete require.cache[require.resolve(templatePath)];
-            templateModule = require(templatePath);
-        });
-
-        it('exports a Definition property', () => {
-            expect(templateModule.Definition).toBeDefined();
-            expect(typeof templateModule.Definition).toBe('object');
-        });
-
-        it('has valid app definition structure', () => {
-            const result = appDefinitionValidator.validate(templateModule.Definition);
-
-            // Log errors for debugging
-            if (!result.isValid()) {
-                console.log('App Definition Errors:', result.getErrors().map(e => `${e.path}: ${e.message}`));
-            }
-
-            expect(result.isValid()).toBe(true);
-        });
-
-        it('has required integrations array', () => {
-            expect(templateModule.Definition.integrations).toBeDefined();
-            expect(Array.isArray(templateModule.Definition.integrations)).toBe(true);
-        });
-
-        it('has valid user configuration', () => {
-            const userConfig = templateModule.Definition.user;
-            expect(userConfig).toBeDefined();
-            expect(typeof userConfig.usePassword).toBe('boolean');
-            expect(['individual', 'organization']).toContain(userConfig.primary);
-        });
-
-        it('has valid database configuration', () => {
-            const dbConfig = templateModule.Definition.database;
-            expect(dbConfig).toBeDefined();
-            // Should have at least one database type configured
-            expect(dbConfig.postgres || dbConfig.mongoDB || dbConfig.documentDB).toBeDefined();
-        });
-
-        it('has valid vpc configuration', () => {
-            const vpcConfig = templateModule.Definition.vpc;
-            expect(vpcConfig).toBeDefined();
-            expect(typeof vpcConfig.enable).toBe('boolean');
-        });
-
-        it('has valid encryption configuration', () => {
-            const encConfig = templateModule.Definition.encryption;
-            expect(encConfig).toBeDefined();
-            expect(['kms', 'aes', 'none']).toContain(encConfig.fieldLevelEncryptionMethod);
-        });
-    });
-
-    describe('ExampleIntegration template', () => {
-        const templatePath = path.join(TEMPLATES_DIR, 'backend/src/integrations/ExampleIntegration.js');
-        let ExampleIntegration;
-
-        beforeAll(() => {
-            // Mock @friggframework/core since it may not be installed in CLI package
-            jest.mock('@friggframework/core', () => ({
-                Integration: class Integration {
-                    static Config = {};
-                }
-            }), { virtual: true });
-
-            delete require.cache[require.resolve(templatePath)];
-            ExampleIntegration = require(templatePath);
-        });
-
-        afterAll(() => {
-            jest.unmock('@friggframework/core');
-        });
-
-        it('is a class/function', () => {
-            expect(typeof ExampleIntegration).toBe('function');
-        });
-
-        it('has static Definition property', () => {
-            expect(ExampleIntegration.Definition).toBeDefined();
-        });
-
-        it('Definition has required properties', () => {
-            const definition = ExampleIntegration.Definition;
-            expect(definition.name).toBeDefined();
-            expect(definition.version).toBeDefined();
-        });
-
-        it('Definition matches pattern used in core integrations', () => {
-            // ExampleIntegration uses static Definition (not Config)
-            // to match the pattern expected by IntegrationClassValidator
-            expect(ExampleIntegration.Definition).toBeDefined();
-            expect(typeof ExampleIntegration.Definition.name).toBe('string');
-            expect(typeof ExampleIntegration.Definition.version).toBe('string');
-        });
-    });
-
-    describe('Template schema compliance', () => {
-        it('template app definition does not use unknown properties', () => {
-            const templatePath = path.join(TEMPLATES_DIR, 'backend/index.js');
-            delete require.cache[require.resolve(templatePath)];
-            const { Definition } = require(templatePath);
-
-            const result = appDefinitionValidator.validate(Definition);
-            const errors = result.getErrors();
-
-            // Check for "additional property" errors which indicate unknown fields
-            const additionalPropErrors = errors.filter(e =>
-                e.message.includes('additional properties') ||
-                e.code === 'ADDITIONALPROPERTIES'
-            );
-
-            if (additionalPropErrors.length > 0) {
-                console.log('Unknown properties in template:',
-                    additionalPropErrors.map(e => e.message));
-            }
-
-            // For now, document what additional properties exist
-            // These may need to be added to the schema or removed from template
-            expect(additionalPropErrors).toEqual([]);
-        });
-    });
-});

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

@@ -1,199 +0,0 @@
-const path = require('path');
-const fs = require('fs');
-const { ValidateAppUseCase } = require('../../application/use-cases/validate-app-use-case');
-const { AppDefinitionValidator } = require('../../infrastructure/validators/app-definition-validator');
-const { IntegrationClassValidator } = require('../../infrastructure/validators/integration-class-validator');
-const { ApiModuleValidator } = require('../../infrastructure/validators/api-module-validator');
-
-function createValidateCommand(program) {
-    program
-        .command('validate [path]')
-        .description('Validate a Frigg application configuration (auto-detects local app if no path given)')
-        .option('-f, --format <format>', 'Output format (console, json)', 'console')
-        .option('-v, --verbose', 'Show detailed output including fix suggestions', false)
-        .action(async (appPath, options) => {
-            const output = require('../../../utils/output');
-            await validateCommand(appPath, options, { output });
-        });
-}
-
-function autoDetectFriggApp(startDir = process.cwd()) {
-    let currentDir = startDir;
-    const root = path.parse(currentDir).root;
-
-    while (currentDir !== root) {
-        const backendPath = findBackendPathInDir(currentDir);
-        if (backendPath) {
-            return { appRoot: currentDir, backendPath };
-        }
-        currentDir = path.dirname(currentDir);
-    }
-
-    return null;
-}
-
-function findBackendPathInDir(dir) {
-    const backendDir = path.join(dir, 'backend');
-    if (fs.existsSync(path.join(backendDir, 'index.js'))) {
-        return backendDir;
-    }
-
-    if (fs.existsSync(path.join(dir, 'index.js'))) {
-        const content = fs.readFileSync(path.join(dir, 'index.js'), 'utf-8');
-        if (content.includes('integrations') || content.includes('Definition')) {
-            return dir;
-        }
-    }
-
-    return null;
-}
-
-function findBackendPath(startPath) {
-    const absolutePath = path.isAbsolute(startPath) ? startPath : path.resolve(process.cwd(), startPath);
-
-    const backendDir = path.join(absolutePath, 'backend');
-    if (fs.existsSync(path.join(backendDir, 'package.json')) || fs.existsSync(path.join(backendDir, 'index.js'))) {
-        return backendDir;
-    }
-
-    if (fs.existsSync(path.join(absolutePath, 'package.json')) || fs.existsSync(path.join(absolutePath, 'index.js'))) {
-        return absolutePath;
-    }
-
-    return null;
-}
-
-function loadAppDefinition(backendPath) {
-    const indexPath = path.join(backendPath, 'index.js');
-    if (!fs.existsSync(indexPath)) {
-        throw new Error(`No index.js found at ${backendPath}`);
-    }
-
-    const originalCwd = process.cwd();
-    try {
-        process.chdir(backendPath);
-        delete require.cache[require.resolve(indexPath)];
-        const exported = require(indexPath);
-        return exported.Definition || exported.default || exported;
-    } finally {
-        process.chdir(originalCwd);
-    }
-}
-
-async function validateCommand(appPath, options, { output }) {
-    try {
-        let backendPath;
-        let definition;
-
-        if (!appPath) {
-            const detected = autoDetectFriggApp();
-            if (!detected) {
-                output.error('No Frigg app found. Run from within a Frigg app directory or specify a path.');
-                return;
-            }
-            backendPath = detected.backendPath;
-            output.info(`Auto-detected Frigg app at: ${detected.appRoot}`);
-        } else {
-            backendPath = findBackendPath(appPath);
-            if (!backendPath) {
-                output.error(`Could not find backend directory in ${appPath}`);
-                return;
-            }
-            output.info(`Validating Frigg app at: ${appPath}`);
-        }
-
-        try {
-            definition = loadAppDefinition(backendPath);
-        } catch (err) {
-            output.error(`Could not load app definition: ${err.message}`);
-            return;
-        }
-
-        const appDefinitionValidator = new AppDefinitionValidator();
-        const integrationClassValidator = new IntegrationClassValidator();
-        const apiModuleValidator = new ApiModuleValidator();
-        const useCase = new ValidateAppUseCase({
-            appDefinitionValidator,
-            integrationClassValidator,
-            apiModuleValidator
-        });
-
-        const result = await useCase.execute({ definition, appPath: backendPath });
-
-        if (options.format === 'json') {
-            output.log(JSON.stringify(result.toJSON(), null, 2));
-            return;
-        }
-
-        formatConsoleOutput(result, options, output);
-    } catch (err) {
-        output.error(`Validation failed: ${err.message}`);
-        if (options.verbose) {
-            output.error(err.stack);
-        }
-    }
-}
-
-function formatConsoleOutput(result, options, output) {
-    const summary = result.getSummary();
-
-    output.log('');
-    output.log('═'.repeat(60));
-    output.log('  FRIGG VALIDATE - App Configuration Report');
-    output.log('═'.repeat(60));
-    output.log('');
-
-    if (result.isValid()) {
-        output.success('App configuration is valid');
-    } else {
-        output.error(`App configuration has ${summary.errorCount} error(s)`);
-    }
-
-    if (summary.warningCount > 0) {
-        output.warn(`${summary.warningCount} warning(s) found`);
-    }
-
-    output.log('');
-
-    if (result.getErrors().length > 0) {
-        output.log('─'.repeat(60));
-        output.log('ERRORS:');
-        output.log('');
-        result.getErrors().forEach((error, idx) => {
-            output.log(`  ${idx + 1}. [${error.path}] ${error.message}`);
-            if (options.verbose && error.fix) {
-                output.log(`     Fix: ${error.fix.description}`);
-                if (error.fix.template) {
-                    output.log(`     Template: ${JSON.stringify(error.fix.template)}`);
-                }
-            }
-        });
-        output.log('');
-    }
-
-    if (result.getWarnings().length > 0) {
-        output.log('─'.repeat(60));
-        output.log('WARNINGS:');
-        output.log('');
-        result.getWarnings().forEach((warning, idx) => {
-            output.log(`  ${idx + 1}. [${warning.path}] ${warning.message}`);
-            if (options.verbose && warning.fix) {
-                output.log(`     Fix: ${warning.fix.description}`);
-            }
-        });
-        output.log('');
-    }
-
-    output.log('═'.repeat(60));
-    output.log('');
-}
-
-module.exports = {
-    validateCommand,
-    createValidateCommand,
-    formatConsoleOutput,
-    autoDetectFriggApp,
-    findBackendPathInDir,
-    findBackendPath,
-    loadAppDefinition
-};

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

@@ -1,35 +0,0 @@
-const { ValidationResult } = require('../../domain/entities/validation-result');
-
-class ValidateAppUseCase {
-    constructor({ appDefinitionValidator, integrationClassValidator, apiModuleValidator }) {
-        this.appDefinitionValidator = appDefinitionValidator;
-        this.integrationClassValidator = integrationClassValidator;
-        this.apiModuleValidator = apiModuleValidator;
-    }
-
-    async execute({ definition, appPath }) {
-        let result = ValidationResult.create({
-            context: { appPath }
-        });
-
-        const appResult = this.appDefinitionValidator.validate(definition);
-        result = result.merge(appResult);
-
-        if (definition.integrations && Array.isArray(definition.integrations)) {
-            definition.integrations.forEach((integration, index) => {
-                const integrationResult = this.integrationClassValidator.validate(integration, index);
-                result = result.merge(integrationResult);
-
-                // Validate API modules within the integration
-                if (this.apiModuleValidator && integration.Definition) {
-                    const moduleResult = this.apiModuleValidator.validate(integration.Definition, index);
-                    result = result.merge(moduleResult);
-                }
-            });
-        }
-
-        return result;
-    }
-}
-
-module.exports = { ValidateAppUseCase };

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

@@ -1,74 +0,0 @@
-class ValidationResult {
-    constructor({ errors, context }) {
-        this.errors = errors || [];
-        this.context = context || {};
-    }
-
-    static create(props = {}) {
-        return new ValidationResult(props);
-    }
-
-    isValid() {
-        return !this.errors.some(e => e.isError());
-    }
-
-    getErrors() {
-        return this.errors.filter(e => e.isError());
-    }
-
-    getWarnings() {
-        return this.errors.filter(e => e.isWarning());
-    }
-
-    getInfos() {
-        return this.errors.filter(e => e.isInfo());
-    }
-
-    addError(error) {
-        this.errors.push(error);
-        return this;
-    }
-
-    merge(other) {
-        return ValidationResult.create({
-            errors: [...this.errors, ...other.errors],
-            context: { ...this.context, ...other.context }
-        });
-    }
-
-    getContext() {
-        return this.context;
-    }
-
-    filterByPath(pathPrefix) {
-        return ValidationResult.create({
-            errors: this.errors.filter(e => e.path.startsWith(pathPrefix)),
-            context: this.context
-        });
-    }
-
-    getBySeverity(severity) {
-        return this.errors.filter(e => e.severity === severity);
-    }
-
-    getSummary() {
-        return {
-            isValid: this.isValid(),
-            errorCount: this.getErrors().length,
-            warningCount: this.getWarnings().length,
-            infoCount: this.getInfos().length,
-            totalCount: this.errors.length
-        };
-    }
-
-    toJSON() {
-        return {
-            valid: this.isValid(),
-            errors: this.errors.map(e => e.toJSON()),
-            summary: this.getSummary(),
-            context: this.context
-        };
-    }
-}
-
-module.exports = { ValidationResult };

package/frigg-cli/validate-command/domain/value-objects/fix-suggestion.js

@@ -1,74 +0,0 @@
-const VALID_ACTIONS = ['add', 'remove', 'replace', 'rename', 'update'];
-
-class FixSuggestion {
-    constructor({ action, description, template, codeSnippet, targetPath, targetFile }) {
-        if (!action) {
-            throw new Error('action is required');
-        }
-        if (!description) {
-            throw new Error('description is required');
-        }
-        if (!VALID_ACTIONS.includes(action)) {
-            throw new Error(`Invalid action: ${action}. Must be one of: ${VALID_ACTIONS.join(', ')}`);
-        }
-
-        this.action = action;
-        this.description = description;
-        this.template = template || null;
-        this.codeSnippet = codeSnippet || null;
-        this.targetPath = targetPath || null;
-        this.targetFile = targetFile || null;
-    }
-
-    static create(props) {
-        return new FixSuggestion(props);
-    }
-
-    isAdd() {
-        return this.action === 'add';
-    }
-
-    isRemove() {
-        return this.action === 'remove';
-    }
-
-    isReplace() {
-        return this.action === 'replace';
-    }
-
-    isRename() {
-        return this.action === 'rename';
-    }
-
-    isUpdate() {
-        return this.action === 'update';
-    }
-
-    isAutoApplicable() {
-        return this.template !== null || this.codeSnippet !== null;
-    }
-
-    toJSON() {
-        return {
-            action: this.action,
-            description: this.description,
-            template: this.template,
-            codeSnippet: this.codeSnippet,
-            targetPath: this.targetPath,
-            targetFile: this.targetFile
-        };
-    }
-
-    format() {
-        let output = `[${this.action}] ${this.description}`;
-        if (this.template) {
-            output += `\n  Template: ${JSON.stringify(this.template)}`;
-        }
-        if (this.codeSnippet) {
-            output += `\n  Code: ${this.codeSnippet}`;
-        }
-        return output;
-    }
-}
-
-module.exports = { FixSuggestion };

package/frigg-cli/validate-command/domain/value-objects/validation-error.js

@@ -1,68 +0,0 @@
-const VALID_SEVERITIES = ['error', 'warning', 'info'];
-
-class ValidationError {
-    constructor({ path, message, severity, code, fix }) {
-        if (!path) {
-            throw new Error('path is required');
-        }
-        if (!message) {
-            throw new Error('message is required');
-        }
-        if (severity && !VALID_SEVERITIES.includes(severity)) {
-            throw new Error(`Invalid severity: ${severity}. Must be one of: ${VALID_SEVERITIES.join(', ')}`);
-        }
-
-        this.path = path;
-        this.message = message;
-        this.severity = severity || 'error';
-        this.code = code || null;
-        this.fix = fix || null;
-    }
-
-    static create(props) {
-        return new ValidationError(props);
-    }
-
-    getPathSegments() {
-        return this.path
-            .replace(/\[(\d+)\]/g, '.$1')
-            .split('.')
-            .filter(Boolean);
-    }
-
-    getRootPath() {
-        return this.getPathSegments()[0];
-    }
-
-    isError() {
-        return this.severity === 'error';
-    }
-
-    isWarning() {
-        return this.severity === 'warning';
-    }
-
-    isInfo() {
-        return this.severity === 'info';
-    }
-
-    hasFix() {
-        return this.fix !== null;
-    }
-
-    equals(other) {
-        return this.path === other.path && this.message === other.message;
-    }
-
-    toJSON() {
-        return {
-            path: this.path,
-            message: this.message,
-            severity: this.severity,
-            code: this.code,
-            fix: this.fix ? this.fix.toJSON() : null
-        };
-    }
-}
-
-module.exports = { ValidationError };