@friggframework/devtools 2.0.0--canary.517.179491e.0 → 2.0.0--canary.522.893db5d.0

package/frigg-cli/application/use-cases/AddApiModuleToIntegrationUseCase.js

@@ -0,0 +1,93 @@
+const {ValidationException} = require('../../domain/exceptions/DomainException');
+const {IntegrationValidator} = require('../../domain/services/IntegrationValidator');
+
+/**
+ * AddApiModuleToIntegrationUseCase
+ *
+ * Application layer use case for adding API modules to existing integrations
+ * Orchestrates the addition with validation and persistence
+ */
+class AddApiModuleToIntegrationUseCase {
+    constructor(integrationRepository, apiModuleRepository, unitOfWork, integrationValidator = null, integrationJsUpdater = null) {
+        this.integrationRepository = integrationRepository;
+        this.apiModuleRepository = apiModuleRepository;
+        this.unitOfWork = unitOfWork;
+        this.integrationValidator = integrationValidator ||
+            new IntegrationValidator(integrationRepository);
+        this.integrationJsUpdater = integrationJsUpdater;
+    }
+
+    /**
+     * Execute the use case
+     * @param {object} request - Request data
+     * @param {string} request.integrationName - Name of the integration
+     * @param {string} request.moduleName - Name of the API module to add
+     * @param {string} request.moduleVersion - Version of the API module
+     * @param {string} request.source - Source of the module (npm, local, git)
+     * @returns {Promise<{success: boolean, integration: object}>}
+     */
+    async execute(request) {
+        try {
+            // 1. Load the integration
+            const integration = await this.integrationRepository.findByName(request.integrationName);
+            if (!integration) {
+                throw new ValidationException(`Integration '${request.integrationName}' not found`);
+            }
+
+            // 2. Verify API module exists
+            const apiModuleExists = await this.apiModuleRepository.exists(request.moduleName);
+            if (!apiModuleExists) {
+                throw new ValidationException(`API module '${request.moduleName}' not found. Create it first with 'frigg create api-module ${request.moduleName}'`);
+            }
+
+            // 3. Validate API module addition
+            const validation = this.integrationValidator.validateApiModuleAddition(
+                integration,
+                request.moduleName,
+                request.moduleVersion || '1.0.0'
+            );
+
+            if (!validation.isValid) {
+                throw new ValidationException(validation.errors);
+            }
+
+            // 4. Add the API module to the integration
+            integration.addApiModule(
+                request.moduleName,
+                request.moduleVersion || '1.0.0',
+                request.source || 'local'
+            );
+
+            // 5. Save the updated integration
+            await this.integrationRepository.save(integration);
+
+            // 6. Update Integration.js file to add module import and Definition entry
+            if (this.integrationJsUpdater) {
+                const integrationJsExists = await this.integrationJsUpdater.exists(request.integrationName);
+                if (integrationJsExists) {
+                    await this.integrationJsUpdater.addModuleToIntegration(
+                        request.integrationName,
+                        request.moduleName,
+                        request.source || 'local'
+                    );
+                }
+            }
+
+            // 7. Commit transaction
+            await this.unitOfWork.commit();
+
+            return {
+                success: true,
+                integration: integration.toObject(),
+                message: `API module '${request.moduleName}' added to integration '${request.integrationName}'`
+            };
+        } catch (error) {
+            // Rollback all file operations on error
+            await this.unitOfWork.rollback();
+
+            throw error;
+        }
+    }
+}
+
+module.exports = {AddApiModuleToIntegrationUseCase};

package/frigg-cli/application/use-cases/CreateApiModuleUseCase.js

@@ -0,0 +1,93 @@
+const {ApiModule} = require('../../domain/entities/ApiModule');
+const {ValidationException} = require('../../domain/exceptions/DomainException');
+
+/**
+ * CreateApiModuleUseCase
+ *
+ * Application layer use case for creating new API modules
+ * Orchestrates API module creation with validation and persistence
+ */
+class CreateApiModuleUseCase {
+    constructor(apiModuleRepository, unitOfWork, appDefinitionRepository = null) {
+        this.apiModuleRepository = apiModuleRepository;
+        this.unitOfWork = unitOfWork;
+        this.appDefinitionRepository = appDefinitionRepository;
+    }
+
+    /**
+     * Execute the use case
+     * @param {object} request - Request data
+     * @param {string} request.name - API module name (kebab-case)
+     * @param {string} request.displayName - Human-readable name
+     * @param {string} request.description - Description
+     * @param {string} request.baseUrl - API base URL
+     * @param {string} request.authType - Authentication type
+     * @param {array} request.scopes - OAuth scopes
+     * @param {array} request.credentials - Required credentials
+     * @param {object} request.entities - Entity configurations
+     * @param {object} request.endpoints - API endpoints
+     * @returns {Promise<{success: boolean, apiModule: object}>}
+     */
+    async execute(request) {
+        try {
+            // 1. Create domain entity
+            const apiModule = ApiModule.create({
+                name: request.name,
+                displayName: request.displayName,
+                description: request.description,
+                apiConfig: {
+                    baseUrl: request.baseUrl || '',
+                    authType: request.authType || 'oauth2',
+                    version: request.apiVersion || 'v1'
+                },
+                entities: request.entities || {},
+                scopes: request.scopes || [],
+                credentials: request.credentials || [],
+                endpoints: request.endpoints || {}
+            });
+
+            // 2. Validate business rules
+            const validation = apiModule.validate();
+            if (!validation.isValid) {
+                throw new ValidationException(validation.errors);
+            }
+
+            // 3. Check for existing API module (uniqueness)
+            const exists = await this.apiModuleRepository.exists(apiModule.name);
+            if (exists) {
+                throw new ValidationException(`API module '${apiModule.name}' already exists`);
+            }
+
+            // 4. Save through repository (writes files atomically)
+            await this.apiModuleRepository.save(apiModule);
+
+            // 5. Register in AppDefinition (if repository is available)
+            if (this.appDefinitionRepository) {
+                try {
+                    const appDef = await this.appDefinitionRepository.load();
+                    if (appDef) {
+                        appDef.registerApiModule(apiModule.name, apiModule.version.value, 'local');
+                        await this.appDefinitionRepository.save(appDef);
+                    }
+                } catch (error) {
+                    console.warn('Could not register API module in app definition:', error.message);
+                }
+            }
+
+            // 6. Commit transaction (cleanup backups)
+            await this.unitOfWork.commit();
+
+            return {
+                success: true,
+                apiModule: apiModule.toObject()
+            };
+        } catch (error) {
+            // Rollback all file operations on error
+            await this.unitOfWork.rollback();
+
+            throw error;
+        }
+    }
+}
+
+module.exports = {CreateApiModuleUseCase};

package/frigg-cli/application/use-cases/CreateIntegrationUseCase.js

@@ -0,0 +1,103 @@
+const {Integration} = require('../../domain/entities/Integration');
+const {ValidationException} = require('../../domain/exceptions/DomainException');
+const {IntegrationValidator} = require('../../domain/services/IntegrationValidator');
+
+/**
+ * CreateIntegrationUseCase
+ * Application layer use case for creating new integrations
+ * Uses IntegrationValidator domain service for comprehensive validation
+ * Automatically registers integration in AppDefinition
+ */
+class CreateIntegrationUseCase {
+    constructor(integrationRepository, unitOfWork, integrationValidator = null, appDefinitionRepository = null, backendJsUpdater = null) {
+        this.integrationRepository = integrationRepository;
+        this.unitOfWork = unitOfWork;
+        this.appDefinitionRepository = appDefinitionRepository;
+        this.backendJsUpdater = backendJsUpdater;
+        // Allow validator injection for testing, or create default
+        this.integrationValidator = integrationValidator ||
+            new IntegrationValidator(integrationRepository);
+    }
+
+    /**
+     * Execute the use case
+     * @param {object} request - Request data
+     * @param {string} request.name - Integration name (kebab-case)
+     * @param {string} request.displayName - Human-readable name
+     * @param {string} request.description - Description
+     * @param {string} request.type - Integration type (api, webhook, sync, etc.)
+     * @param {string} request.category - Category
+     * @param {array} request.tags - Tags
+     * @param {object} request.entities - Entity configuration
+     * @param {object} request.capabilities - Capabilities
+     * @param {object} request.requirements - Requirements
+     * @returns {Promise<{success: boolean, integration: object}>}
+     */
+    async execute(request) {
+        try {
+            // 1. Create domain entity (validates name format via value object)
+            const integration = Integration.create({
+                name: request.name,
+                displayName: request.displayName,
+                description: request.description,
+                type: request.type || 'custom',
+                category: request.category,
+                tags: request.tags || [],
+                entities: request.entities || {},
+                capabilities: request.capabilities || {},
+                requirements: request.requirements || {},
+                options: request.options || {}
+            });
+
+            // 2. Validate through domain service (entity rules + domain rules + uniqueness)
+            const validation = await this.integrationValidator.validate(integration);
+            if (!validation.isValid) {
+                throw new ValidationException(validation.errors);
+            }
+
+            // 3. Save through repository (validates schema, writes files atomically)
+            await this.integrationRepository.save(integration);
+
+            // 4. Register in AppDefinition (if repository is available)
+            if (this.appDefinitionRepository) {
+                try {
+                    const appDef = await this.appDefinitionRepository.load();
+                    if (appDef) {
+                        appDef.registerIntegration(integration.name.value);
+                        await this.appDefinitionRepository.save(appDef);
+                    }
+                } catch (error) {
+                    // Log but don't fail - app definition might not exist yet
+                    console.warn('Could not register integration in app definition:', error.message);
+                }
+            }
+
+            // 5. Register in backend.js (if updater is available)
+            if (this.backendJsUpdater) {
+                try {
+                    if (await this.backendJsUpdater.exists()) {
+                        await this.backendJsUpdater.registerIntegration(integration.name.value);
+                    }
+                } catch (error) {
+                    // Log but don't fail - backend.js might not exist or have different structure
+                    console.warn('Could not register integration in backend.js:', error.message);
+                }
+            }
+
+            // 6. Commit transaction (cleanup backups)
+            await this.unitOfWork.commit();
+
+            return {
+                success: true,
+                integration: integration.toObject()
+            };
+        } catch (error) {
+            // Rollback all file operations on error
+            await this.unitOfWork.rollback();
+
+            throw error;
+        }
+    }
+}
+
+module.exports = {CreateIntegrationUseCase};

package/frigg-cli/container.js

@@ -0,0 +1,172 @@
+const path = require('path');
+const {findNearestBackendPackageJson} = require('./utils/backend-path');
+
+// Infrastructure
+const {FileSystemAdapter} = require('./infrastructure/adapters/FileSystemAdapter');
+const {SchemaValidator} = require('./infrastructure/adapters/SchemaValidator');
+const {BackendJsUpdater} = require('./infrastructure/adapters/BackendJsUpdater');
+const {IntegrationJsUpdater} = require('./infrastructure/adapters/IntegrationJsUpdater');
+const {FileSystemIntegrationRepository} = require('./infrastructure/repositories/FileSystemIntegrationRepository');
+const {FileSystemAppDefinitionRepository} = require('./infrastructure/repositories/FileSystemAppDefinitionRepository');
+const {FileSystemApiModuleRepository} = require('./infrastructure/repositories/FileSystemApiModuleRepository');
+const {UnitOfWork} = require('./infrastructure/UnitOfWork');
+
+// Domain Services
+const {IntegrationValidator} = require('./domain/services/IntegrationValidator');
+
+// Application
+const {CreateIntegrationUseCase} = require('./application/use-cases/CreateIntegrationUseCase');
+const {CreateApiModuleUseCase} = require('./application/use-cases/CreateApiModuleUseCase');
+const {AddApiModuleToIntegrationUseCase} = require('./application/use-cases/AddApiModuleToIntegrationUseCase');
+
+/**
+ * Dependency Injection Container
+ * Manages object creation and dependency wiring
+ */
+class Container {
+    constructor(startDir = process.cwd()) {
+        // Find backend directory
+        this.backendPath = findNearestBackendPackageJson(startDir);
+        if (!this.backendPath) {
+            throw new Error('Could not find backend directory. Make sure you are in a Frigg project.');
+        }
+        this.projectRoot = path.dirname(this.backendPath); // For backwards compatibility
+        this.instances = new Map();
+    }
+
+    /**
+     * Get or create singleton instance
+     */
+    get(serviceName) {
+        if (this.instances.has(serviceName)) {
+            return this.instances.get(serviceName);
+        }
+
+        const instance = this._create(serviceName);
+        this.instances.set(serviceName, instance);
+        return instance;
+    }
+
+    /**
+     * Create service instance with dependencies
+     */
+    _create(serviceName) {
+        switch (serviceName) {
+            // Infrastructure - Adapters
+            case 'FileSystemAdapter':
+                return new FileSystemAdapter();
+
+            case 'SchemaValidator':
+                // Point to schemas package in monorepo
+                // Schema validator should always use the schemas from the frigg monorepo,
+                // not relative to the user's project
+                const schemasPath = path.join(__dirname, '../../schemas/schemas');
+                return new SchemaValidator(schemasPath);
+
+            case 'BackendJsUpdater':
+                return new BackendJsUpdater(
+                    this.get('FileSystemAdapter'),
+                    this.backendPath
+                );
+
+            case 'IntegrationJsUpdater':
+                return new IntegrationJsUpdater(
+                    this.get('FileSystemAdapter'),
+                    this.backendPath
+                );
+
+            // Infrastructure - Repositories
+            case 'IntegrationRepository':
+                return new FileSystemIntegrationRepository(
+                    this.get('FileSystemAdapter'),
+                    this.backendPath,
+                    this.get('SchemaValidator')
+                );
+
+            case 'AppDefinitionRepository':
+                return new FileSystemAppDefinitionRepository(
+                    this.get('FileSystemAdapter'),
+                    this.backendPath,
+                    this.get('SchemaValidator')
+                );
+
+            case 'ApiModuleRepository':
+                return new FileSystemApiModuleRepository(
+                    this.get('FileSystemAdapter'),
+                    this.backendPath,
+                    this.get('SchemaValidator')
+                );
+
+            // Infrastructure - Unit of Work
+            case 'UnitOfWork':
+                return new UnitOfWork(
+                    this.get('FileSystemAdapter')
+                );
+
+            // Domain Services
+            case 'IntegrationValidator':
+                return new IntegrationValidator(
+                    this.get('IntegrationRepository')
+                );
+
+            // Application - Use Cases
+            case 'CreateIntegrationUseCase':
+                return new CreateIntegrationUseCase(
+                    this.get('IntegrationRepository'),
+                    this.get('UnitOfWork'),
+                    this.get('IntegrationValidator'),
+                    this.get('AppDefinitionRepository'),
+                    this.get('BackendJsUpdater')
+                );
+
+            case 'CreateApiModuleUseCase':
+                return new CreateApiModuleUseCase(
+                    this.get('ApiModuleRepository'),
+                    this.get('UnitOfWork'),
+                    this.get('AppDefinitionRepository')
+                );
+
+            case 'AddApiModuleToIntegrationUseCase':
+                return new AddApiModuleToIntegrationUseCase(
+                    this.get('IntegrationRepository'),
+                    this.get('ApiModuleRepository'),
+                    this.get('UnitOfWork'),
+                    this.get('IntegrationValidator'),
+                    this.get('IntegrationJsUpdater')
+                );
+
+            default:
+                throw new Error(`Unknown service: ${serviceName}`);
+        }
+    }
+
+    /**
+     * Clear all instances (useful for testing)
+     */
+    clear() {
+        this.instances.clear();
+    }
+
+    /**
+     * Set project root directory
+     */
+    setProjectRoot(projectRoot) {
+        this.projectRoot = projectRoot;
+        this.clear(); // Clear cached instances
+    }
+}
+
+// Export singleton container
+let containerInstance = null;
+
+module.exports = {
+    Container,
+    getContainer: (projectRoot) => {
+        if (!containerInstance) {
+            containerInstance = new Container(projectRoot);
+        } else if (projectRoot) {
+            containerInstance.setProjectRoot(projectRoot);
+        }
+        return containerInstance;
+    }
+};