@friggframework/devtools 2.0.0-next.45 → 2.0.0-next.47

package/infrastructure/domains/shared/validation/env-validator.test.js

@@ -0,0 +1,173 @@
+/**
+ * Tests for Environment Variable Validator
+ * 
+ * Tests validation of required environment variables
+ */
+
+const { validateEnvironmentVariables } = require('./env-validator');
+
+describe('Environment Validator', () => {
+    let originalEnv;
+
+    beforeEach(() => {
+        originalEnv = { ...process.env };
+        // Clear test-related env vars
+        delete process.env.TEST_VAR_1;
+        delete process.env.TEST_VAR_2;
+        delete process.env.NODE_ENV;
+    });
+
+    afterEach(() => {
+        process.env = originalEnv;
+    });
+
+    describe('validateEnvironmentVariables()', () => {
+        it('should return empty results for app definition without environment', () => {
+            const appDefinition = {};
+
+            const result = validateEnvironmentVariables(appDefinition);
+
+            expect(result.valid).toEqual([]);
+            expect(result.missing).toEqual([]);
+            expect(result.warnings).toEqual([]);
+        });
+
+        it('should validate present environment variables', () => {
+            process.env.TEST_VAR_1 = 'value1';
+            process.env.TEST_VAR_2 = 'value2';
+
+            const appDefinition = {
+                environment: {
+                    TEST_VAR_1: true,
+                    TEST_VAR_2: true,
+                },
+            };
+
+            const result = validateEnvironmentVariables(appDefinition);
+
+            expect(result.valid).toEqual(['TEST_VAR_1', 'TEST_VAR_2']);
+            expect(result.missing).toEqual([]);
+        });
+
+        it('should detect missing environment variables', () => {
+            process.env.TEST_VAR_1 = 'value1';
+            // TEST_VAR_2 not set
+
+            const appDefinition = {
+                environment: {
+                    TEST_VAR_1: true,
+                    TEST_VAR_2: true,
+                },
+            };
+
+            const result = validateEnvironmentVariables(appDefinition);
+
+            expect(result.valid).toEqual(['TEST_VAR_1']);
+            expect(result.missing).toEqual(['TEST_VAR_2']);
+        });
+
+        it('should only validate variables with value true', () => {
+            process.env.TEST_VAR_1 = 'value1';
+
+            const appDefinition = {
+                environment: {
+                    TEST_VAR_1: true,
+                    TEST_VAR_2: false,
+                    TEST_VAR_3: 'string-value',
+                },
+            };
+
+            const result = validateEnvironmentVariables(appDefinition);
+
+            expect(result.valid).toEqual(['TEST_VAR_1']);
+            expect(result.missing).toEqual([]);
+        });
+
+        it('should handle NODE_ENV specially with warning', () => {
+            // NODE_ENV not set
+
+            const appDefinition = {
+                environment: {
+                    NODE_ENV: true,
+                },
+            };
+
+            const result = validateEnvironmentVariables(appDefinition);
+
+            expect(result.missing).not.toContain('NODE_ENV');
+            expect(result.warnings).toContain('NODE_ENV not set, defaulting to "production"');
+        });
+
+        it('should not warn about NODE_ENV if it is set', () => {
+            process.env.NODE_ENV = 'development';
+
+            const appDefinition = {
+                environment: {
+                    NODE_ENV: true,
+                },
+            };
+
+            const result = validateEnvironmentVariables(appDefinition);
+
+            expect(result.valid).toContain('NODE_ENV');
+            expect(result.warnings).not.toContain('NODE_ENV not set, defaulting to "production"');
+        });
+
+        it('should warn about missing variables', () => {
+            const appDefinition = {
+                environment: {
+                    MISSING_VAR_1: true,
+                    MISSING_VAR_2: true,
+                },
+            };
+
+            const result = validateEnvironmentVariables(appDefinition);
+
+            expect(result.missing).toEqual(['MISSING_VAR_1', 'MISSING_VAR_2']);
+            expect(result.warnings.length).toBeGreaterThan(0);
+        });
+
+        it('should handle mixed valid and missing variables', () => {
+            process.env.VALID_VAR = 'value';
+
+            const appDefinition = {
+                environment: {
+                    VALID_VAR: true,
+                    MISSING_VAR: true,
+                },
+            };
+
+            const result = validateEnvironmentVariables(appDefinition);
+
+            expect(result.valid).toEqual(['VALID_VAR']);
+            expect(result.missing).toEqual(['MISSING_VAR']);
+        });
+
+        it('should handle empty environment object', () => {
+            const appDefinition = {
+                environment: {},
+            };
+
+            const result = validateEnvironmentVariables(appDefinition);
+
+            expect(result.valid).toEqual([]);
+            expect(result.missing).toEqual([]);
+        });
+
+        it('should handle environment variables with empty string values', () => {
+            process.env.TEST_VAR = '';
+
+            const appDefinition = {
+                environment: {
+                    TEST_VAR: true,
+                },
+            };
+
+            const result = validateEnvironmentVariables(appDefinition);
+
+            // Empty string is still considered "present"
+            expect(result.valid).toContain('TEST_VAR');
+        });
+    });
+});
+

package/infrastructure/esbuild.config.js

@@ -0,0 +1,53 @@
+/**
+ * esbuild Configuration for Frigg Lambda Functions
+ * 
+ * Optimized for AWS Lambda Node.js 22.x runtime with:
+ * - Tree-shaking for minimal bundle size
+ * - AWS SDK v3 externalization (provided by Lambda)
+ * - Prisma client externalization (in Lambda layer)
+ * - Source maps for debugging
+ */
+
+module.exports = {
+    bundle: true,
+    minify: true,
+    sourcemap: true,
+    target: 'node22',              // AWS Lambda Node.js 22.x (latest supported)
+    platform: 'node',
+    format: 'cjs',                 // CommonJS for Lambda
+    mainFields: ['main', 'module'],
+
+    // External packages - not included in bundle
+    external: [
+        // AWS SDK v3 - provided by Lambda runtime
+        '@aws-sdk/*',
+        'aws-sdk',                 // Legacy v2 SDK
+
+        // Prisma - in Lambda layer
+        '@prisma/client',
+        'prisma',
+        '.prisma/*',
+
+        // Native modules
+        'sharp',
+        'canvas',
+        'sqlite3',
+        'pg-native',
+    ],
+
+    // Package manager
+    packager: 'npm',
+
+    // Additional esbuild options
+    keepNames: true,               // Preserve function names for debugging
+    metafile: true,                // Generate build metadata
+
+    // Exclude patterns (for serverless-esbuild plugin)
+    exclude: [
+        'aws-sdk',
+        '@aws-sdk/*',
+        '@prisma/client',
+        'prisma',
+    ],
+};
+

package/infrastructure/infrastructure-composer.js

@@ -0,0 +1,87 @@
+/**
+ * Infrastructure Composer
+ * 
+ * Application Layer - Hexagonal Architecture
+ * 
+ * Orchestrates the composition of serverless infrastructure definitions
+ * using domain builders and shared utilities.
+ */
+
+// Domain Builders
+const { BuilderOrchestrator } = require('./domains/shared/builder-orchestrator');
+const { VpcBuilder } = require('./domains/networking/vpc-builder');
+const { KmsBuilder } = require('./domains/security/kms-builder');
+const { AuroraBuilder } = require('./domains/database/aurora-builder');
+const { MigrationBuilder } = require('./domains/database/migration-builder');
+const { SsmBuilder } = require('./domains/parameters/ssm-builder');
+const { WebsocketBuilder } = require('./domains/integration/websocket-builder');
+const { IntegrationBuilder } = require('./domains/integration/integration-builder');
+
+// Utilities
+const { modifyHandlerPaths } = require('./domains/shared/utilities/handler-path-resolver');
+const { createBaseDefinition } = require('./domains/shared/utilities/base-definition-factory');
+const { ensurePrismaLayerExists } = require('./domains/shared/utilities/prisma-layer-manager');
+
+/**
+ * Compose serverless definition using domain builders
+ * 
+ * This is the main entry point that orchestrates all infrastructure building
+ * using the DDD/Hexagonal architecture pattern.
+ */
+const composeServerlessDefinition = async (AppDefinition) => {
+    console.log('🏗️  Composing serverless definition with domain builders...');
+
+    // Ensure Prisma layer exists (minimal, runtime only)
+    await ensurePrismaLayerExists(AppDefinition.database || {});
+
+    // Create orchestrator with all domain builders
+    const orchestrator = new BuilderOrchestrator([
+        new VpcBuilder(),
+        new KmsBuilder(),
+        new AuroraBuilder(),
+        new MigrationBuilder(), // Add migration infrastructure after Aurora
+        new SsmBuilder(),
+        new WebsocketBuilder(),
+        new IntegrationBuilder(),
+    ]);
+
+    // Build all infrastructure (orchestrator handles validation, dependencies, parallel execution)
+    // Builders automatically skip if shouldExecute() returns false (e.g., local mode)
+    const { merged, discoveredResources, appEnvironmentVars } =
+        await orchestrator.buildAll(AppDefinition);
+
+    // Create base definition with core functions
+    const definition = createBaseDefinition(
+        AppDefinition,
+        appEnvironmentVars,
+        discoveredResources
+    );
+
+    // Merge builder results into definition
+    Object.assign(definition.resources.Resources, merged.resources);
+    definition.provider.iamRoleStatements.push(...merged.iamStatements);
+    Object.assign(definition.provider.environment, merged.environment);
+    Object.assign(definition.functions, merged.functions);
+
+    if (merged.vpcConfig) {
+        definition.provider.vpc = merged.vpcConfig;
+    }
+
+    // Add unique plugins (avoid duplicates)
+    merged.plugins.forEach(plugin => {
+        if (!definition.plugins.includes(plugin)) {
+            definition.plugins.push(plugin);
+        }
+    });
+
+    Object.assign(definition.custom, merged.custom);
+
+    // Modify handler paths for offline mode
+    definition.functions = modifyHandlerPaths(definition.functions);
+
+    console.log('✅ Serverless definition composed successfully');
+    return definition;
+};
+
+module.exports = { composeServerlessDefinition };
+

package/infrastructure/{serverless-template.test.js → infrastructure-composer.test.js}

@@ -1,4 +1,4 @@
-const { composeServerlessDefinition } = require('./serverless-template');
+const { composeServerlessDefinition } = require('./infrastructure-composer');
 
 // Helper to build discovery responses with overridable fields
 const createDiscoveryResponse = (overrides = {}) => ({
@@ -7,36 +7,36 @@ const createDiscoveryResponse = (overrides = {}) => ({
     defaultSecurityGroupId: 'sg-123456',
     privateSubnetId1: 'subnet-123456',
     privateSubnetId2: 'subnet-789012',
-    publicSubnetId: 'subnet-public',
+    publicSubnetId: 'subnet-public', // Keep for backward compat
+    publicSubnetId1: 'subnet-public-1',
+    publicSubnetId2: 'subnet-public-2',
     defaultRouteTableId: 'rtb-123456',
     defaultKmsKeyId:
         'arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012',
     existingNatGatewayId: 'nat-default123',
+    auroraClusterEndpoint: 'test-cluster.cluster-abc123.us-east-1.rds.amazonaws.com',
+    auroraPort: 5432,
+    auroraEngine: 'aurora-postgresql',
     ...overrides,
 });
 
-// Mock AWS Discovery to prevent actual AWS calls
-jest.mock('./aws-discovery', () => {
+// Mock resource discovery to prevent actual AWS calls
+jest.mock('./domains/shared/resource-discovery', () => {
+    const originalModule = jest.requireActual('./domains/shared/resource-discovery');
     return {
-        AWSDiscovery: jest.fn().mockImplementation(() => ({
-            discoverResources: jest
-                .fn()
-                .mockResolvedValue(createDiscoveryResponse()),
-        })),
+        ...originalModule,
+        gatherDiscoveredResources: jest.fn().mockResolvedValue(createDiscoveryResponse()),
     };
 });
 
-const { AWSDiscovery } = require('./aws-discovery');
+const { gatherDiscoveredResources } = require('./domains/shared/resource-discovery');
 
 describe('composeServerlessDefinition', () => {
     let mockIntegration;
 
     beforeEach(() => {
-        AWSDiscovery.mockImplementation(() => ({
-            discoverResources: jest
-                .fn()
-                .mockResolvedValue(createDiscoveryResponse()),
-        }));
+        // Reset the mock to default behavior
+        gatherDiscoveredResources.mockResolvedValue(createDiscoveryResponse());
 
         mockIntegration = {
             Definition: {
@@ -52,7 +52,7 @@ describe('composeServerlessDefinition', () => {
     });
 
     afterEach(() => {
-        jest.restoreAllMocks();
+        jest.clearAllMocks();
         // Restore env
         delete process.env.AWS_REGION;
         delete process.env.FRIGG_SKIP_AWS_DISCOVERY;
@@ -61,7 +61,7 @@ describe('composeServerlessDefinition', () => {
 
     describe('AWS discovery gating', () => {
         it('should skip AWS discovery when no features require it', async () => {
-            AWSDiscovery.mockClear();
+            gatherDiscoveredResources.mockClear();
 
             const appDefinition = {
                 integrations: [],
@@ -72,11 +72,11 @@ describe('composeServerlessDefinition', () => {
 
             await composeServerlessDefinition(appDefinition);
 
-            expect(AWSDiscovery).not.toHaveBeenCalled();
+            expect(gatherDiscoveredResources).not.toHaveBeenCalled();
         });
 
         it('should run AWS discovery when VPC features are enabled', async () => {
-            AWSDiscovery.mockClear();
+            gatherDiscoveredResources.mockClear();
 
             const appDefinition = {
                 integrations: [],
@@ -85,11 +85,11 @@ describe('composeServerlessDefinition', () => {
 
             await composeServerlessDefinition(appDefinition);
 
-            expect(AWSDiscovery).toHaveBeenCalledTimes(1);
+            expect(gatherDiscoveredResources).toHaveBeenCalledTimes(1);
         });
 
         it('should skip AWS discovery when FRIGG_SKIP_AWS_DISCOVERY is set to true', async () => {
-            AWSDiscovery.mockClear();
+            gatherDiscoveredResources.mockClear();
             process.env.FRIGG_SKIP_AWS_DISCOVERY = 'true';
 
             const appDefinition = {
@@ -101,11 +101,11 @@ describe('composeServerlessDefinition', () => {
 
             await composeServerlessDefinition(appDefinition);
 
-            expect(AWSDiscovery).not.toHaveBeenCalled();
+            expect(gatherDiscoveredResources).not.toHaveBeenCalled();
         });
 
         it('should run AWS discovery when FRIGG_SKIP_AWS_DISCOVERY is not set', async () => {
-            AWSDiscovery.mockClear();
+            gatherDiscoveredResources.mockClear();
             delete process.env.FRIGG_SKIP_AWS_DISCOVERY;
 
             const appDefinition = {
@@ -115,7 +115,7 @@ describe('composeServerlessDefinition', () => {
 
             await composeServerlessDefinition(appDefinition);
 
-            expect(AWSDiscovery).toHaveBeenCalledTimes(1);
+            expect(gatherDiscoveredResources).toHaveBeenCalledTimes(1);
         });
 
         it('should skip VPC configuration when FRIGG_SKIP_AWS_DISCOVERY is true', async () => {
@@ -1762,6 +1762,97 @@ describe('composeServerlessDefinition', () => {
         });
     });
 
+    describe('Database Migration Lambda', () => {
+        it('should include dbMigrate function in all deployments', async () => {
+            const appDefinition = {
+                name: 'test-app',
+                integrations: []
+            };
+
+            const result = await composeServerlessDefinition(appDefinition);
+
+            // Check dbMigrate function exists
+            expect(result.functions.dbMigrate).toBeDefined();
+            expect(result.functions.dbMigrate.handler).toBe(
+                'node_modules/@friggframework/core/handlers/workers/db-migration.handler'
+            );
+        });
+
+        it('should configure dbMigrate with correct settings', async () => {
+            const appDefinition = {
+                integrations: []
+            };
+
+            const result = await composeServerlessDefinition(appDefinition);
+
+            const dbMigrate = result.functions.dbMigrate;
+
+            // Check timeout (5 minutes for long migrations)
+            expect(dbMigrate.timeout).toBe(300);
+
+            // Check memory allocation (extra for Prisma CLI)
+            expect(dbMigrate.memorySize).toBe(512);
+
+            // Check description
+            expect(dbMigrate.description).toContain('database migrations');
+            expect(dbMigrate.description).toContain('Prisma');
+        });
+
+        it('should not have HTTP events (manual invocation only)', async () => {
+            const appDefinition = {
+                integrations: []
+            };
+
+            const result = await composeServerlessDefinition(appDefinition);
+
+            const dbMigrate = result.functions.dbMigrate;
+
+            // Should have no events (manually invoked via AWS CLI)
+            expect(dbMigrate.events).toBeUndefined();
+        });
+
+        it('should include dbMigrate even with VPC enabled', async () => {
+            const appDefinition = {
+                vpc: {
+                    enable: true,
+                    management: 'discover'
+                },
+                integrations: []
+            };
+
+            const result = await composeServerlessDefinition(appDefinition);
+
+            // dbMigrate should exist with VPC configuration
+            expect(result.functions.dbMigrate).toBeDefined();
+
+            // Should have same VPC access as other functions
+            expect(result.provider.vpc).toBeDefined();
+        });
+
+        it('should include dbMigrate with database configuration', async () => {
+            const appDefinition = {
+                vpc: {
+                    enable: true,
+                    management: 'discover'
+                },
+                database: {
+                    postgres: {
+                        enable: true,
+                        management: 'discover'
+                    }
+                },
+                integrations: []
+            };
+
+            const result = await composeServerlessDefinition(appDefinition);
+
+            // dbMigrate should exist alongside database configuration
+            expect(result.functions.dbMigrate).toBeDefined();
+            expect(result.provider.environment.DB_TYPE).toBe('postgresql');
+            expect(result.provider.environment.DATABASE_URL).toBeDefined();
+        });
+    });
+
     describe('Edge Cases', () => {
         it('should handle empty app definition', async () => {
             const appDefinition = {};