@friggframework/devtools 2.0.0-next.40 → 2.0.0-next.42

package/frigg-cli/generate-iam-command.js

@@ -55,12 +55,15 @@ async function generateIamCommand(options = {}) {
 
         // Generate the CloudFormation template
         console.log('\\n🏗️  Generating IAM CloudFormation template...');
-        
+
         const deploymentUserName = options.user || 'frigg-deployment-user';
         const stackName = options.stackName || 'frigg-deployment-iam';
-        
-        const cloudFormationYaml = generateIAMCloudFormation(appDefinition, {
-            deploymentUserName,
+
+        // Use the summary already extracted above (line 44)
+        const cloudFormationYaml = generateIAMCloudFormation({
+            appName: summary.appName,
+            features: summary.features,
+            userPrefix: deploymentUserName,
             stackName
         });
 

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/install-command/index.js

@@ -9,7 +9,7 @@ const {
     validatePackageExists,
     searchAndSelectPackage,
 } = require('./validate-package');
-const { findNearestBackendPackageJson, validateBackendPath } = require('@friggframework/core');
+const { findNearestBackendPackageJson, validateBackendPath } = require('@friggframework/core/utils');
 
 const installCommand = async (apiModuleName) => {
     try {

package/frigg-cli/jest.config.js

@@ -0,0 +1,124 @@
+module.exports = {
+  displayName: 'Frigg CLI Tests',
+  testMatch: [
+    '<rootDir>/__tests__/**/*.test.js',
+    '<rootDir>/__tests__/**/*.spec.js',
+    '<rootDir>/**/start-command.test.js',
+    '<rootDir>/**/__tests__/**/*.test.js'
+  ],
+  // Exclude utility files and config from being treated as tests
+  testPathIgnorePatterns: [
+    '/node_modules/',
+    '/__tests__/utils/',
+    '/__tests__/jest.config.js',
+    '/test-setup.js'
+  ],
+  testEnvironment: 'node',
+  collectCoverageFrom: [
+    '**/*.js',
+    '!**/*.test.js',
+    '!**/*.spec.js',
+    '!**/node_modules/**',
+    '!**/__tests__/**',
+    '!**/coverage/**'
+  ],
+  coverageDirectory: 'coverage',
+  coverageReporters: [
+    'text',
+    'text-summary',
+    'html',
+    'lcov',
+    'json'
+  ],
+  coverageThreshold: {
+    global: {
+      branches: 85,
+      functions: 85,
+      lines: 85,
+      statements: 85
+    },
+    './install-command/index.js': {
+      branches: 90,
+      functions: 90,
+      lines: 90,
+      statements: 90
+    },
+    './build-command/index.js': {
+      branches: 90,
+      functions: 90,
+      lines: 90,
+      statements: 90
+    },
+    './deploy-command/index.js': {
+      branches: 90,
+      functions: 90,
+      lines: 90,
+      statements: 90
+    },
+    './ui-command/index.js': {
+      branches: 90,
+      functions: 90,
+      lines: 90,
+      statements: 90
+    },
+    './generate-command/index.js': {
+      branches: 90,
+      functions: 90,
+      lines: 90,
+      statements: 90
+    },
+    './db-setup-command/index.js': {
+      branches: 90,
+      functions: 90,
+      lines: 90,
+      statements: 90
+    },
+    './utils/database-validator.js': {
+      branches: 85,
+      functions: 85,
+      lines: 85,
+      statements: 85
+    },
+    './utils/prisma-runner.js': {
+      branches: 85,
+      functions: 85,
+      lines: 85,
+      statements: 85
+    },
+    './utils/error-messages.js': {
+      branches: 85,
+      functions: 85,
+      lines: 85,
+      statements: 85
+    }
+  },
+  setupFilesAfterEnv: [
+    '<rootDir>/__tests__/utils/test-setup.js'
+  ],
+  testTimeout: 10000,
+  maxWorkers: '50%',
+  verbose: true,
+  collectCoverage: true,
+  coveragePathIgnorePatterns: [
+    '/node_modules/',
+    '/__tests__/',
+    '/coverage/',
+    '.test.js',
+    '.spec.js'
+  ],
+  moduleFileExtensions: [
+    'js',
+    'json',
+    'node'
+  ],
+  transform: {},
+  // testResultsProcessor: 'jest-sonar-reporter', // Optional dependency
+  reporters: [
+    'default'
+    // jest-junit reporter removed - optional dependency
+  ],
+  watchman: false,
+  forceExit: true,
+  detectOpenHandles: true,
+  errorOnDeprecated: true
+};

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,14 +1,46 @@
 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');
 
-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;
+    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';
@@ -34,6 +66,10 @@ function startCommand(options) {
     const childProcess = spawn(command, args, {
         cwd: backendPath,
         stdio: 'inherit',
+        env: {
+            ...process.env,
+            FRIGG_SKIP_AWS_DISCOVERY: 'true',
+        },
     });
 
     childProcess.on('error', (error) => {
@@ -47,4 +83,67 @@ 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: 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(
+            'serverless',
+            ['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(
+            'serverless',
+            ['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(
+                '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')
+            }));
+        });
+    });
+});