@friggframework/devtools 2.0.0--canary.474.edb48ba.0 → 2.0.0--canary.482.c063a2a.0

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);
+        });
+    });
+});

package/infrastructure/infrastructure-composer.js

@@ -21,6 +21,7 @@ const { IntegrationBuilder } = require('./domains/integration/integration-builde
 const { modifyHandlerPaths } = require('./domains/shared/utilities/handler-path-resolver');
 const { createBaseDefinition } = require('./domains/shared/utilities/base-definition-factory');
 const { ensurePrismaLayerExists } = require('./domains/shared/utilities/prisma-layer-manager');
+const { validateAndCleanPlugins, validatePackagingConfiguration } = require('./domains/shared/validation/plugin-validator');
 
 /**
  * Compose serverless definition using domain builders
@@ -76,6 +77,27 @@ const composeServerlessDefinition = async (AppDefinition) => {
 
     Object.assign(definition.custom, merged.custom);
 
+    // Validate and clean plugins (detect conflicts, auto-fix if needed)
+    const pluginValidation = validateAndCleanPlugins(definition.plugins, {
+        autoFix: true,
+        silent: false,
+    });
+
+    if (pluginValidation.modified) {
+        definition.plugins = pluginValidation.plugins;
+        console.log('   ✓ Plugin configuration auto-fixed');
+    }
+
+    // Validate packaging configuration
+    const packagingValidation = validatePackagingConfiguration(definition);
+    if (!packagingValidation.valid) {
+        console.warn('⚠️  Packaging configuration issues detected:');
+        packagingValidation.errors.forEach(err => console.warn(`   ✗ ${err}`));
+    }
+    if (packagingValidation.warnings.length > 0) {
+        packagingValidation.warnings.forEach(warn => console.warn(`   ℹ ${warn}`));
+    }
+
     // Modify handler paths for offline mode
     definition.functions = modifyHandlerPaths(definition.functions);
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@friggframework/devtools",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0--canary.474.edb48ba.0",
+  "version": "2.0.0--canary.482.c063a2a.0",
   "dependencies": {
     "@aws-sdk/client-ec2": "^3.835.0",
     "@aws-sdk/client-kms": "^3.835.0",
@@ -12,8 +12,8 @@
     "@babel/eslint-parser": "^7.18.9",
     "@babel/parser": "^7.25.3",
     "@babel/traverse": "^7.25.3",
-    "@friggframework/schemas": "2.0.0--canary.474.edb48ba.0",
-    "@friggframework/test": "2.0.0--canary.474.edb48ba.0",
+    "@friggframework/schemas": "2.0.0--canary.482.c063a2a.0",
+    "@friggframework/test": "2.0.0--canary.482.c063a2a.0",
     "@hapi/boom": "^10.0.1",
     "@inquirer/prompts": "^5.3.8",
     "axios": "^1.7.2",
@@ -35,8 +35,8 @@
     "serverless-http": "^2.7.0"
   },
   "devDependencies": {
-    "@friggframework/eslint-config": "2.0.0--canary.474.edb48ba.0",
-    "@friggframework/prettier-config": "2.0.0--canary.474.edb48ba.0",
+    "@friggframework/eslint-config": "2.0.0--canary.482.c063a2a.0",
+    "@friggframework/prettier-config": "2.0.0--canary.482.c063a2a.0",
     "aws-sdk-client-mock": "^4.1.0",
     "aws-sdk-client-mock-jest": "^4.1.0",
     "jest": "^30.1.3",
@@ -68,5 +68,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "edb48ba0a837958952432272ef74cc5506a74756"
+  "gitHead": "c063a2aaaaae0e4eaac6338f6adc250cf46b9103"
 }