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

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

@@ -16,6 +16,33 @@ jest.mock('../../../scripts/build-prisma-layer', () => ({
 
 const { buildPrismaLayer } = require('../../../scripts/build-prisma-layer');
 
+// Helper to mock fs methods for different scenarios
+const mockFs = {
+    completedBuild: () => {
+        fs.existsSync = jest.fn((path) => {
+            if (path.endsWith('.build-complete')) return true;
+            if (path.endsWith('layers/prisma')) return true;
+            return false;
+        });
+        fs.writeFileSync = jest.fn();
+        fs.rmSync = jest.fn();
+    },
+    incompleteBuild: () => {
+        fs.existsSync = jest.fn((path) => {
+            if (path.endsWith('.build-complete')) return false;
+            if (path.endsWith('layers/prisma')) return true;
+            return false;
+        });
+        fs.writeFileSync = jest.fn();
+        fs.rmSync = jest.fn();
+    },
+    noBuild: () => {
+        fs.existsSync = jest.fn().mockReturnValue(false);
+        fs.writeFileSync = jest.fn();
+        fs.rmSync = jest.fn();
+    },
+};
+
 describe('Prisma Layer Manager', () => {
     let originalCwd;
 
@@ -31,11 +58,15 @@ describe('Prisma Layer Manager', () => {
 
     describe('ensurePrismaLayerExists()', () => {
         it('should skip build if layer already exists', async () => {
-            fs.existsSync = jest.fn().mockReturnValue(true);
+            fs.existsSync = jest.fn((path) => {
+                // Completion marker exists
+                if (path.endsWith('.build-complete')) return true;
+                return false;
+            });
 
             await ensurePrismaLayerExists();
 
-            expect(fs.existsSync).toHaveBeenCalledWith('/project/layers/prisma');
+            expect(fs.existsSync).toHaveBeenCalledWith('/project/layers/prisma/.build-complete');
             expect(buildPrismaLayer).not.toHaveBeenCalled();
         });
 
@@ -79,11 +110,15 @@ describe('Prisma Layer Manager', () => {
 
         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);
+            fs.existsSync = jest.fn((path) => {
+                // Completion marker exists
+                if (path.endsWith('.build-complete')) return true;
+                return false;
+            });
 
             await ensurePrismaLayerExists();
 
-            expect(fs.existsSync).toHaveBeenCalledWith('/custom/project/path/layers/prisma');
+            expect(fs.existsSync).toHaveBeenCalledWith('/custom/project/path/layers/prisma/.build-complete');
         });
 
         it('should log success when layer already exists', async () => {
@@ -133,6 +168,277 @@ describe('Prisma Layer Manager', () => {
 
             consoleErrorSpy.mockRestore();
         });
+
+        describe('Concurrent Build Protection', () => {
+            it('should skip build if completion marker exists (TDD)', async () => {
+                mockFs.completedBuild();
+
+                await ensurePrismaLayerExists();
+
+                expect(fs.existsSync).toHaveBeenCalledWith('/project/layers/prisma/.build-complete');
+                expect(buildPrismaLayer).not.toHaveBeenCalled();
+            });
+
+            it('should wait for active build process to complete (TDD)', async () => {
+                jest.useFakeTimers();
+
+                // Mock active lock file with running process
+                const activePid = 12345;
+                let completionMarkerExists = false;
+                fs.existsSync = jest.fn((path) => {
+                    if (path.endsWith('.build-complete')) return completionMarkerExists;
+                    if (path.endsWith('.build-lock')) return true;
+                    if (path.endsWith('layers/prisma')) return true;
+                    return false;
+                });
+                fs.readFileSync = jest.fn().mockReturnValue(activePid.toString());
+                fs.writeFileSync = jest.fn();
+                fs.rmSync = jest.fn();
+
+                // Mock process.kill to simulate running process, then completion
+                let killCallCount = 0;
+                const originalKill = process.kill;
+                process.kill = jest.fn((pid, signal) => {
+                    killCallCount++;
+                    if (killCallCount >= 3) {
+                        // After 3 seconds, build completes
+                        completionMarkerExists = true;
+                    }
+                    return true; // Process is running
+                });
+
+                const promise = ensurePrismaLayerExists();
+
+                // Fast-forward through the wait loop
+                for (let i = 0; i < 5; i++) {
+                    jest.advanceTimersByTime(1000);
+                    await Promise.resolve();
+                }
+
+                await promise;
+
+                // Should not rebuild (waited for concurrent build)
+                expect(buildPrismaLayer).not.toHaveBeenCalled();
+
+                process.kill = originalKill;
+                jest.useRealTimers();
+            });
+
+            it('should clean stale lock file if process not running (TDD)', async () => {
+                // Mock stale lock file (process not running)
+                fs.existsSync = jest.fn((path) => {
+                    if (path.endsWith('.build-complete')) return false;
+                    if (path.endsWith('.build-lock')) return true;
+                    if (path.endsWith('layers/prisma')) return false;
+                    return false;
+                });
+                fs.readFileSync = jest.fn().mockReturnValue('99999');
+                fs.writeFileSync = jest.fn();
+                fs.mkdirSync = jest.fn();
+                fs.rmSync = jest.fn();
+
+                // Mock process.kill to throw (process not running)
+                const originalKill = process.kill;
+                process.kill = jest.fn(() => {
+                    throw new Error('ESRCH');
+                });
+
+                buildPrismaLayer.mockResolvedValue();
+
+                await ensurePrismaLayerExists();
+
+                // Should remove stale lock
+                expect(fs.rmSync).toHaveBeenCalledWith('/project/layers/prisma/.build-lock', { force: true });
+                // Should proceed with build
+                expect(buildPrismaLayer).toHaveBeenCalled();
+
+                process.kill = originalKill;
+            });
+
+            it('should create and remove lock file during build (TDD)', async () => {
+                // Mock to simulate successful build flow
+                fs.existsSync = jest.fn((path) => {
+                    // Completion marker doesn't exist initially
+                    if (path.endsWith('.build-complete')) return false;
+                    // Lock file exists in finally block (after writeFileSync)
+                    if (path.endsWith('.build-lock')) return true;
+                    // Directory doesn't exist initially
+                    if (path.endsWith('layers/prisma')) return false;
+                    return false;
+                });
+                fs.writeFileSync = jest.fn();
+                fs.mkdirSync = jest.fn();
+                fs.rmSync = jest.fn();
+                buildPrismaLayer.mockResolvedValue();
+
+                await ensurePrismaLayerExists();
+
+                // Should create directory for lock file
+                expect(fs.mkdirSync).toHaveBeenCalledWith('/project/layers/prisma', { recursive: true });
+
+                // Should create lock file with PID
+                expect(fs.writeFileSync).toHaveBeenCalledWith(
+                    '/project/layers/prisma/.build-lock',
+                    expect.any(String)
+                );
+
+                // Should create completion marker
+                expect(fs.writeFileSync).toHaveBeenCalledWith(
+                    '/project/layers/prisma/.build-complete',
+                    expect.any(String)
+                );
+
+                // Should remove lock file in finally block
+                expect(fs.rmSync).toHaveBeenCalledWith(
+                    '/project/layers/prisma/.build-lock',
+                    { force: true }
+                );
+            });
+
+            it('should remove lock file even if build fails (TDD)', async () => {
+                mockFs.noBuild();
+                fs.mkdirSync = jest.fn();
+                buildPrismaLayer.mockRejectedValue(new Error('Build failed'));
+
+                // After failure, directory exists
+                fs.existsSync = jest.fn((path) => {
+                    if (path.endsWith('.build-complete')) return false;
+                    if (path.endsWith('.build-lock')) return true;
+                    if (path.endsWith('layers/prisma')) return true;
+                    return false;
+                });
+
+                await expect(ensurePrismaLayerExists()).rejects.toThrow('Build failed');
+
+                // Should remove lock file in finally block
+                expect(fs.rmSync).toHaveBeenCalledWith(
+                    '/project/layers/prisma/.build-lock',
+                    { force: true }
+                );
+            });
+
+            it('should wait and rebuild if directory exists without completion marker (TDD)', async () => {
+                jest.useFakeTimers();
+                mockFs.incompleteBuild();
+                buildPrismaLayer.mockResolvedValue();
+
+                const promise = ensurePrismaLayerExists();
+
+                // Fast-forward through the wait
+                jest.advanceTimersByTime(1000);
+
+                await promise;
+
+                // Should NOT manually clean (buildPrismaLayer handles this)
+                expect(fs.rmSync).not.toHaveBeenCalled();
+                // Should rebuild
+                expect(buildPrismaLayer).toHaveBeenCalled();
+                // Should create completion marker
+                expect(fs.writeFileSync).toHaveBeenCalledWith(
+                    '/project/layers/prisma/.build-complete',
+                    expect.any(String)
+                );
+
+                jest.useRealTimers();
+            });
+
+            it('should create completion marker after successful build (TDD)', async () => {
+                mockFs.noBuild();
+                buildPrismaLayer.mockResolvedValue();
+
+                await ensurePrismaLayerExists();
+
+                expect(fs.writeFileSync).toHaveBeenCalledWith(
+                    '/project/layers/prisma/.build-complete',
+                    expect.any(String)
+                );
+            });
+
+            it('should clean up partial build on failure (TDD)', async () => {
+                mockFs.noBuild();
+                buildPrismaLayer.mockRejectedValue(new Error('Build failed'));
+
+                // After build attempt fails, directory exists
+                fs.existsSync = jest.fn((path) => {
+                    if (path.endsWith('.build-complete')) return false;
+                    if (path.endsWith('layers/prisma')) return true;
+                    return false;
+                });
+
+                await expect(ensurePrismaLayerExists()).rejects.toThrow('Build failed');
+
+                // Should clean up after failure
+                expect(fs.rmSync).toHaveBeenCalledWith(
+                    '/project/layers/prisma',
+                    { recursive: true, force: true }
+                );
+            });
+
+            it('should wait for potential concurrent build before rebuilding (TDD)', async () => {
+                jest.useFakeTimers();
+                mockFs.incompleteBuild();
+                buildPrismaLayer.mockResolvedValue();
+
+                const promise = ensurePrismaLayerExists();
+
+                // Fast-forward through the wait
+                jest.advanceTimersByTime(1000);
+
+                await promise;
+
+                // Should wait before rebuilding
+                // Should still attempt to build
+                expect(buildPrismaLayer).toHaveBeenCalled();
+
+                jest.useRealTimers();
+            });
+
+            it('should detect when concurrent process completes during wait (TDD)', async () => {
+                jest.useFakeTimers();
+
+                // Simulate lock file existing with completion happening during wait
+                let completionMarkerExists = false;
+                let lockFileExists = true;
+                fs.existsSync = jest.fn((path) => {
+                    if (path.endsWith('.build-complete')) return completionMarkerExists;
+                    if (path.endsWith('.build-lock')) return lockFileExists;
+                    if (path.endsWith('layers/prisma')) return true;
+                    return false;
+                });
+                fs.readFileSync = jest.fn().mockReturnValue('12345');
+                fs.writeFileSync = jest.fn();
+                fs.rmSync = jest.fn();
+
+                // Mock process.kill to simulate active process
+                let killCallCount = 0;
+                const originalKill = process.kill;
+                process.kill = jest.fn((pid, signal) => {
+                    killCallCount++;
+                    if (killCallCount >= 3) {
+                        // After 3 checks, build completes
+                        completionMarkerExists = true;
+                        lockFileExists = false;
+                    }
+                    return true; // Process is running
+                });
+
+                const promise = ensurePrismaLayerExists();
+
+                // Fast-forward through the wait loop
+                for (let i = 0; i < 5; i++) {
+                    jest.advanceTimersByTime(1000);
+                    await Promise.resolve();
+                }
+
+                await promise;
+
+                // Should not rebuild (concurrent process completed)
+                expect(buildPrismaLayer).not.toHaveBeenCalled();
+
+                process.kill = originalKill;
+                jest.useRealTimers();
+            });
+        });
     });
 });
 

package/infrastructure/domains/shared/validation/plugin-validator.js

@@ -0,0 +1,187 @@
+/**
+ * Plugin Validator
+ *
+ * Validation Layer - Hexagonal Architecture
+ *
+ * Validates serverless plugin configuration to detect conflicts and provide
+ * migration guidance for packaging plugins (serverless-esbuild vs serverless-jetpack).
+ */
+
+/**
+ * Detect conflicting packaging plugins in serverless configuration
+ *
+ * @param {Array<string>} plugins - List of serverless plugins
+ * @returns {Object} Validation result with conflict detection
+ */
+function detectConflictingPlugins(plugins = []) {
+    const hasEsbuild = plugins.includes('serverless-esbuild');
+    const hasJetpack = plugins.includes('serverless-jetpack');
+
+    const result = {
+        hasConflict: false,
+        hasEsbuild,
+        hasJetpack,
+        warnings: [],
+        recommendations: [],
+    };
+
+    // Check for explicit conflict - both plugins present
+    if (hasEsbuild && hasJetpack) {
+        result.hasConflict = true;
+        result.warnings.push(
+            'Both serverless-esbuild and serverless-jetpack are configured. ' +
+            'These plugins have overlapping functionality for Lambda packaging.'
+        );
+        result.recommendations.push(
+            'Remove serverless-jetpack from your serverless.yml plugins array.',
+            'The Frigg framework now uses serverless-esbuild as the standard bundling solution.',
+            'See docs/reference/aws-sdk-v3-osls-migration.md for migration guidance.'
+        );
+    }
+
+    // Check for legacy jetpack usage (jetpack without esbuild)
+    if (hasJetpack && !hasEsbuild) {
+        result.warnings.push(
+            'serverless-jetpack is a legacy packaging plugin. ' +
+            'Frigg framework now recommends serverless-esbuild for better performance and compatibility.'
+        );
+        result.recommendations.push(
+            'Consider migrating to serverless-esbuild for improved build times and tree-shaking.',
+            'Update your serverless.yml to use serverless-esbuild instead of serverless-jetpack.',
+            'See docs/reference/aws-sdk-v3-osls-migration.md for migration guidance.'
+        );
+    }
+
+    // Validate esbuild is present (standard for Frigg)
+    if (!hasEsbuild && !hasJetpack) {
+        result.warnings.push(
+            'No packaging plugin detected. Serverless will use default packaging which may be slow.'
+        );
+        result.recommendations.push(
+            'Add serverless-esbuild to your serverless.yml plugins array for optimized Lambda bundling.'
+        );
+    }
+
+    return result;
+}
+
+/**
+ * Validate and clean plugin list by removing conflicts
+ *
+ * Automatically removes serverless-jetpack if serverless-esbuild is present.
+ * This provides automatic migration for users with legacy configurations.
+ *
+ * @param {Array<string>} plugins - List of serverless plugins
+ * @param {Object} options - Validation options
+ * @param {boolean} options.autoFix - Automatically fix conflicts by removing jetpack (default: true)
+ * @param {boolean} options.silent - Suppress console warnings (default: false)
+ * @returns {Object} Result with cleaned plugins and validation info
+ */
+function validateAndCleanPlugins(plugins = [], options = {}) {
+    const { autoFix = true, silent = false } = options;
+    const validation = detectConflictingPlugins(plugins);
+
+    let cleanedPlugins = [...plugins];
+    let modified = false;
+
+    // Auto-fix: Remove jetpack if esbuild is present
+    if (validation.hasConflict && autoFix) {
+        cleanedPlugins = plugins.filter(p => p !== 'serverless-jetpack');
+        modified = true;
+
+        if (!silent) {
+            console.warn('\n⚠️  Plugin Conflict Detected and Auto-Fixed:');
+            console.warn('   Removed serverless-jetpack (using serverless-esbuild instead)');
+            console.warn('   The Frigg framework uses serverless-esbuild as the standard bundling solution.\n');
+        }
+    }
+
+    // Show warnings for other cases
+    if (!silent && validation.warnings.length > 0 && !modified) {
+        console.warn('\n⚠️  Plugin Configuration Warning:');
+        validation.warnings.forEach(warning => {
+            console.warn(`   ${warning}`);
+        });
+
+        if (validation.recommendations.length > 0) {
+            console.warn('\n💡 Recommendations:');
+            validation.recommendations.forEach(rec => {
+                console.warn(`   • ${rec}`);
+            });
+            console.warn('');
+        }
+    }
+
+    return {
+        plugins: cleanedPlugins,
+        modified,
+        validation,
+    };
+}
+
+/**
+ * Check if a serverless definition has proper packaging configuration
+ *
+ * @param {Object} serverlessDefinition - Serverless framework definition
+ * @returns {Object} Validation result
+ */
+function validatePackagingConfiguration(serverlessDefinition) {
+    const plugins = serverlessDefinition?.plugins || [];
+    const custom = serverlessDefinition?.custom || {};
+
+    const result = {
+        valid: true,
+        errors: [],
+        warnings: [],
+    };
+
+    const hasEsbuild = plugins.includes('serverless-esbuild');
+    const hasEsbuildConfig = custom.esbuild !== undefined;
+
+    // If esbuild plugin is present, ensure it's configured
+    if (hasEsbuild && !hasEsbuildConfig) {
+        result.warnings.push(
+            'serverless-esbuild plugin is present but custom.esbuild configuration is missing. ' +
+            'Using default esbuild settings.'
+        );
+    }
+
+    // Check for external dependencies in esbuild config
+    if (hasEsbuildConfig && hasEsbuild) {
+        const external = custom.esbuild.external || [];
+
+        // Validate that AWS SDK and Prisma are externalized
+        const hasAwsSdkExternal = external.some(e =>
+            e === '@aws-sdk/*' || e === 'aws-sdk' || e.startsWith('@aws-sdk/')
+        );
+        const hasPrismaExternal = external.some(e =>
+            e === '@prisma/client' || e === 'prisma' || e.startsWith('.prisma')
+        );
+
+        if (!hasAwsSdkExternal) {
+            result.warnings.push(
+                'AWS SDK is not externalized in esbuild config. ' +
+                'Consider adding "@aws-sdk/*" to external array to reduce bundle size.'
+            );
+        }
+
+        if (!hasPrismaExternal) {
+            result.warnings.push(
+                'Prisma is not externalized in esbuild config. ' +
+                'Consider adding "@prisma/client" to external array since it\'s provided via Lambda Layer.'
+            );
+        }
+    }
+
+    if (result.errors.length > 0) {
+        result.valid = false;
+    }
+
+    return result;
+}
+
+module.exports = {
+    detectConflictingPlugins,
+    validateAndCleanPlugins,
+    validatePackagingConfiguration,
+};