@friggframework/serverless-plugin 2.0.0-next.45 → 2.0.0-next.47

package/index.js

@@ -28,6 +28,18 @@ class FriggServerlessPlugin {
   async asyncInit() {
     this.serverless.cli.log("Initializing Frigg Serverless Plugin...");
     console.log("Hello from Frigg Serverless Plugin!");
+    
+    // CRITICAL: Create .esbuild/.serverless directory before serverless-esbuild needs it
+    // This prevents ENOENT errors during packaging
+    const fs = require('fs');
+    const path = require('path');
+    const esbuildDir = path.join(this.serverless.config.servicePath || process.cwd(), '.esbuild', '.serverless');
+
+    if (!fs.existsSync(esbuildDir)) {
+      fs.mkdirSync(esbuildDir, { recursive: true });
+      console.log(`✓ Created ${esbuildDir} directory for serverless-esbuild`);
+    }
+    
     if (this.serverless.processedInput.commands.includes("offline")) {
       console.log("Running in offline mode. Making queues!");
       const queues = Object.keys(this.serverless.service.custom)
@@ -42,16 +54,24 @@ class FriggServerlessPlugin {
 
       const AWS = require("aws-sdk");
 
-      const endpointUrl = "localhost:4566"; // Assuming localstack is running on port 4
-      const region = "us-east-1";
+      const endpointUrl = process.env.AWS_ENDPOINT || "http://localhost:4566"; // LocalStack SQS endpoint
+      const region = process.env.AWS_REGION || "us-east-1";
+      const accessKeyId = process.env.AWS_ACCESS_KEY_ID || "root"; // LocalStack default
+      const secretAccessKey = process.env.AWS_SECRET_ACCESS_KEY || "root"; // LocalStack default
 
-      // Configure AWS SDK
+      // Configure AWS SDK for LocalStack
       AWS.config.update({
         region: region,
         endpoint: endpointUrl,
+        accessKeyId: accessKeyId,
+        secretAccessKey: secretAccessKey,
+        s3ForcePathStyle: true, // Required for LocalStack
+        sslEnabled: false, // Disable SSL for LocalStack
       });
 
-      const sqs = new AWS.SQS();
+      const sqs = new AWS.SQS({
+        sslEnabled: false, // Disable SSL validation for LocalStack
+      });
       // Find the environment variables that we need to override and create an easy map
       const environmentMap = {};
       const environment = this.serverless.service.provider.environment;
@@ -107,13 +127,35 @@ class FriggServerlessPlugin {
     // 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");
+
+    // Ensure .esbuild/.serverless directory exists to prevent ENOENT errors
+    // serverless-esbuild may try to access this directory during packaging
+    const fs = require('fs');
+    const path = require('path');
+    const esbuildDir = path.join(this.serverless.config.servicePath || process.cwd(), '.esbuild', '.serverless');
+
+    if (!fs.existsSync(esbuildDir)) {
+      fs.mkdirSync(esbuildDir, { recursive: true });
+    }
   }
 
 
   /**
-   * Initialization hook (currently empty)
+   * Initialization hook - runs very early, before packaging
+   * Create .esbuild/.serverless directory to prevent ENOENT errors
    */
-  init() { }
+  init() {
+    // Ensure .esbuild/.serverless directory exists to prevent ENOENT errors
+    // serverless-esbuild may try to access this directory during packaging
+    const fs = require('fs');
+    const path = require('path');
+    const esbuildDir = path.join(this.serverless.config.servicePath || process.cwd(), '.esbuild', '.serverless');
+
+    if (!fs.existsSync(esbuildDir)) {
+      fs.mkdirSync(esbuildDir, { recursive: true });
+      console.log(`Created ${esbuildDir} directory for serverless-esbuild`);
+    }
+  }
   /**
    * Hook that runs after serverless package
    */

package/index.test.js

@@ -1,183 +1,307 @@
 const FriggServerlessPlugin = require('./index');
+const fs = require('fs');
+const path = require('path');
 
-// Mock dependencies
-jest.mock('aws-sdk');
+// Mock fs module
+jest.mock('fs');
 
 describe('FriggServerlessPlugin', () => {
     let plugin;
     let mockServerless;
     let mockOptions;
-    const originalEnv = process.env;
+    let mockServicePath;
 
     beforeEach(() => {
+        mockServicePath = '/test/service/path';
 
-        // Mock serverless object
         mockServerless = {
+            config: {
+                servicePath: mockServicePath,
+            },
             cli: {
-                log: jest.fn()
+                log: jest.fn(),
             },
             service: {
+                custom: {},
                 provider: {
-                    name: 'aws',
-                    region: 'us-east-1'
+                    environment: {},
                 },
-                plugins: [],
-                custom: {},
-                functions: {}
             },
             processedInput: {
-                commands: []
+                commands: [],
             },
-            getProvider: jest.fn(() => ({})),
-            extendConfiguration: jest.fn()
+            getProvider: jest.fn().mockReturnValue({}),
+            extendConfiguration: jest.fn(),
         };
 
         mockOptions = {
-            stage: 'test'
+            stage: 'test',
         };
 
-        // Reset environment
-        process.env = { ...originalEnv };
-
+        // Clear all mocks before each test
         jest.clearAllMocks();
-        
-        plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
     });
 
-    afterEach(() => {
-        process.env = originalEnv;
-    });
+    describe('Constructor', () => {
+        it('should initialize with serverless instance and options', () => {
+            plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
 
-    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)
-            });
+            expect(plugin.hooks).toBeDefined();
         });
 
-        it('should get AWS provider from serverless', () => {
-            expect(mockServerless.getProvider).toHaveBeenCalledWith('aws');
+        it('should register required hooks', () => {
+            plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+
+            expect(plugin.hooks).toHaveProperty('initialize');
+            expect(plugin.hooks).toHaveProperty('before:package:initialize');
+            expect(plugin.hooks).toHaveProperty('after:package:package');
+            expect(plugin.hooks).toHaveProperty('before:deploy:deploy');
         });
     });
 
-    describe('beforePackageInitialize', () => {
-        it('should log pre-package hook message', async () => {
-            await plugin.beforePackageInitialize();
+    describe('asyncInit - Directory Creation', () => {
+        it('should create .esbuild/.serverless directory if it does not exist', async () => {
+            plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
 
-            expect(mockServerless.cli.log).toHaveBeenCalledWith('Frigg Serverless Plugin: Pre-package hook');
-        });
-    });
+            // Mock fs.existsSync to return false (directory doesn't exist)
+            fs.existsSync.mockReturnValue(false);
+            fs.mkdirSync.mockImplementation(() => { });
 
+            // Spy on console.log
+            const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
 
-    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()
-                }
-            }));
+            await plugin.asyncInit();
 
-            mockServerless.service.custom = {
-                TestQueue: 'test-queue-name',
-                AnotherQueue: 'another-queue-name'
-            };
+            const expectedPath = path.join(mockServicePath, '.esbuild', '.serverless');
 
-            mockServerless.service.provider.environment = {
-                TEST_QUEUE_URL: { Ref: 'TestQueue' },
-                ANOTHER_QUEUE_URL: { Ref: 'AnotherQueue' },
-                NORMAL_VAR: 'normal-value'
-            };
+            // Verify directory existence check
+            expect(fs.existsSync).toHaveBeenCalledWith(expectedPath);
+
+            // Verify directory creation
+            expect(fs.mkdirSync).toHaveBeenCalledWith(expectedPath, { recursive: true });
+
+            // Verify success message
+            expect(consoleLogSpy).toHaveBeenCalledWith(
+                expect.stringContaining('Created')
+            );
+            expect(consoleLogSpy).toHaveBeenCalledWith(
+                expect.stringContaining('.esbuild')
+            );
+
+            consoleLogSpy.mockRestore();
         });
 
-        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}` });
-            });
+        it('should not create directory if it already exists', async () => {
+            plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+
+            // Mock fs.existsSync to return true (directory exists)
+            fs.existsSync.mockReturnValue(true);
+            fs.mkdirSync.mockImplementation(() => { });
+
+            const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
 
             await plugin.asyncInit();
 
-            expect(AWS.config.update).toHaveBeenCalledWith({
-                region: 'us-east-1',
-                endpoint: 'localhost:4566'
-            });
+            const expectedPath = path.join(mockServicePath, '.esbuild', '.serverless');
 
-            expect(mockSQS.createQueue).toHaveBeenCalledWith(
-                { QueueName: 'test-queue-name' },
-                expect.any(Function)
-            );
+            // Verify directory existence check
+            expect(fs.existsSync).toHaveBeenCalledWith(expectedPath);
+
+            // Verify directory creation was NOT called
+            expect(fs.mkdirSync).not.toHaveBeenCalled();
 
-            expect(mockSQS.createQueue).toHaveBeenCalledWith(
-                { QueueName: 'another-queue-name' },
-                expect.any(Function)
+            // Verify success message was NOT logged
+            expect(consoleLogSpy).not.toHaveBeenCalledWith(
+                expect.stringContaining('Created')
             );
 
-            expect(mockServerless.extendConfiguration).toHaveBeenCalled();
+            consoleLogSpy.mockRestore();
+        });
+
+        it('should use process.cwd() if servicePath is not available', async () => {
+            // Remove servicePath from config
+            mockServerless.config.servicePath = undefined;
+
+            plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+
+            fs.existsSync.mockReturnValue(false);
+            fs.mkdirSync.mockImplementation(() => { });
+
+            await plugin.asyncInit();
+
+            const expectedPath = path.join(process.cwd(), '.esbuild', '.serverless');
+
+            expect(fs.existsSync).toHaveBeenCalledWith(expectedPath);
+            expect(fs.mkdirSync).toHaveBeenCalledWith(expectedPath, { recursive: true });
+        });
+
+        it('should log initialization messages', async () => {
+            plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+
+            fs.existsSync.mockReturnValue(true);
+
+            const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+
+            await plugin.asyncInit();
+
+            // Verify plugin initialization messages
+            expect(mockServerless.cli.log).toHaveBeenCalledWith('Initializing Frigg Serverless Plugin...');
+            expect(consoleLogSpy).toHaveBeenCalledWith('Hello from Frigg Serverless Plugin!');
+
+            consoleLogSpy.mockRestore();
         });
+    });
+
+    describe('asyncInit - Offline Mode', () => {
+        it('should not create SQS queues when not in offline mode', async () => {
+            plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+
+            fs.existsSync.mockReturnValue(true);
 
-        it('should skip queue creation in online mode', async () => {
+            // Not in offline mode
             mockServerless.processedInput.commands = ['deploy'];
 
+            const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+
             await plugin.asyncInit();
 
-            const AWS = require('aws-sdk');
-            expect(AWS.config.update).not.toHaveBeenCalled();
+            expect(consoleLogSpy).toHaveBeenCalledWith('Running in online mode, doing nothing');
+            expect(consoleLogSpy).not.toHaveBeenCalledWith(
+                expect.stringContaining('offline mode')
+            );
+
+            consoleLogSpy.mockRestore();
         });
 
-        it('should handle queue creation errors', async () => {
+        it('should create SQS queues when in offline mode', async () => {
+            plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+
+            fs.existsSync.mockReturnValue(true);
+
+            // Set offline mode
             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'));
+            mockServerless.service.custom = {
+                testQueue: 'test-queue-name',
+            };
+
+            // Mock AWS SDK
+            const mockCreateQueue = jest.fn((params, callback) => {
+                callback(null, { QueueUrl: 'http://localhost:4566/queue/test-queue-name' });
             });
 
-            await expect(plugin.asyncInit()).rejects.toThrow('Queue creation failed');
+            jest.mock('aws-sdk', () => ({
+                SQS: jest.fn(() => ({
+                    createQueue: mockCreateQueue,
+                })),
+                config: {
+                    update: jest.fn(),
+                },
+            }));
+
+            const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+
+            await plugin.asyncInit();
+
+            expect(consoleLogSpy).toHaveBeenCalledWith(
+                expect.stringContaining('offline mode')
+            );
+
+            consoleLogSpy.mockRestore();
         });
     });
 
-    describe('hook methods', () => {
-        it('should have init method', () => {
-            expect(plugin.init).toBeDefined();
-            expect(typeof plugin.init).toBe('function');
+    describe('beforePackageInitialize', () => {
+        it('should create .esbuild/.serverless directory', () => {
+            plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+
+            fs.existsSync.mockReturnValue(false);
+            fs.mkdirSync.mockImplementation(() => { });
+
+            plugin.beforePackageInitialize();
+
+            const expectedPath = path.join(mockServicePath, '.esbuild', '.serverless');
+
+            expect(fs.existsSync).toHaveBeenCalledWith(expectedPath);
+            expect(fs.mkdirSync).toHaveBeenCalledWith(expectedPath, { recursive: true });
         });
 
-        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');
+        it('should log pre-package hook message', () => {
+            plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+
+            fs.existsSync.mockReturnValue(true);
+
+            plugin.beforePackageInitialize();
+
+            expect(mockServerless.cli.log).toHaveBeenCalledWith('Frigg Serverless Plugin: Pre-package hook');
+        });
+    });
+
+    describe('init', () => {
+        it('should create .esbuild/.serverless directory', () => {
+            plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+
+            fs.existsSync.mockReturnValue(false);
+            fs.mkdirSync.mockImplementation(() => { });
+
+            const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+
+            plugin.init();
+
+            const expectedPath = path.join(mockServicePath, '.esbuild', '.serverless');
+
+            expect(fs.existsSync).toHaveBeenCalledWith(expectedPath);
+            expect(fs.mkdirSync).toHaveBeenCalledWith(expectedPath, { recursive: true });
+            expect(consoleLogSpy).toHaveBeenCalledWith(
+                expect.stringContaining('Created')
+            );
+
+            consoleLogSpy.mockRestore();
+        });
+    });
+
+    describe('afterPackage', () => {
+        it('should log after package hook message', () => {
+            plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+
+            const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+
             plugin.afterPackage();
-            expect(consoleSpy).toHaveBeenCalledWith('After package hook called');
-            consoleSpy.mockRestore();
+
+            expect(consoleLogSpy).toHaveBeenCalledWith('After package hook called');
+
+            consoleLogSpy.mockRestore();
         });
+    });
+
+    describe('beforeDeploy', () => {
+        it('should log before deploy hook message', () => {
+            plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+
+            const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
 
-        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();
+
+            expect(consoleLogSpy).toHaveBeenCalledWith('Before deploy hook called');
+
+            consoleLogSpy.mockRestore();
         });
     });
 
-});
+    describe('Error Handling', () => {
+        it('should handle fs.mkdirSync errors gracefully', async () => {
+            plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+
+            fs.existsSync.mockReturnValue(false);
+            fs.mkdirSync.mockImplementation(() => {
+                throw new Error('Permission denied');
+            });
+
+            // Should not throw - error should be caught or allowed to propagate
+            await expect(plugin.asyncInit()).rejects.toThrow('Permission denied');
+        });
+    });
+});
+
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@friggframework/serverless-plugin",
-  "version": "2.0.0-next.45",
+  "version": "2.0.0-next.47",
   "description": "Plugin to help dynamically load frigg resources",
   "main": "index.js",
   "scripts": {
@@ -11,5 +11,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "996a15bcdfaa4252b9891a33f1b1c84548d66bbc"
+  "gitHead": "7a7b05dc023f05a6b1c18075064e88f29156fee1"
 }