@friggframework/serverless-plugin 2.0.0--canary.398.c9e5d61.0 → 2.0.0--canary.398.90b58c8.0

package/index.js

@@ -1,5 +1,4 @@
 const { spawn } = require("child_process");
-const { BuildTimeDiscovery } = require("@friggframework/devtools/infrastructure/build-time-discovery");
 
 /**
  * Frigg Serverless Plugin - Handles AWS discovery and local development setup
@@ -53,7 +52,7 @@ class FriggServerlessPlugin {
       });
 
       const sqs = new AWS.SQS();
-// Find the environment variables that we need to override and create an easy map
+      // Find the environment variables that we need to override and create an easy map
       const environmentMap = {};
       const environment = this.serverless.service.provider.environment;
 
@@ -101,123 +100,20 @@ class FriggServerlessPlugin {
 
   /**
    * Hook that runs before serverless package initialization
-   * Performs AWS resource discovery if needed
+   * AWS discovery is now handled in serverless-template.js
    * @returns {Promise<void>}
    */
   async beforePackageInitialize() {
-    this.serverless.cli.log("Running Frigg AWS discovery...");
-    
-    try {
-      // Check if we need AWS discovery based on the service configuration
-      const service = this.serverless.service;
-      const needsDiscovery = this.checkIfDiscoveryNeeded(service);
-      
-      if (!needsDiscovery) {
-        this.serverless.cli.log("No AWS discovery needed for this configuration");
-        return;
-      }
-
-      // Get region from serverless configuration
-      const region = service.provider?.region || process.env.AWS_REGION || 'us-east-1';
-      
-      // Create mock app definition from serverless service
-      const appDefinition = this.createAppDefinitionFromService(service);
-      
-      // Run AWS discovery
-      const discovery = new BuildTimeDiscovery(region);
-      const resources = await discovery.preBuildHook(appDefinition, region);
-      
-      if (resources) {
-        this.serverless.cli.log("AWS discovery completed successfully");
-        // Environment variables are already set by preBuildHook
-      }
-      
-    } catch (error) {
-      this.serverless.cli.log("AWS discovery failed, continuing with deployment...");
-      console.warn("AWS Discovery Error:", error.message);
-      
-      // Set fallback values to prevent deployment failures
-      const fallbackEnvVars = {
-        AWS_DISCOVERY_VPC_ID: 'vpc-fallback',
-        AWS_DISCOVERY_SECURITY_GROUP_ID: 'sg-fallback',
-        AWS_DISCOVERY_SUBNET_ID_1: 'subnet-fallback-1',
-        AWS_DISCOVERY_SUBNET_ID_2: 'subnet-fallback-2',
-        AWS_DISCOVERY_ROUTE_TABLE_ID: 'rtb-fallback',
-        AWS_DISCOVERY_KMS_KEY_ID: 'arn:aws:kms:*:*:key/*'
-      };
-      
-      Object.assign(process.env, fallbackEnvVars);
-      this.serverless.cli.log("Using fallback values for AWS resources");
-    }
+    // AWS discovery is now handled directly in serverless-template.js
+    // This hook remains for potential future use or other pre-package tasks
+    this.serverless.cli.log("Frigg Serverless Plugin: Pre-package hook");
   }
 
-  /**
-   * Check if AWS discovery is needed based on service configuration
-   * @param {Object} service - Serverless service configuration
-   * @returns {boolean} True if discovery is needed, false otherwise
-   */
-  checkIfDiscoveryNeeded(service) {
-    // Check if VPC configuration is present
-    if (service.provider?.vpc) {
-      return true;
-    }
-    
-    // Check if KMS grants plugin is present
-    if (service.plugins?.includes('serverless-kms-grants')) {
-      return true;
-    }
-    
-    // Check if lambda layers are configured (SSM)
-    if (service.provider?.layers && service.provider.layers.length > 0) {
-      return true;
-    }
-    
-    // Check for AWS discovery environment variable references
-    const serviceString = JSON.stringify(service);
-    if (serviceString.includes('AWS_DISCOVERY_')) {
-      return true;
-    }
-    
-    return false;
-  }
-
-  /**
-   * Create a mock app definition from serverless service configuration
-   * @param {Object} service - Serverless service configuration
-   * @returns {Object} App definition object with vpc, encryption, and ssm configuration
-   */
-  createAppDefinitionFromService(service) {
-    // Create a mock app definition from serverless service configuration
-    const appDefinition = {
-      integrations: [],
-      vpc: {},
-      encryption: {},
-      ssm: {}
-    };
-    
-    // Check for VPC configuration
-    if (service.provider?.vpc) {
-      appDefinition.vpc.enable = true;
-    }
-    
-    // Check for KMS configuration
-    if (service.plugins?.includes('serverless-kms-grants')) {
-      appDefinition.encryption.useDefaultKMSForFieldLevelEncryption = true;
-    }
-    
-    // Check for SSM configuration (lambda layers)
-    if (service.provider?.layers && service.provider.layers.some(layer => 
-      typeof layer === 'string' && layer.includes('AWS-Parameters-and-Secrets-Lambda-Extension'))) {
-      appDefinition.ssm.enable = true;
-    }
-    
-    return appDefinition;
-  }
 
   /**
    * Initialization hook (currently empty)
    */
-  init() {}
+  init() { }
   /**
    * Hook that runs after serverless package
    */

package/index.test.js

@@ -1,23 +1,15 @@
 const FriggServerlessPlugin = require('./index');
-const { BuildTimeDiscovery } = require('@friggframework/devtools/infrastructure/build-time-discovery');
 
 // Mock dependencies
-jest.mock('@friggframework/devtools/infrastructure/build-time-discovery');
 jest.mock('aws-sdk');
 
 describe('FriggServerlessPlugin', () => {
     let plugin;
     let mockServerless;
     let mockOptions;
-    let mockBuildTimeDiscovery;
     const originalEnv = process.env;
 
     beforeEach(() => {
-        // Mock BuildTimeDiscovery
-        mockBuildTimeDiscovery = {
-            preBuildHook: jest.fn()
-        };
-        BuildTimeDiscovery.mockImplementation(() => mockBuildTimeDiscovery);
 
         // Mock serverless object
         mockServerless = {
@@ -44,12 +36,12 @@ describe('FriggServerlessPlugin', () => {
             stage: 'test'
         };
 
-        plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
-
         // Reset environment
         process.env = { ...originalEnv };
 
         jest.clearAllMocks();
+        
+        plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
     });
 
     afterEach(() => {
@@ -74,284 +66,13 @@ describe('FriggServerlessPlugin', () => {
     });
 
     describe('beforePackageInitialize', () => {
-        it('should run AWS discovery when VPC is configured', async () => {
-            mockServerless.service.provider.vpc = '${self:custom.vpc.${self:provider.stage}}';
-            const mockResources = {
-                defaultVpcId: 'vpc-12345678',
-                defaultKmsKeyId: 'arn:aws:kms:us-east-1:123456789012:key/12345678'
-            };
-            mockBuildTimeDiscovery.preBuildHook.mockResolvedValue(mockResources);
-
-            await plugin.beforePackageInitialize();
-
-            expect(mockBuildTimeDiscovery.preBuildHook).toHaveBeenCalledWith(
-                expect.objectContaining({
-                    vpc: { enable: true }
-                }),
-                'us-east-1'
-            );
-            expect(mockServerless.cli.log).toHaveBeenCalledWith('AWS discovery completed successfully');
-        });
-
-        it('should run AWS discovery when KMS grants plugin is present', async () => {
-            mockServerless.service.plugins = ['serverless-kms-grants'];
-            const mockResources = {
-                defaultKmsKeyId: 'arn:aws:kms:us-east-1:123456789012:key/12345678'
-            };
-            mockBuildTimeDiscovery.preBuildHook.mockResolvedValue(mockResources);
-
-            await plugin.beforePackageInitialize();
-
-            expect(mockBuildTimeDiscovery.preBuildHook).toHaveBeenCalledWith(
-                expect.objectContaining({
-                    encryption: { useDefaultKMSForFieldLevelEncryption: true }
-                }),
-                'us-east-1'
-            );
-        });
-
-        it('should run AWS discovery when lambda layers are configured', async () => {
-            mockServerless.service.provider.layers = [
-                'arn:aws:lambda:us-east-1:177933569100:layer:AWS-Parameters-and-Secrets-Lambda-Extension:11'
-            ];
-            const mockResources = {
-                defaultVpcId: 'vpc-12345678'
-            };
-            mockBuildTimeDiscovery.preBuildHook.mockResolvedValue(mockResources);
-
-            await plugin.beforePackageInitialize();
-
-            expect(mockBuildTimeDiscovery.preBuildHook).toHaveBeenCalledWith(
-                expect.objectContaining({
-                    ssm: { enable: true }
-                }),
-                'us-east-1'
-            );
-        });
-
-        it('should run AWS discovery when AWS_DISCOVERY_ environment variables are referenced', async () => {
-            mockServerless.service.custom.vpc = {
-                securityGroupIds: ['${env:AWS_DISCOVERY_SECURITY_GROUP_ID}']
-            };
-            const mockResources = {
-                defaultVpcId: 'vpc-12345678'
-            };
-            mockBuildTimeDiscovery.preBuildHook.mockResolvedValue(mockResources);
-
-            await plugin.beforePackageInitialize();
-
-            expect(mockBuildTimeDiscovery.preBuildHook).toHaveBeenCalled();
-        });
-
-        it('should skip discovery when no AWS discovery features are needed', async () => {
-            await plugin.beforePackageInitialize();
-
-            expect(mockBuildTimeDiscovery.preBuildHook).not.toHaveBeenCalled();
-            expect(mockServerless.cli.log).toHaveBeenCalledWith('No AWS discovery needed for this configuration');
-        });
-
-        it('should use custom region from serverless configuration', async () => {
-            mockServerless.service.provider.region = 'eu-west-1';
-            mockServerless.service.provider.vpc = '${self:custom.vpc}';
-            mockBuildTimeDiscovery.preBuildHook.mockResolvedValue({});
-
-            await plugin.beforePackageInitialize();
-
-            expect(mockBuildTimeDiscovery.preBuildHook).toHaveBeenCalledWith(
-                expect.any(Object),
-                'eu-west-1'
-            );
-        });
-
-        it('should use AWS_REGION environment variable when region not in config', async () => {
-            process.env.AWS_REGION = 'ap-southeast-1';
-            delete mockServerless.service.provider.region;
-            mockServerless.service.provider.vpc = '${self:custom.vpc}';
-            mockBuildTimeDiscovery.preBuildHook.mockResolvedValue({});
-
-            await plugin.beforePackageInitialize();
-
-            expect(mockBuildTimeDiscovery.preBuildHook).toHaveBeenCalledWith(
-                expect.any(Object),
-                'ap-southeast-1'
-            );
-        });
-
-        it('should fall back to us-east-1 when no region specified', async () => {
-            delete mockServerless.service.provider.region;
-            delete process.env.AWS_REGION;
-            mockServerless.service.provider.vpc = '${self:custom.vpc}';
-            mockBuildTimeDiscovery.preBuildHook.mockResolvedValue({});
-
-            await plugin.beforePackageInitialize();
-
-            expect(mockBuildTimeDiscovery.preBuildHook).toHaveBeenCalledWith(
-                expect.any(Object),
-                'us-east-1'
-            );
-        });
-
-        it('should handle discovery failure gracefully with fallback values', async () => {
-            mockServerless.service.provider.vpc = '${self:custom.vpc}';
-            const error = new Error('AWS discovery failed');
-            mockBuildTimeDiscovery.preBuildHook.mockRejectedValue(error);
-
+        it('should log pre-package hook message', async () => {
             await plugin.beforePackageInitialize();
 
-            expect(mockServerless.cli.log).toHaveBeenCalledWith('AWS discovery failed, continuing with deployment...');
-            expect(mockServerless.cli.log).toHaveBeenCalledWith('Using fallback values for AWS resources');
-            
-            // Check that fallback environment variables are set
-            expect(process.env.AWS_DISCOVERY_VPC_ID).toBe('vpc-fallback');
-            expect(process.env.AWS_DISCOVERY_SECURITY_GROUP_ID).toBe('sg-fallback');
-            expect(process.env.AWS_DISCOVERY_SUBNET_ID_1).toBe('subnet-fallback-1');
-            expect(process.env.AWS_DISCOVERY_SUBNET_ID_2).toBe('subnet-fallback-2');
-            expect(process.env.AWS_DISCOVERY_ROUTE_TABLE_ID).toBe('rtb-fallback');
-            expect(process.env.AWS_DISCOVERY_KMS_KEY_ID).toBe('arn:aws:kms:*:*:key/*');
-        });
-
-        it('should not set environment variables when discovery returns null', async () => {
-            mockServerless.service.provider.vpc = '${self:custom.vpc}';
-            mockBuildTimeDiscovery.preBuildHook.mockResolvedValue(null);
-
-            await plugin.beforePackageInitialize();
-
-            expect(process.env.AWS_DISCOVERY_VPC_ID).toBeUndefined();
-        });
-    });
-
-    describe('checkIfDiscoveryNeeded', () => {
-        it('should return true when VPC is configured', () => {
-            const service = {
-                provider: {
-                    vpc: '${self:custom.vpc}'
-                }
-            };
-
-            const result = plugin.checkIfDiscoveryNeeded(service);
-
-            expect(result).toBe(true);
-        });
-
-        it('should return true when serverless-kms-grants plugin is present', () => {
-            const service = {
-                provider: {},
-                plugins: ['serverless-kms-grants']
-            };
-
-            const result = plugin.checkIfDiscoveryNeeded(service);
-
-            expect(result).toBe(true);
-        });
-
-        it('should return true when lambda layers are configured', () => {
-            const service = {
-                provider: {
-                    layers: ['arn:aws:lambda:us-east-1:123:layer:test:1']
-                }
-            };
-
-            const result = plugin.checkIfDiscoveryNeeded(service);
-
-            expect(result).toBe(true);
-        });
-
-        it('should return true when AWS_DISCOVERY_ environment variables are referenced', () => {
-            const service = {
-                provider: {},
-                custom: {
-                    vpc: {
-                        securityGroupIds: ['${env:AWS_DISCOVERY_SECURITY_GROUP_ID}']
-                    }
-                }
-            };
-
-            const result = plugin.checkIfDiscoveryNeeded(service);
-
-            expect(result).toBe(true);
-        });
-
-        it('should return false when no discovery features are present', () => {
-            const service = {
-                provider: {},
-                plugins: ['serverless-offline']
-            };
-
-            const result = plugin.checkIfDiscoveryNeeded(service);
-
-            expect(result).toBe(false);
+            expect(mockServerless.cli.log).toHaveBeenCalledWith('Frigg Serverless Plugin: Pre-package hook');
         });
     });
 
-    describe('createAppDefinitionFromService', () => {
-        it('should create app definition with VPC enabled when VPC is configured', () => {
-            const service = {
-                provider: {
-                    vpc: '${self:custom.vpc}'
-                }
-            };
-
-            const result = plugin.createAppDefinitionFromService(service);
-
-            expect(result.vpc.enable).toBe(true);
-        });
-
-        it('should create app definition with encryption enabled when KMS grants plugin is present', () => {
-            const service = {
-                plugins: ['serverless-kms-grants']
-            };
-
-            const result = plugin.createAppDefinitionFromService(service);
-
-            expect(result.encryption.useDefaultKMSForFieldLevelEncryption).toBe(true);
-        });
-
-        it('should create app definition with SSM enabled when lambda layers include AWS extension', () => {
-            const service = {
-                provider: {
-                    layers: [
-                        'arn:aws:lambda:us-east-1:177933569100:layer:AWS-Parameters-and-Secrets-Lambda-Extension:11',
-                        'arn:aws:lambda:us-east-1:123:layer:other:1'
-                    ]
-                }
-            };
-
-            const result = plugin.createAppDefinitionFromService(service);
-
-            expect(result.ssm.enable).toBe(true);
-        });
-
-        it('should create app definition with all features enabled', () => {
-            const service = {
-                provider: {
-                    vpc: '${self:custom.vpc}',
-                    layers: ['arn:aws:lambda:us-east-1:177933569100:layer:AWS-Parameters-and-Secrets-Lambda-Extension:11']
-                },
-                plugins: ['serverless-kms-grants']
-            };
-
-            const result = plugin.createAppDefinitionFromService(service);
-
-            expect(result.vpc.enable).toBe(true);
-            expect(result.encryption.useDefaultKMSForFieldLevelEncryption).toBe(true);
-            expect(result.ssm.enable).toBe(true);
-        });
-
-        it('should create minimal app definition when no features are configured', () => {
-            const service = {
-                provider: {}
-            };
-
-            const result = plugin.createAppDefinitionFromService(service);
-
-            expect(result).toEqual({
-                integrations: [],
-                vpc: {},
-                encryption: {},
-                ssm: {}
-            });
-        });
-    });
 
     describe('asyncInit (offline mode)', () => {
         beforeEach(() => {
@@ -459,36 +180,4 @@ describe('FriggServerlessPlugin', () => {
         });
     });
 
-    describe('integration with BuildTimeDiscovery', () => {
-        it('should pass correct region to BuildTimeDiscovery constructor', async () => {
-            mockServerless.service.provider.region = 'eu-central-1';
-            mockServerless.service.provider.vpc = '${self:custom.vpc}';
-            mockBuildTimeDiscovery.preBuildHook.mockResolvedValue({});
-
-            await plugin.beforePackageInitialize();
-
-            expect(BuildTimeDiscovery).toHaveBeenCalledWith('eu-central-1');
-        });
-
-        it('should pass correct app definition to preBuildHook', async () => {
-            mockServerless.service.provider.vpc = '${self:custom.vpc}';
-            mockServerless.service.plugins = ['serverless-kms-grants'];
-            mockServerless.service.provider.layers = [
-                'arn:aws:lambda:us-east-1:177933569100:layer:AWS-Parameters-and-Secrets-Lambda-Extension:11'
-            ];
-            mockBuildTimeDiscovery.preBuildHook.mockResolvedValue({});
-
-            await plugin.beforePackageInitialize();
-
-            expect(mockBuildTimeDiscovery.preBuildHook).toHaveBeenCalledWith(
-                {
-                    integrations: [],
-                    vpc: { enable: true },
-                    encryption: { useDefaultKMSForFieldLevelEncryption: true },
-                    ssm: { enable: true }
-                },
-                'us-east-1'
-            );
-        });
-    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@friggframework/serverless-plugin",
-  "version": "2.0.0--canary.398.c9e5d61.0",
+  "version": "2.0.0--canary.398.90b58c8.0",
   "description": "Plugin to help dynamically load frigg resources",
   "main": "index.js",
   "scripts": {
@@ -11,5 +11,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "c9e5d614b0abcc3a1066ffa87da17ada71dc8f9d"
+  "gitHead": "90b58c8e19b569bca169038b097a8b7358ca3268"
 }