@friggframework/devtools 2.0.0-next.47 → 2.0.0-next.48

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

@@ -0,0 +1,149 @@
+const { spawn } = require('node:child_process');
+const path = require('node:path');
+const dotenv = require('dotenv');
+const chalk = require('chalk');
+const {
+    validateDatabaseUrl,
+    getDatabaseType,
+    checkPrismaClientGenerated
+} = require('../utils/database-validator');
+const {
+    getDatabaseUrlMissingError,
+    getDatabaseTypeNotConfiguredError,
+    getPrismaClientNotGeneratedError
+} = require('../utils/error-messages');
+
+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
+    process.env.FRIGG_SKIP_AWS_DISCOVERY = 'true';
+    const backendPath = path.resolve(process.cwd());
+    console.log(`Starting backend in ${backendPath}...`);
+    const infrastructurePath = 'infrastructure.js';
+    const command = 'osls';  // OSS-Serverless (drop-in replacement for serverless v3)
+    const args = [
+        'offline',
+        '--config',
+        infrastructurePath,
+        '--stage',
+        options.stage
+    ];
+
+    // Add verbose flag to serverless if verbose option is enabled
+    if (options.verbose) {
+        args.push('--verbose');
+    }
+
+    if (options.verbose) {
+        console.log(`Executing command: ${command} ${args.join(' ')}`);
+        console.log(`Working directory: ${backendPath}`);
+    }
+
+    const childProcess = spawn(command, args, {
+        cwd: backendPath,
+        stdio: 'inherit',
+        env: {
+            ...process.env,
+            FRIGG_SKIP_AWS_DISCOVERY: 'true',
+        },
+    });
+
+    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}`);
+        }
+    });
+}
+
+/**
+ * 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: Verify Prisma client is generated (BEFORE connection test to prevent auto-generation)
+    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'));
+    }
+
+    // Note: We skip connection testing in the start command because when using frigg:local,
+    // the CLI code runs from tmp/frigg but the client is in backend/node_modules,
+    // causing module resolution mismatches. The backend will test its own database
+    // connection when it starts.
+}
+
+module.exports = { startCommand };

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

@@ -0,0 +1,297 @@
+/**
+ * Test suite for the frigg start command
+ *
+ * These tests ensure that the start command properly:
+ * 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.
+ */
+
+// Mock dependencies BEFORE importing startCommand
+const mockValidator = {
+    validateDatabaseUrl: jest.fn(),
+    getDatabaseType: jest.fn(),
+    checkPrismaClientGenerated: jest.fn()
+};
+
+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 to throw error and stop execution (prevents actual exits)
+        const exitError = new Error('process.exit called');
+        exitError.code = 'PROCESS_EXIT';
+        mockProcessExit = jest.spyOn(process, 'exit').mockImplementation(() => {
+            throw exitError;
+        });
+
+        // Reset mocks
+        jest.clearAllMocks();
+
+        // Re-apply process.exit mock after clearAllMocks
+        mockProcessExit = jest.spyOn(process, 'exit').mockImplementation(() => {
+            throw exitError;
+        });
+
+        // Set up default database validator mocks for all tests
+        const defaultValidator = createMockDatabaseValidator();
+        mockValidator.validateDatabaseUrl.mockReturnValue(defaultValidator.validateDatabaseUrl());
+        mockValidator.getDatabaseType.mockReturnValue(defaultValidator.getDatabaseType());
+        mockValidator.checkPrismaClientGenerated.mockReturnValue(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;
+
+        // Create a mock child process
+        mockChildProcess = {
+            on: jest.fn(),
+            stdout: { on: jest.fn() },
+            stderr: { on: jest.fn() },
+        };
+
+        spawn.mockReturnValue(mockChildProcess);
+    });
+
+    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', async () => {
+        const options = { stage: 'dev' };
+
+        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', async () => {
+        const options = { stage: 'dev' };
+
+        await startCommand(options);
+
+        expect(process.env.AWS_SDK_JS_SUPPRESS_MAINTENANCE_MODE_MESSAGE).toBe('1');
+    });
+
+    it('should spawn serverless with correct arguments', async () => {
+        const options = { stage: 'prod' };
+
+        await startCommand(options);
+
+        expect(spawn).toHaveBeenCalledWith(
+            'osls',
+            ['offline', '--config', 'infrastructure.js', '--stage', 'prod'],
+            expect.objectContaining({
+                cwd: expect.any(String),
+                stdio: 'inherit',
+                env: expect.objectContaining({
+                    FRIGG_SKIP_AWS_DISCOVERY: 'true',
+                }),
+            })
+        );
+    });
+
+    it('should include verbose flag when verbose option is enabled', async () => {
+        const options = { stage: 'dev', verbose: true };
+
+        await startCommand(options);
+
+        expect(spawn).toHaveBeenCalledWith(
+            'osls',
+            ['offline', '--config', 'infrastructure.js', '--stage', 'dev', '--verbose'],
+            expect.any(Object)
+        );
+    });
+
+    it('should pass FRIGG_SKIP_AWS_DISCOVERY in spawn environment', async () => {
+        const options = { stage: 'dev' };
+
+        await startCommand(options);
+
+        const spawnCall = spawn.mock.calls[0];
+        const spawnOptions = spawnCall[2];
+
+        expect(spawnOptions.env).toHaveProperty('FRIGG_SKIP_AWS_DISCOVERY', 'true');
+    });
+
+    it('should handle child process errors', async () => {
+        const options = { stage: 'dev' };
+        const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+
+        await startCommand(options);
+
+        // Simulate an error
+        const errorCallback = mockChildProcess.on.mock.calls.find(call => call[0] === 'error')[1];
+        const testError = new Error('Test error');
+        errorCallback(testError);
+
+        expect(consoleErrorSpy).toHaveBeenCalledWith('Error executing command: Test error');
+
+        consoleErrorSpy.mockRestore();
+    });
+
+    it('should handle child process exit with non-zero code', async () => {
+        const options = { stage: 'dev' };
+        const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+
+        await startCommand(options);
+
+        // Simulate exit with error code
+        const closeCallback = mockChildProcess.on.mock.calls.find(call => call[0] === 'close')[1];
+        closeCallback(1);
+
+        expect(consoleLogSpy).toHaveBeenCalledWith('Child process exited with code 1');
+
+        consoleLogSpy.mockRestore();
+    });
+
+    it('should not log on successful exit', async () => {
+        const options = { stage: 'dev' };
+        const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+
+        await startCommand(options);
+
+        // Clear the spy calls from startCommand execution
+        consoleLogSpy.mockClear();
+
+        // Simulate successful exit
+        const closeCallback = mockChildProcess.on.mock.calls.find(call => call[0] === 'close')[1];
+        closeCallback(0);
+
+        // Should not log anything for successful exit
+        expect(consoleLogSpy).not.toHaveBeenCalledWith(expect.stringContaining('exited'));
+
+        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.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 expect(startCommand({})).rejects.toThrow('process.exit called');
+
+            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 expect(startCommand({})).rejects.toThrow('process.exit called');
+
+            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 expect(startCommand({})).rejects.toThrow('process.exit called');
+
+            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 expect(startCommand({})).rejects.toThrow('process.exit called');
+
+            expect(mockConsoleError).toHaveBeenCalledWith(expect.stringContaining('frigg db:setup'));
+        });
+
+        it('should exit with code 1 on validation failure', async () => {
+            mockValidator.validateDatabaseUrl.mockReturnValue({
+                valid: false
+            });
+
+            await expect(startCommand({})).rejects.toThrow('process.exit called');
+
+            expect(mockProcessExit).toHaveBeenCalledWith(1);
+        });
+
+        it('should continue to serverless start when validation passes', async () => {
+            await startCommand({ stage: 'dev' });
+
+            expect(spawn).toHaveBeenCalledWith(
+                'osls',
+                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')
+            }));
+        });
+    });
+});

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

@@ -0,0 +1,180 @@
+const path = require('path');
+const fs = require('fs-extra');
+const { initCommand } = require('../init-command');
+const BackendFirstHandler = require('../init-command/backend-first-handler');
+
+// Mock dependencies
+jest.mock('fs-extra');
+jest.mock('chalk', () => ({
+    blue: jest.fn(text => text),
+    green: jest.fn(text => text),
+    red: jest.fn(text => text),
+    yellow: jest.fn(text => text),
+    gray: jest.fn(text => text),
+    cyan: jest.fn(text => text),
+    bold: jest.fn(text => text)
+}));
+jest.mock('@inquirer/prompts');
+jest.mock('child_process');
+jest.mock('cross-spawn');
+jest.mock('../init-command/backend-first-handler');
+jest.mock('validate-npm-package-name');
+
+describe('Init Command', () => {
+    const mockProjectPath = '/test/project/path';
+    const mockProjectName = 'test-project';
+    let mockExit;
+    let mockConsoleLog;
+    const validateProjectName = require('validate-npm-package-name');
+    
+    beforeEach(() => {
+        jest.clearAllMocks();
+        
+        // Mock process.exit
+        mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {
+            throw new Error('process.exit');
+        });
+        
+        // Mock console.log and console.error
+        mockConsoleLog = jest.spyOn(console, 'log').mockImplementation();
+        jest.spyOn(console, 'error').mockImplementation();
+        
+        // Reset fs mocks
+        const fs = require('fs-extra');
+        fs.ensureDirSync.mockImplementation(() => {});
+        fs.pathExists.mockResolvedValue(false);
+        fs.readdir.mockResolvedValue([]);
+        fs.readdirSync.mockReturnValue([]);
+        fs.writeFileSync.mockImplementation(() => {});
+        fs.lstatSync.mockReturnValue({ isDirectory: () => false });
+        
+        // Mock BackendFirstHandler
+        BackendFirstHandler.mockImplementation(() => ({
+            initialize: jest.fn().mockResolvedValue()
+        }));
+        
+        // Mock validate-npm-package-name
+        validateProjectName.mockReturnValue({
+            validForNewPackages: true,
+            errors: [],
+            warnings: []
+        });
+    });
+    
+    afterEach(() => {
+        mockExit.mockRestore();
+        mockConsoleLog.mockRestore();
+    });
+
+    describe('Validation', () => {
+        it('should validate project name', async () => {
+            validateProjectName.mockReturnValue({
+                validForNewPackages: false,
+                errors: ['Invalid name'],
+                warnings: []
+            });
+            
+            await expect(initCommand('invalid-name', {})).rejects.toThrow('process.exit');
+            expect(mockExit).toHaveBeenCalledWith(1);
+            expect(console.error).toHaveBeenCalledWith(expect.stringContaining('npm naming restrictions'));
+        });
+
+        it('should accept valid project names', async () => {
+            validateProjectName.mockReturnValue({
+                validForNewPackages: true,
+                errors: [],
+                warnings: []
+            });
+            
+            await initCommand('valid-name', {});
+            expect(BackendFirstHandler).toHaveBeenCalled();
+        });
+
+        it('should check Node.js version compatibility', async () => {
+            const originalVersion = process.version;
+            Object.defineProperty(process, 'version', {
+                value: 'v12.0.0',
+                configurable: true
+            });
+
+            const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+            await initCommand(mockProjectName, {});
+            
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Node 14 or higher'));
+            
+            Object.defineProperty(process, 'version', {
+                value: originalVersion,
+                configurable: true
+            });
+            consoleSpy.mockRestore();
+        });
+    });
+
+    describe('Project Creation Modes', () => {
+        it('should use BackendFirstHandler by default', async () => {
+            await initCommand(mockProjectName, {});
+            
+            expect(BackendFirstHandler).toHaveBeenCalledWith(
+                expect.stringContaining(mockProjectName),
+                expect.objectContaining({
+                    force: false,
+                    verbose: false
+                })
+            );
+        });
+
+        it('should pass options to BackendFirstHandler', async () => {
+            const options = {
+                force: true,
+                verbose: true,
+                mode: 'standalone',
+                frontend: false
+            };
+            
+            await initCommand(mockProjectName, options);
+            
+            expect(BackendFirstHandler).toHaveBeenCalledWith(
+                expect.any(String),
+                expect.objectContaining(options)
+            );
+        });
+
+        it('should handle initialization errors gracefully', async () => {
+            const mockError = new Error('Initialization failed');
+            BackendFirstHandler.mockImplementation(() => ({
+                initialize: jest.fn().mockRejectedValue(mockError)
+            }));
+            
+            await expect(initCommand(mockProjectName, {})).rejects.toThrow('process.exit');
+            
+            expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringContaining('Aborting'));
+            expect(mockExit).toHaveBeenCalledWith(1);
+        });
+    });
+
+    describe('Directory Safety', () => {
+        it('should check if directory is safe to use', async () => {
+            BackendFirstHandler.mockImplementation(() => ({
+                initialize: jest.fn().mockRejectedValue(new Error('Directory not empty'))
+            }));
+            
+            await expect(initCommand(mockProjectName, {})).rejects.toThrow('process.exit');
+            
+            expect(mockExit).toHaveBeenCalledWith(1);
+        });
+
+        it('should allow safe files in directory', async () => {
+            await initCommand(mockProjectName, {});
+            expect(BackendFirstHandler).toHaveBeenCalled();
+        });
+
+        it('should force overwrite when --force flag is used', async () => {
+            await initCommand(mockProjectName, { force: true });
+            expect(BackendFirstHandler).toHaveBeenCalledWith(
+                expect.any(String),
+                expect.objectContaining({ force: true })
+            );
+        });
+    });
+
+});