@friggframework/devtools 2.0.0-next.44 → 2.0.0-next.46

package/frigg-cli/utils/error-messages.js

@@ -1,257 +0,0 @@
-const chalk = require('chalk');
-
-/**
- * Error Messages Module
- * Provides helpful, context-aware error messages for database setup issues
- */
-
-/**
- * Database URL examples for both supported database types
- */
-const DATABASE_URL_EXAMPLES = {
-    mongodb: 'mongodb://localhost:27017/frigg?replicaSet=rs0',
-    postgresql: 'postgresql://postgres:postgres@localhost:5432/frigg?schema=public'
-};
-
-/**
- * Gets helpful error message for missing DATABASE_URL
- * @returns {string} Formatted error message
- */
-function getDatabaseUrlMissingError() {
-    return `
-${chalk.red('❌ DATABASE_URL environment variable not found')}
-
-${chalk.bold('Add DATABASE_URL to your .env file:')}
-
-${chalk.cyan('For MongoDB:')}
-  ${chalk.gray('DATABASE_URL')}=${chalk.green(`"${DATABASE_URL_EXAMPLES.mongodb}"`)}
-
-${chalk.cyan('For PostgreSQL:')}
-  ${chalk.gray('DATABASE_URL')}=${chalk.green(`"${DATABASE_URL_EXAMPLES.postgresql}"`)}
-
-${chalk.yellow('Then run:')} ${chalk.cyan('frigg db:setup')}
-`;
-}
-
-/**
- * Gets helpful error message for missing database type configuration
- * @returns {string} Formatted error message
- */
-function getDatabaseTypeNotConfiguredError() {
-    return `
-${chalk.red('❌ Database type not configured in app definition')}
-
-${chalk.bold('Add database configuration to your app definition file:')}
-${chalk.gray('(backend/index.js or index.js)')}
-
-${chalk.cyan('For PostgreSQL:')}
-${chalk.gray(`
-const appDefinition = {
-  // ... other configuration
-  database: {
-    postgres: { enable: true }
-  }
-};
-`)}
-
-${chalk.cyan('For MongoDB:')}
-${chalk.gray(`
-const appDefinition = {
-  // ... other configuration
-  database: {
-    mongoDB: { enable: true }
-  }
-};
-`)}
-
-${chalk.cyan('For AWS DocumentDB (MongoDB-compatible):')}
-${chalk.gray(`
-const appDefinition = {
-  // ... other configuration
-  database: {
-    documentDB: { enable: true }
-  }
-};
-`)}
-`;
-}
-
-/**
- * Gets helpful error message for database connection failure
- * @param {string} error - Connection error message
- * @param {'mongodb'|'postgresql'} dbType - Database type
- * @returns {string} Formatted error message
- */
-function getDatabaseConnectionError(error, dbType) {
-    const troubleshootingSteps = dbType === 'mongodb'
-        ? getMongoDatabaseTroubleshooting()
-        : getPostgresTroubleshooting();
-
-    return `
-${chalk.red('❌ Failed to connect to database')}
-
-${chalk.bold('Connection error:')}
-${chalk.gray(error)}
-
-${chalk.bold('Troubleshooting steps:')}
-${troubleshootingSteps}
-
-${chalk.yellow('Verify your DATABASE_URL:')} ${chalk.cyan(process.env.DATABASE_URL || 'not set')}
-`;
-}
-
-/**
- * Gets MongoDB-specific troubleshooting steps
- * @returns {string} Formatted troubleshooting steps
- */
-function getMongoDatabaseTroubleshooting() {
-    return `
-${chalk.gray('1.')} Verify MongoDB is running
-   ${chalk.cyan('docker ps')} ${chalk.gray('(if using Docker)')}
-   ${chalk.cyan('mongosh --eval "db.version()"')} ${chalk.gray('(test connection)')}
-
-${chalk.gray('2.')} Check if replica set is initialized
-   ${chalk.gray('MongoDB requires a replica set for Prisma')}
-   ${chalk.cyan('mongosh')}
-   ${chalk.cyan('rs.status()')} ${chalk.gray('(should show replica set info)')}
-
-${chalk.gray('3.')} Initialize replica set if needed
-   ${chalk.cyan('docker exec -it <mongodb-container> mongosh')}
-   ${chalk.cyan('rs.initiate()')}
-
-${chalk.gray('4.')} Verify connection string format
-   ${chalk.gray('mongodb://[username:password@]host[:port]/database[?options]')}
-   ${chalk.green('Example: mongodb://localhost:27017/frigg?replicaSet=rs0')}
-
-${chalk.gray('5.')} Check network/firewall settings
-   ${chalk.gray('Ensure port 27017 (default) is accessible')}
-`;
-}
-
-/**
- * Gets PostgreSQL-specific troubleshooting steps
- * @returns {string} Formatted troubleshooting steps
- */
-function getPostgresTroubleshooting() {
-    return `
-${chalk.gray('1.')} Verify PostgreSQL is running
-   ${chalk.cyan('docker ps')} ${chalk.gray('(if using Docker)')}
-   ${chalk.cyan('pg_isready')} ${chalk.gray('(test if server is ready)')}
-
-${chalk.gray('2.')} Check connection string format
-   ${chalk.gray('postgresql://[username:password@]host[:port]/database[?options]')}
-   ${chalk.green('Example: postgresql://postgres:postgres@localhost:5432/frigg?schema=public')}
-
-${chalk.gray('3.')} Verify database exists
-   ${chalk.cyan('psql -U postgres -l')} ${chalk.gray('(list databases)')}
-   ${chalk.cyan('CREATE DATABASE frigg;')} ${chalk.gray('(if needed)')}
-
-${chalk.gray('4.')} Check pg_hba.conf allows connections
-   ${chalk.gray('Location: /var/lib/postgresql/data/pg_hba.conf (Docker)')}
-   ${chalk.gray('Ensure trust/md5 authentication is enabled for your host')}
-
-${chalk.gray('5.')} Verify network/firewall settings
-   ${chalk.gray('Ensure port 5432 (default) is accessible')}
-`;
-}
-
-/**
- * Gets helpful error message for missing Prisma client
- * @param {'mongodb'|'postgresql'} dbType - Database type
- * @returns {string} Formatted error message
- */
-function getPrismaClientNotGeneratedError(dbType) {
-    const clientName = `@prisma-${dbType}/client`;
-
-    return `
-${chalk.red(`❌ Prisma client not generated for ${dbType}`)}
-
-${chalk.bold('The Prisma client needs to be generated before starting the application.')}
-
-${chalk.yellow('Run:')} ${chalk.cyan('frigg db:setup')}
-
-${chalk.gray('This will:')}
-${chalk.gray('  • Generate the Prisma client')} ${chalk.gray(`(${clientName})`)}
-${chalk.gray('  • Set up database schema')}
-${chalk.gray('  • Run migrations (PostgreSQL) or db push (MongoDB)')}
-`;
-}
-
-/**
- * Gets helpful error message for Prisma command failures
- * @param {string} command - Command that failed (generate, migrate, push)
- * @param {string} error - Error message
- * @returns {string} Formatted error message
- */
-function getPrismaCommandError(command, error) {
-    return `
-${chalk.red(`❌ Prisma ${command} failed`)}
-
-${chalk.bold('Error:')}
-${chalk.gray(error)}
-
-${chalk.bold('Common causes:')}
-${chalk.gray('  • Database schema has conflicts')}
-${chalk.gray('  • Database connection lost during operation')}
-${chalk.gray('  • Insufficient permissions')}
-${chalk.gray('  • Schema file is invalid')}
-
-${chalk.yellow('Try:')}
-${chalk.cyan('  frigg db:setup')} ${chalk.gray('(re-run setup)')}
-${chalk.cyan('  Check your DATABASE_URL')} ${chalk.gray('(verify connection string)')}
-${chalk.cyan('  Review Prisma schema')} ${chalk.gray('(node_modules/@friggframework/core/prisma-*/schema.prisma)')}
-`;
-}
-
-/**
- * Gets success message for database setup completion
- * @param {'mongodb'|'postgresql'} dbType - Database type
- * @param {string} stage - Deployment stage
- * @returns {string} Formatted success message
- */
-function getDatabaseSetupSuccess(dbType, stage) {
-    return `
-${chalk.green('✅ Database setup completed successfully!')}
-
-${chalk.bold('Configuration:')}
-${chalk.gray('  Database type:')} ${chalk.cyan(dbType)}
-${chalk.gray('  Stage:')} ${chalk.cyan(stage)}
-${chalk.gray('  Connection:')} ${chalk.green('verified')}
-
-${chalk.bold('What happened:')}
-${chalk.gray('  ✓')} Prisma client generated
-${chalk.gray('  ✓')} Database connection verified
-${chalk.gray('  ✓')} ${dbType === 'postgresql' ? 'Migrations applied' : 'Schema pushed to database'}
-
-${chalk.yellow('Next steps:')}
-${chalk.cyan('  frigg start')} ${chalk.gray('(start your application)')}
-`;
-}
-
-/**
- * Gets warning message for database already up-to-date
- * @returns {string} Formatted warning message
- */
-function getDatabaseAlreadyUpToDate() {
-    return `
-${chalk.yellow('⚠️  Database is already up-to-date')}
-
-${chalk.gray('No migrations or schema changes detected.')}
-
-${chalk.yellow('If you expected changes:')}
-${chalk.gray('  • Check if schema was modified in node_modules/@friggframework/core/prisma-*/')}
-${chalk.gray('  • Verify DATABASE_URL points to the correct database')}
-${chalk.gray('  • Check if you\'re in the correct project directory')}
-`;
-}
-
-module.exports = {
-    DATABASE_URL_EXAMPLES,
-    getDatabaseUrlMissingError,
-    getDatabaseTypeNotConfiguredError,
-    getDatabaseConnectionError,
-    getPrismaClientNotGeneratedError,
-    getPrismaCommandError,
-    getDatabaseSetupSuccess,
-    getDatabaseAlreadyUpToDate
-};

package/frigg-cli/utils/npm-registry.js

@@ -1,167 +0,0 @@
-/**
- * NPM Registry Service for CLI
- * CommonJS version of the npm-registry service
- */
-
-'use strict';
-
-const axios = require('axios');
-const NodeCache = require('node-cache');
-const semver = require('semver');
-
-class NPMRegistryService {
-    constructor() {
-        // Cache with 1 hour TTL by default
-        this.cache = new NodeCache({ 
-            stdTTL: 3600,
-            checkperiod: 600,
-            useClones: false
-        });
-        
-        this.npmRegistryUrl = 'https://registry.npmjs.org';
-        this.searchUrl = `${this.npmRegistryUrl}/-/v1/search`;
-        this.packageScope = '@friggframework';
-        this.modulePrefix = 'api-module-';
-    }
-
-    /**
-     * Search for all @friggframework/api-module-* packages
-     * @param {Object} options - Search options
-     * @param {boolean} options.includePrerelease - Include prerelease versions
-     * @param {boolean} options.forceRefresh - Force cache refresh
-     * @returns {Promise<Array>} Array of package information
-     */
-    async searchApiModules(options = {}) {
-        const cacheKey = `api-modules-${JSON.stringify(options)}`;
-        
-        // Check cache first unless force refresh is requested
-        if (!options.forceRefresh) {
-            const cached = this.cache.get(cacheKey);
-            if (cached) {
-                return cached;
-            }
-        }
-
-        try {
-            // Search for packages matching our pattern
-            const searchQuery = `${this.packageScope}/${this.modulePrefix}`;
-            const response = await axios.get(this.searchUrl, {
-                params: {
-                    text: searchQuery,
-                    size: 250, // Get up to 250 results
-                    quality: 0.65,
-                    popularity: 0.98,
-                    maintenance: 0.5
-                },
-                timeout: 10000
-            });
-
-            const packages = response.data.objects
-                .filter(obj => obj.package.name.startsWith(`${this.packageScope}/${this.modulePrefix}`))
-                .map(obj => this.formatPackageInfo(obj.package));
-
-            // Filter out prereleases if requested
-            const filtered = options.includePrerelease 
-                ? packages 
-                : packages.filter(pkg => !semver.prerelease(pkg.version));
-
-            // Cache the results
-            this.cache.set(cacheKey, filtered);
-            
-            return filtered;
-        } catch (error) {
-            console.error('Error searching NPM registry:', error.message);
-            // Return empty array on error to allow offline usage
-            return [];
-        }
-    }
-
-    /**
-     * Extract integration name from package name
-     * @private
-     */
-    extractIntegrationName(packageName) {
-        return packageName
-            .replace(`${this.packageScope}/${this.modulePrefix}`, '')
-            .replace(/-/g, ' ')
-            .replace(/\b\w/g, l => l.toUpperCase());
-    }
-
-    /**
-     * Format package information for API response
-     * @private
-     */
-    formatPackageInfo(pkg) {
-        return {
-            name: pkg.name,
-            version: pkg.version,
-            description: pkg.description,
-            keywords: pkg.keywords || [],
-            author: pkg.author,
-            publisher: pkg.publisher,
-            date: pkg.date,
-            links: pkg.links,
-            integrationName: this.extractIntegrationName(pkg.name),
-            category: this.categorizeModule(pkg)
-        };
-    }
-
-    /**
-     * Categorize module based on keywords and name
-     * @private
-     */
-    categorizeModule(module) {
-        const name = module.name?.toLowerCase() || '';
-        const keywords = module.keywords?.map(k => k.toLowerCase()) || [];
-        const allTerms = [...keywords, name];
-
-        // Categories based on common integration types - ordered by specificity
-        const categories = {
-            'Marketing': ['marketing', 'mailchimp', 'campaign', 'automation', 'klaviyo', 'activecampaign'],
-            'CRM': ['crm', 'customer', 'salesforce', 'hubspot', 'pipedrive', 'zoho'],
-            'E-commerce': ['ecommerce', 'shop', 'store', 'payment', 'stripe', 'paypal', 'shopify', 'woocommerce'],
-            'Analytics': ['analytics', 'tracking', 'google-analytics', 'mixpanel', 'segment', 'amplitude'],
-            'Social Media': ['social', 'facebook', 'twitter', 'instagram', 'linkedin', 'youtube'],
-            'Project Management': ['project', 'task', 'jira', 'trello', 'asana', 'monday', 'notion'],
-            'Storage': ['storage', 'file', 'dropbox', 'google-drive', 's3', 'box', 'onedrive'],
-            'Productivity': ['spreadsheet', 'google-sheets', 'airtable', 'calendar', 'todo'],
-            'Development': ['github', 'gitlab', 'bitbucket', 'git', 'ci', 'cd', 'jenkins'],
-            'Support': ['support', 'zendesk', 'freshdesk', 'intercom', 'helpdesk'],
-            'Finance': ['accounting', 'quickbooks', 'xero', 'sage', 'invoice', 'billing'],
-            'Communication': ['email', 'sms', 'chat', 'messaging', 'slack', 'discord', 'twilio', 'sendgrid'],
-            'Other': []
-        };
-
-        for (const [category, terms] of Object.entries(categories)) {
-            if (category === 'Other') continue;
-            
-            if (terms.some(term => allTerms.some(t => t.includes(term)))) {
-                return category;
-            }
-        }
-
-        return 'Other';
-    }
-
-    /**
-     * Get grouped modules by integration type
-     * @returns {Promise<Object>} Modules grouped by type
-     */
-    async getModulesByType() {
-        const modules = await this.searchApiModules();
-        
-        const grouped = modules.reduce((acc, module) => {
-            const type = module.category;
-            if (!acc[type]) {
-                acc[type] = [];
-            }
-            acc[type].push(module);
-            return acc;
-        }, {});
-
-        return grouped;
-    }
-}
-
-// Export singleton instance
-module.exports = new NPMRegistryService();

package/frigg-cli/utils/prisma-runner.js

@@ -1,280 +0,0 @@
-const { execSync, spawn } = require('child_process');
-const path = require('path');
-const fs = require('fs');
-const chalk = require('chalk');
-
-/**
- * Prisma Command Runner Utility
- * Handles execution of Prisma CLI commands for database setup
- */
-
-/**
- * Gets the path to the Prisma schema file for the database type
- * @param {'mongodb'|'postgresql'} dbType - Database type
- * @param {string} projectRoot - Project root directory
- * @returns {string} Absolute path to schema file
- * @throws {Error} If schema file doesn't exist
- */
-function getPrismaSchemaPath(dbType, projectRoot = process.cwd()) {
-    // Try multiple locations for the schema file
-    // Priority order:
-    // 1. Local node_modules (where @friggframework/core is installed - production scenario)
-    // 2. Parent node_modules (workspace/monorepo setup)
-    const possiblePaths = [
-        // Check where Frigg is installed via npm (production scenario)
-        path.join(projectRoot, 'node_modules', '@friggframework', 'core', `prisma-${dbType}`, 'schema.prisma'),
-        path.join(projectRoot, '..', 'node_modules', '@friggframework', 'core', `prisma-${dbType}`, 'schema.prisma')
-    ];
-
-    for (const schemaPath of possiblePaths) {
-        if (fs.existsSync(schemaPath)) {
-            return schemaPath;
-        }
-    }
-
-    // If not found in any location, throw error
-    throw new Error(
-        `Prisma schema not found at:\n${possiblePaths.join('\n')}\n\n` +
-        'Ensure @friggframework/core is installed.'
-    );
-}
-
-/**
- * Runs prisma generate for the specified database type
- * @param {'mongodb'|'postgresql'} dbType - Database type
- * @param {boolean} verbose - Enable verbose output
- * @returns {Promise<Object>} { success: boolean, output?: string, error?: string }
- */
-async function runPrismaGenerate(dbType, verbose = false) {
-    try {
-        const schemaPath = getPrismaSchemaPath(dbType);
-
-        if (verbose) {
-            console.log(chalk.gray(`Running: npx prisma generate --schema=${schemaPath}`));
-        }
-
-        const output = execSync(
-            `npx prisma generate --schema=${schemaPath}`,
-            {
-                encoding: 'utf8',
-                stdio: verbose ? 'inherit' : 'pipe',
-                env: {
-                    ...process.env,
-                    // Suppress Prisma telemetry prompts
-                    PRISMA_HIDE_UPDATE_MESSAGE: '1'
-                }
-            }
-        );
-
-        return {
-            success: true,
-            output: verbose ? 'Generated successfully' : output
-        };
-
-    } catch (error) {
-        return {
-            success: false,
-            error: error.message,
-            output: error.stdout?.toString() || error.stderr?.toString()
-        };
-    }
-}
-
-/**
- * Checks database migration status
- * @param {'mongodb'|'postgresql'} dbType - Database type
- * @returns {Promise<Object>} { upToDate: boolean, pendingMigrations?: number, error?: string }
- */
-async function checkDatabaseState(dbType) {
-    try {
-        // Only applicable for PostgreSQL (MongoDB uses db push)
-        if (dbType !== 'postgresql') {
-            return { upToDate: true };
-        }
-
-        const schemaPath = getPrismaSchemaPath(dbType);
-
-        const output = execSync(
-            `npx prisma migrate status --schema=${schemaPath}`,
-            {
-                encoding: 'utf8',
-                stdio: 'pipe',
-                env: {
-                    ...process.env,
-                    PRISMA_HIDE_UPDATE_MESSAGE: '1'
-                }
-            }
-        );
-
-        if (output.includes('Database schema is up to date')) {
-            return { upToDate: true };
-        }
-
-        // Parse pending migrations count
-        const pendingMatch = output.match(/(\d+) migration/);
-        const pendingMigrations = pendingMatch ? parseInt(pendingMatch[1]) : 0;
-
-        return {
-            upToDate: false,
-            pendingMigrations
-        };
-
-    } catch (error) {
-        // If migrate status fails, database might not be initialized
-        return {
-            upToDate: false,
-            error: error.message
-        };
-    }
-}
-
-/**
- * Runs Prisma migrate for PostgreSQL
- * @param {'dev'|'deploy'} command - Migration command (dev or deploy)
- * @param {boolean} verbose - Enable verbose output
- * @returns {Promise<Object>} { success: boolean, output?: string, error?: string }
- */
-async function runPrismaMigrate(command = 'dev', verbose = false) {
-    return new Promise((resolve) => {
-        try {
-            const schemaPath = getPrismaSchemaPath('postgresql');
-
-            const args = [
-                'prisma',
-                'migrate',
-                command,
-                '--schema',
-                schemaPath
-            ];
-
-            if (verbose) {
-                console.log(chalk.gray(`Running: npx ${args.join(' ')}`));
-            }
-
-            const proc = spawn('npx', args, {
-                stdio: 'inherit',
-                env: {
-                    ...process.env,
-                    PRISMA_HIDE_UPDATE_MESSAGE: '1'
-                }
-            });
-
-            proc.on('error', (error) => {
-                resolve({
-                    success: false,
-                    error: error.message
-                });
-            });
-
-            proc.on('close', (code) => {
-                if (code === 0) {
-                    resolve({
-                        success: true,
-                        output: 'Migration completed successfully'
-                    });
-                } else {
-                    resolve({
-                        success: false,
-                        error: `Migration process exited with code ${code}`
-                    });
-                }
-            });
-
-        } catch (error) {
-            resolve({
-                success: false,
-                error: error.message
-            });
-        }
-    });
-}
-
-/**
- * Runs Prisma db push for MongoDB
- * Interactive - will prompt user if data loss detected
- * @param {boolean} verbose - Enable verbose output
- * @returns {Promise<Object>} { success: boolean, output?: string, error?: string }
- */
-async function runPrismaDbPush(verbose = false) {
-    return new Promise((resolve) => {
-        try {
-            const schemaPath = getPrismaSchemaPath('mongodb');
-
-            const args = [
-                'prisma',
-                'db',
-                'push',
-                '--schema',
-                schemaPath,
-                '--skip-generate' // We generate separately
-            ];
-
-            if (verbose) {
-                console.log(chalk.gray(`Running: npx ${args.join(' ')}`));
-            }
-
-            console.log(chalk.yellow('⚠️  Interactive mode: You may be prompted if schema changes cause data loss'));
-
-            const proc = spawn('npx', args, {
-                stdio: 'inherit', // Interactive mode - user can respond to prompts
-                env: {
-                    ...process.env,
-                    PRISMA_HIDE_UPDATE_MESSAGE: '1'
-                }
-            });
-
-            proc.on('error', (error) => {
-                resolve({
-                    success: false,
-                    error: error.message
-                });
-            });
-
-            proc.on('close', (code) => {
-                if (code === 0) {
-                    resolve({
-                        success: true,
-                        output: 'Database push completed successfully'
-                    });
-                } else {
-                    resolve({
-                        success: false,
-                        error: `Database push process exited with code ${code}`
-                    });
-                }
-            });
-
-        } catch (error) {
-            resolve({
-                success: false,
-                error: error.message
-            });
-        }
-    });
-}
-
-/**
- * Determines migration command based on STAGE environment variable
- * @param {string} stage - Stage from CLI option or environment
- * @returns {'dev'|'deploy'}
- */
-function getMigrationCommand(stage) {
-    const normalizedStage = (stage || process.env.STAGE || 'development').toLowerCase();
-
-    const developmentStages = ['dev', 'local', 'test', 'development'];
-
-    if (developmentStages.includes(normalizedStage)) {
-        return 'dev';
-    }
-
-    return 'deploy';
-}
-
-module.exports = {
-    getPrismaSchemaPath,
-    runPrismaGenerate,
-    checkDatabaseState,
-    runPrismaMigrate,
-    runPrismaDbPush,
-    getMigrationCommand
-};