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

package/frigg-cli/validate-command/__tests__/infrastructure/integration-class-validator.test.js

@@ -0,0 +1,146 @@
+const { IntegrationClassValidator } = require('../../infrastructure/validators/integration-class-validator');
+
+describe('IntegrationClassValidator', () => {
+    let validator;
+
+    beforeEach(() => {
+        validator = new IntegrationClassValidator();
+    });
+
+    describe('valid integration classes', () => {
+        it('validates class with Definition static property', () => {
+            class ValidIntegration {
+                static Definition = {
+                    name: 'test-integration',
+                    version: '1.0.0',
+                    modules: {}
+                };
+            }
+            const result = validator.validate(ValidIntegration, 0);
+            expect(result.isValid()).toBe(true);
+        });
+
+        it('validates class with modules configuration', () => {
+            class ValidIntegration {
+                static Definition = {
+                    name: 'oauth-integration',
+                    version: '1.0.0',
+                    modules: {
+                        hubspot: {
+                            definition: { moduleName: 'hubspot' },
+                            options: {}
+                        }
+                    }
+                };
+            }
+            const result = validator.validate(ValidIntegration, 0);
+            expect(result.isValid()).toBe(true);
+        });
+    });
+
+    describe('invalid integration classes', () => {
+        it('errors when not a function/class', () => {
+            const notAClass = { Definition: { name: 'test' } };
+            const result = validator.validate(notAClass, 0);
+            expect(result.isValid()).toBe(false);
+            expect(result.getErrors()[0].message).toContain('class');
+        });
+
+        it('errors when Definition is missing', () => {
+            class NoDefinition {}
+            const result = validator.validate(NoDefinition, 0);
+            expect(result.isValid()).toBe(false);
+            expect(result.getErrors()[0].path).toBe('integrations[0].Definition');
+        });
+
+        it('errors when Definition.name is missing', () => {
+            class MissingName {
+                static Definition = { version: '1.0.0' };
+            }
+            const result = validator.validate(MissingName, 0);
+            expect(result.isValid()).toBe(false);
+            expect(result.getErrors()[0].path).toBe('integrations[0].Definition');
+            expect(result.getErrors()[0].message).toContain('name');
+        });
+
+        it('errors when Definition.name is not a string', () => {
+            class BadName {
+                static Definition = { name: 123, version: '1.0.0' };
+            }
+            const result = validator.validate(BadName, 0);
+            expect(result.isValid()).toBe(false);
+            expect(result.getErrors()[0].path).toBe('integrations[0].Definition.name');
+        });
+    });
+
+    describe('modules validation', () => {
+        it('errors when module lacks definition', () => {
+            class BadModule {
+                static Definition = {
+                    name: 'test',
+                    version: '1.0.0',
+                    modules: {
+                        hubspot: { options: {} }
+                    }
+                };
+            }
+            const result = validator.validate(BadModule, 0);
+            expect(result.isValid()).toBe(false);
+            expect(result.getErrors().some(e => e.path.includes('modules.hubspot') && e.message.includes('definition'))).toBe(true);
+        });
+
+        it('warns when module definition lacks moduleName', () => {
+            class ModuleNoModuleName {
+                static Definition = {
+                    name: 'test',
+                    version: '1.0.0',
+                    modules: {
+                        hubspot: {
+                            definition: {},
+                            options: {}
+                        }
+                    }
+                };
+            }
+            const result = validator.validate(ModuleNoModuleName, 0);
+            expect(result.getWarnings().some(w =>
+                w.code === 'MISSING_MODULE_NAME' && w.message.includes('moduleName')
+            )).toBe(true);
+        });
+    });
+
+    describe('lifecycle methods', () => {
+        it('warns when onCreate is not implemented', () => {
+            class NoOnCreate {
+                static Definition = { name: 'test-integration', version: '1.0.0' };
+            }
+            const result = validator.validate(NoOnCreate, 0);
+            expect(result.getWarnings().some(w => w.message.includes('onCreate'))).toBe(true);
+        });
+
+        it('passes when onCreate is implemented', () => {
+            class WithOnCreate {
+                static Definition = { name: 'test-integration', version: '1.0.0' };
+                async onCreate() {}
+            }
+            const result = validator.validate(WithOnCreate, 0);
+            expect(result.getWarnings().filter(w => w.message.includes('onCreate'))).toHaveLength(0);
+        });
+
+        it('warns when getConfigOptions is not implemented', () => {
+            class NoConfigOptions {
+                static Definition = { name: 'test-integration', version: '1.0.0' };
+            }
+            const result = validator.validate(NoConfigOptions, 0);
+            expect(result.getWarnings().some(w => w.message.includes('getConfigOptions'))).toBe(true);
+        });
+    });
+
+    describe('index parameter', () => {
+        it('includes correct index in error paths', () => {
+            class Invalid {}
+            const result = validator.validate(Invalid, 5);
+            expect(result.getErrors()[0].path).toContain('integrations[5]');
+        });
+    });
+});

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

@@ -0,0 +1,155 @@
+/**
+ * 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

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

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

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

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