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

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

@@ -0,0 +1,195 @@
+/**
+ * Tests for WebSocket Builder
+ * 
+ * Tests WebSocket API Gateway configuration
+ */
+
+const { WebsocketBuilder } = require('./websocket-builder');
+const { ValidationResult } = require('../shared/base-builder');
+
+describe('WebsocketBuilder', () => {
+    let websocketBuilder;
+
+    beforeEach(() => {
+        websocketBuilder = new WebsocketBuilder();
+        delete process.env.FRIGG_SKIP_AWS_DISCOVERY;
+    });
+
+    afterEach(() => {
+        delete process.env.FRIGG_SKIP_AWS_DISCOVERY;
+    });
+
+    describe('shouldExecute()', () => {
+        it('should return true when websockets are enabled', () => {
+            const appDefinition = {
+                websockets: { enable: true },
+            };
+
+            expect(websocketBuilder.shouldExecute(appDefinition)).toBe(true);
+        });
+
+        it('should return false when websockets are disabled', () => {
+            const appDefinition = {
+                websockets: { enable: false },
+            };
+
+            expect(websocketBuilder.shouldExecute(appDefinition)).toBe(false);
+        });
+
+        it('should return false when websockets are not defined', () => {
+            const appDefinition = {};
+
+            expect(websocketBuilder.shouldExecute(appDefinition)).toBe(false);
+        });
+
+        it('should return false when FRIGG_SKIP_AWS_DISCOVERY is set (local mode)', () => {
+            process.env.FRIGG_SKIP_AWS_DISCOVERY = 'true';
+            const appDefinition = {
+                websockets: { enable: true },
+            };
+
+            expect(websocketBuilder.shouldExecute(appDefinition)).toBe(false);
+        });
+    });
+
+    describe('validate()', () => {
+        it('should pass validation for valid websocket config', () => {
+            const appDefinition = {
+                websockets: {
+                    enable: true,
+                },
+            };
+
+            const result = websocketBuilder.validate(appDefinition);
+
+            expect(result).toBeInstanceOf(ValidationResult);
+            expect(result.valid).toBe(true);
+            expect(result.errors).toEqual([]);
+        });
+
+        it('should error when websocket configuration is missing', () => {
+            const appDefinition = {};
+
+            const result = websocketBuilder.validate(appDefinition);
+
+            expect(result.valid).toBe(false);
+            expect(result.errors).toContain('WebSocket configuration is missing');
+        });
+    });
+
+    describe('build()', () => {
+        it('should create defaultWebsocket function', async () => {
+            const appDefinition = {
+                websockets: {
+                    enable: true,
+                },
+            };
+
+            const result = await websocketBuilder.build(appDefinition, {});
+
+            expect(result.functions.defaultWebsocket).toBeDefined();
+        });
+
+        it('should configure correct handler path', async () => {
+            const appDefinition = {
+                websockets: {
+                    enable: true,
+                },
+            };
+
+            const result = await websocketBuilder.build(appDefinition, {});
+
+            expect(result.functions.defaultWebsocket.handler).toBe(
+                'node_modules/@friggframework/core/handlers/routers/websocket.handler'
+            );
+        });
+
+        it('should configure $connect route', async () => {
+            const appDefinition = {
+                websockets: {
+                    enable: true,
+                },
+            };
+
+            const result = await websocketBuilder.build(appDefinition, {});
+
+            const connectEvent = result.functions.defaultWebsocket.events.find(
+                e => e.websocket?.route === '$connect'
+            );
+
+            expect(connectEvent).toBeDefined();
+        });
+
+        it('should configure $default route', async () => {
+            const appDefinition = {
+                websockets: {
+                    enable: true,
+                },
+            };
+
+            const result = await websocketBuilder.build(appDefinition, {});
+
+            const defaultEvent = result.functions.defaultWebsocket.events.find(
+                e => e.websocket?.route === '$default'
+            );
+
+            expect(defaultEvent).toBeDefined();
+        });
+
+        it('should configure $disconnect route', async () => {
+            const appDefinition = {
+                websockets: {
+                    enable: true,
+                },
+            };
+
+            const result = await websocketBuilder.build(appDefinition, {});
+
+            const disconnectEvent = result.functions.defaultWebsocket.events.find(
+                e => e.websocket?.route === '$disconnect'
+            );
+
+            expect(disconnectEvent).toBeDefined();
+        });
+
+        it('should configure all three WebSocket routes', async () => {
+            const appDefinition = {
+                websockets: {
+                    enable: true,
+                },
+            };
+
+            const result = await websocketBuilder.build(appDefinition, {});
+
+            expect(result.functions.defaultWebsocket.events).toHaveLength(3);
+        });
+
+        it('should not depend on discovered resources', async () => {
+            const appDefinition = {
+                websockets: {
+                    enable: true,
+                },
+            };
+
+            const result1 = await websocketBuilder.build(appDefinition, {});
+            const result2 = await websocketBuilder.build(appDefinition, { vpcId: 'vpc-123' });
+
+            expect(result1.functions).toEqual(result2.functions);
+        });
+    });
+
+    describe('getDependencies()', () => {
+        it('should have no dependencies', () => {
+            const deps = websocketBuilder.getDependencies();
+
+            expect(deps).toEqual([]);
+        });
+    });
+
+    describe('getName()', () => {
+        it('should return WebsocketBuilder', () => {
+            expect(websocketBuilder.getName()).toBe('WebsocketBuilder');
+        });
+    });
+});
+

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

@@ -0,0 +1,257 @@
+/**
+ * Tests for VPC Discovery Service
+ * 
+ * Tests VPC resource discovery with mocked cloud provider
+ */
+
+const { VpcDiscovery } = require('./vpc-discovery');
+
+describe('VpcDiscovery', () => {
+    let mockProvider;
+    let vpcDiscovery;
+
+    beforeEach(() => {
+        mockProvider = {
+            discoverVpc: jest.fn(),
+            getName: jest.fn().mockReturnValue('aws'),
+        };
+        vpcDiscovery = new VpcDiscovery(mockProvider);
+    });
+
+    describe('discover()', () => {
+        it('should delegate to provider and transform results', async () => {
+            const mockProviderResponse = {
+                vpcId: 'vpc-123456',
+                vpcCidr: '172.31.0.0/16',
+                subnets: [
+                    {
+                        SubnetId: 'subnet-private1',
+                        MapPublicIpOnLaunch: false,
+                        AvailabilityZone: 'us-east-1a',
+                    },
+                    {
+                        SubnetId: 'subnet-private2',
+                        MapPublicIpOnLaunch: false,
+                        AvailabilityZone: 'us-east-1b',
+                    },
+                    {
+                        SubnetId: 'subnet-public1',
+                        MapPublicIpOnLaunch: true,
+                        AvailabilityZone: 'us-east-1a',
+                    },
+                ],
+                securityGroups: [
+                    { GroupId: 'sg-default', GroupName: 'default' },
+                    { GroupId: 'sg-custom', GroupName: 'custom' },
+                ],
+                routeTables: [
+                    {
+                        RouteTableId: 'rtb-123',
+                        Associations: [{ Main: true }],
+                    },
+                ],
+                natGateways: [],
+                internetGateways: [
+                    { InternetGatewayId: 'igw-123' },
+                ],
+            };
+
+            mockProvider.discoverVpc.mockResolvedValue(mockProviderResponse);
+
+            const result = await vpcDiscovery.discover({ vpcId: 'vpc-123456' });
+
+            expect(mockProvider.discoverVpc).toHaveBeenCalledWith({ vpcId: 'vpc-123456' });
+            expect(result.defaultVpcId).toBe('vpc-123456');
+            expect(result.vpcCidr).toBe('172.31.0.0/16');
+            expect(result.privateSubnetId1).toBe('subnet-private1');
+            expect(result.privateSubnetId2).toBe('subnet-private2');
+            expect(result.publicSubnetId).toBe('subnet-public1');
+            expect(result.publicSubnetId1).toBe('subnet-public1');
+            expect(result.defaultSecurityGroupId).toBe('sg-default');
+            expect(result.defaultRouteTableId).toBe('rtb-123');
+            expect(result.internetGatewayId).toBe('igw-123');
+        });
+
+        it('should handle VPC with only private subnets', async () => {
+            mockProvider.discoverVpc.mockResolvedValue({
+                vpcId: 'vpc-123',
+                vpcCidr: '10.0.0.0/16',
+                subnets: [
+                    { SubnetId: 'subnet-1', MapPublicIpOnLaunch: false },
+                ],
+                securityGroups: [],
+                routeTables: [],
+                natGateways: [],
+                internetGateways: [],
+            });
+
+            const result = await vpcDiscovery.discover({});
+
+            expect(result.privateSubnetId1).toBe('subnet-1');
+            expect(result.privateSubnetId2).toBeUndefined();
+            expect(result.publicSubnetId).toBeUndefined();
+        });
+
+        it('should handle NAT gateway discovery', async () => {
+            mockProvider.discoverVpc.mockResolvedValue({
+                vpcId: 'vpc-123',
+                vpcCidr: '10.0.0.0/16',
+                subnets: [
+                    { SubnetId: 'subnet-public', MapPublicIpOnLaunch: true },
+                    { SubnetId: 'subnet-private', MapPublicIpOnLaunch: false },
+                ],
+                securityGroups: [],
+                routeTables: [],
+                natGateways: [
+                    {
+                        NatGatewayId: 'nat-123',
+                        State: 'available',
+                        SubnetId: 'subnet-public',
+                        NatGatewayAddresses: [
+                            { AllocationId: 'eipalloc-456' },
+                        ],
+                    },
+                ],
+                internetGateways: [],
+            });
+
+            const result = await vpcDiscovery.discover({});
+
+            expect(result.existingNatGatewayId).toBe('nat-123');
+            expect(result.natGatewayInPrivateSubnet).toBe(false);
+            expect(result.existingElasticIpAllocationId).toBe('eipalloc-456');
+        });
+
+        it('should detect NAT gateway in private subnet (configuration error)', async () => {
+            mockProvider.discoverVpc.mockResolvedValue({
+                vpcId: 'vpc-123',
+                vpcCidr: '10.0.0.0/16',
+                subnets: [
+                    { SubnetId: 'subnet-private', MapPublicIpOnLaunch: false },
+                ],
+                securityGroups: [],
+                routeTables: [],
+                natGateways: [
+                    {
+                        NatGatewayId: 'nat-misplaced',
+                        State: 'available',
+                        SubnetId: 'subnet-private',
+                        NatGatewayAddresses: [],
+                    },
+                ],
+                internetGateways: [],
+            });
+
+            const result = await vpcDiscovery.discover({});
+
+            expect(result.existingNatGatewayId).toBe('nat-misplaced');
+            expect(result.natGatewayInPrivateSubnet).toBe(true);
+        });
+
+        it('should ignore NAT gateways that are not available', async () => {
+            mockProvider.discoverVpc.mockResolvedValue({
+                vpcId: 'vpc-123',
+                vpcCidr: '10.0.0.0/16',
+                subnets: [],
+                securityGroups: [],
+                routeTables: [],
+                natGateways: [
+                    {
+                        NatGatewayId: 'nat-pending',
+                        State: 'pending',
+                        SubnetId: 'subnet-public',
+                    },
+                    {
+                        NatGatewayId: 'nat-failed',
+                        State: 'failed',
+                        SubnetId: 'subnet-public',
+                    },
+                ],
+                internetGateways: [],
+            });
+
+            const result = await vpcDiscovery.discover({});
+
+            expect(result.existingNatGatewayId).toBeUndefined();
+        });
+
+        it('should handle discovery errors gracefully', async () => {
+            mockProvider.discoverVpc.mockRejectedValue(new Error('AWS API Error'));
+
+            const result = await vpcDiscovery.discover({});
+
+            expect(result.defaultVpcId).toBeNull();
+            expect(result.vpcCidr).toBeNull();
+            expect(result.privateSubnetId1).toBeNull();
+        });
+
+        it('should find default route table from main association', async () => {
+            mockProvider.discoverVpc.mockResolvedValue({
+                vpcId: 'vpc-123',
+                vpcCidr: '10.0.0.0/16',
+                subnets: [],
+                securityGroups: [],
+                routeTables: [
+                    {
+                        RouteTableId: 'rtb-custom',
+                        Associations: [{ Main: false }],
+                    },
+                    {
+                        RouteTableId: 'rtb-main',
+                        Associations: [{ Main: true }],
+                    },
+                ],
+                natGateways: [],
+                internetGateways: [],
+            });
+
+            const result = await vpcDiscovery.discover({});
+
+            expect(result.defaultRouteTableId).toBe('rtb-main');
+            expect(result.privateRouteTableId).toBe('rtb-main');
+        });
+
+        it('should handle multiple public subnets', async () => {
+            mockProvider.discoverVpc.mockResolvedValue({
+                vpcId: 'vpc-123',
+                vpcCidr: '10.0.0.0/16',
+                subnets: [
+                    { SubnetId: 'subnet-public-1', MapPublicIpOnLaunch: true },
+                    { SubnetId: 'subnet-public-2', MapPublicIpOnLaunch: true },
+                ],
+                securityGroups: [],
+                routeTables: [],
+                natGateways: [],
+                internetGateways: [],
+            });
+
+            const result = await vpcDiscovery.discover({});
+
+            expect(result.publicSubnetId).toBe('subnet-public-1');
+            expect(result.publicSubnetId1).toBe('subnet-public-1');
+            expect(result.publicSubnetId2).toBe('subnet-public-2');
+        });
+
+        it('should pass config to provider', async () => {
+            mockProvider.discoverVpc.mockResolvedValue({
+                vpcId: 'vpc-custom',
+                subnets: [],
+                securityGroups: [],
+                routeTables: [],
+                natGateways: [],
+                internetGateways: [],
+            });
+
+            const config = {
+                vpcId: 'vpc-custom',
+                serviceName: 'test-service',
+                stage: 'prod',
+            };
+
+            await vpcDiscovery.discover(config);
+
+            expect(mockProvider.discoverVpc).toHaveBeenCalledWith(config);
+        });
+    });
+});
+

package/infrastructure/domains/parameters/ssm-builder.js

@@ -0,0 +1,79 @@
+/**
+ * SSM Parameter Store Builder
+ * 
+ * Domain Layer - Hexagonal Architecture
+ * 
+ * Responsible for:
+ * - Configuring IAM permissions for SSM Parameter Store access
+ * - Setting up SSM parameter references for Lambda functions
+ */
+
+const { InfrastructureBuilder, ValidationResult } = require('../shared/base-builder');
+
+class SsmBuilder extends InfrastructureBuilder {
+    constructor() {
+        super();
+        this.name = 'SsmBuilder';
+    }
+
+    shouldExecute(appDefinition) {
+        // Skip SSM in local mode (when FRIGG_SKIP_AWS_DISCOVERY is set)
+        // SSM Parameter Store is an AWS-specific service that should only be used in production
+        if (process.env.FRIGG_SKIP_AWS_DISCOVERY === 'true') {
+            return false;
+        }
+
+        return appDefinition.ssm?.enable === true;
+    }
+
+    validate(appDefinition) {
+        const result = new ValidationResult();
+
+        if (!appDefinition.ssm) {
+            result.addError('SSM configuration is missing');
+            return result;
+        }
+
+        // Validate parameters if provided
+        if (appDefinition.ssm.parameters) {
+            if (typeof appDefinition.ssm.parameters !== 'object') {
+                result.addError('ssm.parameters must be an object');
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * Build SSM configuration
+     */
+    async build(appDefinition, discoveredResources) {
+        console.log(`\n[${this.name}] Configuring SSM Parameter Store...`);
+
+        const result = {
+            iamStatements: [],
+            environment: {},
+        };
+
+        // Add IAM permissions for SSM Parameter Store
+        result.iamStatements.push({
+            Effect: 'Allow',
+            Action: [
+                'ssm:GetParameter',
+                'ssm:GetParameters',
+                'ssm:GetParametersByPath',
+            ],
+            Resource: {
+                'Fn::Sub': 'arn:aws:ssm:${AWS::Region}:${AWS::AccountId}:parameter/*',
+            },
+        });
+
+        console.log('  ✅ SSM Parameter Store IAM permissions added');
+        console.log(`[${this.name}] ✅ SSM configuration completed`);
+
+        return result;
+    }
+}
+
+module.exports = { SsmBuilder };
+