@friggframework/devtools 2.0.0--canary.461.ec909cf.0 → 2.0.0--canary.461.9483dbe.0

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

@@ -0,0 +1,178 @@
+/**
+ * Integration Builder
+ * 
+ * Domain Layer - Hexagonal Architecture
+ * 
+ * Responsible for:
+ * - Creating SQS queues for each integration
+ * - Creating queue worker Lambda functions
+ * - Creating webhook handler functions
+ * - Configuring integration-specific routes and handlers
+ */
+
+const { InfrastructureBuilder, ValidationResult } = require('../shared/base-builder');
+
+class IntegrationBuilder extends InfrastructureBuilder {
+    constructor() {
+        super();
+        this.name = 'IntegrationBuilder';
+    }
+
+    shouldExecute(appDefinition) {
+        return Array.isArray(appDefinition.integrations) && appDefinition.integrations.length > 0;
+    }
+
+    validate(appDefinition) {
+        const result = new ValidationResult();
+
+        if (!appDefinition.integrations) {
+            return result; // Not an error, just no integrations
+        }
+
+        if (!Array.isArray(appDefinition.integrations)) {
+            result.addError('integrations must be an array');
+            return result;
+        }
+
+        // Validate each integration
+        appDefinition.integrations.forEach((integration, index) => {
+            if (!integration?.Definition?.name) {
+                result.addError(`Integration at index ${index} is missing Definition or name`);
+            }
+        });
+
+        return result;
+    }
+
+    /**
+     * Build integration infrastructure
+     */
+    async build(appDefinition, discoveredResources) {
+        console.log(`\n[${this.name}] Configuring integrations...`);
+        console.log(`  Processing ${appDefinition.integrations.length} integrations...`);
+
+        const result = {
+            functions: {},
+            resources: {},
+            environment: {},
+            custom: {},
+        };
+
+        const functionPackageConfig = {
+            exclude: [
+                'node_modules/aws-sdk/**',
+                'node_modules/@aws-sdk/**',
+                'node_modules/@prisma/**',
+                'node_modules/.prisma/**',
+                'node_modules/prisma/**',
+                'node_modules/@friggframework/core/generated/**',
+
+                // Exclude development/test files
+                'coverage/**',
+                'test/**',
+                'src/**',
+                'layers/**',
+                '**/*.test.js',
+                '**/*.spec.js',
+            ],
+        };
+
+        for (const integration of appDefinition.integrations) {
+            const integrationName = integration.Definition.name;
+            const queueReference = `${integrationName.charAt(0).toUpperCase() + integrationName.slice(1)}Queue`;
+            const queueName = `\${self:service}--\${self:provider.stage}-${queueReference}`;
+
+            console.log(`    Adding integration: ${integrationName}`);
+
+            // Create HTTP API handler for integration
+            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
+                package: functionPackageConfig,
+                events: [
+                    {
+                        httpApi: {
+                            path: `/api/${integrationName}-integration/{proxy+}`,
+                            method: 'ANY',
+                        },
+                    },
+                ],
+            };
+
+            // Create SQS Queue for integration
+            result.resources[queueReference] = {
+                Type: 'AWS::SQS::Queue',
+                Properties: {
+                    QueueName: `\${self:custom.${queueReference}}`,
+                    MessageRetentionPeriod: 60,
+                    VisibilityTimeout: 1800,
+                    RedrivePolicy: {
+                        maxReceiveCount: 1,
+                        deadLetterTargetArn: {
+                            'Fn::GetAtt': ['InternalErrorQueue', 'Arn'],
+                        },
+                    },
+                },
+            };
+
+            // Create Queue Worker function
+            const queueWorkerName = `${integrationName}QueueWorker`;
+            result.functions[queueWorkerName] = {
+                handler: `node_modules/@friggframework/core/handlers/workers/integration-defined-workers.handlers.${integrationName}.queueWorker`,
+                skipEsbuild: true,  // Nested exports in node_modules - skip esbuild bundling
+                package: functionPackageConfig,
+                reservedConcurrency: 5,
+                events: [
+                    {
+                        sqs: {
+                            arn: { 'Fn::GetAtt': [queueReference, 'Arn'] },
+                            batchSize: 1,
+                        },
+                    },
+                ],
+                timeout: 900,  // 15 minutes max for queue workers (Lambda maximum)
+            };
+
+            // Add queue URL to environment
+            result.environment[`${integrationName.toUpperCase()}_QUEUE_URL`] = {
+                Ref: queueReference,
+            };
+
+            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`);
+        console.log(`[${this.name}] ✅ Integration configuration completed`);
+
+        return result;
+    }
+}
+
+module.exports = { IntegrationBuilder };
+

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

@@ -0,0 +1,362 @@
+/**
+ * Tests for Integration Builder
+ * 
+ * Tests integration-specific Lambda functions and SQS queues
+ */
+
+const { IntegrationBuilder } = require('./integration-builder');
+const { ValidationResult } = require('../shared/base-builder');
+
+describe('IntegrationBuilder', () => {
+    let integrationBuilder;
+
+    beforeEach(() => {
+        integrationBuilder = new IntegrationBuilder();
+    });
+
+    describe('shouldExecute()', () => {
+        it('should return true when integrations array has items', () => {
+            const appDefinition = {
+                integrations: [
+                    { Definition: { name: 'test' } },
+                ],
+            };
+
+            expect(integrationBuilder.shouldExecute(appDefinition)).toBe(true);
+        });
+
+        it('should return false when integrations array is empty', () => {
+            const appDefinition = {
+                integrations: [],
+            };
+
+            expect(integrationBuilder.shouldExecute(appDefinition)).toBe(false);
+        });
+
+        it('should return false when integrations is not defined', () => {
+            const appDefinition = {};
+
+            expect(integrationBuilder.shouldExecute(appDefinition)).toBe(false);
+        });
+
+        it('should return false when integrations is not an array', () => {
+            const appDefinition = {
+                integrations: { name: 'test' },
+            };
+
+            expect(integrationBuilder.shouldExecute(appDefinition)).toBe(false);
+        });
+    });
+
+    describe('validate()', () => {
+        it('should pass validation for valid integrations', () => {
+            const appDefinition = {
+                integrations: [
+                    { Definition: { name: 'hubspot' } },
+                    { Definition: { name: 'salesforce' } },
+                ],
+            };
+
+            const result = integrationBuilder.validate(appDefinition);
+
+            expect(result).toBeInstanceOf(ValidationResult);
+            expect(result.valid).toBe(true);
+            expect(result.errors).toEqual([]);
+        });
+
+        it('should pass when integrations is undefined', () => {
+            const appDefinition = {};
+
+            const result = integrationBuilder.validate(appDefinition);
+
+            expect(result.valid).toBe(true);
+        });
+
+        it('should error when integrations is not an array', () => {
+            const appDefinition = {
+                integrations: 'invalid',
+            };
+
+            const result = integrationBuilder.validate(appDefinition);
+
+            expect(result.valid).toBe(false);
+            expect(result.errors).toContain('integrations must be an array');
+        });
+
+        it('should error when integration is missing Definition', () => {
+            const appDefinition = {
+                integrations: [
+                    { someOtherField: 'value' },
+                ],
+            };
+
+            const result = integrationBuilder.validate(appDefinition);
+
+            expect(result.valid).toBe(false);
+            expect(result.errors).toContain(
+                'Integration at index 0 is missing Definition or name'
+            );
+        });
+
+        it('should error when integration Definition is missing name', () => {
+            const appDefinition = {
+                integrations: [
+                    { Definition: {} },
+                ],
+            };
+
+            const result = integrationBuilder.validate(appDefinition);
+
+            expect(result.valid).toBe(false);
+            expect(result.errors).toContain(
+                'Integration at index 0 is missing Definition or name'
+            );
+        });
+
+        it('should validate all integrations', () => {
+            const appDefinition = {
+                integrations: [
+                    { Definition: { name: 'valid' } },
+                    { Definition: {} }, // Invalid - no name
+                    { someField: 'value' }, // Invalid - no Definition
+                ],
+            };
+
+            const result = integrationBuilder.validate(appDefinition);
+
+            expect(result.valid).toBe(false);
+            expect(result.errors).toHaveLength(2);
+        });
+    });
+
+    describe('build()', () => {
+        it('should create HTTP handler for integration', async () => {
+            const appDefinition = {
+                integrations: [
+                    { Definition: { name: 'hubspot' } },
+                ],
+            };
+
+            const result = await integrationBuilder.build(appDefinition, {});
+
+            expect(result.functions.hubspot).toBeDefined();
+            expect(result.functions.hubspot.handler).toBe(
+                'node_modules/@friggframework/core/handlers/routers/integration-defined-routers.handlers.hubspot.handler'
+            );
+        });
+
+        it('should configure HTTP API event for integration', async () => {
+            const appDefinition = {
+                integrations: [
+                    { Definition: { name: 'salesforce' } },
+                ],
+            };
+
+            const result = await integrationBuilder.build(appDefinition, {});
+
+            expect(result.functions.salesforce.events).toEqual([
+                {
+                    httpApi: {
+                        path: '/api/salesforce-integration/{proxy+}',
+                        method: 'ANY',
+                    },
+                },
+            ]);
+        });
+
+        it('should create SQS queue for integration', async () => {
+            const appDefinition = {
+                integrations: [
+                    { Definition: { name: 'slack' } },
+                ],
+            };
+
+            const result = await integrationBuilder.build(appDefinition, {});
+
+            expect(result.resources.SlackQueue).toBeDefined();
+            expect(result.resources.SlackQueue.Type).toBe('AWS::SQS::Queue');
+        });
+
+        it('should configure queue with correct retention and visibility timeout', async () => {
+            const appDefinition = {
+                integrations: [
+                    { Definition: { name: 'test' } },
+                ],
+            };
+
+            const result = await integrationBuilder.build(appDefinition, {});
+
+            expect(result.resources.TestQueue.Properties.MessageRetentionPeriod).toBe(60);
+            expect(result.resources.TestQueue.Properties.VisibilityTimeout).toBe(1800);
+        });
+
+        it('should configure redrive policy to internal error queue', async () => {
+            const appDefinition = {
+                integrations: [
+                    { Definition: { name: 'test' } },
+                ],
+            };
+
+            const result = await integrationBuilder.build(appDefinition, {});
+
+            expect(result.resources.TestQueue.Properties.RedrivePolicy).toEqual({
+                maxReceiveCount: 1,
+                deadLetterTargetArn: {
+                    'Fn::GetAtt': ['InternalErrorQueue', 'Arn'],
+                },
+            });
+        });
+
+        it('should create queue worker function', async () => {
+            const appDefinition = {
+                integrations: [
+                    { Definition: { name: 'hubspot' } },
+                ],
+            };
+
+            const result = await integrationBuilder.build(appDefinition, {});
+
+            expect(result.functions.hubspotQueueWorker).toBeDefined();
+        });
+
+        it('should configure queue worker with SQS event', async () => {
+            const appDefinition = {
+                integrations: [
+                    { Definition: { name: 'test' } },
+                ],
+            };
+
+            const result = await integrationBuilder.build(appDefinition, {});
+
+            expect(result.functions.testQueueWorker.events).toEqual([
+                {
+                    sqs: {
+                        arn: { 'Fn::GetAtt': ['TestQueue', 'Arn'] },
+                        batchSize: 1,
+                    },
+                },
+            ]);
+        });
+
+        it('should set queue worker timeout to 600 seconds', async () => {
+            const appDefinition = {
+                integrations: [
+                    { Definition: { name: 'test' } },
+                ],
+            };
+
+            const result = await integrationBuilder.build(appDefinition, {});
+
+            expect(result.functions.testQueueWorker.timeout).toBe(600);
+        });
+
+        it('should set queue worker reserved concurrency', async () => {
+            const appDefinition = {
+                integrations: [
+                    { Definition: { name: 'test' } },
+                ],
+            };
+
+            const result = await integrationBuilder.build(appDefinition, {});
+
+            expect(result.functions.testQueueWorker.reservedConcurrency).toBe(5);
+        });
+
+        it('should add queue URL to environment variables', async () => {
+            const appDefinition = {
+                integrations: [
+                    { Definition: { name: 'slack' } },
+                ],
+            };
+
+            const result = await integrationBuilder.build(appDefinition, {});
+
+            expect(result.environment.SLACK_QUEUE_URL).toEqual({
+                Ref: 'SlackQueue',
+            });
+        });
+
+        it('should add queue name to custom variables', async () => {
+            const appDefinition = {
+                integrations: [
+                    { Definition: { name: 'stripe' } },
+                ],
+            };
+
+            const result = await integrationBuilder.build(appDefinition, {});
+
+            expect(result.custom.StripeQueue).toBe('${self:service}--${self:provider.stage}-StripeQueue');
+        });
+
+        it('should handle multiple integrations', async () => {
+            const appDefinition = {
+                integrations: [
+                    { Definition: { name: 'hubspot' } },
+                    { Definition: { name: 'salesforce' } },
+                    { Definition: { name: 'slack' } },
+                ],
+            };
+
+            const result = await integrationBuilder.build(appDefinition, {});
+
+            // Check functions
+            expect(result.functions.hubspot).toBeDefined();
+            expect(result.functions.salesforce).toBeDefined();
+            expect(result.functions.slack).toBeDefined();
+            expect(result.functions.hubspotQueueWorker).toBeDefined();
+            expect(result.functions.salesforceQueueWorker).toBeDefined();
+            expect(result.functions.slackQueueWorker).toBeDefined();
+
+            // Check queues
+            expect(result.resources.HubspotQueue).toBeDefined();
+            expect(result.resources.SalesforceQueue).toBeDefined();
+            expect(result.resources.SlackQueue).toBeDefined();
+
+            // Check environment vars
+            expect(result.environment.HUBSPOT_QUEUE_URL).toBeDefined();
+            expect(result.environment.SALESFORCE_QUEUE_URL).toBeDefined();
+            expect(result.environment.SLACK_QUEUE_URL).toBeDefined();
+        });
+
+        it('should capitalize integration name for queue reference', async () => {
+            const appDefinition = {
+                integrations: [
+                    { Definition: { name: 'myIntegration' } },
+                ],
+            };
+
+            const result = await integrationBuilder.build(appDefinition, {});
+
+            // Queue name should start with capital letter
+            expect(result.resources.MyIntegrationQueue).toBeDefined();
+        });
+
+        it('should handle integration names with hyphens', async () => {
+            const appDefinition = {
+                integrations: [
+                    { Definition: { name: 'my-integration' } },
+                ],
+            };
+
+            const result = await integrationBuilder.build(appDefinition, {});
+
+            expect(result.functions['my-integration']).toBeDefined();
+            expect(result.functions['my-integrationQueueWorker']).toBeDefined();
+        });
+    });
+
+    describe('getDependencies()', () => {
+        it('should have no dependencies', () => {
+            const deps = integrationBuilder.getDependencies();
+
+            expect(deps).toEqual([]);
+        });
+    });
+
+    describe('getName()', () => {
+        it('should return IntegrationBuilder', () => {
+            expect(integrationBuilder.getName()).toBe('IntegrationBuilder');
+        });
+    });
+});
+

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

@@ -0,0 +1,69 @@
+/**
+ * WebSocket Builder
+ * 
+ * Domain Layer - Hexagonal Architecture
+ * 
+ * Responsible for:
+ * - WebSocket API Gateway configuration
+ * - WebSocket route handlers ($connect, $default, $disconnect)
+ * - WebSocket function definitions
+ */
+
+const { InfrastructureBuilder, ValidationResult } = require('../shared/base-builder');
+
+class WebsocketBuilder extends InfrastructureBuilder {
+    constructor() {
+        super();
+        this.name = 'WebsocketBuilder';
+    }
+
+    shouldExecute(appDefinition) {
+        // Skip WebSocket in local mode (when FRIGG_SKIP_AWS_DISCOVERY is set)
+        // API Gateway WebSocket is an AWS-specific service that should only be created in production
+        if (process.env.FRIGG_SKIP_AWS_DISCOVERY === 'true') {
+            return false;
+        }
+
+        return appDefinition.websockets?.enable === true;
+    }
+
+    validate(appDefinition) {
+        const result = new ValidationResult();
+
+        if (!appDefinition.websockets) {
+            result.addError('WebSocket configuration is missing');
+            return result;
+        }
+
+        return result;
+    }
+
+    /**
+     * Build WebSocket infrastructure
+     */
+    async build(appDefinition, discoveredResources) {
+        console.log(`\n[${this.name}] Configuring WebSocket API Gateway...`);
+
+        const result = {
+            functions: {},
+        };
+
+        // Create default WebSocket handler
+        result.functions.defaultWebsocket = {
+            handler: 'node_modules/@friggframework/core/handlers/routers/websocket.handler',
+            events: [
+                { websocket: { route: '$connect' } },
+                { websocket: { route: '$default' } },
+                { websocket: { route: '$disconnect' } },
+            ],
+        };
+
+        console.log('  ✅ WebSocket functions configured ($connect, $default, $disconnect)');
+        console.log(`[${this.name}] ✅ WebSocket configuration completed`);
+
+        return result;
+    }
+}
+
+module.exports = { WebsocketBuilder };
+