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

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

@@ -0,0 +1,134 @@
+/**
+ * Handler Path Resolver Utility
+ * 
+ * Utility Layer - Hexagonal Architecture
+ * 
+ * Handles Lambda handler path resolution for offline mode compatibility.
+ * In offline mode, handler paths need to be relative to the working directory
+ * rather than absolute paths to node_modules.
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+/**
+ * Find node_modules path for offline mode handler path resolution
+ * 
+ * Searches upward from current directory to locate node_modules directory
+ * using multiple fallback strategies.
+ * 
+ * @returns {string} Path to node_modules directory
+ */
+function findNodeModulesPath() {
+    try {
+        let currentDir = process.cwd();
+        let nodeModulesPath = null;
+
+        // Strategy 1: Search upward through directory tree
+        for (let i = 0; i < 5; i++) {
+            const potentialPath = path.join(currentDir, 'node_modules');
+            if (fs.existsSync(potentialPath)) {
+                nodeModulesPath = potentialPath;
+                console.log(
+                    `Found node_modules at: ${nodeModulesPath} (method 1)`
+                );
+                break;
+            }
+            const parentDir = path.dirname(currentDir);
+            if (parentDir === currentDir) break;
+            currentDir = parentDir;
+        }
+
+        // Strategy 2: Use npm root command
+        if (!nodeModulesPath) {
+            try {
+                const { execSync } = require('node:child_process');
+                const npmRoot = execSync('npm root', {
+                    encoding: 'utf8',
+                }).trim();
+                if (fs.existsSync(npmRoot)) {
+                    nodeModulesPath = npmRoot;
+                    console.log(
+                        `Found node_modules at: ${nodeModulesPath} (method 2)`
+                    );
+                }
+            } catch (npmError) {
+                console.error('Error executing npm root:', npmError);
+            }
+        }
+
+        // Strategy 3: Search from package.json locations
+        if (!nodeModulesPath) {
+            currentDir = process.cwd();
+            for (let i = 0; i < 5; i++) {
+                const packageJsonPath = path.join(currentDir, 'package.json');
+                if (fs.existsSync(packageJsonPath)) {
+                    const potentialNodeModules = path.join(
+                        currentDir,
+                        'node_modules'
+                    );
+                    if (fs.existsSync(potentialNodeModules)) {
+                        nodeModulesPath = potentialNodeModules;
+                        console.log(
+                            `Found node_modules at: ${nodeModulesPath} (method 3)`
+                        );
+                        break;
+                    }
+                }
+                const parentDir = path.dirname(currentDir);
+                if (parentDir === currentDir) break;
+                currentDir = parentDir;
+            }
+        }
+
+        if (nodeModulesPath) {
+            return nodeModulesPath;
+        }
+
+        // Fallback: Assume parent directory
+        console.warn(
+            'Could not find node_modules path, falling back to default'
+        );
+        return path.resolve(process.cwd(), '../node_modules');
+    } catch (error) {
+        console.error('Error finding node_modules path:', error);
+        return path.resolve(process.cwd(), '../node_modules');
+    }
+}
+
+/**
+ * Modify handler paths for offline mode
+ * 
+ * In serverless-offline mode, handler paths need to be relative
+ * to the current working directory rather than using absolute
+ * node_modules paths.
+ * 
+ * @param {Object} functions - Serverless functions configuration
+ * @returns {Object} Functions with modified handler paths
+ */
+function modifyHandlerPaths(functions) {
+    const isOffline = process.argv.includes('offline');
+    console.log('isOffline', isOffline);
+
+    if (!isOffline) {
+        console.log('Not in offline mode, skipping handler path modification');
+        // Return shallow copy to prevent mutations (DDD immutability principle)
+        return { ...functions };
+    }
+
+    // In offline mode, don't modify the handler paths at all
+    // serverless-offline will resolve node_modules paths from the working directory
+    console.log('Offline mode detected - keeping original handler paths for serverless-offline');
+
+    // Return deep copy to prevent mutations (DDD immutability principle)
+    return Object.entries(functions).reduce((acc, [key, value]) => {
+        acc[key] = { ...value };
+        return acc;
+    }, {});
+}
+
+module.exports = {
+    findNodeModulesPath,
+    modifyHandlerPaths,
+};
+

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

@@ -0,0 +1,268 @@
+/**
+ * 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('/some/unusual/directory');
+            
+            const { execSync } = require('node:child_process');
+            // npm root returns a different path
+            execSync.mockReturnValue('/usr/local/lib/node_modules\n');
+
+            // Mock to fail directory searches but succeed for npm root result
+            fs.existsSync = jest.fn().mockImplementation((p) => {
+                // Only succeed for the npm root path (not under /some/unusual/directory)
+                return p === '/usr/local/lib/node_modules';
+            });
+
+            const result = findNodeModulesPath();
+
+            expect(result).toBe('/usr/local/lib/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().mockReturnValue('/project');
+            // Mock fs.existsSync to throw an error
+            fs.existsSync = jest.fn().mockImplementation(() => {
+                throw new Error('fs error');
+            });
+
+            const { execSync } = require('node:child_process');
+            execSync.mockImplementation(() => {
+                throw new Error('npm error');
+            });
+
+            const result = findNodeModulesPath();
+
+            // Should fallback to default path even when search methods fail
+            expect(result).toBe(path.resolve('/project', '../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,138 @@
+/**
+ * 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();
+
+            // console.log is called with 2 args: message + path
+            expect(consoleSpy).toHaveBeenCalledWith(
+                expect.stringContaining('already exists'),
+                expect.any(String)
+            );
+
+            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();
+
+            // console.error is called with 2 args: message + error
+            expect(consoleErrorSpy).toHaveBeenCalledWith(
+                expect.stringContaining('Failed to build'),
+                expect.any(String)
+            );
+
+            consoleErrorSpy.mockRestore();
+        });
+    });
+});
+

package/infrastructure/{env-validator.js → domains/shared/validation/env-validator.js}

@@ -23,7 +23,8 @@ const validateEnvironmentVariables = (AppDefinition) => {
 
     for (const [key, value] of Object.entries(AppDefinition.environment)) {
         if (value === true) {
-            if (process.env[key]) {
+            // Use 'in' operator to check if key exists (undefined = missing, empty string = present)
+            if (key in process.env) {
                 results.valid.push(key);
             } else {
                 results.missing.push(key);