@friggframework/core 2.0.0--canary.522.cbd3d5a.0 → 2.0.0--canary.517.35ee143.0

package/handlers/WEBHOOKS.md

@@ -5,36 +5,31 @@ This document explains how to implement webhook handling for your Frigg integrat
 ## Overview
 
 Frigg provides a scalable webhook architecture that:
-
--   **Receives webhooks without database connections** for fast response times
--   **Queues webhooks to SQS** for async processing
--   **Processes webhooks with fully hydrated integrations** (with DB and API modules loaded)
--   **Supports custom signature verification** for security
--   **Throttles database connections** using SQS to handle webhook bursts
+- **Receives webhooks without database connections** for fast response times
+- **Queues webhooks to SQS** for async processing
+- **Processes webhooks with fully hydrated integrations** (with DB and API modules loaded)
+- **Supports custom signature verification** for security
+- **Throttles database connections** using SQS to handle webhook bursts
 
 ## Architecture
 
 The webhook flow consists of two stages:
 
 ### Stage 1: HTTP Webhook Receiver (No DB)
-
 ```
 Webhook → Lambda → WEBHOOK_RECEIVED event → Queue to SQS → 200 OK Response
 ```
-
--   Fast response (no database query)
--   Optional signature verification
--   Messages queued for processing
+- Fast response (no database query)
+- Optional signature verification
+- Messages queued for processing
 
 ### Stage 2: Queue Worker (DB-Connected)
-
 ```
 SQS Queue → Lambda Worker → ON_WEBHOOK event → Process with hydrated integration
 ```
-
--   Full database access
--   API modules loaded
--   Can use integration context
+- Full database access
+- API modules loaded
+- Can use integration context
 
 ## Enabling Webhooks
 
@@ -64,9 +59,7 @@ class MyIntegration extends IntegrationBase {
     static Definition = {
         name: 'my-integration',
         version: '1.0.0',
-        modules: {
-            /* ... */
-        },
+        modules: { /* ... */ },
         webhooks: {
             enabled: true,
             // Future options will be added here
@@ -80,24 +73,20 @@ class MyIntegration extends IntegrationBase {
 When webhooks are enabled, two routes are automatically created:
 
 ### General Webhook
-
 ```
 POST /api/{integrationName}-integration/webhooks
 ```
-
--   No integration ID required
--   Useful for system-wide events
--   Creates unhydrated integration instance
+- No integration ID required
+- Useful for system-wide events
+- Creates unhydrated integration instance
 
 ### Integration-Specific Webhook
-
 ```
 POST /api/{integrationName}-integration/webhooks/:integrationId
 ```
-
--   Includes integration ID in URL
--   Worker loads full integration with DB and modules
--   Recommended for most use cases
+- Includes integration ID in URL
+- Worker loads full integration with DB and modules
+- Recommended for most use cases
 
 ## Event Handlers
 
@@ -106,7 +95,6 @@ POST /api/{integrationName}-integration/webhooks/:integrationId
 Triggered when a webhook HTTP request is received (no database connection).
 
 #### Default Behavior
-
 Queues the webhook to SQS and responds with `200 OK`:
 
 ```javascript
@@ -137,7 +125,7 @@ class MyIntegration extends IntegrationBase {
         // Verify webhook signature
         const signature = req.headers['x-webhook-signature'];
         const expectedSignature = this.calculateSignature(req.body);
-
+        
         if (signature !== expectedSignature) {
             return res.status(401).json({ error: 'Invalid signature' });
         }
@@ -168,7 +156,6 @@ class MyIntegration extends IntegrationBase {
 Triggered by the queue worker (with database connection and hydrated integration).
 
 #### Default Behavior
-
 Logs the webhook data (override this!):
 
 ```javascript
@@ -275,26 +262,27 @@ class SlackIntegration extends IntegrationBase {
         const crypto = require('crypto');
         const signingSecret = process.env.SLACK_SIGNING_SECRET;
         const timestamp = req.headers['x-slack-request-timestamp'];
-
+        
         // Validate timestamp is recent (within 5 minutes)
         const currentTime = Math.floor(Date.now() / 1000);
         if (Math.abs(currentTime - parseInt(timestamp)) > 300) {
             return false; // Request is older than 5 minutes
         }
-
+        
         const hmac = crypto.createHmac('sha256', signingSecret);
         hmac.update(`v0:${timestamp}:${JSON.stringify(req.body)}`);
         const expected = `v0=${hmac.digest('hex')}`;
-
+        
         // Check lengths first to avoid errors in timingSafeEqual
-        const expectedBuffer = Buffer.from(expected);
-        const signatureBuffer = Buffer.from(signature);
-
+        const expectedBuffer = Buffer.from(expected)
+        const signatureBuffer = Buffer.from(signature)
+        
         if (expectedBuffer.length !== signatureBuffer.length) {
-            return false;
+            return false
         }
+        
+        return crypto.timingSafeEqual(expectedBuffer, signatureBuffer)
 
-        return crypto.timingSafeEqual(expectedBuffer, signatureBuffer);
     }
 }
 ```
@@ -457,7 +445,6 @@ describe('MyIntegration Webhooks', () => {
 ## Best Practices
 
 ### 1. Always Verify Signatures
-
 ```javascript
 async onWebhookReceived({ req, res }) {
     // Verify before queueing
@@ -470,17 +457,14 @@ async onWebhookReceived({ req, res }) {
 ```
 
 ### 2. Respond Quickly
-
 The `WEBHOOK_RECEIVED` handler should complete in < 3 seconds:
-
--   Verify signature
--   Queue message
--   Return 200 OK
+- Verify signature
+- Queue message
+- Return 200 OK
 
 Heavy processing goes in `ON_WEBHOOK`.
 
 ### 3. Handle Idempotency
-
 ```javascript
 async onWebhook({ data }) {
     const { body } = data;
@@ -500,7 +484,6 @@ async onWebhook({ data }) {
 ```
 
 ### 4. Error Handling
-
 ```javascript
 async onWebhook({ data }) {
     try {
@@ -508,7 +491,7 @@ async onWebhook({ data }) {
     } catch (error) {
         // Log error - message will go to DLQ after retries
         console.error('Webhook processing failed:', error);
-
+        
         // Update integration status if needed
         await this.updateIntegrationMessages.execute(
             this.id,
@@ -517,7 +500,7 @@ async onWebhook({ data }) {
             error.message,
             Date.now()
         );
-
+        
         throw error; // Re-throw for retry/DLQ
     }
 }
@@ -530,20 +513,18 @@ async onWebhook({ data }) {
 When `webhooks: true` is set, the Frigg infrastructure automatically creates:
 
 1. **HTTP Lambda Function**
-
-    - Handler: `integration-webhook-routers.js`
-    - No database connection
-    - Fast cold start
+   - Handler: `integration-webhook-routers.js`
+   - No database connection
+   - Fast cold start
 
 2. **Webhook Routes**
+   - `POST /api/{name}-integration/webhooks`
+   - `POST /api/{name}-integration/webhooks/:integrationId`
 
-    - `POST /api/{name}-integration/webhooks`
-    - `POST /api/{name}-integration/webhooks/:integrationId`
-
-3. **Queue Worker**
-    - Processes from existing integration queue
-    - Handles `ON_WEBHOOK` events
-    - Full database access
+3. **Queue Worker**  
+   - Processes from existing integration queue
+   - Handles `ON_WEBHOOK` events
+   - Full database access
 
 ### Serverless Configuration (Automatic)
 
@@ -551,22 +532,22 @@ The following is generated automatically in `serverless.yml`:
 
 ```yaml
 functions:
-    myintegrationWebhook:
-        handler: node_modules/@friggframework/core/handlers/routers/integration-webhook-routers.handlers.myintegrationWebhook.handler
-        events:
-            - httpApi:
-                  path: /api/myintegration-integration/webhooks
-                  method: POST
-            - httpApi:
-                  path: /api/myintegration-integration/webhooks/{integrationId}
-                  method: POST
-
-    myintegrationQueueWorker:
-        handler: node_modules/@friggframework/core/handlers/workers/integration-defined-workers.handlers.myintegration.queueWorker
-        events:
-            - sqs:
-                  arn: !GetAtt MyintegrationQueue.Arn
-                  batchSize: 1
+  myintegrationWebhook:
+    handler: node_modules/@friggframework/core/handlers/routers/integration-webhook-routers.handlers.myintegrationWebhook.handler
+    events:
+      - httpApi:
+          path: /api/myintegration-integration/webhooks
+          method: POST
+      - httpApi:
+          path: /api/myintegration-integration/webhooks/{integrationId}
+          method: POST
+
+  myintegrationQueueWorker:
+    handler: node_modules/@friggframework/core/handlers/workers/integration-defined-workers.handlers.myintegration.queueWorker
+    events:
+      - sqs:
+          arn: !GetAtt MyintegrationQueue.Arn
+          batchSize: 1
 ```
 
 ## Event Handler Reference
@@ -579,14 +560,13 @@ functions:
 **Must:** Respond to `res` with status code
 
 **Parameters:**
-
--   `req` - Express request object
-    -   `req.body` - Webhook payload
-    -   `req.params.integrationId` - Integration ID (if in URL)
-    -   `req.headers` - HTTP headers
-    -   `req.query` - Query parameters
--   `res` - Express response object
-    -   Call `res.status(code).json(data)` to respond
+- `req` - Express request object
+  - `req.body` - Webhook payload
+  - `req.params.integrationId` - Integration ID (if in URL)
+  - `req.headers` - HTTP headers
+  - `req.query` - Query parameters
+- `res` - Express response object
+  - Call `res.status(code).json(data)` to respond
 
 ### onWebhook({ data, context })
 
@@ -596,13 +576,12 @@ functions:
 **Can:** Use `this.modules`, `this.config`, DB operations
 
 **Parameters:**
-
--   `data` - Queued webhook data
-    -   `data.integrationId` - Integration ID (if provided)
-    -   `data.body` - Original webhook payload
-    -   `data.headers` - Original HTTP headers
-    -   `data.query` - Original query parameters
--   `context` - Lambda context object
+- `data` - Queued webhook data
+  - `data.integrationId` - Integration ID (if provided)
+  - `data.body` - Original webhook payload
+  - `data.headers` - Original HTTP headers
+  - `data.query` - Original query parameters
+- `context` - Lambda context object
 
 ## Queue Helper
 
@@ -629,7 +608,6 @@ Automatically uses the correct SQS queue URL based on integration name.
 **Error:** `Queue URL not found for {NAME}_QUEUE_URL`
 
 **Solution:** Ensure environment variable is set:
-
 ```bash
 export MY_INTEGRATION_QUEUE_URL=https://sqs.us-east-1.amazonaws.com/...
 ```
@@ -637,7 +615,6 @@ export MY_INTEGRATION_QUEUE_URL=https://sqs.us-east-1.amazonaws.com/...
 ### Webhook Not Responding
 
 **Check:**
-
 1. Is `webhooks: true` in Definition?
 2. Is webhook endpoint deployed?
 3. Are you sending POST requests?
@@ -646,7 +623,6 @@ export MY_INTEGRATION_QUEUE_URL=https://sqs.us-east-1.amazonaws.com/...
 ### Worker Not Processing
 
 **Check:**
-
 1. Is SQS queue receiving messages?
 2. Is queue worker Lambda function deployed?
 3. Check CloudWatch logs for worker errors
@@ -662,15 +638,16 @@ export MY_INTEGRATION_QUEUE_URL=https://sqs.us-east-1.amazonaws.com/...
 
 ## Performance
 
--   **HTTP Response:** < 100ms (signature check + queue)
--   **Worker Processing:** Based on your logic
--   **Concurrency:** Controlled by SQS worker `reservedConcurrency: 5`
--   **Burst Handling:** Unlimited HTTP, throttled processing
+- **HTTP Response:** < 100ms (signature check + queue)
+- **Worker Processing:** Based on your logic
+- **Concurrency:** Controlled by SQS worker `reservedConcurrency: 5`
+- **Burst Handling:** Unlimited HTTP, throttled processing
 
 ## Related Files
 
--   `packages/core/integrations/integration-base.js` - Event definitions and default handlers
--   `packages/core/handlers/routers/integration-webhook-routers.js` - HTTP webhook routes
--   `packages/core/handlers/backend-utils.js` - Queue worker with hydration logic
--   `packages/core/handlers/integration-event-dispatcher.js` - Event dispatching
--   `packages/devtools/infrastructure/serverless-template.js` - Automatic infrastructure generation
+- `packages/core/integrations/integration-base.js` - Event definitions and default handlers
+- `packages/core/handlers/routers/integration-webhook-routers.js` - HTTP webhook routes
+- `packages/core/handlers/backend-utils.js` - Queue worker with hydration logic
+- `packages/core/handlers/integration-event-dispatcher.js` - Event dispatching
+- `packages/devtools/infrastructure/serverless-template.js` - Automatic infrastructure generation
+

package/handlers/app-definition-loader.js

@@ -35,4 +35,4 @@ function loadAppDefinition() {
 
 module.exports = {
     loadAppDefinition,
-};
+}; 

package/handlers/app-handler-helpers.js

@@ -3,7 +3,6 @@ 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) => {
@@ -20,8 +19,6 @@ const createApp = (applyMiddleware) => {
         })
     );
 
-    app.use(loadUserManager);
-
     if (applyMiddleware) applyMiddleware(app);
 
     // Handle sending error response and logging server errors to console
@@ -42,18 +39,9 @@ const createApp = (applyMiddleware) => {
     return app;
 };
 
-function createAppHandler(
-    eventName,
-    router,
-    shouldUseDatabase = true,
-    basePath = null
-) {
+function createAppHandler(eventName, router, shouldUseDatabase = true) {
     const app = createApp((app) => {
-        if (basePath) {
-            app.use(basePath, router);
-        } else {
-            app.use(router);
-        }
+        app.use(router);
     });
     return createHandler({
         eventName,

package/handlers/backend-utils.js

@@ -101,6 +101,7 @@ 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,18 +35,16 @@ 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
@@ -55,7 +53,7 @@ async function executePrismaMigration(command, schemaPath) {
         }
 
         console.log(`Running: prisma ${args.join(' ')}`);
-
+        
         // Execute Prisma CLI
         execFile(
             path.resolve('./node_modules/prisma/build/index.js'),
@@ -65,7 +63,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
@@ -77,10 +75,7 @@ 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 {
@@ -97,11 +92,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(', ')}`
         );
     }
 
@@ -111,12 +106,10 @@ 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!');
     }
 }
 
@@ -126,17 +119,14 @@ 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`;
@@ -145,15 +135,13 @@ 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
@@ -161,48 +149,41 @@ 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,
@@ -211,27 +192,26 @@ 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',
@@ -239,8 +219,9 @@ exports.handler = async (event, context) => {
             duration: `${duration}ms`,
             timestamp: new Date().toISOString(),
         };
-
+        
         // Return error (don't throw) so Lambda doesn't retry
         return errorResult;
     }
 };
+