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

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

@@ -1,134 +0,0 @@
-/**
- * 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

@@ -1,268 +0,0 @@
-/**
- * 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

@@ -1,159 +0,0 @@
-/**
- * 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,
-};
-