@friggframework/devtools 2.0.0--canary.548.c8ae0ca.0 → 2.0.0--canary.545.c40eca4.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/build-command/index.js

@@ -1,7 +1,15 @@
 const { spawnSync } = require('child_process');
 const path = require('path');
+const fs = require('fs');
 
 async function buildCommand(options) {
+    // Check if the app uses a non-AWS provider
+    const providerResult = loadProviderIfConfigured();
+    if (providerResult) {
+        return buildWithProvider(providerResult, options);
+    }
+
+    // Default: AWS build via serverless framework
     console.log('Building the serverless application...');
 
     // Suppress AWS SDK warning message about maintenance mode
@@ -10,13 +18,13 @@ async function buildCommand(options) {
     // Skip AWS discovery for local builds (unless --production flag is set)
     if (!options.production) {
         process.env.FRIGG_SKIP_AWS_DISCOVERY = 'true';
-        console.log('🏠 Building in local mode (use --production flag for production builds with AWS discovery)');
+        console.log('Building in local mode (use --production flag for production builds with AWS discovery)');
     } else {
-        console.log('🚀 Building in production mode with AWS discovery enabled');
+        console.log('Building in production mode with AWS discovery enabled');
     }
 
     // AWS discovery is now handled directly in serverless-template.js
-    console.log('📦 Packaging serverless application...');
+    console.log('Packaging serverless application...');
     const backendPath = path.resolve(process.cwd());
     const infrastructurePath = 'infrastructure.js';
     const command = 'osls';  // OSS-Serverless (drop-in replacement for serverless v3)
@@ -51,16 +59,120 @@ async function buildCommand(options) {
         console.error(`Serverless build failed with code ${result.status}`);
         process.exit(1);
     }
+}
+
+/**
+ * Check if the appDefinition specifies a non-AWS provider and resolve it.
+ */
+function loadProviderIfConfigured() {
+    try {
+        const { loadProviderForCli } = require('../utils/provider-helper');
+        const result = loadProviderForCli();
+        if (result && result.provider) {
+            return result;
+        }
+    } catch {
+        // Provider helper not available or appDefinition not found — fall through
+    }
+    return null;
+}
+
+/**
+ * Build using a provider plugin.
+ * Provider build steps:
+ *   1. generateConfig() — generate platform-specific config (netlify.toml, etc.)
+ *   2. getFunctionEntryPoints() — copy function files to the project
+ */
+async function buildWithProvider({ provider, appDefinition, providerName }, options) {
+    console.log(`Building for ${providerName} provider...`);
+    const projectDir = path.resolve(process.cwd());
+
+    // 1. Validate
+    if (typeof provider.validate === 'function') {
+        const validation = provider.validate(appDefinition);
+        if (validation.errors?.length > 0) {
+            console.error(`\nValidation errors for ${providerName}:`);
+            for (const error of validation.errors) {
+                console.error(`  - ${error}`);
+            }
+            process.exit(1);
+        }
+        if (validation.warnings?.length > 0) {
+            for (const warning of validation.warnings) {
+                console.warn(`  Warning: ${warning}`);
+            }
+        }
+    }
+
+    // 2. Generate platform config (e.g., netlify.toml)
+    if (typeof provider.generateConfig === 'function') {
+        console.log(`Generating ${providerName} configuration...`);
+        const config = provider.generateConfig(appDefinition);
+
+        const configFileNames = {
+            netlify: 'netlify.toml',
+        };
+        const configFileName = configFileNames[providerName] || `${providerName}.config`;
+        const configPath = path.join(projectDir, configFileName);
+
+        fs.writeFileSync(configPath, config, 'utf-8');
+        console.log(`  Written ${configFileName}`);
+    }
 
-    // childProcess.on('error', (error) => {
-    //     console.error(`Error executing command: ${error.message}`);
-    // });
+    // 3. Copy function entry points
+    if (typeof provider.getFunctionEntryPoints === 'function') {
+        console.log('Generating function entry points...');
+        const entryPoints = provider.getFunctionEntryPoints(appDefinition);
+        const functionsDir = path.join(projectDir, 'netlify', 'functions');
+
+        fs.mkdirSync(functionsDir, { recursive: true });
+
+        for (const [filename, content] of Object.entries(entryPoints)) {
+            const filePath = path.join(functionsDir, filename);
+            fs.writeFileSync(filePath, content, 'utf-8');
+            if (options.verbose) {
+                console.log(`  Written ${path.relative(projectDir, filePath)}`);
+            }
+        }
+
+        console.log(`  Generated ${Object.keys(entryPoints).length} function entry points`);
+    }
+
+    // 4. Copy lib entry points (re-export shims for runtime dependencies)
+    if (typeof provider.getLibEntryPoints === 'function') {
+        const libEntryPoints = provider.getLibEntryPoints(appDefinition);
+        const libDir = path.join(projectDir, 'netlify', 'lib');
+
+        fs.mkdirSync(libDir, { recursive: true });
+
+        for (const [filename, content] of Object.entries(libEntryPoints)) {
+            const filePath = path.join(libDir, filename);
+            fs.writeFileSync(filePath, content, 'utf-8');
+            if (options.verbose) {
+                console.log(`  Written ${path.relative(projectDir, filePath)}`);
+            }
+        }
+
+        console.log(`  Generated ${Object.keys(libEntryPoints).length} lib entry points`);
+    }
+
+    // 5. Generate env template (informational)
+    if (typeof provider.generateEnvTemplate === 'function') {
+        const envTemplate = provider.generateEnvTemplate(appDefinition);
+        const missingEnvVars = Object.entries(envTemplate)
+            .filter(([key]) => !process.env[key])
+            .map(([key, desc]) => `${key}: ${desc}`);
+
+        if (missingEnvVars.length > 0) {
+            console.log(`\n  Required environment variables not set locally:`);
+            for (const entry of missingEnvVars) {
+                console.log(`    - ${entry}`);
+            }
+            console.log(`  Configure these in your ${providerName} dashboard.`);
+        }
+    }
 
-    // childProcess.on('close', (code) => {
-    //     if (code !== 0) {
-    //         console.log(`Child process exited with code ${code}`);
-    //     }
-    // });
+    console.log(`\nBuild complete for ${providerName}.`);
 }
 
 module.exports = { buildCommand };

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;
+    }
+};