@friggframework/devtools 2.0.0--canary.395.04851d8.0 → 2.0.0--canary.395.8f4c094.0

package/frigg-cli/__tests__/unit/commands/db-setup.test.js

@@ -83,12 +83,16 @@ describe('DB Setup Command', () => {
     describe('Success Cases', () => {
         it('should complete setup successfully for MongoDB', async () => {
             mockValidator.getDatabaseType.mockReturnValue({ dbType: 'mongodb' });
+            mockValidator.checkPrismaClientGenerated.mockReturnValue({
+                generated: false // Client doesn't exist, will generate
+            });
             mockRunner.checkDatabaseState.mockResolvedValue({ upToDate: false });
 
             await dbSetupCommand({ verbose: false, stage: 'development' });
 
             expect(mockValidator.validateDatabaseUrl).toHaveBeenCalled();
             expect(mockValidator.getDatabaseType).toHaveBeenCalled();
+            expect(mockValidator.checkPrismaClientGenerated).toHaveBeenCalledWith('mongodb');
             expect(mockValidator.testDatabaseConnection).toHaveBeenCalled();
             expect(mockRunner.runPrismaGenerate).toHaveBeenCalledWith('mongodb', false);
             expect(mockRunner.runPrismaDbPush).toHaveBeenCalled();
@@ -97,10 +101,14 @@ describe('DB Setup Command', () => {
 
         it('should complete setup successfully for PostgreSQL', async () => {
             mockValidator.getDatabaseType.mockReturnValue({ dbType: 'postgresql' });
+            mockValidator.checkPrismaClientGenerated.mockReturnValue({
+                generated: false // Client doesn't exist, will generate
+            });
             mockRunner.checkDatabaseState.mockResolvedValue({ upToDate: false });
 
             await dbSetupCommand({ verbose: false, stage: 'development' });
 
+            expect(mockValidator.checkPrismaClientGenerated).toHaveBeenCalledWith('postgresql');
             expect(mockRunner.runPrismaGenerate).toHaveBeenCalledWith('postgresql', false);
             expect(mockRunner.runPrismaMigrate).toHaveBeenCalled();
             expect(mockProcessExit).not.toHaveBeenCalled();
@@ -140,6 +148,10 @@ describe('DB Setup Command', () => {
         });
 
         it('should respect --verbose flag', async () => {
+            mockValidator.checkPrismaClientGenerated.mockReturnValue({
+                generated: false // Client doesn't exist, will generate
+            });
+
             await dbSetupCommand({ verbose: true, stage: 'development' });
 
             expect(mockRunner.runPrismaGenerate).toHaveBeenCalledWith('mongodb', true);
@@ -154,6 +166,89 @@ describe('DB Setup Command', () => {
         });
     });
 
+    describe('Conditional Client Generation', () => {
+        it('should skip generation when client already exists', async () => {
+            // Client exists
+            mockValidator.checkPrismaClientGenerated.mockReturnValue({
+                generated: true,
+                path: '/path/to/client'
+            });
+
+            await dbSetupCommand({ verbose: false, stage: 'development' });
+
+            // Should check if client exists
+            expect(mockValidator.checkPrismaClientGenerated).toHaveBeenCalledWith('mongodb');
+            // Should NOT call generate
+            expect(mockRunner.runPrismaGenerate).not.toHaveBeenCalled();
+            // Should still test connection and complete setup
+            expect(mockValidator.testDatabaseConnection).toHaveBeenCalled();
+            expect(mockProcessExit).not.toHaveBeenCalled();
+        });
+
+        it('should generate client when it does not exist', async () => {
+            // Client does NOT exist
+            mockValidator.checkPrismaClientGenerated.mockReturnValue({
+                generated: false,
+                error: 'Client not found'
+            });
+
+            await dbSetupCommand({ verbose: false, stage: 'development' });
+
+            // Should check if client exists
+            expect(mockValidator.checkPrismaClientGenerated).toHaveBeenCalledWith('mongodb');
+            // Should call generate
+            expect(mockRunner.runPrismaGenerate).toHaveBeenCalledWith('mongodb', false);
+            // Should complete setup
+            expect(mockProcessExit).not.toHaveBeenCalled();
+        });
+
+        it('should regenerate client when --force flag is provided', async () => {
+            // Client exists
+            mockValidator.checkPrismaClientGenerated.mockReturnValue({
+                generated: true,
+                path: '/path/to/client'
+            });
+
+            await dbSetupCommand({ verbose: false, stage: 'development', force: true });
+
+            // Should check if client exists
+            expect(mockValidator.checkPrismaClientGenerated).toHaveBeenCalledWith('mongodb');
+            // Should STILL call generate because of --force
+            expect(mockRunner.runPrismaGenerate).toHaveBeenCalledWith('mongodb', false);
+            // Should complete setup
+            expect(mockProcessExit).not.toHaveBeenCalled();
+        });
+
+        it('should show client location in verbose mode when skipping generation', async () => {
+            mockValidator.checkPrismaClientGenerated.mockReturnValue({
+                generated: true,
+                path: '/path/to/prisma/client'
+            });
+
+            await dbSetupCommand({ verbose: true, stage: 'development' });
+
+            // Should log the client path
+            expect(mockConsoleLog).toHaveBeenCalledWith(
+                expect.stringContaining('/path/to/prisma/client')
+            );
+            expect(mockRunner.runPrismaGenerate).not.toHaveBeenCalled();
+        });
+
+        it('should generate for different database types', async () => {
+            // Test PostgreSQL
+            mockValidator.getDatabaseType.mockReturnValue({ dbType: 'postgresql' });
+            mockValidator.checkPrismaClientGenerated.mockReturnValue({
+                generated: false
+            });
+            mockRunner.checkDatabaseState.mockResolvedValue({ upToDate: false });
+
+            await dbSetupCommand({ verbose: false, stage: 'development' });
+
+            expect(mockValidator.checkPrismaClientGenerated).toHaveBeenCalledWith('postgresql');
+            expect(mockRunner.runPrismaGenerate).toHaveBeenCalledWith('postgresql', false);
+        });
+    });
+
     describe('Failure Cases - Validation', () => {
         it('should fail when DATABASE_URL missing', async () => {
             mockValidator.validateDatabaseUrl.mockReturnValue({
@@ -242,6 +337,9 @@ describe('DB Setup Command', () => {
 
     describe('Failure Cases - Prisma Operations', () => {
         it('should fail when prisma generate fails', async () => {
+            mockValidator.checkPrismaClientGenerated.mockReturnValue({
+                generated: false // Client doesn't exist, will attempt generation
+            });
             mockRunner.runPrismaGenerate.mockResolvedValue({
                 success: false,
                 error: 'Generation failed'
@@ -304,6 +402,9 @@ describe('DB Setup Command', () => {
         });
 
         it('should fail when schema file missing', async () => {
+            mockValidator.checkPrismaClientGenerated.mockReturnValue({
+                generated: false // Client doesn't exist, will attempt generation
+            });
             mockRunner.runPrismaGenerate.mockResolvedValue({
                 success: false,
                 error: 'Schema not found'
@@ -342,6 +443,9 @@ describe('DB Setup Command', () => {
         });
 
         it('should display helpful error for Prisma failures', async () => {
+            mockValidator.checkPrismaClientGenerated.mockReturnValue({
+                generated: false // Client doesn't exist, will attempt generation
+            });
             mockRunner.runPrismaGenerate.mockResolvedValue({
                 success: false,
                 error: 'Some error',
@@ -392,6 +496,10 @@ describe('DB Setup Command', () => {
         });
 
         it('should pass verbose flag to Prisma commands', async () => {
+            mockValidator.checkPrismaClientGenerated.mockReturnValue({
+                generated: false // Client doesn't exist, will generate
+            });
+
             await dbSetupCommand({ verbose: true });
 
             expect(mockRunner.runPrismaGenerate).toHaveBeenCalledWith('mongodb', true);
@@ -399,6 +507,10 @@ describe('DB Setup Command', () => {
         });
 
         it('should not show verbose output when flag disabled', async () => {
+            mockValidator.checkPrismaClientGenerated.mockReturnValue({
+                generated: false // Client doesn't exist, will generate
+            });
+
             await dbSetupCommand({ verbose: false });
 
             expect(mockRunner.runPrismaGenerate).toHaveBeenCalledWith('mongodb', false);

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

@@ -4,7 +4,7 @@ const dotenv = require('dotenv');
 const {
     validateDatabaseUrl,
     getDatabaseType,
-    testDatabaseConnection
+    checkPrismaClientGenerated
 } = require('../utils/database-validator');
 const {
     runPrismaGenerate,
@@ -16,7 +16,6 @@ const {
 const {
     getDatabaseUrlMissingError,
     getDatabaseTypeNotConfiguredError,
-    getDatabaseConnectionError,
     getPrismaCommandError,
     getDatabaseSetupSuccess
 } = require('../utils/error-messages');
@@ -75,44 +74,52 @@ async function dbSetupCommand(options = {}) {
             console.log(chalk.green(`✓ Using ${dbType}\n`));
         }
 
-        // Step 3: Test database connection
+        // Step 3: Check if Prisma client exists, generate if needed
         if (verbose) {
-            console.log(chalk.gray('Step 3: Testing database connection...'));
+            console.log(chalk.gray('Step 3: Checking Prisma client...'));
         }
 
-        console.log(chalk.gray('Connecting to database...'));
-        const connectionTest = await testDatabaseConnection(urlValidation.url, dbType);
+        const clientCheck = checkPrismaClientGenerated(dbType);
+        const forceRegenerate = options.force || false;
 
-        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...'));
+        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(dbType, verbose);
+            const generateResult = await runPrismaGenerate(dbType, verbose);
 
-        if (!generateResult.success) {
-            console.error(getPrismaCommandError('generate', generateResult.error));
-            if (generateResult.output) {
-                console.error(chalk.gray(generateResult.output));
+            if (!generateResult.success) {
+                console.error(getPrismaCommandError('generate', generateResult.error));
+                if (generateResult.output) {
+                    console.error(chalk.gray(generateResult.output));
+                }
+                process.exit(1);
             }
-            process.exit(1);
-        }
 
-        console.log(chalk.green('✓ Prisma client generated\n'));
+            console.log(chalk.green('✓ Prisma client generated\n'));
+        }
 
-        // Step 5: Check database state
+        // 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 5: Checking database state...'));
+            console.log(chalk.gray('Step 4: Checking database state...'));
         }
 
         const stateCheck = await checkDatabaseState(dbType);
 
-        // Step 6: Run migrations or db push
+        // Step 5: Run migrations or db push
         if (dbType === 'postgresql') {
             console.log(chalk.cyan('Running database migrations...'));
 

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

@@ -5,13 +5,11 @@ const chalk = require('chalk');
 const {
     validateDatabaseUrl,
     getDatabaseType,
-    testDatabaseConnection,
     checkPrismaClientGenerated
 } = require('../utils/database-validator');
 const {
     getDatabaseUrlMissingError,
     getDatabaseTypeNotConfiguredError,
-    getDatabaseConnectionError,
     getPrismaClientNotGeneratedError
 } = require('../utils/error-messages');
 
@@ -142,21 +140,10 @@ async function performDatabaseChecks(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'));
-    }
+    // 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

@@ -15,7 +15,6 @@
 const mockValidator = {
     validateDatabaseUrl: jest.fn(),
     getDatabaseType: jest.fn(),
-    testDatabaseConnection: jest.fn(),
     checkPrismaClientGenerated: jest.fn()
 };
 
@@ -55,7 +54,6 @@ describe('startCommand', () => {
         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
@@ -213,7 +211,6 @@ describe('startCommand', () => {
 
             expect(mockValidator.validateDatabaseUrl).toHaveBeenCalled();
             expect(mockValidator.getDatabaseType).toHaveBeenCalled();
-            expect(mockValidator.testDatabaseConnection).toHaveBeenCalled();
             expect(mockValidator.checkPrismaClientGenerated).toHaveBeenCalled();
             expect(mockProcessExit).not.toHaveBeenCalled();
             expect(spawn).toHaveBeenCalled();
@@ -244,19 +241,6 @@ describe('startCommand', () => {
             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,

package/frigg-cli/utils/database-validator.js

@@ -104,7 +104,7 @@ async function testDatabaseConnection(databaseUrl, dbType, timeout = 5000) {
 
 /**
  * Checks if Prisma client is generated for the database type
- * Uses require.resolve() to find the client regardless of package manager hoisting
+ * Uses require.resolve to find the client in node_modules
  *
  * @param {'mongodb'|'postgresql'} dbType - Database type
  * @param {string} projectRoot - Project root directory (used for require.resolve context)

package/frigg-cli/utils/prisma-runner.js

@@ -17,9 +17,11 @@ const chalk = require('chalk');
  */
 function getPrismaSchemaPath(dbType, projectRoot = process.cwd()) {
     // Try multiple locations for the schema file
-    // 1. Local node_modules (standard install)
+    // Priority order:
+    // 1. Local node_modules (where @friggframework/core is installed - production scenario)
     // 2. Parent node_modules (workspace/monorepo setup)
     const possiblePaths = [
+        // Check where Frigg is installed via npm (production scenario)
         path.join(projectRoot, 'node_modules', '@friggframework', 'core', `prisma-${dbType}`, 'schema.prisma'),
         path.join(projectRoot, '..', 'node_modules', '@friggframework', 'core', `prisma-${dbType}`, 'schema.prisma')
     ];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@friggframework/devtools",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0--canary.395.04851d8.0",
+  "version": "2.0.0--canary.395.8f4c094.0",
   "dependencies": {
     "@aws-sdk/client-ec2": "^3.835.0",
     "@aws-sdk/client-kms": "^3.835.0",
@@ -9,8 +9,8 @@
     "@babel/eslint-parser": "^7.18.9",
     "@babel/parser": "^7.25.3",
     "@babel/traverse": "^7.25.3",
-    "@friggframework/schemas": "2.0.0--canary.395.04851d8.0",
-    "@friggframework/test": "2.0.0--canary.395.04851d8.0",
+    "@friggframework/schemas": "2.0.0--canary.395.8f4c094.0",
+    "@friggframework/test": "2.0.0--canary.395.8f4c094.0",
     "@hapi/boom": "^10.0.1",
     "@inquirer/prompts": "^5.3.8",
     "axios": "^1.7.2",
@@ -32,8 +32,8 @@
     "serverless-http": "^2.7.0"
   },
   "devDependencies": {
-    "@friggframework/eslint-config": "2.0.0--canary.395.04851d8.0",
-    "@friggframework/prettier-config": "2.0.0--canary.395.04851d8.0",
+    "@friggframework/eslint-config": "2.0.0--canary.395.8f4c094.0",
+    "@friggframework/prettier-config": "2.0.0--canary.395.8f4c094.0",
     "aws-sdk-client-mock": "^4.1.0",
     "aws-sdk-client-mock-jest": "^4.1.0",
     "jest": "^30.1.3",
@@ -68,5 +68,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "04851d8d253adc1abe6aeae2d8e26e9887d7334b"
+  "gitHead": "8f4c0943481f1c896d9dc593f3bc766ed7537a58"
 }