@friggframework/devtools 2.0.0-next.6 → 2.0.0-next.60

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,159 @@
+/**
+ * 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');
+
+/**
+ * Check if a process is still running
+ * @param {number} pid - Process ID to check
+ * @returns {boolean} True if process is running
+ */
+function isProcessRunning(pid) {
+    try {
+        // Signal 0 checks if process exists without killing it
+        process.kill(pid, 0);
+        return true;
+    } catch (error) {
+        return false;
+    }
+}
+
+/**
+ * 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.
+ *
+ * Domain Concept: Build Completion State & Process Locking
+ * - Uses .build-complete marker file to track successful builds
+ * - Uses .build-lock PID file to prevent concurrent builds
+ * - Waits for active builds to complete before starting new one
+ * - Cleans stale locks and incomplete builds before retry
+ *
+ * @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');
+    const completionMarkerPath = path.join(layerPath, '.build-complete');
+    const lockFilePath = path.join(layerPath, '.build-lock');
+
+    // Check if build is complete (marker exists)
+    if (fs.existsSync(completionMarkerPath)) {
+        console.log('✓ Prisma Lambda Layer already exists at', layerPath);
+        return;
+    }
+
+    // Check for active build process
+    if (fs.existsSync(lockFilePath)) {
+        const lockPid = parseInt(fs.readFileSync(lockFilePath, 'utf-8').trim(), 10);
+
+        if (isProcessRunning(lockPid)) {
+            console.log(`⏳ Another build process (PID ${lockPid}) is active - waiting...`);
+
+            // Wait up to 60 seconds for the other process to complete
+            for (let i = 0; i < 60; i++) {
+                await new Promise(resolve => setTimeout(resolve, 1000));
+
+                // Check if build completed
+                if (fs.existsSync(completionMarkerPath)) {
+                    console.log('✓ Concurrent build completed successfully');
+                    return;
+                }
+
+                // Check if process died
+                if (!isProcessRunning(lockPid)) {
+                    console.log(`⚠ Build process ${lockPid} terminated - cleaning up stale lock`);
+                    fs.rmSync(lockFilePath, { force: true });
+                    break;
+                }
+            }
+
+            // Timeout - check one final time
+            if (fs.existsSync(completionMarkerPath)) {
+                console.log('✓ Concurrent build completed');
+                return;
+            }
+
+            // Still locked after 60s - remove stale lock
+            console.log('⚠ Build timeout - removing stale lock and rebuilding');
+            fs.rmSync(lockFilePath, { force: true });
+        } else {
+            // Stale lock file (process not running)
+            console.log(`⚠ Stale lock file detected (PID ${lockPid} not running) - cleaning up`);
+            fs.rmSync(lockFilePath, { force: true });
+        }
+    }
+
+    // Check if incomplete build exists (directory without marker)
+    if (fs.existsSync(layerPath) && !fs.existsSync(completionMarkerPath)) {
+        console.log('⚠ Incomplete Prisma layer detected - will be cleaned by buildPrismaLayer()');
+    }
+
+    // Build layer
+    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');
+
+    // Create lock file with current process PID
+    try {
+        if (!fs.existsSync(layerPath)) {
+            fs.mkdirSync(layerPath, { recursive: true });
+        }
+        fs.writeFileSync(lockFilePath, process.pid.toString());
+    } catch (error) {
+        console.warn('⚠ Could not create lock file:', error.message);
+    }
+
+    try {
+        // Build layer WITHOUT CLI (runtime only for minimal size)
+        await buildPrismaLayer(databaseConfig);
+
+        // Create completion marker
+        fs.writeFileSync(
+            completionMarkerPath,
+            `Build completed: ${new Date().toISOString()}\nNode: ${process.version}\nPlatform: ${process.platform}\n`
+        );
+
+        console.log('✓ Prisma Lambda Layer built successfully (~10-15MB)\n');
+    } catch (error) {
+        // Clean up partial build on failure
+        if (fs.existsSync(layerPath)) {
+            try {
+                fs.rmSync(layerPath, { recursive: true, force: true });
+            } catch (cleanupError) {
+                console.warn('⚠ Could not clean failed build:', cleanupError.message);
+            }
+        }
+
+        console.error('✗ Failed to build Prisma Lambda Layer:', error.message);
+        console.error('  You may need to run: npm install @friggframework/core\n');
+        throw error;
+    } finally {
+        // Always remove lock file when done (success or failure)
+        if (fs.existsSync(lockFilePath)) {
+            try {
+                fs.rmSync(lockFilePath, { force: true });
+            } catch (error) {
+                console.warn('⚠ Could not remove lock file:', error.message);
+            }
+        }
+    }
+}
+
+module.exports = {
+    ensurePrismaLayerExists,
+};
+