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

package/infrastructure/domains/shared/utilities/handler-path-resolver.test.js

@@ -0,0 +1,259 @@
+/**
+ * Tests for Handler Path Resolver Utility
+ * 
+ * Tests offline mode handler path resolution
+ */
+
+const path = require('path');
+const fs = require('fs');
+const { findNodeModulesPath, modifyHandlerPaths } = require('./handler-path-resolver');
+
+// Mock fs and child_process
+jest.mock('fs');
+jest.mock('node:child_process', () => ({
+    execSync: jest.fn(),
+}));
+
+describe('Handler Path Resolver', () => {
+    let originalArgv;
+    let originalCwd;
+
+    beforeEach(() => {
+        originalArgv = process.argv;
+        originalCwd = process.cwd;
+        jest.clearAllMocks();
+    });
+
+    afterEach(() => {
+        process.argv = originalArgv;
+        process.cwd = originalCwd;
+    });
+
+    describe('findNodeModulesPath()', () => {
+        it('should find node_modules in current directory (method 1)', () => {
+            const mockCwd = '/project';
+            process.cwd = jest.fn().mockReturnValue(mockCwd);
+            fs.existsSync = jest.fn().mockImplementation((p) =>
+                p === path.join(mockCwd, 'node_modules')
+            );
+
+            const result = findNodeModulesPath();
+
+            expect(result).toBe(path.join(mockCwd, 'node_modules'));
+        });
+
+        it('should search parent directories if not found in current (method 1)', () => {
+            const mockCwd = '/project/nested/deep';
+            process.cwd = jest.fn().mockReturnValue(mockCwd);
+            fs.existsSync = jest.fn().mockImplementation((p) =>
+                p === '/project/node_modules'
+            );
+
+            const result = findNodeModulesPath();
+
+            expect(result).toBe('/project/node_modules');
+            expect(fs.existsSync).toHaveBeenCalledWith('/project/nested/deep/node_modules');
+            expect(fs.existsSync).toHaveBeenCalledWith('/project/nested/node_modules');
+            expect(fs.existsSync).toHaveBeenCalledWith('/project/node_modules');
+        });
+
+        it('should use npm root if directory search fails (method 2)', () => {
+            process.cwd = jest.fn().mockReturnValue('/project');
+            fs.existsSync = jest.fn().mockReturnValue(false);
+
+            const { execSync } = require('node:child_process');
+            execSync.mockReturnValue('/project/node_modules\n');
+
+            // On second call for npm root, return true
+            fs.existsSync.mockImplementation((p) =>
+                p === '/project/node_modules'
+            );
+
+            const result = findNodeModulesPath();
+
+            expect(result).toBe('/project/node_modules');
+            expect(execSync).toHaveBeenCalledWith('npm root', { encoding: 'utf8' });
+        });
+
+        it('should handle npm root errors gracefully', () => {
+            process.cwd = jest.fn().mockReturnValue('/project');
+            fs.existsSync = jest.fn().mockReturnValue(false);
+
+            const { execSync } = require('node:child_process');
+            execSync.mockImplementation(() => {
+                throw new Error('npm not found');
+            });
+
+            const result = findNodeModulesPath();
+
+            // Should fall back to default
+            expect(result).toBe(path.resolve('/project', '../node_modules'));
+        });
+
+        it('should search from package.json locations (method 3)', () => {
+            process.cwd = jest.fn().mockReturnValue('/project/workspace');
+
+            let callCount = 0;
+            fs.existsSync = jest.fn().mockImplementation((p) => {
+                callCount++;
+                // First 5 calls fail (directory search)
+                if (callCount <= 5) return false;
+                // Package.json search
+                if (p === '/project/package.json') return true;
+                if (p === '/project/node_modules') return true;
+                return false;
+            });
+
+            const { execSync } = require('node:child_process');
+            execSync.mockImplementation(() => {
+                throw new Error('npm root failed');
+            });
+
+            const result = findNodeModulesPath();
+
+            expect(result).toBe('/project/node_modules');
+        });
+
+        it('should fall back to default path if all methods fail', () => {
+            process.cwd = jest.fn().mockReturnValue('/project');
+            fs.existsSync = jest.fn().mockReturnValue(false);
+
+            const { execSync } = require('node:child_process');
+            execSync.mockImplementation(() => {
+                throw new Error('npm root failed');
+            });
+
+            const result = findNodeModulesPath();
+
+            expect(result).toBe(path.resolve('/project', '../node_modules'));
+        });
+
+        it('should handle errors during search', () => {
+            process.cwd = jest.fn().mockImplementation(() => {
+                throw new Error('cwd error');
+            });
+
+            const result = findNodeModulesPath();
+
+            expect(result).toBe(path.resolve(process.cwd(), '../node_modules'));
+        });
+    });
+
+    describe('modifyHandlerPaths()', () => {
+        it('should not modify paths when not in offline mode', () => {
+            process.argv = ['node', 'test'];
+
+            const functions = {
+                auth: {
+                    handler: 'node_modules/@friggframework/core/handlers/routers/auth.handler',
+                },
+            };
+
+            const result = modifyHandlerPaths(functions);
+
+            expect(result.auth.handler).toBe('node_modules/@friggframework/core/handlers/routers/auth.handler');
+        });
+
+        it('should modify handler paths in offline mode', () => {
+            process.argv = ['node', 'test', 'offline'];
+            process.cwd = jest.fn().mockReturnValue('/project');
+            fs.existsSync = jest.fn().mockImplementation((p) =>
+                p === '/project/node_modules'
+            );
+
+            const functions = {
+                auth: {
+                    handler: 'node_modules/@friggframework/core/handlers/routers/auth.handler',
+                },
+            };
+
+            const result = modifyHandlerPaths(functions);
+
+            expect(result.auth.handler).toBe('node_modules/@friggframework/core/handlers/routers/auth.handler');
+        });
+
+        it('should handle functions without handlers', () => {
+            process.argv = ['node', 'test', 'offline'];
+
+            const functions = {
+                noHandler: {
+                    events: [{ http: { path: '/test' } }],
+                },
+            };
+
+            const result = modifyHandlerPaths(functions);
+
+            expect(result.noHandler.handler).toBeUndefined();
+        });
+
+        it('should only modify handlers with node_modules path', () => {
+            process.argv = ['node', 'test', 'offline'];
+            process.cwd = jest.fn().mockReturnValue('/project');
+            fs.existsSync = jest.fn().mockImplementation((p) =>
+                p === '/project/node_modules'
+            );
+
+            const functions = {
+                coreHandler: {
+                    handler: 'node_modules/@friggframework/core/handlers/auth.handler',
+                },
+                customHandler: {
+                    handler: 'src/handlers/custom.handler',
+                },
+            };
+
+            const result = modifyHandlerPaths(functions);
+
+            expect(result.coreHandler.handler).toContain('node_modules');
+            expect(result.customHandler.handler).toBe('src/handlers/custom.handler');
+        });
+
+        it('should not mutate original functions object', () => {
+            process.argv = ['node', 'test', 'offline'];
+            process.cwd = jest.fn().mockReturnValue('/project');
+            fs.existsSync = jest.fn().mockImplementation((p) =>
+                p === '/project/node_modules'
+            );
+
+            const original = {
+                auth: {
+                    handler: 'node_modules/@friggframework/core/handlers/auth.handler',
+                },
+            };
+
+            const result = modifyHandlerPaths(original);
+
+            // Result should be a copy
+            expect(result).not.toBe(original);
+            expect(result.auth).not.toBe(original.auth);
+        });
+
+        it('should handle multiple functions', () => {
+            process.argv = ['node', 'test', 'offline'];
+            process.cwd = jest.fn().mockReturnValue('/project');
+            fs.existsSync = jest.fn().mockImplementation((p) =>
+                p === '/project/node_modules'
+            );
+
+            const functions = {
+                auth: {
+                    handler: 'node_modules/@friggframework/core/handlers/auth.handler',
+                },
+                user: {
+                    handler: 'node_modules/@friggframework/core/handlers/user.handler',
+                },
+                health: {
+                    handler: 'node_modules/@friggframework/core/handlers/health.handler',
+                },
+            };
+
+            const result = modifyHandlerPaths(functions);
+
+            expect(Object.keys(result)).toHaveLength(3);
+            expect(result.auth.handler).toContain('node_modules');
+            expect(result.user.handler).toContain('node_modules');
+            expect(result.health.handler).toContain('node_modules');
+        });
+    });
+});
+

package/infrastructure/domains/shared/utilities/prisma-layer-manager.js

@@ -0,0 +1,55 @@
+/**
+ * Prisma Lambda Layer Manager
+ * 
+ * Utility Layer - Hexagonal Architecture
+ * 
+ * Manages Prisma Lambda Layer for serverless deployments.
+ * Ensures the layer exists and is built before deployment.
+ */
+
+const path = require('path');
+const fs = require('fs');
+const { buildPrismaLayer } = require('../../../scripts/build-prisma-layer');
+
+/**
+ * Ensure Prisma Lambda Layer exists
+ * 
+ * Automatically builds the layer if it doesn't exist.
+ * The layer contains ONLY the Prisma runtime client (minimal, ~10-15MB).
+ * Prisma CLI is bundled separately in the dbMigrate function.
+ * 
+ * @param {Object} databaseConfig - Database configuration from app definition
+ * @returns {Promise<void>}
+ * @throws {Error} If layer build fails
+ */
+async function ensurePrismaLayerExists(databaseConfig = {}) {
+    const projectRoot = process.cwd();
+    const layerPath = path.join(projectRoot, 'layers/prisma');
+
+    // Check if layer already exists
+    if (fs.existsSync(layerPath)) {
+        console.log('✓ Prisma Lambda Layer already exists at', layerPath);
+        return;
+    }
+
+    // Layer doesn't exist - build it automatically
+    console.log('📦 Prisma Lambda Layer not found - building automatically...');
+    console.log('   Building MINIMAL layer (runtime only, NO CLI)');
+    console.log('   CLI is packaged separately in dbMigrate function');
+    console.log('   This may take a minute on first deployment.\n');
+
+    try {
+        // Build layer WITHOUT CLI (runtime only for minimal size)
+        await buildPrismaLayer(databaseConfig);
+        console.log('✓ Prisma Lambda Layer built successfully (~10-15MB)\n');
+    } catch (error) {
+        console.error('✗ Failed to build Prisma Lambda Layer:', error.message);
+        console.error('  You may need to run: npm install @friggframework/core\n');
+        throw error;
+    }
+}
+
+module.exports = {
+    ensurePrismaLayerExists,
+};
+

package/infrastructure/domains/shared/utilities/prisma-layer-manager.test.js

@@ -0,0 +1,134 @@
+/**
+ * Tests for Prisma Layer Manager
+ * 
+ * Tests Prisma Lambda Layer existence checking and building
+ */
+
+const path = require('path');
+const fs = require('fs');
+const { ensurePrismaLayerExists } = require('./prisma-layer-manager');
+
+// Mock fs and buildPrismaLayer
+jest.mock('fs');
+jest.mock('../../../scripts/build-prisma-layer', () => ({
+    buildPrismaLayer: jest.fn(),
+}));
+
+const { buildPrismaLayer } = require('../../../scripts/build-prisma-layer');
+
+describe('Prisma Layer Manager', () => {
+    let originalCwd;
+
+    beforeEach(() => {
+        originalCwd = process.cwd;
+        process.cwd = jest.fn().mockReturnValue('/project');
+        jest.clearAllMocks();
+    });
+
+    afterEach(() => {
+        process.cwd = originalCwd;
+    });
+
+    describe('ensurePrismaLayerExists()', () => {
+        it('should skip build if layer already exists', async () => {
+            fs.existsSync = jest.fn().mockReturnValue(true);
+
+            await ensurePrismaLayerExists();
+
+            expect(fs.existsSync).toHaveBeenCalledWith('/project/layers/prisma');
+            expect(buildPrismaLayer).not.toHaveBeenCalled();
+        });
+
+        it('should build layer if it does not exist', async () => {
+            fs.existsSync = jest.fn().mockReturnValue(false);
+            buildPrismaLayer.mockResolvedValue();
+
+            await ensurePrismaLayerExists();
+
+            expect(buildPrismaLayer).toHaveBeenCalledTimes(1);
+        });
+
+        it('should pass database config to buildPrismaLayer', async () => {
+            fs.existsSync = jest.fn().mockReturnValue(false);
+            buildPrismaLayer.mockResolvedValue();
+
+            const databaseConfig = {
+                postgres: { enable: true },
+            };
+
+            await ensurePrismaLayerExists(databaseConfig);
+
+            expect(buildPrismaLayer).toHaveBeenCalledWith(databaseConfig);
+        });
+
+        it('should handle build errors and rethrow', async () => {
+            fs.existsSync = jest.fn().mockReturnValue(false);
+            buildPrismaLayer.mockRejectedValue(new Error('Build failed'));
+
+            await expect(ensurePrismaLayerExists()).rejects.toThrow('Build failed');
+        });
+
+        it('should default to empty database config', async () => {
+            fs.existsSync = jest.fn().mockReturnValue(false);
+            buildPrismaLayer.mockResolvedValue();
+
+            await ensurePrismaLayerExists();
+
+            expect(buildPrismaLayer).toHaveBeenCalledWith({});
+        });
+
+        it('should use correct layer path relative to project root', async () => {
+            process.cwd = jest.fn().mockReturnValue('/custom/project/path');
+            fs.existsSync = jest.fn().mockReturnValue(true);
+
+            await ensurePrismaLayerExists();
+
+            expect(fs.existsSync).toHaveBeenCalledWith('/custom/project/path/layers/prisma');
+        });
+
+        it('should log success when layer already exists', async () => {
+            fs.existsSync = jest.fn().mockReturnValue(true);
+            const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+
+            await ensurePrismaLayerExists();
+
+            expect(consoleSpy).toHaveBeenCalledWith(
+                expect.stringContaining('already exists')
+            );
+
+            consoleSpy.mockRestore();
+        });
+
+        it('should log build progress when building layer', async () => {
+            fs.existsSync = jest.fn().mockReturnValue(false);
+            buildPrismaLayer.mockResolvedValue();
+            const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+
+            await ensurePrismaLayerExists();
+
+            expect(consoleSpy).toHaveBeenCalledWith(
+                expect.stringContaining('building automatically')
+            );
+            expect(consoleSpy).toHaveBeenCalledWith(
+                expect.stringContaining('built successfully')
+            );
+
+            consoleSpy.mockRestore();
+        });
+
+        it('should log error message on build failure', async () => {
+            fs.existsSync = jest.fn().mockReturnValue(false);
+            buildPrismaLayer.mockRejectedValue(new Error('Build error'));
+            const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+
+            await expect(ensurePrismaLayerExists()).rejects.toThrow();
+
+            expect(consoleErrorSpy).toHaveBeenCalledWith(
+                expect.stringContaining('Failed to build')
+            );
+
+            consoleErrorSpy.mockRestore();
+        });
+    });
+});
+

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',
+    ],
+};
+