@friggframework/devtools 2.0.0--canary.461.d2e26d0.0 → 2.0.0--canary.461.9667b72.0

package/infrastructure/domains/database/aurora-builder.js

@@ -99,10 +99,23 @@ class AuroraBuilder extends InfrastructureBuilder {
             // Clear granular option to prevent conflicts
             delete appDefinition.database.postgres.management;
 
-            // Set management based on isolation strategy
+            // Set management based on isolation strategy AND existing stack resources
             if (vpcIsolation === 'isolated') {
-                management = 'managed';  // New VPC = new Aurora
-                console.log(`  managementMode='managed' + vpcIsolation='isolated' → creating new Aurora`);
+                // Check if CloudFormation stack already has Aurora (stage-specific)
+                // CloudFormation discovery sets 'auroraClusterId' (string) when found in stack
+                const hasStackAurora = discoveredResources?.auroraClusterId && 
+                                     typeof discoveredResources.auroraClusterId === 'string';
+                
+                if (hasStackAurora) {
+                    // Stack has Aurora - reuse it (standard flow: stack → orphaned → create)
+                    management = 'discover';
+                    appDefinition.database.postgres.autoCreateCredentials = true;
+                    console.log(`  managementMode='managed' + vpcIsolation='isolated' → stack has Aurora, reusing`);
+                } else {
+                    // No stack Aurora - create new isolated Aurora for this stage
+                    management = 'managed';
+                    console.log(`  managementMode='managed' + vpcIsolation='isolated' → no stack Aurora, creating new`);
+                }
             } else {
                 management = 'discover';  // Shared VPC = reuse Aurora
                 appDefinition.database.postgres.autoCreateCredentials = true;

package/infrastructure/domains/database/aurora-builder.test.js

@@ -750,7 +750,52 @@ describe('AuroraBuilder', () => {
     });
 
     describe('Top-Level Management Mode', () => {
-        it('should use managementMode=managed with vpcIsolation=isolated to create new Aurora', async () => {
+        it('should reuse stack Aurora when managementMode=managed + vpcIsolation=isolated AND stack has Aurora', async () => {
+            const appDefinition = {
+                managementMode: 'managed',
+                vpcIsolation: 'isolated',
+                database: {
+                    postgres: {
+                        enable: true,
+                        management: 'managed',  // Should be IGNORED
+                        minCapacity: 0.5,
+                        maxCapacity: 1,
+                    },
+                },
+            };
+
+            // CloudFormation stack has Aurora (from previous deployment of this stage)
+            const discoveredResources = {
+                auroraClusterId: 'stack-cluster-dev',  // CloudFormation discovery sets this
+                auroraClusterEndpoint: 'stack-cluster-dev.us-east-1.rds.amazonaws.com',  // For discover mode
+                auroraClusterPort: 5432,
+                auroraClusterIdentifier: 'stack-cluster-dev',
+                privateSubnetId1: 'subnet-1',
+                privateSubnetId2: 'subnet-2',
+            };
+
+            const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+
+            const result = await auroraBuilder.build(appDefinition, discoveredResources);
+
+            // Should warn about ignored options
+            expect(consoleLogSpy).toHaveBeenCalledWith(
+                expect.stringContaining("managementMode='managed' ignoring")
+            );
+
+            // Should log reusing stack Aurora
+            expect(consoleLogSpy).toHaveBeenCalledWith(
+                expect.stringContaining("stack has Aurora, reusing")
+            );
+
+            // Should REUSE stack Aurora (not create new)
+            expect(result.resources.FriggAuroraCluster).toBeUndefined();
+            expect(result.environment.DATABASE_URL).toBeDefined();
+
+            consoleLogSpy.mockRestore();
+        });
+
+        it('should create new Aurora when managementMode=managed + vpcIsolation=isolated AND stack has NO Aurora', async () => {
             const appDefinition = {
                 managementMode: 'managed',
                 vpcIsolation: 'isolated',
@@ -764,10 +809,11 @@ describe('AuroraBuilder', () => {
                 },
             };
 
+            // No Aurora in CloudFormation stack (fresh deployment)
             const discoveredResources = {
-                auroraClusterEndpoint: 'existing-cluster.us-east-1.rds.amazonaws.com',
                 privateSubnetId1: 'subnet-1',
                 privateSubnetId2: 'subnet-2',
+                // No auroraEndpoint
             };
 
             const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
@@ -779,6 +825,11 @@ describe('AuroraBuilder', () => {
                 expect.stringContaining("managementMode='managed' ignoring")
             );
 
+            // Should log creating new Aurora
+            expect(consoleLogSpy).toHaveBeenCalledWith(
+                expect.stringContaining("no stack Aurora, creating new")
+            );
+
             // Should create new Aurora cluster (isolated mode)
             expect(result.resources.FriggAuroraCluster).toBeDefined();
             expect(result.environment.DATABASE_URL).toBeDefined();

package/infrastructure/domains/integration/integration-builder.js

@@ -126,7 +126,36 @@ class IntegrationBuilder extends InfrastructureBuilder {
 
             console.log(`    Adding integration: ${integrationName}`);
 
-            // Create HTTP API handler for integration
+            // Add webhook handler if enabled (BEFORE catch-all proxy route)
+            // CRITICAL: Webhook routes must be defined before the catch-all {proxy+} route
+            // to ensure proper route matching in AWS API Gateway/HTTP API
+            const webhookConfig = integration.Definition.webhooks;
+            if (webhookConfig && (webhookConfig === true || webhookConfig.enabled === true)) {
+                const webhookFunctionName = `${integrationName}Webhook`;
+
+                result.functions[webhookFunctionName] = {
+                    handler: `node_modules/@friggframework/core/handlers/routers/integration-webhook-routers.handlers.${integrationName}Webhook.handler`,
+                    skipEsbuild: true,  // Nested exports in node_modules - skip esbuild bundling
+                    package: functionPackageConfig,
+                    events: [
+                        {
+                            httpApi: {
+                                path: `/api/${integrationName}-integration/webhooks`,
+                                method: 'POST',
+                            },
+                        },
+                        {
+                            httpApi: {
+                                path: `/api/${integrationName}-integration/webhooks/{integrationId}`,
+                                method: 'POST',
+                            },
+                        },
+                    ],
+                };
+                console.log(`      + Webhook handler enabled`);
+            }
+
+            // Create HTTP API handler for integration (catch-all route AFTER webhooks)
             result.functions[integrationName] = {
                 handler: `node_modules/@friggframework/core/handlers/routers/integration-defined-routers.handlers.${integrationName}.handler`,
                 skipEsbuild: true,  // Nested exports in node_modules - skip esbuild bundling
@@ -181,32 +210,6 @@ class IntegrationBuilder extends InfrastructureBuilder {
             };
 
             result.custom[queueReference] = queueName;
-
-            // Add webhook handler if enabled
-            const webhookConfig = integration.Definition.webhooks;
-            if (webhookConfig && (webhookConfig === true || webhookConfig.enabled === true)) {
-                const webhookFunctionName = `${integrationName}Webhook`;
-
-                result.functions[webhookFunctionName] = {
-                    handler: `node_modules/@friggframework/core/handlers/routers/integration-webhook-routers.handlers.${integrationName}Webhook.handler`,
-                    skipEsbuild: true,  // Nested exports in node_modules - skip esbuild bundling
-                    events: [
-                        {
-                            httpApi: {
-                                path: `/api/${integrationName}-integration/webhooks`,
-                                method: 'POST',
-                            },
-                        },
-                        {
-                            httpApi: {
-                                path: `/api/${integrationName}-integration/webhooks/{integrationId}`,
-                                method: 'POST',
-                            },
-                        },
-                    ],
-                };
-                console.log(`      + Webhook handler enabled`);
-            }
         }
 
         console.log(`  ✅ Configured ${appDefinition.integrations.length} integrations`);

package/infrastructure/domains/integration/integration-builder.test.js

@@ -358,5 +358,236 @@ describe('IntegrationBuilder', () => {
             expect(integrationBuilder.getName()).toBe('IntegrationBuilder');
         });
     });
+
+    describe('Webhook Handler Configuration', () => {
+        it('should create webhook handler when webhooks enabled with boolean true', async () => {
+            const appDefinition = {
+                integrations: [
+                    {
+                        Definition: {
+                            name: 'hubspot',
+                            webhooks: true,
+                        }
+                    },
+                ],
+            };
+
+            const result = await integrationBuilder.build(appDefinition, {});
+
+            expect(result.functions.hubspotWebhook).toBeDefined();
+            expect(result.functions.hubspotWebhook.handler).toBe(
+                'node_modules/@friggframework/core/handlers/routers/integration-webhook-routers.handlers.hubspotWebhook.handler'
+            );
+        });
+
+        it('should create webhook handler when webhooks enabled with object', async () => {
+            const appDefinition = {
+                integrations: [
+                    {
+                        Definition: {
+                            name: 'salesforce',
+                            webhooks: { enabled: true },
+                        }
+                    },
+                ],
+            };
+
+            const result = await integrationBuilder.build(appDefinition, {});
+
+            expect(result.functions.salesforceWebhook).toBeDefined();
+        });
+
+        it('should NOT create webhook handler when webhooks disabled', async () => {
+            const appDefinition = {
+                integrations: [
+                    {
+                        Definition: {
+                            name: 'slack',
+                            webhooks: false,
+                        }
+                    },
+                ],
+            };
+
+            const result = await integrationBuilder.build(appDefinition, {});
+
+            expect(result.functions.slackWebhook).toBeUndefined();
+        });
+
+        it('should NOT create webhook handler when webhooks explicitly disabled in object', async () => {
+            const appDefinition = {
+                integrations: [
+                    {
+                        Definition: {
+                            name: 'test',
+                            webhooks: { enabled: false },
+                        }
+                    },
+                ],
+            };
+
+            const result = await integrationBuilder.build(appDefinition, {});
+
+            expect(result.functions.testWebhook).toBeUndefined();
+        });
+
+        it('should configure webhook with both base and ID-specific routes', async () => {
+            const appDefinition = {
+                integrations: [
+                    {
+                        Definition: {
+                            name: 'stripe',
+                            webhooks: true,
+                        }
+                    },
+                ],
+            };
+
+            const result = await integrationBuilder.build(appDefinition, {});
+
+            expect(result.functions.stripeWebhook.events).toEqual([
+                {
+                    httpApi: {
+                        path: '/api/stripe-integration/webhooks',
+                        method: 'POST',
+                    },
+                },
+                {
+                    httpApi: {
+                        path: '/api/stripe-integration/webhooks/{integrationId}',
+                        method: 'POST',
+                    },
+                },
+            ]);
+        });
+
+        it('should define webhook handler BEFORE catch-all proxy route (ordering bug fix)', async () => {
+            const appDefinition = {
+                integrations: [
+                    {
+                        Definition: {
+                            name: 'asana',
+                            webhooks: true,
+                        }
+                    },
+                ],
+            };
+
+            const result = await integrationBuilder.build(appDefinition, {});
+
+            // Get the keys (function names) in the order they were added
+            const functionKeys = Object.keys(result.functions);
+
+            // Webhook handler should be defined before the main integration handler
+            const webhookIndex = functionKeys.indexOf('asanaWebhook');
+            const integrationIndex = functionKeys.indexOf('asana');
+
+            expect(webhookIndex).toBeGreaterThanOrEqual(0);
+            expect(integrationIndex).toBeGreaterThan(0);
+            expect(webhookIndex).toBeLessThan(integrationIndex);
+        });
+
+        it('should maintain correct function order: webhook, integration, queue worker', async () => {
+            const appDefinition = {
+                integrations: [
+                    {
+                        Definition: {
+                            name: 'test',
+                            webhooks: true,
+                        }
+                    },
+                ],
+            };
+
+            const result = await integrationBuilder.build(appDefinition, {});
+
+            const functionKeys = Object.keys(result.functions);
+
+            // Expected order: webhook, integration, queueWorker
+            expect(functionKeys).toEqual([
+                'testWebhook',
+                'test',
+                'testQueueWorker',
+            ]);
+        });
+
+        it('should handle multiple integrations with mixed webhook configurations', async () => {
+            const appDefinition = {
+                integrations: [
+                    {
+                        Definition: {
+                            name: 'hubspot',
+                            webhooks: true,
+                        }
+                    },
+                    {
+                        Definition: {
+                            name: 'salesforce',
+                            webhooks: false,
+                        }
+                    },
+                    {
+                        Definition: {
+                            name: 'slack',
+                            webhooks: { enabled: true },
+                        }
+                    },
+                ],
+            };
+
+            const result = await integrationBuilder.build(appDefinition, {});
+
+            // Hubspot: webhook enabled
+            expect(result.functions.hubspotWebhook).toBeDefined();
+            expect(result.functions.hubspot).toBeDefined();
+            expect(result.functions.hubspotQueueWorker).toBeDefined();
+
+            // Salesforce: webhook disabled
+            expect(result.functions.salesforceWebhook).toBeUndefined();
+            expect(result.functions.salesforce).toBeDefined();
+            expect(result.functions.salesforceQueueWorker).toBeDefined();
+
+            // Slack: webhook enabled via object
+            expect(result.functions.slackWebhook).toBeDefined();
+            expect(result.functions.slack).toBeDefined();
+            expect(result.functions.slackQueueWorker).toBeDefined();
+        });
+
+        it('should use skipEsbuild for webhook handlers', async () => {
+            const appDefinition = {
+                integrations: [
+                    {
+                        Definition: {
+                            name: 'test',
+                            webhooks: true,
+                        }
+                    },
+                ],
+            };
+
+            const result = await integrationBuilder.build(appDefinition, {});
+
+            expect(result.functions.testWebhook.skipEsbuild).toBe(true);
+        });
+
+        it('should apply package configuration to webhook handlers', async () => {
+            const appDefinition = {
+                integrations: [
+                    {
+                        Definition: {
+                            name: 'test',
+                            webhooks: true,
+                        }
+                    },
+                ],
+            };
+
+            const result = await integrationBuilder.build(appDefinition, {});
+
+            expect(result.functions.testWebhook.package).toBeDefined();
+            expect(result.functions.testWebhook.package.exclude).toContain('node_modules/aws-sdk/**');
+            expect(result.functions.testWebhook.package.exclude).toContain('node_modules/@prisma/**');
+        });
+    });
 });
 

package/infrastructure/domains/networking/vpc-builder.js

@@ -141,12 +141,24 @@ class VpcBuilder extends InfrastructureBuilder {
             if (appDefinition.vpc.natGateway) delete appDefinition.vpc.natGateway.management;
             delete appDefinition.vpc.shareAcrossStages;
 
-            // Set management based on isolation strategy
+            // Set management based on isolation strategy AND existing stack resources
             if (vpcIsolation === 'isolated') {
-                management = 'create-new';
-                appDefinition.vpc.natGateway = appDefinition.vpc.natGateway || {};
-                appDefinition.vpc.natGateway.management = 'createAndManage';
-                console.log(`  managementMode='managed' + vpcIsolation='isolated' → creating new VPC`);
+                // Check if CloudFormation stack already has a VPC (stage-specific)
+                // CloudFormation discovery sets 'defaultVpcId' (string) when found in stack
+                const hasStackVpc = discoveredResources?.defaultVpcId && typeof discoveredResources.defaultVpcId === 'string';
+                
+                if (hasStackVpc) {
+                    // Stack has VPC - reuse it (standard flow: stack → orphaned → create)
+                    management = 'discover';
+                    appDefinition.vpc.selfHeal = true;
+                    console.log(`  managementMode='managed' + vpcIsolation='isolated' → stack has VPC, reusing`);
+                } else {
+                    // No stack VPC - create new isolated VPC for this stage
+                    management = 'create-new';
+                    appDefinition.vpc.natGateway = appDefinition.vpc.natGateway || {};
+                    appDefinition.vpc.natGateway.management = 'createAndManage';
+                    console.log(`  managementMode='managed' + vpcIsolation='isolated' → no stack VPC, creating new`);
+                }
             } else {
                 management = 'discover';
                 appDefinition.vpc.selfHeal = true;

package/infrastructure/domains/networking/vpc-builder.test.js

@@ -837,7 +837,53 @@ describe('VpcBuilder', () => {
     });
 
     describe('Management Mode (Simplified API)', () => {
-        it('should use managementMode=managed with vpcIsolation=isolated to create new VPC', async () => {
+        it('should reuse stack VPC when managementMode=managed + vpcIsolation=isolated AND stack has VPC', async () => {
+            const appDefinition = {
+                managementMode: 'managed',
+                vpcIsolation: 'isolated',
+                vpc: {
+                    enable: true,
+                    management: 'create-new',  // Should be IGNORED
+                },
+            };
+
+            // CloudFormation stack has VPC (from previous deployment of this stage)
+            const discoveredResources = {
+                defaultVpcId: 'vpc-stack-dev',  // CloudFormation discovery sets this
+                privateSubnetId1: 'subnet-private-1',
+                privateSubnetId2: 'subnet-private-2',
+                publicSubnetId1: 'subnet-public-1',
+                publicSubnetId2: 'subnet-public-2',
+            };
+
+            const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+
+            const result = await vpcBuilder.build(appDefinition, discoveredResources);
+
+            // Should warn about ignored options
+            expect(consoleLogSpy).toHaveBeenCalledWith(
+                expect.stringContaining("managementMode='managed' ignoring")
+            );
+
+            // Should log reusing stack VPC
+            expect(consoleLogSpy).toHaveBeenCalledWith(
+                expect.stringContaining("stack has VPC, reusing")
+            );
+
+            // Should REUSE stack VPC (not create new)
+            expect(result.vpcId).toBe('vpc-stack-dev');
+            expect(result.resources.FriggVPC).toBeUndefined();
+
+            // Should REUSE stack subnets
+            expect(result.vpcConfig.subnetIds).toEqual([
+                'subnet-private-1',
+                'subnet-private-2'
+            ]);
+
+            consoleLogSpy.mockRestore();
+        });
+
+        it('should create new VPC when managementMode=managed + vpcIsolation=isolated AND stack has NO VPC', async () => {
             const appDefinition = {
                 managementMode: 'managed',
                 vpcIsolation: 'isolated',
@@ -847,9 +893,9 @@ describe('VpcBuilder', () => {
                 },
             };
 
+            // No VPC in CloudFormation stack (fresh deployment)
             const discoveredResources = {
-                defaultVpcId: 'vpc-existing',
-                natGatewayId: 'nat-existing',
+                defaultVpcId: 'vpc-default',  // Only default VPC exists (not from stack)
             };
 
             const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
@@ -860,8 +906,10 @@ describe('VpcBuilder', () => {
             expect(consoleLogSpy).toHaveBeenCalledWith(
                 expect.stringContaining("managementMode='managed' ignoring")
             );
+
+            // Should log creating new VPC
             expect(consoleLogSpy).toHaveBeenCalledWith(
-                expect.stringContaining("vpc.management")
+                expect.stringContaining("no stack VPC, creating new")
             );
 
             // Should create new isolated VPC

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@friggframework/devtools",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0--canary.461.d2e26d0.0",
+  "version": "2.0.0--canary.461.9667b72.0",
   "dependencies": {
     "@aws-sdk/client-ec2": "^3.835.0",
     "@aws-sdk/client-kms": "^3.835.0",
@@ -11,8 +11,8 @@
     "@babel/eslint-parser": "^7.18.9",
     "@babel/parser": "^7.25.3",
     "@babel/traverse": "^7.25.3",
-    "@friggframework/schemas": "2.0.0--canary.461.d2e26d0.0",
-    "@friggframework/test": "2.0.0--canary.461.d2e26d0.0",
+    "@friggframework/schemas": "2.0.0--canary.461.9667b72.0",
+    "@friggframework/test": "2.0.0--canary.461.9667b72.0",
     "@hapi/boom": "^10.0.1",
     "@inquirer/prompts": "^5.3.8",
     "axios": "^1.7.2",
@@ -34,8 +34,8 @@
     "serverless-http": "^2.7.0"
   },
   "devDependencies": {
-    "@friggframework/eslint-config": "2.0.0--canary.461.d2e26d0.0",
-    "@friggframework/prettier-config": "2.0.0--canary.461.d2e26d0.0",
+    "@friggframework/eslint-config": "2.0.0--canary.461.9667b72.0",
+    "@friggframework/prettier-config": "2.0.0--canary.461.9667b72.0",
     "aws-sdk-client-mock": "^4.1.0",
     "aws-sdk-client-mock-jest": "^4.1.0",
     "jest": "^30.1.3",
@@ -70,5 +70,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "d2e26d09ccf4457e3bb42559d6f7e400779cdba7"
+  "gitHead": "9667b7204b9faaeb6caf8d1a94841ab365f9b7a3"
 }