@friggframework/devtools 2.0.0--canary.549.70ef06a.0 → 2.0.0--canary.545.ccb5010.0

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

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

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

package/frigg-cli/infrastructure/repositories/FileSystemApiModuleRepository.js

@@ -0,0 +1,373 @@
+const path = require('path');
+const {ApiModule} = require('../../domain/entities/ApiModule');
+const {IApiModuleRepository} = require('../../domain/ports/IApiModuleRepository');
+
+/**
+ * FileSystemApiModuleRepository
+ *
+ * Concrete implementation of IApiModuleRepository for file system storage
+ * Creates API module directories with class files, definitions, and configs
+ */
+class FileSystemApiModuleRepository extends IApiModuleRepository {
+    constructor(fileSystemAdapter, projectRoot, schemaValidator) {
+        super();
+        this.fileSystemAdapter = fileSystemAdapter;
+        this.projectRoot = projectRoot;
+        this.schemaValidator = schemaValidator;
+        this.apiModulesDir = path.join(projectRoot, 'backend/src/api-modules');
+    }
+
+    /**
+     * Save API module to file system
+     */
+    async save(apiModule) {
+        // 1. Validate domain entity
+        const validation = apiModule.validate();
+        if (!validation.isValid) {
+            throw new Error(`ApiModule validation failed: ${validation.errors.join(', ')}`);
+        }
+
+        // 2. Convert to persistence format
+        const persistenceData = this._toPersistenceFormat(apiModule);
+
+        // 3. Validate against schema (if schema exists)
+        // TODO: Create api-module schema
+        // const schemaValidation = await this.schemaValidator.validate('api-module', persistenceData.definition);
+
+        // 4. Create directories
+        const modulePath = path.join(this.apiModulesDir, apiModule.name);
+        await this.fileSystemAdapter.ensureDirectory(modulePath);
+
+        // 5. Write files atomically
+        const files = [
+            {
+                path: path.join(modulePath, 'Api.js'),
+                content: persistenceData.classFile
+            },
+            {
+                path: path.join(modulePath, 'definition.js'),
+                content: persistenceData.definitionFile
+            },
+            {
+                path: path.join(modulePath, 'config.json'),
+                content: JSON.stringify(persistenceData.config, null, 2)
+            },
+            {
+                path: path.join(modulePath, 'README.md'),
+                content: persistenceData.readme
+            }
+        ];
+
+        // Create Entity.js if module has entities
+        if (Object.keys(apiModule.entities).length > 0) {
+            files.push({
+                path: path.join(modulePath, 'Entity.js'),
+                content: this._generateEntityClass(apiModule)
+            });
+        }
+
+        // Create tests directory
+        const testsDir = path.join(modulePath, 'tests');
+        await this.fileSystemAdapter.ensureDirectory(testsDir);
+
+        for (const file of files) {
+            await this.fileSystemAdapter.writeFile(file.path, file.content);
+        }
+
+        return apiModule;
+    }
+
+    /**
+     * Find API module by name
+     */
+    async findByName(name) {
+        const modulePath = path.join(this.apiModulesDir, name);
+
+        if (!await this.fileSystemAdapter.exists(modulePath)) {
+            return null;
+        }
+
+        const definitionPath = path.join(modulePath, 'definition.js');
+        if (!await this.fileSystemAdapter.exists(definitionPath)) {
+            return null;
+        }
+
+        // Read definition file (this is a simple implementation)
+        const content = await this.fileSystemAdapter.readFile(definitionPath);
+        // For now, return a basic ApiModule - full parsing would require more work
+        return ApiModule.create({name});
+    }
+
+    /**
+     * Check if API module exists
+     */
+    async exists(name) {
+        const modulePath = path.join(this.apiModulesDir, name);
+        return await this.fileSystemAdapter.exists(modulePath);
+    }
+
+    /**
+     * List all API modules
+     */
+    async list() {
+        if (!await this.fileSystemAdapter.exists(this.apiModulesDir)) {
+            return [];
+        }
+
+        const moduleDirs = await this.fileSystemAdapter.listDirectories(this.apiModulesDir);
+        const modules = [];
+
+        for (const dirName of moduleDirs) {
+            try {
+                const module = await this.findByName(dirName);
+                if (module) {
+                    modules.push(module);
+                }
+            } catch (error) {
+                console.warn(`Failed to load API module ${dirName}:`, error.message);
+            }
+        }
+
+        return modules;
+    }
+
+    /**
+     * Delete API module
+     */
+    async delete(name) {
+        const modulePath = path.join(this.apiModulesDir, name);
+
+        if (!await this.fileSystemAdapter.exists(modulePath)) {
+            return false;
+        }
+
+        await this.fileSystemAdapter.deleteDirectory(modulePath);
+        return true;
+    }
+
+    /**
+     * Convert domain entity to persistence format
+     */
+    _toPersistenceFormat(apiModule) {
+        const obj = apiModule.toObject();
+        const json = apiModule.toJSON();
+
+        return {
+            classFile: this._generateApiClass(apiModule),
+            definitionFile: this._generateDefinitionFile(apiModule),
+            definition: json,
+            config: {
+                name: obj.name,
+                version: obj.version,
+                authType: obj.apiConfig.authType
+            },
+            readme: this._generateReadme(apiModule)
+        };
+    }
+
+    /**
+     * Generate Api.js class file
+     */
+    _generateApiClass(apiModule) {
+        const className = apiModule.name
+            .split('-')
+            .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+            .join('');
+
+        const obj = apiModule.toObject();
+
+        return `const { ApiBase } = require('@friggframework/core');
+
+/**
+ * ${apiModule.displayName} API Client
+ * ${apiModule.description || 'No description provided'}
+ *
+ * Base URL: ${obj.apiConfig.baseUrl || 'Not configured'}
+ * Auth Type: ${obj.apiConfig.authType}
+ */
+class ${className}Api extends ApiBase {
+    constructor(params) {
+        super(params);
+        this.baseUrl = '${obj.apiConfig.baseUrl || ''}';
+        this.authType = '${obj.apiConfig.authType}';
+${obj.entities.credential ? `        this.credential = params.credential;\n` : ''}    }
+
+    static get Definition() {
+        return require('./definition');
+    }
+
+    /**
+     * Get authorization URL for OAuth2 flow
+     */
+    async getAuthorizationUri() {
+        // TODO: Implement OAuth authorization URL
+        return \`\${this.baseUrl}/oauth/authorize\`;
+    }
+
+    /**
+     * Exchange authorization code for access token
+     */
+    async getTokenFromCode(code) {
+        // TODO: Implement token exchange
+        return await this.api.post('/oauth/token', {
+            code,
+            grant_type: 'authorization_code'
+        });
+    }
+
+    /**
+     * Set API credentials
+     */
+    async setCredential(credential) {
+        this.credential = credential;
+
+        // Set auth headers based on auth type
+        if (this.authType === 'oauth2' && credential.accessToken) {
+            this.setHeader('Authorization', \`Bearer \${credential.accessToken}\`);
+        } else if (this.authType === 'api-key' && credential.apiKey) {
+            this.setHeader('X-API-Key', credential.apiKey);
+        }
+    }
+
+    /**
+     * Test API connection
+     */
+    async testAuth() {
+        // TODO: Implement connection test
+        return await this.get('/user/me');
+    }
+
+${this._generateEndpointMethods(apiModule)}
+    // TODO: Add your API methods here
+}
+
+module.exports = ${className}Api;
+`;
+    }
+
+    /**
+     * Generate endpoint methods
+     */
+    _generateEndpointMethods(apiModule) {
+        if (Object.keys(apiModule.endpoints).length === 0) {
+            return '';
+        }
+
+        return Object.entries(apiModule.endpoints).map(([name, config]) => {
+            const method = config.method.toLowerCase();
+            const params = config.parameters || [];
+            const paramList = params.map(p => p.name).join(', ');
+
+            return `    /**
+     * ${config.description || name}
+     */
+    async ${name}(${paramList}) {
+        return await this.${method}('${config.path}'${paramList ? `, {${paramList}}` : ''});
+    }
+`;
+        }).join('\n');
+    }
+
+    /**
+     * Generate Entity.js class file
+     */
+    _generateEntityClass(apiModule) {
+        const className = apiModule.name
+            .split('-')
+            .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+            .join('');
+
+        const entities = Object.entries(apiModule.entities);
+        const primaryEntity = entities[0]; // Use first entity as primary
+
+        return `const { EntityBase } = require('@friggframework/core');
+
+/**
+ * ${apiModule.displayName} Entity
+ * Database entity for storing ${apiModule.displayName} credentials and state
+ */
+class ${className}Entity extends EntityBase {
+    static getName() {
+        return '${primaryEntity[0]}';
+    }
+
+    static get Definition() {
+        return {
+            type: '${primaryEntity[0]}',
+            fields: ${JSON.stringify(primaryEntity[1].fields || [], null, 12)}
+        };
+    }
+}
+
+module.exports = ${className}Entity;
+`;
+    }
+
+    /**
+     * Generate definition.js file
+     */
+    _generateDefinitionFile(apiModule) {
+        const json = apiModule.toJSON();
+
+        return `module.exports = ${JSON.stringify(json, null, 2)};
+`;
+    }
+
+    /**
+     * Generate README.md
+     */
+    _generateReadme(apiModule) {
+        const obj = apiModule.toObject();
+
+        return `# ${apiModule.displayName}
+
+${apiModule.description || 'No description provided'}
+
+## Configuration
+
+**Base URL:** ${obj.apiConfig.baseUrl || 'Not configured'}
+**Auth Type:** ${obj.apiConfig.authType}
+**API Version:** ${obj.apiConfig.version || 'v1'}
+
+## Required Credentials
+
+${obj.credentials.length > 0 ? obj.credentials.map(c =>
+`- **${c.name}** (\`${c.type}\`): ${c.description || 'No description'}${c.required ? ' (Required)' : ''}`
+).join('\n') : 'No credentials required'}
+
+## OAuth Scopes
+
+${obj.scopes.length > 0 ? obj.scopes.map(s => `- ${s}`).join('\n') : 'No scopes required'}
+
+## Entities
+
+${Object.keys(obj.entities).length > 0 ? Object.entries(obj.entities).map(([name, config]) =>
+`### ${config.label || name}
+
+- Type: \`${config.type}\`
+- Required: ${config.required ? 'Yes' : 'No'}
+`).join('\n') : 'No entities defined'}
+
+## Usage
+
+\`\`\`javascript
+const ${apiModule.name.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join('')}Api = require('./${apiModule.name}/Api');
+
+const api = new ${apiModule.name.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join('')}Api({
+    credential: myCredential
+});
+
+// Test authentication
+await api.testAuth();
+\`\`\`
+
+## Development
+
+1. Implement the API methods in \`Api.js\`
+2. Add entity configuration in \`Entity.js\` if needed
+3. Test with \`frigg start\`
+`;
+    }
+}
+
+module.exports = {FileSystemApiModuleRepository};