@friggframework/devtools 2.0.0-next.6 → 2.0.0-next.60

package/frigg-cli/__tests__/utils/test-setup.js

@@ -0,0 +1,287 @@
+/**
+ * Global test setup for Frigg CLI tests
+ * This file is executed before each test file
+ */
+
+// Store original environment
+const originalEnv = process.env;
+const originalConsole = { ...console };
+// Store original process methods (not entire object due to read-only properties)
+const originalProcessExit = process.exit;
+const originalProcessCwd = process.cwd;
+
+// Mock console to prevent noisy output during tests
+global.console = {
+  ...console,
+  log: jest.fn(),
+  info: jest.fn(),
+  warn: jest.fn(),
+  error: jest.fn(),
+  debug: jest.fn()
+};
+
+// Set up test environment variables
+process.env = {
+  ...originalEnv,
+  NODE_ENV: 'test',
+  HOME: '/mock/home',
+  PATH: '/mock/path',
+  CI: 'true'
+};
+
+// Global setup before each test
+beforeEach(() => {
+  // Clear all mocks
+  jest.clearAllMocks();
+  
+  // Reset timers
+  jest.clearAllTimers();
+  
+  // Reset modules
+  jest.resetModules();
+
+  // Mock process.exit to prevent actual exit
+  process.exit = jest.fn();
+
+  // Mock process.cwd to return predictable path
+  process.cwd = jest.fn().mockReturnValue('/mock/cwd');
+  
+  // Reset console mocks
+  global.console.log.mockClear();
+  global.console.info.mockClear();
+  global.console.warn.mockClear();
+  global.console.error.mockClear();
+  global.console.debug.mockClear();
+});
+
+// Global cleanup after each test
+afterEach(() => {
+  // Restore environment
+  process.env = { ...originalEnv };
+
+  // Restore process methods
+  process.exit = originalProcessExit;
+  process.cwd = originalProcessCwd;
+
+  // Clear any remaining timers
+  jest.clearAllTimers();
+
+  // Unmock all modules
+  jest.restoreAllMocks();
+});
+
+// Global teardown after all tests
+afterAll(() => {
+  // Restore original environment completely
+  process.env = originalEnv;
+
+  // Restore original console
+  global.console = originalConsole;
+
+  // Restore original process methods
+  process.exit = originalProcessExit;
+  process.cwd = originalProcessCwd;
+});
+
+// Custom matchers for CLI testing
+expect.extend({
+  toBeValidExitCode(received) {
+    const validCodes = [0, 1, 2];
+    const pass = validCodes.includes(received);
+    
+    if (pass) {
+      return {
+        message: () => `expected ${received} not to be a valid exit code`,
+        pass: true
+      };
+    } else {
+      return {
+        message: () => `expected ${received} to be a valid exit code (0, 1, or 2)`,
+        pass: false
+      };
+    }
+  },
+  
+  toHaveLoggedError(received, expected) {
+    const errorLogs = global.console.error.mock.calls;
+    const pass = errorLogs.some(call => 
+      call.some(arg => 
+        typeof arg === 'string' && arg.includes(expected)
+      )
+    );
+    
+    if (pass) {
+      return {
+        message: () => `expected not to have logged error containing "${expected}"`,
+        pass: true
+      };
+    } else {
+      return {
+        message: () => `expected to have logged error containing "${expected}"`,
+        pass: false
+      };
+    }
+  },
+  
+  toHaveLoggedInfo(received, expected) {
+    const infoLogs = global.console.info.mock.calls;
+    const pass = infoLogs.some(call => 
+      call.some(arg => 
+        typeof arg === 'string' && arg.includes(expected)
+      )
+    );
+    
+    if (pass) {
+      return {
+        message: () => `expected not to have logged info containing "${expected}"`,
+        pass: true
+      };
+    } else {
+      return {
+        message: () => `expected to have logged info containing "${expected}"`,
+        pass: false
+      };
+    }
+  },
+  
+  toBeWithinTimeLimit(received, limit) {
+    const pass = received <= limit;
+    
+    if (pass) {
+      return {
+        message: () => `expected ${received}ms not to be within ${limit}ms`,
+        pass: true
+      };
+    } else {
+      return {
+        message: () => `expected ${received}ms to be within ${limit}ms`,
+        pass: false
+      };
+    }
+  }
+});
+
+// Helper functions available in all tests
+global.TestHelpers = {
+  /**
+   * Create a temporary directory for tests
+   */
+  createTempDir() {
+    const fs = require('fs');
+    const path = require('path');
+    const os = require('os');
+    
+    return fs.mkdtempSync(path.join(os.tmpdir(), 'frigg-cli-test-'));
+  },
+  
+  /**
+   * Clean up temporary directory
+   */
+  cleanupTempDir(dirPath) {
+    const fs = require('fs');
+    
+    if (fs.existsSync(dirPath)) {
+      fs.rmSync(dirPath, { recursive: true, force: true });
+    }
+  },
+  
+  /**
+   * Create a mock package.json file
+   */
+  createMockPackageJson(overrides = {}) {
+    return JSON.stringify({
+      name: 'test-package',
+      version: '1.0.0',
+      main: 'index.js',
+      scripts: {
+        test: 'jest',
+        start: 'node index.js'
+      },
+      dependencies: {},
+      devDependencies: {},
+      ...overrides
+    }, null, 2);
+  },
+  
+  /**
+   * Create a mock frigg.config.json file
+   */
+  createMockFriggConfig(overrides = {}) {
+    return JSON.stringify({
+      stage: 'dev',
+      region: 'us-east-1',
+      profile: 'default',
+      backend: {
+        runtime: 'nodejs18.x',
+        timeout: 30,
+        memory: 128
+      },
+      ...overrides
+    }, null, 2);
+  },
+  
+  /**
+   * Wait for a specific amount of time
+   */
+  async delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  },
+  
+  /**
+   * Generate a random string for test data
+   */
+  randomString(length = 10) {
+    return Math.random().toString(36).substring(2, length + 2);
+  },
+  
+  /**
+   * Simulate file system structure
+   */
+  mockFileSystem(structure) {
+    const fs = require('fs');
+    
+    const originalExistsSync = fs.existsSync;
+    const originalReadFileSync = fs.readFileSync;
+    const originalWriteFileSync = fs.writeFileSync;
+    
+    fs.existsSync = jest.fn((path) => {
+      return structure.hasOwnProperty(path);
+    });
+    
+    fs.readFileSync = jest.fn((path) => {
+      if (structure.hasOwnProperty(path)) {
+        return structure[path];
+      }
+      throw new Error(`ENOENT: no such file or directory, open '${path}'`);
+    });
+    
+    fs.writeFileSync = jest.fn((path, data) => {
+      structure[path] = data;
+    });
+    
+    return {
+      restore() {
+        fs.existsSync = originalExistsSync;
+        fs.readFileSync = originalReadFileSync;
+        fs.writeFileSync = originalWriteFileSync;
+      }
+    };
+  }
+};
+
+// Global timeout for all tests
+jest.setTimeout(30000);
+
+// Suppress specific warnings during tests
+// Note: console.warn is already mocked above, so we keep the mock
+// and just suppress certain warnings in the implementation
+const originalWarnMock = global.console.warn;
+global.console.warn = jest.fn((...args) => {
+  // Suppress specific warnings that are expected during testing
+  const message = args.join(' ');
+  if (message.includes('ExperimentalWarning') ||
+      message.includes('DeprecationWarning')) {
+    return;
+  }
+  // Still track the call in the mock
+});

package/frigg-cli/build-command/index.js

@@ -1,27 +1,66 @@
-const { spawn } = require('child_process');
+const { spawnSync } = require('child_process');
 const path = require('path');
 
-function buildCommand(...args) {
+async function buildCommand(options) {
     console.log('Building the serverless application...');
+
+    // Suppress AWS SDK warning message about maintenance mode
+    process.env.AWS_SDK_JS_SUPPRESS_MAINTENANCE_MODE_MESSAGE = '1';
+
+    // 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)');
+    } else {
+        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...');
     const backendPath = path.resolve(process.cwd());
     const infrastructurePath = 'infrastructure.js';
-    const command = 'serverless';
-    const serverlessArgs = ['package', '--config', infrastructurePath, ...args.filter(arg => arg !== 'build')];
+    const command = 'osls';  // OSS-Serverless (drop-in replacement for serverless v3)
+    const serverlessArgs = [
+        'package',
+        '--config',
+        infrastructurePath,
+        '--stage',
+        options.stage
+    ];
+
+    // Add support for --verbose option
+    if (options.verbose) {
+        serverlessArgs.push('--verbose');
+    }
+
+    console.log('Running command from ', backendPath);
+    console.log('Serverless Command:', command, serverlessArgs.join(' '));
 
-    const childProcess = spawn(command, serverlessArgs, {
+    const result = spawnSync(command, serverlessArgs, {
         cwd: backendPath,
         stdio: 'inherit',
+        shell: true,
+        env: {
+            ...process.env,
+            NODE_PATH: path.resolve(backendPath, 'node_modules'),
+            SLS_STAGE: options.stage, // Set stage for resource discovery
+        }
     });
 
-    childProcess.on('error', (error) => {
-        console.error(`Error executing command: ${error.message}`);
-    });
+    if (result.status !== 0) {
+        console.error(`Serverless build failed with code ${result.status}`);
+        process.exit(1);
+    }
 
-    childProcess.on('close', (code) => {
-        if (code !== 0) {
-            console.log(`Child process exited with code ${code}`);
-        }
-    });
-} 
+    // childProcess.on('error', (error) => {
+    //     console.error(`Error executing command: ${error.message}`);
+    // });
+
+    // childProcess.on('close', (code) => {
+    //     if (code !== 0) {
+    //         console.log(`Child process exited with code ${code}`);
+    //     }
+    // });
+}
 
 module.exports = { buildCommand };

package/frigg-cli/db-setup-command/index.js

@@ -0,0 +1,246 @@
+const path = require('path');
+const chalk = require('chalk');
+const dotenv = require('dotenv');
+const {
+    validateDatabaseUrl,
+    getDatabaseType,
+    checkPrismaClientGenerated,
+} = require('../utils/database-validator');
+const {
+    runPrismaGenerate,
+    checkDatabaseState,
+    runPrismaMigrate,
+    runPrismaDbPush,
+    getMigrationCommand,
+} = require('@friggframework/core/database/utils/prisma-runner');
+const {
+    getDatabaseUrlMissingError,
+    getDatabaseTypeNotConfiguredError,
+    getPrismaCommandError,
+    getDatabaseSetupSuccess,
+} = require('../utils/error-messages');
+
+function getDatabaseDisplayName(dbType) {
+    switch (dbType) {
+        case 'postgresql':
+            return 'PostgreSQL';
+        case 'mongodb':
+            return 'MongoDB';
+        case 'documentdb':
+            return 'AWS DocumentDB (MongoDB-compatible)';
+        default:
+            return dbType;
+    }
+}
+
+function getPrismaRunnerDbType(dbType) {
+    return dbType === 'documentdb' ? 'mongodb' : dbType;
+}
+
+/**
+ * Database Setup Command
+ * Sets up the database for a Frigg application:
+ * - Validates configuration
+ * - Generates Prisma client
+ * - Runs migrations (PostgreSQL) or db push (MongoDB)
+ */
+
+async function dbSetupCommand(options = {}) {
+    const verbose = options.verbose || false;
+    const stage = options.stage || process.env.STAGE || 'development';
+
+    console.log(chalk.blue('🔧 Frigg Database Setup'));
+    console.log(chalk.gray(`Stage: ${stage}\n`));
+
+    // Load environment variables from .env file
+    const envPath = path.join(process.cwd(), '.env');
+    dotenv.config({ path: envPath });
+
+    try {
+        // Step 1: Validate DATABASE_URL
+        if (verbose) {
+            console.log(chalk.gray('Step 1: Validating DATABASE_URL...'));
+        }
+
+        const urlValidation = validateDatabaseUrl();
+        if (!urlValidation.valid) {
+            console.error(getDatabaseUrlMissingError());
+            process.exit(1);
+        }
+
+        if (verbose) {
+            console.log(chalk.green('✓ DATABASE_URL found\n'));
+        }
+
+        // Step 2: Determine database type from app definition
+        if (verbose) {
+            console.log(chalk.gray('Step 2: Determining database type...'));
+        }
+
+        const dbTypeResult = getDatabaseType();
+        if (dbTypeResult.error) {
+            console.error(chalk.red('❌ ' + dbTypeResult.error));
+
+            // Show stack trace in verbose mode for debugging
+            if (verbose && dbTypeResult.stack) {
+                console.error(chalk.gray('\nStack trace:'));
+                console.error(chalk.gray(dbTypeResult.stack));
+            }
+
+            console.error(getDatabaseTypeNotConfiguredError());
+            process.exit(1);
+        }
+
+        const dbType = dbTypeResult.dbType;
+        const dbDisplayName = getDatabaseDisplayName(dbType);
+        const isPostgres = dbType === 'postgresql';
+        const isDocumentDb = dbType === 'documentdb';
+        const isMongoFamily = dbType === 'mongodb' || isDocumentDb;
+        const runnerDbType = getPrismaRunnerDbType(dbType);
+
+        console.log(chalk.cyan(`Database type: ${dbDisplayName}`));
+
+        if (verbose) {
+            console.log(chalk.green(`✓ Using ${dbDisplayName}\n`));
+        }
+
+        // Step 3: Check if Prisma client exists, generate if needed
+        if (verbose) {
+            console.log(chalk.gray('Step 3: Checking Prisma client...'));
+        }
+
+        const clientCheck = checkPrismaClientGenerated(dbType);
+        const forceRegenerate = options.force || false;
+
+        if (clientCheck.generated && !forceRegenerate) {
+            // Client already exists and --force not specified
+            console.log(
+                chalk.green(
+                    '✓ Prisma client already exists (skipping generation)\n'
+                )
+            );
+            if (verbose) {
+                console.log(
+                    chalk.gray(`  Client location: ${clientCheck.path}\n`)
+                );
+            }
+        } else {
+            // Client doesn't exist OR --force specified - generate it
+            if (forceRegenerate && clientCheck.generated) {
+                console.log(
+                    chalk.yellow('⚠️  Forcing Prisma client regeneration...')
+                );
+            } else {
+                console.log(chalk.cyan('Generating Prisma client...'));
+            }
+
+            const generateResult = await runPrismaGenerate(
+                runnerDbType,
+                verbose
+            );
+
+            if (!generateResult.success) {
+                console.error(
+                    getPrismaCommandError('generate', generateResult.error)
+                );
+                if (generateResult.output) {
+                    console.error(chalk.gray(generateResult.output));
+                }
+                process.exit(1);
+            }
+
+            console.log(chalk.green('✓ Prisma client generated\n'));
+        }
+
+        // Step 4: Check database state
+        // Note: We skip connection testing in db:setup because when using frigg:local,
+        // the CLI code runs from tmp/frigg but the client is in backend/node_modules,
+        // causing module resolution mismatches. Connection testing happens in frigg start.
+        if (verbose) {
+            console.log(chalk.gray('Step 4: Checking database state...'));
+        }
+
+        const stateCheck = await checkDatabaseState(runnerDbType);
+
+        // Step 5: Run migrations or db push
+        if (isPostgres) {
+            console.log(chalk.cyan('Running database migrations...'));
+
+            const migrationCommand = getMigrationCommand(stage);
+
+            if (verbose) {
+                console.log(
+                    chalk.gray(`Using migration command: ${migrationCommand}`)
+                );
+            }
+
+            if (stateCheck.upToDate && migrationCommand === 'deploy') {
+                console.log(chalk.yellow('Database is already up-to-date'));
+            } else {
+                const migrateResult = await runPrismaMigrate(
+                    migrationCommand,
+                    verbose
+                );
+
+                if (!migrateResult.success) {
+                    console.error(
+                        getPrismaCommandError('migrate', migrateResult.error)
+                    );
+                    if (migrateResult.output) {
+                        console.error(chalk.gray(migrateResult.output));
+                    }
+                    process.exit(1);
+                }
+
+                console.log(chalk.green('✓ Migrations applied\n'));
+            }
+        } else if (isMongoFamily) {
+            const targetName = isDocumentDb
+                ? 'AWS DocumentDB (MongoDB-compatible)'
+                : 'MongoDB';
+
+            console.log(chalk.cyan(`Pushing schema to ${targetName}...`));
+
+            const pushResult = await runPrismaDbPush(verbose);
+
+            if (!pushResult.success) {
+                console.error(
+                    getPrismaCommandError('db push', pushResult.error)
+                );
+                if (pushResult.output) {
+                    console.error(chalk.gray(pushResult.output));
+                }
+                process.exit(1);
+            }
+
+            console.log(chalk.green('✓ Schema pushed to database\n'));
+        }
+
+        // Success!
+        console.log(getDatabaseSetupSuccess(dbType, stage));
+    } catch (error) {
+        console.error(chalk.red('\n❌ Database setup failed'));
+        console.error(chalk.gray(error.message));
+
+        if (verbose && error.stack) {
+            console.error(chalk.gray('\nStack trace:'));
+            console.error(chalk.gray(error.stack));
+        }
+
+        console.error(chalk.yellow('\nTroubleshooting:'));
+        console.error(chalk.gray('  • Verify DATABASE_URL in your .env file'));
+        console.error(
+            chalk.gray('  • Check database is running and accessible')
+        );
+        console.error(
+            chalk.gray('  • Ensure app definition has database configuration')
+        );
+        console.error(
+            chalk.gray('  • Run with --verbose flag for more details')
+        );
+
+        process.exit(1);
+    }
+}
+
+module.exports = { dbSetupCommand };