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

package/frigg-cli/infrastructure/adapters/FileSystemAdapter.js

@@ -1,224 +0,0 @@
-const fs = require('fs-extra');
-const path = require('path');
-
-/**
- * FileSystemAdapter
- * Low-level file system operations with atomic write/update and rollback support
- */
-class FileSystemAdapter {
-    constructor() {
-        this.operations = []; // Track operations for rollback
-    }
-
-    /**
-     * Write file atomically (temp file + rename)
-     */
-    async writeFile(filePath, content) {
-        const tempPath = `${filePath}.tmp.${Date.now()}`;
-
-        try {
-            await fs.writeFile(tempPath, content, 'utf-8');
-            await fs.rename(tempPath, filePath);
-
-            this.operations.push({
-                type: 'create',
-                path: filePath,
-                backup: null
-            });
-
-            return {success: true, path: filePath};
-        } catch (error) {
-            // Clean up temp file on error
-            if (await fs.pathExists(tempPath)) {
-                await fs.unlink(tempPath);
-            }
-            throw new Error(`Failed to write file ${filePath}: ${error.message}`);
-        }
-    }
-
-    /**
-     * Update file atomically (backup + write + rename)
-     */
-    async updateFile(filePath, updateFn) {
-        const backupPath = `${filePath}.backup.${Date.now()}`;
-
-        try {
-            // Create backup if file exists
-            if (await fs.pathExists(filePath)) {
-                await fs.copy(filePath, backupPath);
-            }
-
-            // Read current content
-            const currentContent = await fs.pathExists(filePath)
-                ? await fs.readFile(filePath, 'utf-8')
-                : '';
-
-            // Apply update function
-            const newContent = await updateFn(currentContent);
-
-            // Write to temp, then rename (atomic)
-            const tempPath = `${filePath}.tmp.${Date.now()}`;
-            await fs.writeFile(tempPath, newContent, 'utf-8');
-            await fs.rename(tempPath, filePath);
-
-            this.operations.push({
-                type: 'update',
-                path: filePath,
-                backup: backupPath
-            });
-
-            return {success: true, path: filePath};
-        } catch (error) {
-            // Restore from backup on error
-            if (await fs.pathExists(backupPath)) {
-                await fs.copy(backupPath, filePath);
-            }
-            throw new Error(`Failed to update file ${filePath}: ${error.message}`);
-        }
-    }
-
-    /**
-     * Read file content
-     */
-    async readFile(filePath) {
-        try {
-            return await fs.readFile(filePath, 'utf-8');
-        } catch (error) {
-            throw new Error(`Failed to read file ${filePath}: ${error.message}`);
-        }
-    }
-
-    /**
-     * Check if file or directory exists
-     */
-    async exists(filePath) {
-        return await fs.pathExists(filePath);
-    }
-
-    /**
-     * Ensure directory exists (create if needed)
-     */
-    async ensureDirectory(dirPath) {
-        if (!await fs.pathExists(dirPath)) {
-            await fs.ensureDir(dirPath);
-
-            this.operations.push({
-                type: 'mkdir',
-                path: dirPath,
-                backup: null
-            });
-        }
-
-        return {exists: true};
-    }
-
-    /**
-     * List directories in a path
-     */
-    async listDirectories(dirPath) {
-        if (!await fs.pathExists(dirPath)) {
-            return [];
-        }
-
-        const entries = await fs.readdir(dirPath, {withFileTypes: true});
-        return entries
-            .filter(entry => entry.isDirectory())
-            .map(entry => entry.name);
-    }
-
-    /**
-     * List files in a path (optionally with pattern)
-     */
-    async listFiles(dirPath, pattern = null) {
-        if (!await fs.pathExists(dirPath)) {
-            return [];
-        }
-
-        const entries = await fs.readdir(dirPath, {withFileTypes: true});
-        let files = entries
-            .filter(entry => entry.isFile())
-            .map(entry => entry.name);
-
-        // Apply pattern filter if provided
-        if (pattern) {
-            const regex = new RegExp(pattern.replace(/\*/g, '.*'));
-            files = files.filter(file => regex.test(file));
-        }
-
-        return files;
-    }
-
-
-    /**
-     * Rollback all tracked operations in reverse order
-     */
-    async rollback() {
-        const errors = [];
-
-        // Reverse order for rollback
-        for (const op of this.operations.reverse()) {
-            try {
-                switch (op.type) {
-                    case 'create':
-                        // Delete created file
-                        if (await fs.pathExists(op.path)) {
-                            await fs.unlink(op.path);
-                        }
-                        break;
-
-                    case 'update':
-                        // Restore from backup
-                        if (op.backup && await fs.pathExists(op.backup)) {
-                            await fs.copy(op.backup, op.path);
-                        }
-                        break;
-
-                    case 'mkdir':
-                        // Remove empty directory
-                        if (await fs.pathExists(op.path)) {
-                            const files = await fs.readdir(op.path);
-                            if (files.length === 0) {
-                                await fs.rmdir(op.path);
-                            }
-                        }
-                        break;
-                }
-            } catch (error) {
-                errors.push({
-                    operation: op,
-                    error: error.message
-                });
-            }
-        }
-
-        this.operations = [];
-
-        return {
-            success: errors.length === 0,
-            errors
-        };
-    }
-
-    /**
-     * Commit operations (clean up backups)
-     */
-    async commit() {
-        for (const op of this.operations) {
-            if (op.backup && await fs.pathExists(op.backup)) {
-                await fs.unlink(op.backup);
-            }
-        }
-
-        this.operations = [];
-        return {success: true};
-    }
-
-    /**
-     * Clear operation tracking without cleanup
-     */
-    clear() {
-        this.operations = [];
-    }
-}
-
-module.exports = {FileSystemAdapter};

package/frigg-cli/infrastructure/adapters/IntegrationJsUpdater.js

@@ -1,249 +0,0 @@
-const path = require('path');
-
-/**
- * IntegrationJsUpdater
- *
- * Infrastructure adapter for updating Integration.js class files
- * Adds API module imports and updates the static Definition.modules object
- */
-class IntegrationJsUpdater {
-    constructor(fileSystemAdapter, backendPath = process.cwd()) {
-        this.fileSystemAdapter = fileSystemAdapter;
-        this.backendPath = backendPath;
-    }
-
-    /**
-     * Add an API module to an Integration.js file
-     *
-     * Updates:
-     * 1. Adds require() import at top of file
-     * 2. Adds module to static Definition.modules object
-     *
-     * @param {string} integrationName - Integration name (kebab-case)
-     * @param {string} moduleName - API module name (kebab-case)
-     * @param {string} source - Module source ('local', 'npm', 'git')
-     */
-    async addModuleToIntegration(integrationName, moduleName, source = 'local') {
-        return this.addModulesToIntegration(integrationName, [{name: moduleName, source}]);
-    }
-
-    /**
-     * Add multiple API modules to an Integration.js file (batch operation)
-     *
-     * @param {string} integrationName - Integration name (kebab-case)
-     * @param {Array<{name: string, source: string}>} modules - Array of modules to add
-     */
-    async addModulesToIntegration(integrationName, modules = []) {
-        const className = this._toClassName(integrationName);
-        const integrationJsPath = path.join(
-            this.backendPath,
-            'src/integrations',
-            `${className}Integration.js`
-        );
-
-        // Check if file exists
-        const exists = await this.fileSystemAdapter.exists(integrationJsPath);
-        if (!exists) {
-            throw new Error(`Integration.js not found at ${integrationJsPath}`);
-        }
-
-        // Write updated content using updateFile's callback pattern
-        await this.fileSystemAdapter.updateFile(integrationJsPath, (currentContent) => {
-            let content = currentContent;
-
-            // Add all imports
-            for (const module of modules) {
-                content = this._addModuleImport(content, module.name, module.source || 'local');
-            }
-
-            // Add all modules to Definition
-            for (const module of modules) {
-                content = this._addModuleToDefinition(content, module.name);
-            }
-
-            return content;
-        });
-    }
-
-    /**
-     * Add require() import for API module at top of file
-     */
-    _addModuleImport(content, moduleName, source = 'local') {
-        const camelName = this._toCamelCase(moduleName);
-        let importStatement;
-
-        // Different import path based on source
-        if (source === 'npm') {
-            importStatement = `const ${camelName} = require('@friggframework/api-module-${moduleName}');`;
-        } else {
-            // local or git - use relative path
-            importStatement = `const ${camelName} = require('../api-modules/${moduleName}');`;
-        }
-
-        // Check if import already exists
-        if (content.includes(importStatement)) {
-            return content;
-        }
-
-        // Find the position to insert (after other requires, before class definition)
-        const lines = content.split('\n');
-        let insertIndex = 0;
-
-        // Find last require statement
-        for (let i = 0; i < lines.length; i++) {
-            if (lines[i].includes('require(')) {
-                insertIndex = i + 1;
-            }
-            // Stop at class definition
-            if (lines[i].includes('class ') && lines[i].includes('Integration')) {
-                break;
-            }
-        }
-
-        // Insert import
-        lines.splice(insertIndex, 0, importStatement);
-
-        return lines.join('\n');
-    }
-
-    /**
-     * Add module to static Definition.modules object
-     */
-    _addModuleToDefinition(content, moduleName) {
-        const camelName = this._toCamelCase(moduleName);
-        const moduleEntry = `            ${camelName}: {\n                definition: ${camelName}.Definition,\n            },`;
-
-        // Check if module already exists in Definition
-        const modulePattern = new RegExp(`${camelName}:\\s*{[\\s\\S]*?definition:`);
-        if (modulePattern.test(content)) {
-            return content;
-        }
-
-        // Find the modules object in static Definition
-        const modulesPattern = /modules:\s*{/;
-        const match = content.match(modulesPattern);
-
-        if (!match) {
-            // No modules object exists yet, need to add it
-            return this._addModulesObjectToDefinition(content, moduleName);
-        }
-
-        // Parse line by line to find the right insertion point
-        const lines = content.split('\n');
-        let insertIndex = -1;
-        let modulesLineIndex = -1;
-        let braceCount = 0;
-        let inModules = false;
-
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-
-            if (line.includes('modules: {')) {
-                modulesLineIndex = i;
-                inModules = true;
-                braceCount = 1;
-                // Always insert right after modules: { line
-                insertIndex = i + 1;
-                break;
-            }
-        }
-
-        // Insert the module entry
-        lines.splice(insertIndex, 0, moduleEntry);
-
-        return lines.join('\n');
-    }
-
-    /**
-     * Add modules object to Definition if it doesn't exist
-     */
-    _addModulesObjectToDefinition(content, moduleName) {
-        const camelName = this._toCamelCase(moduleName);
-        const modulesBlock = `        modules: {\n            ${camelName}: {\n                definition: ${camelName}.Definition,\n            },\n        },`;
-
-        // Find static Definition
-        const definitionPattern = /static\s+Definition\s*=\s*{/;
-        const match = content.match(definitionPattern);
-
-        if (!match) {
-            throw new Error('Could not find static Definition in Integration.js');
-        }
-
-        // Find good insertion point (after display object)
-        const displayEndPattern = /},\s*$/m;
-        let lines = content.split('\n');
-        let insertIndex = -1;
-
-        let inDefinition = false;
-        let braceCount = 0;
-
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-
-            if (line.includes('static Definition')) {
-                inDefinition = true;
-                braceCount = 1;
-                continue;
-            }
-
-            if (inDefinition) {
-                // Count braces
-                braceCount += (line.match(/{/g) || []).length;
-                braceCount -= (line.match(/}/g) || []).length;
-
-                // Look for display block end
-                if (line.includes('display:')) {
-                    // Find the closing of display object
-                    for (let j = i + 1; j < lines.length; j++) {
-                        if (lines[j].trim().startsWith('},')) {
-                            insertIndex = j + 1;
-                            break;
-                        }
-                    }
-                    if (insertIndex !== -1) break;
-                }
-            }
-        }
-
-        if (insertIndex === -1) {
-            throw new Error('Could not find insertion point for modules in static Definition');
-        }
-
-        // Insert modules block
-        lines.splice(insertIndex, 0, modulesBlock);
-
-        return lines.join('\n');
-    }
-
-    /**
-     * Convert kebab-case to camelCase
-     */
-    _toCamelCase(str) {
-        return str.replace(/-([a-z])/g, (match, letter) => letter.toUpperCase());
-    }
-
-    /**
-     * Convert kebab-case to ClassName
-     */
-    _toClassName(str) {
-        return str
-            .split('-')
-            .map(word => word.charAt(0).toUpperCase() + word.slice(1))
-            .join('');
-    }
-
-    /**
-     * Check if Integration.js file exists
-     */
-    async exists(integrationName) {
-        const className = this._toClassName(integrationName);
-        const integrationJsPath = path.join(
-            this.backendPath,
-            'src/integrations',
-            `${className}Integration.js`
-        );
-        return await this.fileSystemAdapter.exists(integrationJsPath);
-    }
-}
-
-module.exports = {IntegrationJsUpdater};

package/frigg-cli/infrastructure/adapters/SchemaValidator.js

@@ -1,92 +0,0 @@
-const Ajv = require('ajv');
-const addFormats = require('ajv-formats');
-const path = require('path');
-const fs = require('fs-extra');
-
-/**
- * SchemaValidator
- * Validates data against JSON schemas from /packages/schemas
- */
-class SchemaValidator {
-    constructor(schemasPath) {
-        // Default to schemas package in monorepo
-        this.schemasPath = schemasPath || path.join(__dirname, '../../../../schemas/schemas');
-
-        this.ajv = new Ajv({
-            allErrors: true,
-            strict: false,
-            validateFormats: true
-        });
-
-        addFormats(this.ajv);
-        this.schemas = new Map();
-    }
-
-    /**
-     * Load and compile a schema
-     */
-    async loadSchema(schemaName) {
-        if (this.schemas.has(schemaName)) {
-            return this.schemas.get(schemaName);
-        }
-
-        const schemaPath = path.join(this.schemasPath, `${schemaName}.schema.json`);
-
-        if (!await fs.pathExists(schemaPath)) {
-            throw new Error(`Schema not found: ${schemaPath}`);
-        }
-
-        const schemaContent = await fs.readFile(schemaPath, 'utf-8');
-        const schema = JSON.parse(schemaContent);
-
-        const validate = this.ajv.compile(schema);
-        this.schemas.set(schemaName, validate);
-
-        return validate;
-    }
-
-    /**
-     * Validate data against a schema
-     * @param {string} schemaName - Name of the schema (e.g., 'integration-definition')
-     * @param {object} data - Data to validate
-     * @returns {Promise<{valid: boolean, errors: string[]}>}
-     */
-    async validate(schemaName, data) {
-        try {
-            const validate = await this.loadSchema(schemaName);
-            const valid = validate(data);
-
-            if (!valid) {
-                const errors = validate.errors.map(err => {
-                    const path = err.instancePath || '/';
-                    return `${path} ${err.message}`;
-                });
-
-                return {
-                    valid: false,
-                    errors
-                };
-            }
-
-            return {
-                valid: true,
-                errors: []
-            };
-        } catch (error) {
-            return {
-                valid: false,
-                errors: [`Schema validation error: ${error.message}`]
-            };
-        }
-    }
-
-    /**
-     * Check if a schema exists
-     */
-    async hasSchema(schemaName) {
-        const schemaPath = path.join(this.schemasPath, `${schemaName}.schema.json`);
-        return await fs.pathExists(schemaPath);
-    }
-}
-
-module.exports = {SchemaValidator};