@friggframework/serverless-plugin 2.0.0--canary.397.155fecd.0 → 2.0.0--canary.398.e2147f7.0

package/index.js

@@ -1,16 +1,31 @@
 const { spawn } = require("child_process");
+const { BuildTimeDiscovery } = require("@friggframework/devtools/infrastructure/build-time-discovery");
 
+/**
+ * Frigg Serverless Plugin - Handles AWS discovery and local development setup
+ */
 class FriggServerlessPlugin {
+  /**
+   * Creates an instance of FriggServerlessPlugin
+   * @param {Object} serverless - Serverless framework instance
+   * @param {Object} options - Plugin options
+   */
   constructor(serverless, options) {
     this.serverless = serverless;
     this.options = options;
     this.provider = serverless.getProvider("aws");
     this.hooks = {
       initialize: () => this.init(),
+      "before:package:initialize": () => this.beforePackageInitialize(),
       "after:package:package": () => this.afterPackage(),
       "before:deploy:deploy": () => this.beforeDeploy(),
     };
   }
+  /**
+   * Asynchronous initialization for offline mode
+   * Creates SQS queues in localstack for local development
+   * @returns {Promise<void>}
+   */
   async asyncInit() {
     this.serverless.cli.log("Initializing Frigg Serverless Plugin...");
     console.log("Hello from Frigg Serverless Plugin!");
@@ -83,7 +98,129 @@ class FriggServerlessPlugin {
       console.log("Running in online mode, doing nothing");
     }
   }
+
+  /**
+   * Hook that runs before serverless package initialization
+   * Performs AWS resource discovery if needed
+   * @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");
+    }
+  }
+
+  /**
+   * 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() {}
+  /**
+   * Hook that runs after serverless package
+   */
   afterPackage() {
     console.log("After package hook called");
     // // const queues = Object.keys(infrastructure.custom)
@@ -123,6 +260,9 @@ class FriggServerlessPlugin {
     // //     });
     // });
   }
+  /**
+   * Hook that runs before serverless deploy
+   */
   beforeDeploy() {
     console.log("Before deploy hook called");
   }

package/index.test.js

@@ -0,0 +1,494 @@
+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 = {
+            cli: {
+                log: jest.fn()
+            },
+            service: {
+                provider: {
+                    name: 'aws',
+                    region: 'us-east-1'
+                },
+                plugins: [],
+                custom: {},
+                functions: {}
+            },
+            processedInput: {
+                commands: []
+            },
+            getProvider: jest.fn(() => ({})),
+            extendConfiguration: jest.fn()
+        };
+
+        mockOptions = {
+            stage: 'test'
+        };
+
+        plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+
+        // Reset environment
+        process.env = { ...originalEnv };
+
+        jest.clearAllMocks();
+    });
+
+    afterEach(() => {
+        process.env = originalEnv;
+    });
+
+    describe('constructor', () => {
+        it('should initialize plugin with correct hooks', () => {
+            expect(plugin.serverless).toBe(mockServerless);
+            expect(plugin.options).toBe(mockOptions);
+            expect(plugin.hooks).toEqual({
+                initialize: expect.any(Function),
+                'before:package:initialize': expect.any(Function),
+                'after:package:package': expect.any(Function),
+                'before:deploy:deploy': expect.any(Function)
+            });
+        });
+
+        it('should get AWS provider from serverless', () => {
+            expect(mockServerless.getProvider).toHaveBeenCalledWith('aws');
+        });
+    });
+
+    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);
+
+            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);
+        });
+    });
+
+    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(() => {
+            // Mock AWS SDK
+            const mockSQS = {
+                createQueue: jest.fn()
+            };
+            
+            jest.doMock('aws-sdk', () => ({
+                SQS: jest.fn(() => mockSQS),
+                config: {
+                    update: jest.fn()
+                }
+            }));
+
+            mockServerless.service.custom = {
+                TestQueue: 'test-queue-name',
+                AnotherQueue: 'another-queue-name'
+            };
+
+            mockServerless.service.provider.environment = {
+                TEST_QUEUE_URL: { Ref: 'TestQueue' },
+                ANOTHER_QUEUE_URL: { Ref: 'AnotherQueue' },
+                NORMAL_VAR: 'normal-value'
+            };
+        });
+
+        it('should create queues in offline mode', async () => {
+            mockServerless.processedInput.commands = ['offline'];
+            
+            const AWS = require('aws-sdk');
+            const mockSQS = new AWS.SQS();
+            mockSQS.createQueue.mockImplementation((params, callback) => {
+                callback(null, { QueueUrl: `http://localhost:4566/000000000000/${params.QueueName}` });
+            });
+
+            await plugin.asyncInit();
+
+            expect(AWS.config.update).toHaveBeenCalledWith({
+                region: 'us-east-1',
+                endpoint: 'localhost:4566'
+            });
+
+            expect(mockSQS.createQueue).toHaveBeenCalledWith(
+                { QueueName: 'test-queue-name' },
+                expect.any(Function)
+            );
+
+            expect(mockSQS.createQueue).toHaveBeenCalledWith(
+                { QueueName: 'another-queue-name' },
+                expect.any(Function)
+            );
+
+            expect(mockServerless.extendConfiguration).toHaveBeenCalled();
+        });
+
+        it('should skip queue creation in online mode', async () => {
+            mockServerless.processedInput.commands = ['deploy'];
+
+            await plugin.asyncInit();
+
+            const AWS = require('aws-sdk');
+            expect(AWS.config.update).not.toHaveBeenCalled();
+        });
+
+        it('should handle queue creation errors', async () => {
+            mockServerless.processedInput.commands = ['offline'];
+            
+            const AWS = require('aws-sdk');
+            const mockSQS = new AWS.SQS();
+            mockSQS.createQueue.mockImplementation((params, callback) => {
+                callback(new Error('Queue creation failed'));
+            });
+
+            await expect(plugin.asyncInit()).rejects.toThrow('Queue creation failed');
+        });
+    });
+
+    describe('hook methods', () => {
+        it('should have init method', () => {
+            expect(plugin.init).toBeDefined();
+            expect(typeof plugin.init).toBe('function');
+        });
+
+        it('should have afterPackage method', () => {
+            expect(plugin.afterPackage).toBeDefined();
+            expect(typeof plugin.afterPackage).toBe('function');
+            
+            // Test that it logs correctly
+            const consoleSpy = jest.spyOn(console, 'log');
+            plugin.afterPackage();
+            expect(consoleSpy).toHaveBeenCalledWith('After package hook called');
+            consoleSpy.mockRestore();
+        });
+
+        it('should have beforeDeploy method', () => {
+            expect(plugin.beforeDeploy).toBeDefined();
+            expect(typeof plugin.beforeDeploy).toBe('function');
+            
+            // Test that it logs correctly
+            const consoleSpy = jest.spyOn(console, 'log');
+            plugin.beforeDeploy();
+            expect(consoleSpy).toHaveBeenCalledWith('Before deploy hook called');
+            consoleSpy.mockRestore();
+        });
+    });
+
+    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.397.155fecd.0",
+  "version": "2.0.0--canary.398.e2147f7.0",
   "description": "Plugin to help dynamically load frigg resources",
   "main": "index.js",
   "scripts": {
@@ -11,5 +11,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "155fecdabd27d01d1c1001261e9ec4b824826411"
+  "gitHead": "e2147f7f03122a5daa917429ba610c1a7c6ef819"
 }