@friggframework/devtools 2.0.0--canary.395.f03dc2b.0 → 2.0.0--canary.395.495dc7d.0

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

@@ -0,0 +1,179 @@
+const path = require('path');
+const chalk = require('chalk');
+const dotenv = require('dotenv');
+const {
+    validateDatabaseUrl,
+    getDatabaseType,
+    testDatabaseConnection
+} = require('../utils/database-validator');
+const {
+    runPrismaGenerate,
+    checkDatabaseState,
+    runPrismaMigrate,
+    runPrismaDbPush,
+    getMigrationCommand
+} = require('../utils/prisma-runner');
+const {
+    getDatabaseUrlMissingError,
+    getDatabaseTypeNotConfiguredError,
+    getDatabaseConnectionError,
+    getPrismaCommandError,
+    getDatabaseSetupSuccess
+} = require('../utils/error-messages');
+
+/**
+ * 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));
+            console.error(getDatabaseTypeNotConfiguredError());
+            process.exit(1);
+        }
+
+        const dbType = dbTypeResult.dbType;
+        console.log(chalk.cyan(`Database type: ${dbType}`));
+
+        if (verbose) {
+            console.log(chalk.green(`✓ Using ${dbType}\n`));
+        }
+
+        // Step 3: Test database connection
+        if (verbose) {
+            console.log(chalk.gray('Step 3: Testing database connection...'));
+        }
+
+        console.log(chalk.gray('Connecting to database...'));
+        const connectionTest = await testDatabaseConnection(urlValidation.url, dbType);
+
+        if (!connectionTest.connected) {
+            console.error(getDatabaseConnectionError(connectionTest.error, dbType));
+            process.exit(1);
+        }
+
+        console.log(chalk.green('✓ Database connection verified\n'));
+
+        // Step 4: Generate Prisma client
+        console.log(chalk.cyan('Generating Prisma client...'));
+
+        const generateResult = await runPrismaGenerate(dbType, 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 5: Check database state
+        if (verbose) {
+            console.log(chalk.gray('Step 5: Checking database state...'));
+        }
+
+        const stateCheck = await checkDatabaseState(dbType);
+
+        // Step 6: Run migrations or db push
+        if (dbType === 'postgresql') {
+            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 (dbType === 'mongodb') {
+            console.log(chalk.cyan('Pushing schema to MongoDB...'));
+
+            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 };

package/frigg-cli/index.js

@@ -8,6 +8,7 @@ const { buildCommand } = require('./build-command');
 const { deployCommand } = require('./deploy-command');
 const { generateIamCommand } = require('./generate-iam-command');
 const { uiCommand } = require('./ui-command');
+const { dbSetupCommand } = require('./db-setup-command');
 
 const program = new Command();
 
@@ -61,6 +62,13 @@ program
     .option('--no-open', 'do not open browser automatically')
     .action(uiCommand);
 
+program
+    .command('db:setup')
+    .description('Set up database schema and generate Prisma client')
+    .option('-s, --stage <stage>', 'deployment stage', 'development')
+    .option('-v, --verbose', 'enable verbose output')
+    .action(dbSetupCommand);
+
 program.parse(process.argv);
 
-module.exports = { initCommand, installCommand, startCommand, buildCommand, deployCommand, generateIamCommand, uiCommand };
+module.exports = { initCommand, installCommand, startCommand, buildCommand, deployCommand, generateIamCommand, uiCommand, dbSetupCommand };

package/frigg-cli/package.json

@@ -12,12 +12,14 @@
   "dependencies": {
     "@babel/parser": "^7.25.3",
     "@babel/traverse": "^7.25.3",
+    "@friggframework/core": "workspace:*",
     "@friggframework/schemas": "workspace:*",
     "@inquirer/prompts": "^5.3.8",
     "axios": "^1.7.2",
     "chalk": "^4.1.2",
     "commander": "^12.1.0",
     "cross-spawn": "^7.0.3",
+    "dotenv": "^16.4.5",
     "fs-extra": "^11.2.0",
     "js-yaml": "^4.1.0",
     "lodash": "4.17.21",
@@ -27,7 +29,8 @@
     "validate-npm-package-name": "^5.0.0"
   },
   "devDependencies": {
-    "jest": "^29.7.0"
+    "jest": "^29.7.0",
+    "jest-mock-extended": "^3.0.5"
   },
   "keywords": [
     "frigg",

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

@@ -1,12 +1,44 @@
 const { spawn } = require('node:child_process');
 const path = require('node:path');
+const dotenv = require('dotenv');
+const chalk = require('chalk');
+const {
+    validateDatabaseUrl,
+    getDatabaseType,
+    testDatabaseConnection,
+    checkPrismaClientGenerated
+} = require('../utils/database-validator');
+const {
+    getDatabaseUrlMissingError,
+    getDatabaseTypeNotConfiguredError,
+    getDatabaseConnectionError,
+    getPrismaClientNotGeneratedError
+} = require('../utils/error-messages');
 
-function startCommand(options) {
+async function startCommand(options) {
     if (options.verbose) {
         console.log('Verbose mode enabled');
         console.log('Options:', options);
     }
+
+    console.log(chalk.blue('🚀 Starting Frigg application...\n'));
+
+    // Load environment variables from .env file
+    const envPath = path.join(process.cwd(), '.env');
+    dotenv.config({ path: envPath });
+
+    // Pre-flight database checks
+    try {
+        await performDatabaseChecks(options.verbose);
+    } catch (error) {
+        console.error(chalk.red('\n❌ Pre-flight checks failed'));
+        console.error(chalk.gray('Fix the issues above before starting the application.\n'));
+        process.exit(1);
+    }
+
+    console.log(chalk.green('✓ Database checks passed\n'));
     console.log('Starting backend and optional frontend...');
+
     // Suppress AWS SDK warning message about maintenance mode
     process.env.AWS_SDK_JS_SUPPRESS_MAINTENANCE_MODE_MESSAGE = 1;
     // Skip AWS discovery for local development
@@ -53,4 +85,78 @@ function startCommand(options) {
     });
 }
 
+/**
+ * Performs pre-flight database validation checks
+ * @param {boolean} verbose - Enable verbose output
+ * @throws {Error} If any validation check fails
+ */
+async function performDatabaseChecks(verbose) {
+    // Check 1: Validate DATABASE_URL exists
+    if (verbose) {
+        console.log(chalk.gray('Checking DATABASE_URL...'));
+    }
+
+    const urlValidation = validateDatabaseUrl();
+    if (!urlValidation.valid) {
+        console.error(getDatabaseUrlMissingError());
+        throw new Error('DATABASE_URL validation failed');
+    }
+
+    if (verbose) {
+        console.log(chalk.green('✓ DATABASE_URL found'));
+    }
+
+    // Check 2: Determine database type
+    if (verbose) {
+        console.log(chalk.gray('Determining database type...'));
+    }
+
+    const dbTypeResult = getDatabaseType();
+    if (dbTypeResult.error) {
+        console.error(chalk.red('❌ ' + dbTypeResult.error));
+        console.error(getDatabaseTypeNotConfiguredError());
+        throw new Error('Database type determination failed');
+    }
+
+    const dbType = dbTypeResult.dbType;
+
+    if (verbose) {
+        console.log(chalk.green(`✓ Database type: ${dbType}`));
+    }
+
+    // Check 3: Test database connection
+    if (verbose) {
+        console.log(chalk.gray('Testing database connection...'));
+    }
+
+    const connectionTest = await testDatabaseConnection(urlValidation.url, dbType, 5000);
+
+    if (!connectionTest.connected) {
+        console.error(getDatabaseConnectionError(connectionTest.error, dbType));
+        throw new Error('Database connection failed');
+    }
+
+    if (verbose) {
+        console.log(chalk.green('✓ Database connection verified'));
+    }
+
+    // Check 4: Verify Prisma client is generated
+    if (verbose) {
+        console.log(chalk.gray('Checking Prisma client...'));
+    }
+
+    const clientCheck = checkPrismaClientGenerated(dbType);
+
+    if (!clientCheck.generated) {
+        console.error(getPrismaClientNotGeneratedError(dbType));
+        console.error(chalk.yellow('\nRun this command to generate the Prisma client:'));
+        console.error(chalk.cyan('  frigg db:setup\n'));
+        throw new Error('Prisma client not generated');
+    }
+
+    if (verbose) {
+        console.log(chalk.green('✓ Prisma client generated'));
+    }
+}
+
 module.exports = { startCommand };

package/frigg-cli/start-command/start-command.test.js

@@ -5,26 +5,56 @@
  * 1. Sets FRIGG_SKIP_AWS_DISCOVERY=true in the parent process to skip AWS API calls
  * 2. Suppresses AWS SDK maintenance mode warnings
  * 3. Spawns serverless with correct configuration
+ * 4. Validates database configuration before starting
  *
  * This fixes the issue where frigg start would attempt AWS discovery during local development,
  * causing unnecessary AWS API calls and potential failures when AWS credentials aren't available.
  */
 
-const { spawn } = require('node:child_process');
-const { startCommand } = require('./index');
+// Mock dependencies BEFORE importing startCommand
+const mockValidator = {
+    validateDatabaseUrl: jest.fn(),
+    getDatabaseType: jest.fn(),
+    testDatabaseConnection: jest.fn(),
+    checkPrismaClientGenerated: jest.fn()
+};
 
-// Mock the spawn function
 jest.mock('node:child_process', () => ({
     spawn: jest.fn(),
 }));
 
+jest.mock('../utils/database-validator', () => mockValidator);
+jest.mock('dotenv');
+
+const { spawn } = require('node:child_process');
+const { startCommand } = require('./index');
+const { createMockDatabaseValidator } = require('../__tests__/utils/prisma-mock');
+const dotenv = require('dotenv');
+
 describe('startCommand', () => {
     let mockChildProcess;
+    let mockProcessExit;
 
     beforeEach(() => {
+        // Mock process.exit BEFORE clearAllMocks to prevent actual exits
+        mockProcessExit = jest.spyOn(process, 'exit').mockImplementation(() => {});
+
         // Reset mocks
         jest.clearAllMocks();
 
+        // Re-apply process.exit mock after clearAllMocks
+        mockProcessExit = jest.spyOn(process, 'exit').mockImplementation(() => {});
+
+        // Set up default database validator mocks for all tests
+        const defaultValidator = createMockDatabaseValidator();
+        mockValidator.validateDatabaseUrl.mockImplementation(defaultValidator.validateDatabaseUrl);
+        mockValidator.getDatabaseType.mockImplementation(defaultValidator.getDatabaseType);
+        mockValidator.testDatabaseConnection.mockImplementation(defaultValidator.testDatabaseConnection);
+        mockValidator.checkPrismaClientGenerated.mockImplementation(defaultValidator.checkPrismaClientGenerated);
+
+        // Mock dotenv
+        dotenv.config = jest.fn();
+
         // Clear environment variables
         delete process.env.AWS_SDK_JS_SUPPRESS_MAINTENANCE_MODE_MESSAGE;
         delete process.env.FRIGG_SKIP_AWS_DISCOVERY;
@@ -40,32 +70,37 @@ describe('startCommand', () => {
     });
 
     afterEach(() => {
+        // Restore process.exit
+        if (mockProcessExit) {
+            mockProcessExit.mockRestore();
+        }
+
         // Clean up environment
         delete process.env.AWS_SDK_JS_SUPPRESS_MAINTENANCE_MODE_MESSAGE;
         delete process.env.FRIGG_SKIP_AWS_DISCOVERY;
     });
 
-    it('should set FRIGG_SKIP_AWS_DISCOVERY to true in the parent process', () => {
+    it('should set FRIGG_SKIP_AWS_DISCOVERY to true in the parent process', async () => {
         const options = { stage: 'dev' };
 
-        startCommand(options);
+        await startCommand(options);
 
         // Verify the environment variable is set in the parent process
         expect(process.env.FRIGG_SKIP_AWS_DISCOVERY).toBe('true');
     });
 
-    it('should set AWS_SDK_JS_SUPPRESS_MAINTENANCE_MODE_MESSAGE to suppress warnings', () => {
+    it('should set AWS_SDK_JS_SUPPRESS_MAINTENANCE_MODE_MESSAGE to suppress warnings', async () => {
         const options = { stage: 'dev' };
 
-        startCommand(options);
+        await startCommand(options);
 
         expect(process.env.AWS_SDK_JS_SUPPRESS_MAINTENANCE_MODE_MESSAGE).toBe('1');
     });
 
-    it('should spawn serverless with correct arguments', () => {
+    it('should spawn serverless with correct arguments', async () => {
         const options = { stage: 'prod' };
 
-        startCommand(options);
+        await startCommand(options);
 
         expect(spawn).toHaveBeenCalledWith(
             'serverless',
@@ -80,10 +115,10 @@ describe('startCommand', () => {
         );
     });
 
-    it('should include verbose flag when verbose option is enabled', () => {
+    it('should include verbose flag when verbose option is enabled', async () => {
         const options = { stage: 'dev', verbose: true };
 
-        startCommand(options);
+        await startCommand(options);
 
         expect(spawn).toHaveBeenCalledWith(
             'serverless',
@@ -92,10 +127,10 @@ describe('startCommand', () => {
         );
     });
 
-    it('should pass FRIGG_SKIP_AWS_DISCOVERY in spawn environment', () => {
+    it('should pass FRIGG_SKIP_AWS_DISCOVERY in spawn environment', async () => {
         const options = { stage: 'dev' };
 
-        startCommand(options);
+        await startCommand(options);
 
         const spawnCall = spawn.mock.calls[0];
         const spawnOptions = spawnCall[2];
@@ -103,11 +138,11 @@ describe('startCommand', () => {
         expect(spawnOptions.env).toHaveProperty('FRIGG_SKIP_AWS_DISCOVERY', 'true');
     });
 
-    it('should handle child process errors', () => {
+    it('should handle child process errors', async () => {
         const options = { stage: 'dev' };
         const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
 
-        startCommand(options);
+        await startCommand(options);
 
         // Simulate an error
         const errorCallback = mockChildProcess.on.mock.calls.find(call => call[0] === 'error')[1];
@@ -119,11 +154,11 @@ describe('startCommand', () => {
         consoleErrorSpy.mockRestore();
     });
 
-    it('should handle child process exit with non-zero code', () => {
+    it('should handle child process exit with non-zero code', async () => {
         const options = { stage: 'dev' };
         const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
 
-        startCommand(options);
+        await startCommand(options);
 
         // Simulate exit with error code
         const closeCallback = mockChildProcess.on.mock.calls.find(call => call[0] === 'close')[1];
@@ -134,11 +169,11 @@ describe('startCommand', () => {
         consoleLogSpy.mockRestore();
     });
 
-    it('should not log on successful exit', () => {
+    it('should not log on successful exit', async () => {
         const options = { stage: 'dev' };
         const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
 
-        startCommand(options);
+        await startCommand(options);
 
         // Clear the spy calls from startCommand execution
         consoleLogSpy.mockClear();
@@ -152,4 +187,121 @@ describe('startCommand', () => {
 
         consoleLogSpy.mockRestore();
     });
+
+    describe('Database Pre-flight Validation', () => {
+        let mockConsoleError;
+
+        beforeEach(() => {
+            // Mock console.error (all other mocks are set up in outer beforeEach)
+            mockConsoleError = jest.spyOn(console, 'error').mockImplementation();
+        });
+
+        afterEach(() => {
+            mockConsoleError.mockRestore();
+        });
+
+        it('should pass pre-flight checks when database valid', async () => {
+            const options = { stage: 'dev' };
+
+            await startCommand(options);
+
+            expect(mockValidator.validateDatabaseUrl).toHaveBeenCalled();
+            expect(mockValidator.getDatabaseType).toHaveBeenCalled();
+            expect(mockValidator.testDatabaseConnection).toHaveBeenCalled();
+            expect(mockValidator.checkPrismaClientGenerated).toHaveBeenCalled();
+            expect(mockProcessExit).not.toHaveBeenCalled();
+            expect(spawn).toHaveBeenCalled();
+        });
+
+        it('should fail when DATABASE_URL missing', async () => {
+            mockValidator.validateDatabaseUrl.mockReturnValue({
+                valid: false,
+                error: 'DATABASE_URL not found'
+            });
+
+            await startCommand({});
+
+            expect(mockConsoleError).toHaveBeenCalled();
+            expect(mockProcessExit).toHaveBeenCalledWith(1);
+            expect(spawn).not.toHaveBeenCalled();
+        });
+
+        it('should fail when database type not configured', async () => {
+            mockValidator.getDatabaseType.mockReturnValue({
+                error: 'Database not configured'
+            });
+
+            await startCommand({});
+
+            expect(mockConsoleError).toHaveBeenCalled();
+            expect(mockProcessExit).toHaveBeenCalledWith(1);
+            expect(spawn).not.toHaveBeenCalled();
+        });
+
+        it('should fail when database connection fails', async () => {
+            mockValidator.testDatabaseConnection.mockResolvedValue({
+                connected: false,
+                error: 'Connection failed'
+            });
+
+            await startCommand({});
+
+            expect(mockConsoleError).toHaveBeenCalled();
+            expect(mockProcessExit).toHaveBeenCalledWith(1);
+            expect(spawn).not.toHaveBeenCalled();
+        });
+
+        it('should fail when Prisma client not generated', async () => {
+            mockValidator.checkPrismaClientGenerated.mockReturnValue({
+                generated: false,
+                error: 'Client not found'
+            });
+
+            await startCommand({});
+
+            expect(mockConsoleError).toHaveBeenCalled();
+            expect(mockConsoleError).toHaveBeenCalledWith(expect.stringContaining('frigg db:setup'));
+            expect(mockProcessExit).toHaveBeenCalledWith(1);
+            expect(spawn).not.toHaveBeenCalled();
+        });
+
+        it('should suggest running frigg db:setup when client missing', async () => {
+            mockValidator.checkPrismaClientGenerated.mockReturnValue({
+                generated: false,
+                error: 'Client not generated'
+            });
+
+            await startCommand({});
+
+            expect(mockConsoleError).toHaveBeenCalledWith(expect.stringContaining('frigg db:setup'));
+        });
+
+        it('should exit with code 1 on validation failure', async () => {
+            mockValidator.validateDatabaseUrl.mockReturnValue({
+                valid: false
+            });
+
+            await startCommand({});
+
+            expect(mockProcessExit).toHaveBeenCalledWith(1);
+        });
+
+        it('should continue to serverless start when validation passes', async () => {
+            await startCommand({ stage: 'dev' });
+
+            expect(spawn).toHaveBeenCalledWith(
+                'serverless',
+                expect.arrayContaining(['offline']),
+                expect.any(Object)
+            );
+        });
+
+        it('should load .env before validation', async () => {
+            await startCommand({});
+
+            expect(dotenv.config).toHaveBeenCalledWith(expect.objectContaining({
+                path: expect.stringContaining('.env')
+            }));
+        });
+    });
 });