@friggframework/serverless-plugin 2.0.0--canary.398.a314355.0 → 2.0.0--canary.397.4957a89.0

package/index.js

@@ -1,30 +1,16 @@
 const { spawn } = require("child_process");
 
-/**
- * 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!");
@@ -52,7 +38,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;
 
@@ -97,26 +83,7 @@ class FriggServerlessPlugin {
       console.log("Running in online mode, doing nothing");
     }
   }
-
-  /**
-   * Hook that runs before serverless package initialization
-   * AWS discovery is now handled in serverless-template.js
-   * @returns {Promise<void>}
-   */
-  async beforePackageInitialize() {
-    // 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");
-  }
-
-
-  /**
-   * Initialization hook (currently empty)
-   */
-  init() { }
-  /**
-   * Hook that runs after serverless package
-   */
+  init() {}
   afterPackage() {
     console.log("After package hook called");
     // // const queues = Object.keys(infrastructure.custom)
@@ -156,9 +123,6 @@ class FriggServerlessPlugin {
     // //     });
     // });
   }
-  /**
-   * Hook that runs before serverless deploy
-   */
   beforeDeploy() {
     console.log("Before deploy hook called");
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@friggframework/serverless-plugin",
-  "version": "2.0.0--canary.398.a314355.0",
+  "version": "2.0.0--canary.397.4957a89.0",
   "description": "Plugin to help dynamically load frigg resources",
   "main": "index.js",
   "scripts": {
@@ -11,5 +11,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "a31435596361f047f54cfbcc03c9863b129d0d1c"
+  "gitHead": "4957a89e2a8ebcc2698dbae047858120ef1725fc"
 }

package/index.test.js

@@ -1,183 +0,0 @@
-const FriggServerlessPlugin = require('./index');
-
-// Mock dependencies
-jest.mock('aws-sdk');
-
-describe('FriggServerlessPlugin', () => {
-    let plugin;
-    let mockServerless;
-    let mockOptions;
-    const originalEnv = process.env;
-
-    beforeEach(() => {
-
-        // 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'
-        };
-
-        // Reset environment
-        process.env = { ...originalEnv };
-
-        jest.clearAllMocks();
-        
-        plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
-    });
-
-    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 log pre-package hook message', async () => {
-            await plugin.beforePackageInitialize();
-
-            expect(mockServerless.cli.log).toHaveBeenCalledWith('Frigg Serverless Plugin: Pre-package hook');
-        });
-    });
-
-
-    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();
-        });
-    });
-
-});