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

package/frigg-cli/infrastructure/UnitOfWork.js

@@ -0,0 +1,46 @@
+/**
+ * UnitOfWork
+ * Coordinates transactions across repositories
+ */
+class UnitOfWork {
+    constructor(fileSystemAdapter) {
+        this.fileSystemAdapter = fileSystemAdapter;
+        this.repositories = new Map();
+    }
+
+    /**
+     * Register a repository
+     */
+    registerRepository(name, repository) {
+        this.repositories.set(name, repository);
+        return this;
+    }
+
+    /**
+     * Commit all tracked operations
+     */
+    async commit() {
+        try {
+            await this.fileSystemAdapter.commit();
+            return {success: true};
+        } catch (error) {
+            throw new Error(`Failed to commit transaction: ${error.message}`);
+        }
+    }
+
+    /**
+     * Rollback all tracked operations
+     */
+    async rollback() {
+        return await this.fileSystemAdapter.rollback();
+    }
+
+    /**
+     * Clear tracked operations without commit/rollback
+     */
+    clear() {
+        this.fileSystemAdapter.clear();
+    }
+}
+
+module.exports = {UnitOfWork};

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

@@ -0,0 +1,197 @@
+const path = require('path');
+const fs = require('fs-extra');
+
+/**
+ * BackendJsUpdater
+ *
+ * Infrastructure service for updating backend.js file with new integrations
+ * Uses AST manipulation to safely add integration imports and registrations
+ */
+class BackendJsUpdater {
+    constructor(fileSystemAdapter, backendPath) {
+        this.fileSystemAdapter = fileSystemAdapter;
+        this.backendPath = backendPath;
+        this.indexJsPath = path.join(backendPath, 'index.js');
+    }
+
+    /**
+     * Register an integration in backend/index.js
+     * @param {string} integrationName - kebab-case integration name
+     * @returns {Promise<void>}
+     */
+    async registerIntegration(integrationName) {
+        if (!await this.fileSystemAdapter.exists(this.indexJsPath)) {
+            throw new Error('backend/index.js not found');
+        }
+
+        const className = this._toClassName(integrationName);
+        const importPath = `./src/integrations/${className}Integration`;
+
+        await this.fileSystemAdapter.updateFile(this.indexJsPath, (content) => {
+            return this._addIntegration(content, className, integrationName, importPath);
+        });
+    }
+
+    /**
+     * Remove an integration from backend/index.js
+     * @param {string} integrationName
+     * @returns {Promise<void>}
+     */
+    async unregisterIntegration(integrationName) {
+        if (!await this.fileSystemAdapter.exists(this.indexJsPath)) {
+            throw new Error('backend/index.js not found');
+        }
+
+        const className = this._toClassName(integrationName);
+
+        await this.fileSystemAdapter.updateFile(this.indexJsPath, (content) => {
+            return this._removeIntegration(content, className, integrationName);
+        });
+    }
+
+    /**
+     * Add integration to backend.js content
+     * Simple string manipulation approach (can be replaced with AST parsing if needed)
+     *
+     * @param {string} content - Current backend.js content
+     * @param {string} className - Integration class name
+     * @param {string} integrationName - kebab-case name
+     * @param {string} importPath - relative import path
+     * @returns {string} - Updated content
+     */
+    _addIntegration(content, className, integrationName, importPath) {
+        // Check if integration is already registered
+        if (content.includes(`const ${className}Integration`)) {
+            console.warn(`Integration ${integrationName} is already registered in backend.js`);
+            return content;
+        }
+
+        let updated = content;
+
+        // 1. Add import statement after other integration imports
+        const importRegex = /(const \w+Integration = require\('\.\/src\/integrations\/[^']+'\);)/g;
+        const importMatches = [...content.matchAll(importRegex)];
+
+        if (importMatches.length > 0) {
+            // Add after last integration import
+            const lastImport = importMatches[importMatches.length - 1];
+            const insertIndex = lastImport.index + lastImport[0].length;
+            const importStatement = `\nconst ${className}Integration = require('${importPath}');`;
+            updated = updated.slice(0, insertIndex) + importStatement + updated.slice(insertIndex);
+        } else {
+            // No existing imports - add at the top after requires
+            const requiresRegex = /const .+ = require\([^)]+\);/g;
+            const requireMatches = [...content.matchAll(requiresRegex)];
+            if (requireMatches.length > 0) {
+                const lastRequire = requireMatches[requireMatches.length - 1];
+                const insertIndex = lastRequire.index + lastRequire[0].length;
+                const importStatement = `\n\n// Integrations\nconst ${className}Integration = require('${importPath}');`;
+                updated = updated.slice(0, insertIndex) + importStatement + updated.slice(insertIndex);
+            }
+        }
+
+        // 2. Add to integrations array
+        // Look for patterns:
+        // - const integrations = [...]
+        // - integrations: [...] (inside appDefinition object)
+
+        // Try standalone array first
+        const standaloneArrayRegex = /const integrations = \[([\s\S]*?)\];/;
+        let match = updated.match(standaloneArrayRegex);
+
+        if (match) {
+            const currentArray = match[1];
+            const newEntry = `\n    ${className}Integration,`;
+
+            // Check if it's an empty array
+            if (currentArray.trim() === '') {
+                updated = updated.replace(standaloneArrayRegex, `const integrations = [${newEntry}\n];`);
+            } else {
+                // Add to existing array
+                const insertAt = match.index + match[0].length - 2; // Before ];
+                updated = updated.slice(0, insertAt) + ',' + newEntry + updated.slice(insertAt);
+            }
+        } else {
+            // Try appDefinition pattern
+            const appDefArrayRegex = /integrations:\s*\[([\s\S]*?)\]/;
+            match = updated.match(appDefArrayRegex);
+
+            if (match) {
+                const currentArray = match[1];
+                const newEntry = `\n        ${className}Integration,`;
+
+                // Check if array is empty or has only comments
+                const hasOnlyComments = currentArray.trim() === '' ||
+                    currentArray.trim().split('\n').every(line => line.trim().startsWith('//'));
+
+                if (hasOnlyComments) {
+                    // Replace entire array content
+                    updated = updated.replace(appDefArrayRegex, `integrations: [${newEntry}\n    ]`);
+                } else {
+                    // Add to existing array - find the last entry and add comma if needed
+                    const lines = currentArray.split('\n');
+                    const lastNonEmptyLine = lines.reverse().find(line => line.trim() && !line.trim().startsWith('//'));
+                    const needsComma = lastNonEmptyLine && !lastNonEmptyLine.trim().endsWith(',');
+                    const comma = needsComma ? ',' : '';
+
+                    const insertAt = match.index + match[0].length - 1; // Before ]
+                    updated = updated.slice(0, insertAt) + comma + newEntry + '\n    ' + updated.slice(insertAt);
+                }
+            } else {
+                // No integrations array found - this is a problem
+                console.warn('Could not find integrations array in backend/index.js');
+            }
+        }
+
+        return updated;
+    }
+
+    /**
+     * Remove integration from backend.js content
+     *
+     * @param {string} content
+     * @param {string} className
+     * @param {string} integrationName
+     * @returns {string}
+     */
+    _removeIntegration(content, className, integrationName) {
+        let updated = content;
+
+        // 1. Remove import statement
+        const importRegex = new RegExp(`\\nconst ${className}Integration = require\\([^)]+\\);`, 'g');
+        updated = updated.replace(importRegex, '');
+
+        // 2. Remove from integrations array
+        const arrayEntryRegex = new RegExp(`,?\\s*${className}Integration,?`, 'g');
+        updated = updated.replace(arrayEntryRegex, '');
+
+        // Clean up extra commas
+        updated = updated.replace(/,\s*,/g, ',');
+        updated = updated.replace(/\[\s*,/g, '[');
+        updated = updated.replace(/,\s*\]/g, ']');
+
+        return updated;
+    }
+
+    /**
+     * Convert kebab-case to ClassName
+     * @param {string} kebabCase
+     * @returns {string}
+     */
+    _toClassName(kebabCase) {
+        return kebabCase
+            .split('-')
+            .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+            .join('');
+    }
+
+    /**
+     * Check if backend/index.js exists
+     * @returns {Promise<boolean>}
+     */
+    async exists() {
+        return await this.fileSystemAdapter.exists(this.indexJsPath);
+    }
+}
+
+module.exports = {BackendJsUpdater};

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

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