@friggframework/devtools 2.0.0--canary.545.ae2019f.0 → 2.0.0--canary.549.a579cca.0

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

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

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

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

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