@friggframework/core 2.0.0--canary.548.c8ae0ca.0 → 2.0.0--canary.545.c40eca4.0

package/database/utils/prisma-runner.js

@@ -30,8 +30,23 @@ function getPrismaSchemaPath(dbType, projectRoot = process.cwd()) {
         // Lambda layer path - this is where the schema actually exists in deployed Lambda
         `/opt/nodejs/node_modules/generated/prisma-${normalizedType}/schema.prisma`,
         // Check where Frigg is installed via npm (production scenario)
-        path.join(projectRoot, 'node_modules', '@friggframework', 'core', `prisma-${normalizedType}`, 'schema.prisma'),
-        path.join(projectRoot, '..', 'node_modules', '@friggframework', 'core', `prisma-${normalizedType}`, 'schema.prisma')
+        path.join(
+            projectRoot,
+            'node_modules',
+            '@friggframework',
+            'core',
+            `prisma-${normalizedType}`,
+            'schema.prisma'
+        ),
+        path.join(
+            projectRoot,
+            '..',
+            'node_modules',
+            '@friggframework',
+            'core',
+            `prisma-${normalizedType}`,
+            'schema.prisma'
+        ),
     ];
 
     for (const schemaPath of possiblePaths) {
@@ -43,7 +58,7 @@ function getPrismaSchemaPath(dbType, projectRoot = process.cwd()) {
     // If not found in any location, throw error
     throw new Error(
         `Prisma schema not found at:\n${possiblePaths.join('\n')}\n\n` +
-        'Ensure @friggframework/core is installed.'
+            'Ensure @friggframework/core is installed.'
     );
 }
 
@@ -59,57 +74,76 @@ async function runPrismaGenerate(dbType, verbose = false) {
 
         // Check if Prisma client already exists (e.g., in Lambda or pre-generated)
         const normalizedType = normalizeMongoCompatible(dbType);
-        const generatedClientPath = path.join(path.dirname(path.dirname(schemaPath)), 'generated', `prisma-${normalizedType}`, 'client.js');
-        const isLambdaEnvironment = !!process.env.AWS_LAMBDA_FUNCTION_NAME || !!process.env.LAMBDA_TASK_ROOT;
+        const generatedClientPath = path.join(
+            path.dirname(path.dirname(schemaPath)),
+            'generated',
+            `prisma-${normalizedType}`,
+            'client.js'
+        );
+        const isLambdaEnvironment =
+            !!process.env.AWS_LAMBDA_FUNCTION_NAME ||
+            !!process.env.LAMBDA_TASK_ROOT;
 
         // In Lambda, also check the layer path (/opt/nodejs/node_modules)
         const lambdaLayerClientPath = `/opt/nodejs/node_modules/generated/prisma-${normalizedType}/client.js`;
 
-        const clientExists = fs.existsSync(generatedClientPath) || (isLambdaEnvironment && fs.existsSync(lambdaLayerClientPath));
+        const clientExists =
+            fs.existsSync(generatedClientPath) ||
+            (isLambdaEnvironment && fs.existsSync(lambdaLayerClientPath));
 
         if (clientExists) {
-            const foundPath = fs.existsSync(generatedClientPath) ? generatedClientPath : lambdaLayerClientPath;
+            const foundPath = fs.existsSync(generatedClientPath)
+                ? generatedClientPath
+                : lambdaLayerClientPath;
             if (verbose) {
-            console.log(chalk.gray(`✓ Prisma client already generated at: ${foundPath}`));
+                console.log(
+                    chalk.gray(
+                        `✓ Prisma client already generated at: ${foundPath}`
+                    )
+                );
             }
             if (isLambdaEnvironment) {
                 if (verbose) {
-                    console.log(chalk.gray('Skipping generation in Lambda environment (using pre-generated client)'));
+                    console.log(
+                        chalk.gray(
+                            'Skipping generation in Lambda environment (using pre-generated client)'
+                        )
+                    );
                 }
                 return {
                     success: true,
-                    output: 'Using pre-generated Prisma client (Lambda environment)'
+                    output: 'Using pre-generated Prisma client (Lambda environment)',
                 };
             }
         }
 
         if (verbose) {
-            console.log(chalk.gray(`Running: npx prisma generate --schema=${schemaPath}`));
+            console.log(
+                chalk.gray(
+                    `Running: npx prisma generate --schema=${schemaPath}`
+                )
+            );
         }
 
-        const output = execSync(
-            `npx prisma generate --schema=${schemaPath}`,
-            {
-                encoding: 'utf8',
-                stdio: verbose ? 'inherit' : 'pipe',
-                env: {
-                    ...process.env,
-                    // Suppress Prisma telemetry prompts
-                    PRISMA_HIDE_UPDATE_MESSAGE: '1'
-                }
-            }
-        );
+        const output = execSync(`npx prisma generate --schema=${schemaPath}`, {
+            encoding: 'utf8',
+            stdio: verbose ? 'inherit' : 'pipe',
+            env: {
+                ...process.env,
+                // Suppress Prisma telemetry prompts
+                PRISMA_HIDE_UPDATE_MESSAGE: '1',
+            },
+        });
 
         return {
             success: true,
-            output: verbose ? 'Generated successfully' : output
+            output: verbose ? 'Generated successfully' : output,
         };
-
     } catch (error) {
         return {
             success: false,
             error: error.message,
-            output: error.stdout?.toString() || error.stderr?.toString()
+            output: error.stdout?.toString() || error.stderr?.toString(),
         };
     }
 }
@@ -135,17 +169,14 @@ async function checkDatabaseState(dbType) {
             ? `${prismaBin} migrate status --schema=${schemaPath}`
             : `npx prisma migrate status --schema=${schemaPath}`;
 
-        const output = execSync(
-            command,
-            {
-                encoding: 'utf8',
-                stdio: 'pipe',
-                env: {
-                    ...process.env,
-                    PRISMA_HIDE_UPDATE_MESSAGE: '1'
-                }
-            }
-        );
+        const output = execSync(command, {
+            encoding: 'utf8',
+            stdio: 'pipe',
+            env: {
+                ...process.env,
+                PRISMA_HIDE_UPDATE_MESSAGE: '1',
+            },
+        });
 
         if (output.includes('Database schema is up to date')) {
             return { upToDate: true };
@@ -157,26 +188,25 @@ async function checkDatabaseState(dbType) {
 
         return {
             upToDate: false,
-            pendingMigrations
+            pendingMigrations,
         };
-
     } catch (error) {
         // If migrate status fails, database might not be initialized
         return {
             upToDate: false,
-            error: error.message
+            error: error.message,
         };
     }
 }
 
 /**
  * Gets the path to the Prisma CLI entry point
- * 
+ *
  * IMPORTANT: We invoke prisma/build/index.js directly instead of .bin/prisma
  * because .bin/prisma uses __dirname to find WASM files, and when the symlink
  * is resolved during Lambda packaging, __dirname points to .bin/ instead of
  * prisma/build/, causing WASM files to not be found.
- * 
+ *
  * @returns {string} Command to run Prisma CLI (e.g., 'node /path/to/index.js' or 'npx prisma')
  */
 function getPrismaBinaryPath() {
@@ -195,7 +225,13 @@ function getPrismaBinaryPath() {
     }
 
     // Check local node_modules - use actual CLI location
-    const localPrisma = path.join(process.cwd(), 'node_modules', 'prisma', 'build', 'index.js');
+    const localPrisma = path.join(
+        process.cwd(),
+        'node_modules',
+        'prisma',
+        'build',
+        'index.js'
+    );
     if (fs.existsSync(localPrisma)) {
         return `node ${localPrisma}`;
     }
@@ -216,7 +252,9 @@ async function runPrismaMigrate(command = 'dev', verbose = false) {
             const schemaPath = getPrismaSchemaPath('postgresql');
 
             // Get Prisma binary path (checks multiple locations)
-            const isLambdaEnvironment = !!process.env.AWS_LAMBDA_FUNCTION_NAME || !!process.env.LAMBDA_TASK_ROOT;
+            const isLambdaEnvironment =
+                !!process.env.AWS_LAMBDA_FUNCTION_NAME ||
+                !!process.env.LAMBDA_TASK_ROOT;
             const prismaBin = getPrismaBinaryPath();
 
             // Determine args based on whether we're using direct binary or npx
@@ -242,14 +280,14 @@ async function runPrismaMigrate(command = 'dev', verbose = false) {
                 stdio: 'inherit',
                 env: {
                     ...process.env,
-                    PRISMA_HIDE_UPDATE_MESSAGE: '1'
-                }
+                    PRISMA_HIDE_UPDATE_MESSAGE: '1',
+                },
             });
 
             proc.on('error', (error) => {
                 resolve({
                     success: false,
-                    error: error.message
+                    error: error.message,
                 });
             });
 
@@ -257,20 +295,19 @@ async function runPrismaMigrate(command = 'dev', verbose = false) {
                 if (code === 0) {
                     resolve({
                         success: true,
-                        output: 'Migration completed successfully'
+                        output: 'Migration completed successfully',
                     });
                 } else {
                     resolve({
                         success: false,
-                        error: `Migration process exited with code ${code}`
+                        error: `Migration process exited with code ${code}`,
                     });
                 }
             });
-
         } catch (error) {
             resolve({
                 success: false,
-                error: error.message
+                error: error.message,
             });
         }
     });
@@ -293,7 +330,7 @@ async function runPrismaDbPush(verbose = false, nonInteractive = false) {
                 'push',
                 '--schema',
                 schemaPath,
-                '--skip-generate' // We generate separately
+                '--skip-generate', // We generate separately
             ];
 
             // Add non-interactive flag for Lambda/CI environments
@@ -306,17 +343,25 @@ async function runPrismaDbPush(verbose = false, nonInteractive = false) {
             }
 
             if (nonInteractive) {
-                console.log(chalk.yellow('⚠️  Non-interactive mode: Data loss will be automatically accepted'));
+                console.log(
+                    chalk.yellow(
+                        '⚠️  Non-interactive mode: Data loss will be automatically accepted'
+                    )
+                );
             } else {
-                console.log(chalk.yellow('⚠️  Interactive mode: You may be prompted if schema changes cause data loss'));
+                console.log(
+                    chalk.yellow(
+                        '⚠️  Interactive mode: You may be prompted if schema changes cause data loss'
+                    )
+                );
             }
 
             const proc = spawn('npx', args, {
                 stdio: nonInteractive ? 'pipe' : 'inherit', // Use pipe for non-interactive to capture output
                 env: {
                     ...process.env,
-                    PRISMA_HIDE_UPDATE_MESSAGE: '1'
-                }
+                    PRISMA_HIDE_UPDATE_MESSAGE: '1',
+                },
             });
 
             let stdout = '';
@@ -345,7 +390,7 @@ async function runPrismaDbPush(verbose = false, nonInteractive = false) {
             proc.on('error', (error) => {
                 resolve({
                     success: false,
-                    error: error.message
+                    error: error.message,
                 });
             });
 
@@ -353,21 +398,22 @@ async function runPrismaDbPush(verbose = false, nonInteractive = false) {
                 if (code === 0) {
                     resolve({
                         success: true,
-                        output: nonInteractive ? stdout || 'Database push completed successfully' : 'Database push completed successfully'
+                        output: nonInteractive
+                            ? stdout || 'Database push completed successfully'
+                            : 'Database push completed successfully',
                     });
                 } else {
                     resolve({
                         success: false,
                         error: `Database push process exited with code ${code}`,
-                        output: stderr || stdout
+                        output: stderr || stdout,
                     });
                 }
             });
-
         } catch (error) {
             resolve({
                 success: false,
-                error: error.message
+                error: error.message,
             });
         }
     });
@@ -380,7 +426,11 @@ async function runPrismaDbPush(verbose = false, nonInteractive = false) {
  * @param {boolean} verbose - Enable verbose output
  * @returns {Promise<Object>} { success: boolean, output?: string, error?: string }
  */
-async function runPrismaMigrateResolve(migrationName, action = 'applied', verbose = false) {
+async function runPrismaMigrateResolve(
+    migrationName,
+    action = 'applied',
+    verbose = false
+) {
     return new Promise((resolve) => {
         try {
             const schemaPath = getPrismaSchemaPath('postgresql');
@@ -391,8 +441,23 @@ async function runPrismaMigrateResolve(migrationName, action = 'applied', verbos
             // Determine args based on whether we're using direct binary or npx
             const isDirectBinary = prismaBin !== 'npx prisma';
             const args = isDirectBinary
-                ? ['migrate', 'resolve', `--${action}`, migrationName, '--schema', schemaPath]
-                : ['prisma', 'migrate', 'resolve', `--${action}`, migrationName, '--schema', schemaPath];
+                ? [
+                      'migrate',
+                      'resolve',
+                      `--${action}`,
+                      migrationName,
+                      '--schema',
+                      schemaPath,
+                  ]
+                : [
+                      'prisma',
+                      'migrate',
+                      'resolve',
+                      `--${action}`,
+                      migrationName,
+                      '--schema',
+                      schemaPath,
+                  ];
 
             if (verbose) {
                 const displayCmd = isDirectBinary
@@ -409,14 +474,14 @@ async function runPrismaMigrateResolve(migrationName, action = 'applied', verbos
                 stdio: 'inherit',
                 env: {
                     ...process.env,
-                    PRISMA_HIDE_UPDATE_MESSAGE: '1'
-                }
+                    PRISMA_HIDE_UPDATE_MESSAGE: '1',
+                },
             });
 
             proc.on('error', (error) => {
                 resolve({
                     success: false,
-                    error: error.message
+                    error: error.message,
                 });
             });
 
@@ -424,20 +489,19 @@ async function runPrismaMigrateResolve(migrationName, action = 'applied', verbos
                 if (code === 0) {
                     resolve({
                         success: true,
-                        output: `Migration ${migrationName} marked as ${action}`
+                        output: `Migration ${migrationName} marked as ${action}`,
                     });
                 } else {
                     resolve({
                         success: false,
-                        error: `Resolve process exited with code ${code}`
+                        error: `Resolve process exited with code ${code}`,
                     });
                 }
             });
-
         } catch (error) {
             resolve({
                 success: false,
-                error: error.message
+                error: error.message,
             });
         }
     });
@@ -450,12 +514,18 @@ async function runPrismaMigrateResolve(migrationName, action = 'applied', verbos
  */
 function getMigrationCommand(stage) {
     // Always use 'deploy' in Lambda environment (it's non-interactive and doesn't create migrations)
-    const isLambdaEnvironment = !!process.env.AWS_LAMBDA_FUNCTION_NAME || !!process.env.LAMBDA_TASK_ROOT;
+    const isLambdaEnvironment =
+        !!process.env.AWS_LAMBDA_FUNCTION_NAME ||
+        !!process.env.LAMBDA_TASK_ROOT;
     if (isLambdaEnvironment) {
         return 'deploy';
     }
 
-    const normalizedStage = (stage || process.env.STAGE || 'development').toLowerCase();
+    const normalizedStage = (
+        stage ||
+        process.env.STAGE ||
+        'development'
+    ).toLowerCase();
 
     const developmentStages = ['dev', 'local', 'test', 'development'];
 
@@ -473,5 +543,5 @@ module.exports = {
     runPrismaMigrate,
     runPrismaMigrateResolve,
     runPrismaDbPush,
-    getMigrationCommand
+    getMigrationCommand,
 };

package/database/utils/prisma-schema-parser.js

@@ -146,7 +146,7 @@ async function getCollectionsFromSchema() {
     if (!schemaPath) {
         throw new Error(
             'Could not find Prisma MongoDB schema file. ' +
-            'Searched: prisma-mongodb/schema.prisma, prisma/schema.prisma, schema.prisma'
+                'Searched: prisma-mongodb/schema.prisma, prisma/schema.prisma, schema.prisma'
         );
     }
 
@@ -165,7 +165,7 @@ function getCollectionsFromSchemaSync() {
     if (!schemaPath) {
         throw new Error(
             'Could not find Prisma MongoDB schema file. ' +
-            'Searched: prisma-mongodb/schema.prisma, prisma/schema.prisma, schema.prisma'
+                'Searched: prisma-mongodb/schema.prisma, prisma/schema.prisma, schema.prisma'
         );
     }