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

package/handlers/app-definition-loader.js

@@ -3,18 +3,60 @@ const path = require('node:path');
 const fs = require('fs-extra');
 
 /**
- * Loads the App definition from the nearest backend package
+ * Cached app definition, set via setAppDefinition().
+ * When set, loadAppDefinition() returns this instead of discovering
+ * the backend via process.cwd().
+ */
+let cachedAppDefinition = null;
+
+/**
+ * Pre-set the app definition so loadAppDefinition() can return it
+ * without needing process.cwd()-based discovery.
+ *
+ * This is critical for platforms like Netlify where:
+ * - nft/esbuild traces static require() calls to determine bundle contents
+ * - process.cwd() at runtime points to /var/task/, not the backend directory
+ * - The caller can use a static require('../../backend/index.js') to make
+ *   the backend traceable, then pass the definition here
+ *
+ * @param {Object} definition - The app definition object (backend's Definition export)
+ */
+function setAppDefinition(definition) {
+    cachedAppDefinition = definition;
+}
+
+/**
+ * Loads the App definition from the nearest backend package.
+ *
+ * If setAppDefinition() was called, returns the cached definition
+ * immediately (no filesystem discovery needed).
+ *
+ * Otherwise, discovers the backend via process.cwd() traversal.
+ *
+ * Returns the full appDefinition object plus convenience destructured fields
+ * for backward compatibility (integrations, userConfig).
+ *
  * @function loadAppDefinition
- * @description Searches for the nearest backend package.json, loads the corresponding index.js file,
- * and extracts the application definition containing integrations and user configuration.
- * @returns {{integrations: Array<object>, userConfig: object | null}} An object containing the application definition.
- * @throws {Error} Throws error if backend package.json cannot be found.
- * @throws {Error} Throws error if index.js file cannot be found in the backend directory.
+ * @returns {{
+ *   integrations: Array<object>,
+ *   userConfig: object | null,
+ *   appDefinition: object
+ * }}
+ * @throws {Error} If backend package.json or index.js cannot be found.
  * @example
- * const { integrations, userConfig } = loadAppDefinition();
- * console.log(`Found ${integrations.length} integrations`);
+ *   // Existing callers still work:
+ *   const { integrations, userConfig } = loadAppDefinition();
+ *
+ *   // New callers can access the full definition:
+ *   const { appDefinition } = loadAppDefinition();
+ *   console.log(appDefinition.provider); // 'aws' | 'netlify'
  */
 function loadAppDefinition() {
+    if (cachedAppDefinition) {
+        const { integrations = [], user: userConfig = null } = cachedAppDefinition;
+        return { integrations, userConfig, appDefinition: cachedAppDefinition };
+    }
+
     const backendPath = findNearestBackendPackageJson();
     if (!backendPath) {
         throw new Error('Could not find backend package.json');
@@ -30,9 +72,10 @@ function loadAppDefinition() {
     const appDefinition = backendJsFile.Definition;
 
     const { integrations = [], user: userConfig = null } = appDefinition;
-    return { integrations, userConfig };
+    return { integrations, userConfig, appDefinition };
 }
 
 module.exports = {
     loadAppDefinition,
-}; 
+    setAppDefinition,
+};

package/handlers/app-handler-helpers.js

@@ -3,6 +3,7 @@ const express = require('express');
 const bodyParser = require('body-parser');
 const cors = require('cors');
 const Boom = require('@hapi/boom');
+const loadUserManager = require('./routers/middleware/loadUser');
 const serverlessHttp = require('serverless-http');
 
 const createApp = (applyMiddleware) => {
@@ -19,6 +20,8 @@ const createApp = (applyMiddleware) => {
         })
     );
 
+    app.use(loadUserManager);
+
     if (applyMiddleware) applyMiddleware(app);
 
     // Handle sending error response and logging server errors to console
@@ -32,7 +35,6 @@ const createApp = (applyMiddleware) => {
             flushDebugLog(boomError);
             res.status(statusCode).json({ error: 'Internal Server Error' });
         } else {
-            console.warn(`[Frigg] ${req.method} ${req.path} -> ${statusCode}: ${err.message}`);
             res.status(statusCode).json({ error: err.message });
         }
     });
@@ -40,9 +42,18 @@ const createApp = (applyMiddleware) => {
     return app;
 };
 
-function createAppHandler(eventName, router, shouldUseDatabase = true) {
+function createAppHandler(
+    eventName,
+    router,
+    shouldUseDatabase = true,
+    basePath = null
+) {
     const app = createApp((app) => {
-        app.use(router);
+        if (basePath) {
+            app.use(basePath, router);
+        } else {
+            app.use(router);
+        }
     });
     return createHandler({
         eventName,

package/handlers/backend-utils.js

@@ -101,7 +101,6 @@ const loadIntegrationForWebhook = async (integrationId) => {
 };
 
 const loadIntegrationForProcess = async (processId, integrationClass) => {
-
     const { processRepository, integrationRepository, moduleRepository } =
         initializeRepositories();
 

package/handlers/database-migration-handler.js

@@ -1,24 +1,24 @@
 /**
  * Database Migration Handler for AWS Lambda
- * 
+ *
  * Executes Prisma migrations in a Lambda environment.
  * Based on AWS best practices for running migrations in serverless environments.
- * 
+ *
  * Supported Commands:
  * - deploy: Apply pending migrations to the database (production-safe)
  * - reset: Reset database and apply all migrations (DANGEROUS - dev only)
- * 
+ *
  * Usage:
  *   // Via Lambda invoke
  *   {
  *     "command": "deploy"  // or "reset"
  *   }
- * 
+ *
  * Requirements:
  * - Prisma CLI must be included in deployment or Lambda layer
  * - DATABASE_URL environment variable must be set
  * - VPC configuration for Aurora access
- * 
+ *
  * Reference: https://www.prisma.io/docs/guides/deployment/deployment-guides/deploying-to-aws-lambda
  */
 
@@ -27,7 +27,7 @@ const path = require('path');
 
 /**
  * Execute Prisma migration command
- * 
+ *
  * @param {string} command - Migration command ('deploy' or 'reset')
  * @param {string} schemaPath - Path to Prisma schema file
  * @returns {Promise<number>} Exit code
@@ -35,16 +35,18 @@ const path = require('path');
 async function executePrismaMigration(command, schemaPath) {
     console.log(`Executing Prisma migration: ${command}`);
     console.log(`Schema path: ${schemaPath}`);
-    console.log(`Database URL: ${process.env.DATABASE_URL ? '[SET]' : '[NOT SET]'}`);
+    console.log(
+        `Database URL: ${process.env.DATABASE_URL ? '[SET]' : '[NOT SET]'}`
+    );
 
     return new Promise((resolve, reject) => {
         // Build command arguments
         const args = ['migrate', command];
-        
+
         // Add command-specific options
         if (command === 'reset') {
-            args.push('--force');           // Skip confirmation prompt
-            args.push('--skip-generate');   // Skip client generation (already done in layer)
+            args.push('--force'); // Skip confirmation prompt
+            args.push('--skip-generate'); // Skip client generation (already done in layer)
         }
 
         // Add schema path if provided
@@ -53,7 +55,7 @@ async function executePrismaMigration(command, schemaPath) {
         }
 
         console.log(`Running: prisma ${args.join(' ')}`);
-        
+
         // Execute Prisma CLI
         execFile(
             path.resolve('./node_modules/prisma/build/index.js'),
@@ -63,7 +65,7 @@ async function executePrismaMigration(command, schemaPath) {
                     ...process.env,
                     // Ensure Prisma uses the correct binary target
                     PRISMA_CLI_BINARY_TARGETS: 'rhel-openssl-3.0.x',
-                }
+                },
             },
             (error, stdout, stderr) => {
                 // Log all output
@@ -75,7 +77,10 @@ async function executePrismaMigration(command, schemaPath) {
                 }
 
                 if (error) {
-                    console.error(`Migration ${command} exited with error:`, error.message);
+                    console.error(
+                        `Migration ${command} exited with error:`,
+                        error.message
+                    );
                     console.error(`Exit code: ${error.code || 1}`);
                     resolve(error.code || 1);
                 } else {
@@ -92,11 +97,11 @@ async function executePrismaMigration(command, schemaPath) {
  */
 function validateCommand(command) {
     const validCommands = ['deploy', 'reset'];
-    
+
     if (!validCommands.includes(command)) {
         throw new Error(
             `Invalid migration command: "${command}". ` +
-            `Valid commands are: ${validCommands.join(', ')}`
+                `Valid commands are: ${validCommands.join(', ')}`
         );
     }
 
@@ -106,10 +111,12 @@ function validateCommand(command) {
         if (stage === 'production' || stage === 'prod') {
             throw new Error(
                 'BLOCKED: "reset" command is not allowed in production environment. ' +
-                'This command would delete all data. Use "deploy" instead.'
+                    'This command would delete all data. Use "deploy" instead.'
             );
         }
-        console.warn('⚠️  WARNING: "reset" will DELETE all data and reset the database!');
+        console.warn(
+            '⚠️  WARNING: "reset" will DELETE all data and reset the database!'
+        );
     }
 }
 
@@ -119,14 +126,17 @@ function validateCommand(command) {
 function getSchemaPath() {
     // In Lambda, schemas are in @friggframework/core/generated/
     const baseSchemaPath = './node_modules/@friggframework/core/generated';
-    
+
     // Check if Postgres is enabled
-    if (process.env.DATABASE_URL?.includes('postgresql') || process.env.DATABASE_URL?.includes('postgres')) {
+    if (
+        process.env.DATABASE_URL?.includes('postgresql') ||
+        process.env.DATABASE_URL?.includes('postgres')
+    ) {
         const schemaPath = `${baseSchemaPath}/prisma-postgresql/schema.prisma`;
         console.log(`Using PostgreSQL schema: ${schemaPath}`);
         return schemaPath;
     }
-    
+
     // Check if MongoDB is enabled
     if (process.env.DATABASE_URL?.includes('mongodb')) {
         const schemaPath = `${baseSchemaPath}/prisma-mongodb/schema.prisma`;
@@ -135,13 +145,15 @@ function getSchemaPath() {
     }
 
     // Default to PostgreSQL
-    console.log('DATABASE_URL not set or database type unknown, defaulting to PostgreSQL');
+    console.log(
+        'DATABASE_URL not set or database type unknown, defaulting to PostgreSQL'
+    );
     return `${baseSchemaPath}/prisma-postgresql/schema.prisma`;
 }
 
 /**
  * Lambda handler for database migrations
- * 
+ *
  * @param {Object} event - Lambda event
  * @param {string} event.command - Migration command ('deploy' or 'reset')
  * @param {Object} context - Lambda context
@@ -149,41 +161,48 @@ function getSchemaPath() {
  */
 exports.handler = async (event, context) => {
     const startTime = Date.now();
-    
+
     console.log('='.repeat(60));
     console.log('Database Migration Handler');
     console.log('='.repeat(60));
     console.log('Event:', JSON.stringify(event, null, 2));
-    console.log('Context:', JSON.stringify({
-        functionName: context.functionName,
-        functionVersion: context.functionVersion,
-        memoryLimitInMB: context.memoryLimitInMB,
-        logGroupName: context.logGroupName,
-    }, null, 2));
-    
+    console.log(
+        'Context:',
+        JSON.stringify(
+            {
+                functionName: context.functionName,
+                functionVersion: context.functionVersion,
+                memoryLimitInMB: context.memoryLimitInMB,
+                logGroupName: context.logGroupName,
+            },
+            null,
+            2
+        )
+    );
+
     try {
         // Get migration command (default to 'deploy')
         const command = event.command || 'deploy';
-        
+
         // Validate command
         validateCommand(command);
-        
+
         // Check required environment variables
         if (!process.env.DATABASE_URL) {
             throw new Error(
                 'DATABASE_URL environment variable is not set. ' +
-                'Cannot connect to database for migrations.'
+                    'Cannot connect to database for migrations.'
             );
         }
-        
+
         // Determine schema path
         const schemaPath = getSchemaPath();
-        
+
         // Execute migration
         const exitCode = await executePrismaMigration(command, schemaPath);
-        
+
         const duration = Date.now() - startTime;
-        
+
         if (exitCode === 0) {
             const result = {
                 success: true,
@@ -192,26 +211,27 @@ exports.handler = async (event, context) => {
                 duration: `${duration}ms`,
                 timestamp: new Date().toISOString(),
             };
-            
+
             console.log('='.repeat(60));
             console.log('Migration completed successfully');
             console.log(JSON.stringify(result, null, 2));
             console.log('='.repeat(60));
-            
+
             return result;
         } else {
-            throw new Error(`Migration ${command} failed with exit code ${exitCode}`);
+            throw new Error(
+                `Migration ${command} failed with exit code ${exitCode}`
+            );
         }
-        
     } catch (error) {
         const duration = Date.now() - startTime;
-        
+
         console.error('='.repeat(60));
         console.error('Migration failed');
         console.error('Error:', error.message);
         console.error('Stack:', error.stack);
         console.error('='.repeat(60));
-        
+
         const errorResult = {
             success: false,
             command: event.command || 'unknown',
@@ -219,9 +239,8 @@ exports.handler = async (event, context) => {
             duration: `${duration}ms`,
             timestamp: new Date().toISOString(),
         };
-        
+
         // Return error (don't throw) so Lambda doesn't retry
         return errorResult;
     }
 };
-

package/handlers/middleware/admin-auth.js

@@ -0,0 +1,53 @@
+/**
+ * Admin Auth Middleware
+ *
+ * Shared authentication middleware for all admin endpoints:
+ * - /admin/db-migrate/*
+ * - /admin/scripts/*
+ *
+ * Uses simple ENV-based API key validation.
+ * Expects: x-frigg-admin-api-key header
+ */
+
+/**
+ * Validate admin API key from request header
+ * @param {import('express').Request} req
+ * @param {import('express').Response} res
+ * @param {import('express').NextFunction} next
+ */
+function validateAdminApiKey(req, res, next) {
+    const expectedKey = process.env.ADMIN_API_KEY;
+
+    // Check if admin API key is configured
+    if (!expectedKey) {
+        console.error('ADMIN_API_KEY environment variable not configured');
+        return res.status(401).json({
+            error: 'Unauthorized',
+            message: 'Admin API key not configured'
+        });
+    }
+
+    const apiKey = req.headers['x-frigg-admin-api-key'];
+
+    // Check if header is present
+    if (!apiKey) {
+        console.error('Missing x-frigg-admin-api-key header');
+        return res.status(401).json({
+            error: 'Unauthorized',
+            message: 'x-frigg-admin-api-key header required'
+        });
+    }
+
+    // Validate key
+    if (apiKey !== expectedKey) {
+        console.error('Invalid admin API key provided');
+        return res.status(401).json({
+            error: 'Unauthorized',
+            message: 'Invalid admin API key'
+        });
+    }
+
+    next();
+}
+
+module.exports = { validateAdminApiKey };