@friggframework/devtools 2.0.0--canary.474.edb48ba.0 → 2.0.0--canary.482.411f36e.0

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,121 @@ 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 clean and rebuild if directory exists without completion marker (TDD)', async () => {
+                mockFs.incompleteBuild();
+                buildPrismaLayer.mockResolvedValue();
+
+                await ensurePrismaLayerExists();
+
+                // Should clean incomplete build
+                expect(fs.rmSync).toHaveBeenCalledWith(
+                    '/project/layers/prisma',
+                    { recursive: true, force: true }
+                );
+                // Should rebuild
+                expect(buildPrismaLayer).toHaveBeenCalled();
+                // Should create completion marker
+                expect(fs.writeFileSync).toHaveBeenCalledWith(
+                    '/project/layers/prisma/.build-complete',
+                    expect.any(String)
+                );
+            });
+
+            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'));
+                fs.existsSync = jest.fn((path) => {
+                    // After build starts, directory exists
+                    if (path.endsWith('layers/prisma')) return true;
+                    return false;
+                });
+
+                await expect(ensurePrismaLayerExists()).rejects.toThrow('Build failed');
+
+                expect(fs.rmSync).toHaveBeenCalledWith(
+                    '/project/layers/prisma',
+                    { recursive: true, force: true }
+                );
+            });
+
+            it('should handle cleanup errors gracefully and attempt rebuild (TDD)', async () => {
+                mockFs.incompleteBuild();
+                fs.rmSync = jest.fn().mockImplementation(() => {
+                    throw new Error('EBUSY: resource busy');
+                });
+                buildPrismaLayer.mockResolvedValue();
+
+                const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
+
+                await ensurePrismaLayerExists();
+
+                // Should log warning about cleanup failure
+                expect(consoleWarnSpy).toHaveBeenCalledWith(
+                    expect.stringContaining('Could not clean'),
+                    expect.any(String)
+                );
+                // Should still attempt to build
+                expect(buildPrismaLayer).toHaveBeenCalled();
+
+                consoleWarnSpy.mockRestore();
+            });
+
+            it('should wait and check for concurrent process completion (TDD)', async () => {
+                jest.useFakeTimers();
+                mockFs.incompleteBuild();
+
+                // First cleanup fails
+                fs.rmSync = jest.fn().mockImplementation(() => {
+                    throw new Error('EBUSY: resource busy');
+                });
+
+                // After 1 second, completion marker appears (concurrent process finished)
+                let callCount = 0;
+                fs.existsSync = jest.fn((path) => {
+                    callCount++;
+                    if (path.endsWith('.build-complete')) {
+                        return callCount > 2; // Appears after setTimeout
+                    }
+                    if (path.endsWith('layers/prisma')) return true;
+                    return false;
+                });
+
+                const promise = ensurePrismaLayerExists();
+
+                // Fast-forward through the wait
+                jest.advanceTimersByTime(1000);
+
+                await promise;
+
+                // Should not rebuild (concurrent process completed)
+                expect(buildPrismaLayer).not.toHaveBeenCalled();
+
+                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,
+};

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

@@ -0,0 +1,323 @@
+/**
+ * Plugin Validator Tests
+ *
+ * Test suite following TDD best practices for plugin conflict detection
+ */
+
+const {
+    detectConflictingPlugins,
+    validateAndCleanPlugins,
+    validatePackagingConfiguration,
+} = require('./plugin-validator');
+
+describe('Plugin Validator', () => {
+    describe('detectConflictingPlugins', () => {
+        it('should detect conflict when both esbuild and jetpack are present', () => {
+            const plugins = ['serverless-esbuild', 'serverless-jetpack'];
+            const result = detectConflictingPlugins(plugins);
+
+            expect(result.hasConflict).toBe(true);
+            expect(result.hasEsbuild).toBe(true);
+            expect(result.hasJetpack).toBe(true);
+            expect(result.warnings).toHaveLength(1);
+            expect(result.warnings[0]).toContain('overlapping functionality');
+            expect(result.recommendations).toHaveLength(3);
+        });
+
+        it('should not detect conflict when only esbuild is present', () => {
+            const plugins = ['serverless-esbuild'];
+            const result = detectConflictingPlugins(plugins);
+
+            expect(result.hasConflict).toBe(false);
+            expect(result.hasEsbuild).toBe(true);
+            expect(result.hasJetpack).toBe(false);
+            expect(result.warnings).toHaveLength(0);
+        });
+
+        it('should warn about legacy jetpack usage', () => {
+            const plugins = ['serverless-jetpack'];
+            const result = detectConflictingPlugins(plugins);
+
+            expect(result.hasConflict).toBe(false);
+            expect(result.hasEsbuild).toBe(false);
+            expect(result.hasJetpack).toBe(true);
+            expect(result.warnings).toHaveLength(1);
+            expect(result.warnings[0]).toContain('legacy packaging plugin');
+            expect(result.recommendations.length).toBeGreaterThan(0);
+        });
+
+        it('should warn when no packaging plugin is present', () => {
+            const plugins = ['serverless-offline'];
+            const result = detectConflictingPlugins(plugins);
+
+            expect(result.hasConflict).toBe(false);
+            expect(result.hasEsbuild).toBe(false);
+            expect(result.hasJetpack).toBe(false);
+            expect(result.warnings).toHaveLength(1);
+            expect(result.warnings[0]).toContain('No packaging plugin detected');
+        });
+
+        it('should handle empty plugin array', () => {
+            const result = detectConflictingPlugins([]);
+
+            expect(result.hasConflict).toBe(false);
+            expect(result.hasEsbuild).toBe(false);
+            expect(result.hasJetpack).toBe(false);
+        });
+
+        it('should handle undefined plugin array', () => {
+            const result = detectConflictingPlugins();
+
+            expect(result.hasConflict).toBe(false);
+            expect(result.hasEsbuild).toBe(false);
+            expect(result.hasJetpack).toBe(false);
+        });
+    });
+
+    describe('validateAndCleanPlugins', () => {
+        it('should auto-fix conflict by removing jetpack when autoFix is true', () => {
+            const plugins = ['serverless-esbuild', 'serverless-jetpack', 'serverless-offline'];
+            const result = validateAndCleanPlugins(plugins, { autoFix: true, silent: true });
+
+            expect(result.modified).toBe(true);
+            expect(result.plugins).toEqual(['serverless-esbuild', 'serverless-offline']);
+            expect(result.plugins).not.toContain('serverless-jetpack');
+            expect(result.validation.hasConflict).toBe(true);
+        });
+
+        it('should not modify plugins when autoFix is false', () => {
+            const plugins = ['serverless-esbuild', 'serverless-jetpack'];
+            const result = validateAndCleanPlugins(plugins, { autoFix: false, silent: true });
+
+            expect(result.modified).toBe(false);
+            expect(result.plugins).toEqual(plugins);
+            expect(result.validation.hasConflict).toBe(true);
+        });
+
+        it('should not modify plugins when no conflict exists', () => {
+            const plugins = ['serverless-esbuild', 'serverless-offline'];
+            const result = validateAndCleanPlugins(plugins, { autoFix: true, silent: true });
+
+            expect(result.modified).toBe(false);
+            expect(result.plugins).toEqual(plugins);
+            expect(result.validation.hasConflict).toBe(false);
+        });
+
+        it('should preserve order of non-conflicting plugins', () => {
+            const plugins = [
+                'serverless-offline',
+                'serverless-esbuild',
+                'serverless-jetpack',
+                '@friggframework/serverless-plugin',
+            ];
+            const result = validateAndCleanPlugins(plugins, { autoFix: true, silent: true });
+
+            expect(result.plugins).toEqual([
+                'serverless-offline',
+                'serverless-esbuild',
+                '@friggframework/serverless-plugin',
+            ]);
+        });
+
+        it('should handle empty plugin array', () => {
+            const result = validateAndCleanPlugins([], { autoFix: true, silent: true });
+
+            expect(result.modified).toBe(false);
+            expect(result.plugins).toEqual([]);
+        });
+
+        it('should use default options when none provided', () => {
+            const plugins = ['serverless-esbuild', 'serverless-jetpack'];
+
+            // Suppress console output for test
+            const originalWarn = console.warn;
+            console.warn = jest.fn();
+
+            const result = validateAndCleanPlugins(plugins);
+
+            expect(result.modified).toBe(true);
+            expect(result.plugins).not.toContain('serverless-jetpack');
+            expect(console.warn).toHaveBeenCalled();
+
+            console.warn = originalWarn;
+        });
+
+        it('should not log warnings when silent is true', () => {
+            const plugins = ['serverless-esbuild', 'serverless-jetpack'];
+            const originalWarn = console.warn;
+            console.warn = jest.fn();
+
+            validateAndCleanPlugins(plugins, { autoFix: true, silent: true });
+
+            expect(console.warn).not.toHaveBeenCalled();
+
+            console.warn = originalWarn;
+        });
+    });
+
+    describe('validatePackagingConfiguration', () => {
+        it('should validate a properly configured esbuild setup', () => {
+            const serverlessDefinition = {
+                plugins: ['serverless-esbuild'],
+                custom: {
+                    esbuild: {
+                        bundle: true,
+                        external: ['@aws-sdk/*', '@prisma/client'],
+                    },
+                },
+            };
+
+            const result = validatePackagingConfiguration(serverlessDefinition);
+
+            expect(result.valid).toBe(true);
+            expect(result.errors).toHaveLength(0);
+            expect(result.warnings).toHaveLength(0);
+        });
+
+        it('should warn when esbuild plugin is present but config is missing', () => {
+            const serverlessDefinition = {
+                plugins: ['serverless-esbuild'],
+                custom: {},
+            };
+
+            const result = validatePackagingConfiguration(serverlessDefinition);
+
+            expect(result.valid).toBe(true);
+            expect(result.warnings).toHaveLength(1);
+            expect(result.warnings[0]).toContain('custom.esbuild configuration is missing');
+        });
+
+        it('should warn when AWS SDK is not externalized', () => {
+            const serverlessDefinition = {
+                plugins: ['serverless-esbuild'],
+                custom: {
+                    esbuild: {
+                        bundle: true,
+                        external: ['@prisma/client'],
+                    },
+                },
+            };
+
+            const result = validatePackagingConfiguration(serverlessDefinition);
+
+            expect(result.valid).toBe(true);
+            expect(result.warnings.some(w => w.includes('AWS SDK'))).toBe(true);
+        });
+
+        it('should warn when Prisma is not externalized', () => {
+            const serverlessDefinition = {
+                plugins: ['serverless-esbuild'],
+                custom: {
+                    esbuild: {
+                        bundle: true,
+                        external: ['@aws-sdk/*'],
+                    },
+                },
+            };
+
+            const result = validatePackagingConfiguration(serverlessDefinition);
+
+            expect(result.valid).toBe(true);
+            expect(result.warnings.some(w => w.includes('Prisma'))).toBe(true);
+        });
+
+        it('should accept aws-sdk as valid AWS SDK externalization', () => {
+            const serverlessDefinition = {
+                plugins: ['serverless-esbuild'],
+                custom: {
+                    esbuild: {
+                        external: ['aws-sdk', '@prisma/client'],
+                    },
+                },
+            };
+
+            const result = validatePackagingConfiguration(serverlessDefinition);
+
+            expect(result.warnings.some(w => w.includes('AWS SDK'))).toBe(false);
+        });
+
+        it('should accept .prisma/* as valid Prisma externalization', () => {
+            const serverlessDefinition = {
+                plugins: ['serverless-esbuild'],
+                custom: {
+                    esbuild: {
+                        external: ['@aws-sdk/*', '.prisma/*'],
+                    },
+                },
+            };
+
+            const result = validatePackagingConfiguration(serverlessDefinition);
+
+            expect(result.warnings.some(w => w.includes('Prisma'))).toBe(false);
+        });
+
+        it('should handle serverless definition without plugins', () => {
+            const serverlessDefinition = {
+                custom: {},
+            };
+
+            const result = validatePackagingConfiguration(serverlessDefinition);
+
+            expect(result.valid).toBe(true);
+        });
+
+        it('should handle empty serverless definition', () => {
+            const result = validatePackagingConfiguration({});
+
+            expect(result.valid).toBe(true);
+        });
+    });
+
+    describe('Integration Tests', () => {
+        it('should handle complete migration scenario from jetpack to esbuild', () => {
+            const plugins = [
+                'serverless-offline',
+                'serverless-jetpack',
+                'serverless-esbuild',
+                '@friggframework/serverless-plugin',
+            ];
+
+            const result = validateAndCleanPlugins(plugins, { autoFix: true, silent: true });
+
+            expect(result.modified).toBe(true);
+            expect(result.plugins).toEqual([
+                'serverless-offline',
+                'serverless-esbuild',
+                '@friggframework/serverless-plugin',
+            ]);
+            expect(result.validation.hasConflict).toBe(true);
+            expect(result.validation.hasEsbuild).toBe(true);
+            expect(result.validation.hasJetpack).toBe(true);
+        });
+
+        it('should provide helpful recommendations for legacy configurations', () => {
+            const plugins = ['serverless-jetpack'];
+            const result = validateAndCleanPlugins(plugins, { autoFix: false, silent: true });
+
+            expect(result.validation.recommendations).toContain(
+                'Consider migrating to serverless-esbuild for improved build times and tree-shaking.'
+            );
+            expect(
+                result.validation.recommendations.some(r => r.includes('migration guidance'))
+            ).toBe(true);
+        });
+
+        it('should work with Frigg standard plugin configuration', () => {
+            const standardPlugins = [
+                'serverless-esbuild',
+                'serverless-offline-sqs',
+                'serverless-offline',
+                '@friggframework/serverless-plugin',
+            ];
+
+            const result = validateAndCleanPlugins(standardPlugins, {
+                autoFix: true,
+                silent: true,
+            });
+
+            expect(result.modified).toBe(false);
+            expect(result.plugins).toEqual(standardPlugins);
+            expect(result.validation.hasConflict).toBe(false);
+        });
+    });
+});