@friggframework/devtools 2.0.0--canary.395.93acf57.0 → 2.0.0--canary.395.04851d8.0

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/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,
+    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;
+    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());
@@ -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: 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'));
+    }
+
+    // Check 4: Test database connection (only after confirming client exists)
+    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'));
+    }
+}
+
 module.exports = { startCommand };

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

@@ -5,26 +5,62 @@
  * 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 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.testDatabaseConnection.mockResolvedValue(defaultValidator.testDatabaseConnection());
+        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;
@@ -40,32 +76,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 +121,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 +133,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 +144,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 +160,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 +175,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 +193,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 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 database connection fails', async () => {
+            mockValidator.testDatabaseConnection.mockResolvedValue({
+                connected: false,
+                error: 'Connection failed'
+            });
+
+            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')
+            }));
+        });
+    });
 });