@friggframework/serverless-plugin 2.0.0-next.8 → 2.0.0-next.81

package/index.js

@@ -1,130 +1,146 @@
-const { spawn } = require("child_process");
+const { QueueEnvironmentMapper } = require('./lib/queue-environment-mapper');
+const { LocalStackQueueService } = require('./lib/localstack-queue-service');
+const { EsbuildDirectoryManager } = require('./lib/esbuild-directory-manager');
 
 class FriggServerlessPlugin {
   constructor(serverless, options) {
     this.serverless = serverless;
     this.options = options;
-    this.provider = serverless.getProvider("aws");
+    this.provider = serverless.getProvider('aws');
+
+    const fs = require('fs');
+    const path = require('path');
+    const basePath = serverless.config.servicePath || process.cwd();
+
+    const dirManager = new EsbuildDirectoryManager(fs, path);
+    try {
+      const esbuildDir = dirManager.ensureDirectory(basePath);
+      console.log(`✓ Frigg plugin created ${esbuildDir}`);
+    } catch (error) {
+      console.error(`⚠️  Failed to create esbuild directory:`, error.message);
+    }
+
     this.hooks = {
       initialize: () => this.init(),
-      "after:package:package": () => this.afterPackage(),
-      "before:deploy:deploy": () => this.beforeDeploy(),
+      'before:package:initialize': () => this.beforePackageInitialize(),
+      'after:package:package': () => this.afterPackage(),
+      'before:deploy:deploy': () => this.beforeDeploy(),
     };
   }
+
   async asyncInit() {
-    this.serverless.cli.log("Initializing Frigg Serverless Plugin...");
-    console.log("Hello from Frigg Serverless Plugin!");
-    if (this.serverless.processedInput.commands.includes("offline")) {
-      console.log("Running in offline mode. Making queues!");
-      const queues = Object.keys(this.serverless.service.custom)
-        .filter((key) => key.endsWith("Queue"))
-        .map((key) => {
-          return {
-            key,
-            name: this.serverless.service.custom[key],
-          };
-        });
-      console.log("Queues to be created:", queues);
-
-      const AWS = require("aws-sdk");
-
-      const endpointUrl = "localhost:4566"; // Assuming localstack is running on port 4
-      const region = "us-east-1";
-
-      // Configure AWS SDK
-      AWS.config.update({
-        region: region,
-        endpoint: endpointUrl,
-      });
+    this.serverless.cli.log('Initializing Frigg Serverless Plugin...');
+    console.log('Hello from Frigg Serverless Plugin!');
 
-      const sqs = new AWS.SQS();
-// Find the environment variables that we need to override and create an easy map
-      const environmentMap = {};
-      const environment = this.serverless.service.provider.environment;
-
-      for (const [key, value] of Object.entries(environment)) {
-        if (typeof value === "object" && value.Ref) {
-          environmentMap[value.Ref] = key;
-        }
-      }
-
-      const queueCreationPromises = queues.map((queue) => {
-        return new Promise((resolve, reject) => {
-          const params = {
-            QueueName: queue.name,
-          };
-
-          sqs.createQueue(params, (err, data) => {
-            if (err) {
-              console.error(
-                `Error creating queue ${queue.name}: ${err.message}`
-              );
-              reject(err);
-            } else {
-              const queueUrl = data.QueueUrl;
-              console.log(
-                `Queue ${queue.name} created successfully. URL: ${queueUrl}`
-              );
-
-              const environmentKey = environmentMap[queue.key];
-              this.serverless.extendConfiguration(
-                ["provider", "environment", environmentKey],
-                queueUrl
-              );
-              console.log(`Set ${environmentKey} to ${queueUrl}`);
-              resolve(queueUrl);
-            }
-          });
-        });
-      });
+    const fs = require('fs');
+    const path = require('path');
+    const basePath = this.serverless.config.servicePath || process.cwd();
+
+    const dirManager = new EsbuildDirectoryManager(fs, path);
+    const esbuildDir = dirManager.ensureDirectory(basePath);
 
-      await Promise.all(queueCreationPromises);
+    if (this.serverless.processedInput.commands.includes('offline')) {
+      console.log('Running in offline mode. Making queues!');
+      await this.setupOfflineQueues();
     } else {
-      console.log("Running in online mode, doing nothing");
+      console.log('Running in online mode, doing nothing');
     }
   }
-  init() {}
+
+  async setupOfflineQueues() {
+    const queues = this.extractQueueDefinitions();
+    console.log('Queues to be created:', queues);
+
+    const sqsClient = this.createLocalStackSQSClient();
+    const queueService = new LocalStackQueueService(sqsClient);
+    const mapper = new QueueEnvironmentMapper();
+
+    const environmentMap = mapper.createMapping(queues);
+    const createdQueues = await queueService.createQueues(queues);
+
+    createdQueues.forEach(({ key, url }) => {
+      const envKey = mapper.getEnvironmentKey(key, environmentMap);
+      this.serverless.extendConfiguration(['provider', 'environment', envKey], url);
+      console.log(`Set ${envKey} to ${url}`);
+    });
+  }
+
+  extractQueueDefinitions() {
+    // Each custom.*Queue entry is the resolved QueueName. The matching
+    // CloudFormation resource (under resources.Resources) has the same
+    // logical ID and carries the Properties block we want to mirror onto
+    // LocalStack (VisibilityTimeout, MessageRetentionPeriod,
+    // RedrivePolicy, …). Deployed AWS applies those via CloudFormation;
+    // locally they'd be silently dropped and LocalStack would fall back
+    // to AWS defaults — notably a 30s VisibilityTimeout which
+    // re-delivers in-flight messages while a long-running queue worker
+    // is still processing them.
+    const resources =
+      this.serverless.service.resources &&
+      this.serverless.service.resources.Resources
+        ? this.serverless.service.resources.Resources
+        : {};
+
+    return Object.keys(this.serverless.service.custom)
+      .filter((key) => key.endsWith('Queue'))
+      .map((key) => {
+        const resource = resources[key];
+        const properties =
+          resource &&
+          resource.Type === 'AWS::SQS::Queue' &&
+          resource.Properties
+            ? resource.Properties
+            : undefined;
+        return {
+          key,
+          name: this.serverless.service.custom[key],
+          ...(properties ? { properties } : {}),
+        };
+      });
+  }
+
+  createLocalStackSQSClient() {
+    const AWS = require('aws-sdk');
+
+    AWS.config.update({
+      region: process.env.AWS_REGION || 'us-east-1',
+      endpoint: process.env.AWS_ENDPOINT || 'http://localhost:4566',
+      accessKeyId: process.env.AWS_ACCESS_KEY_ID || 'root',
+      secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY || 'root',
+      s3ForcePathStyle: true,
+      sslEnabled: false,
+    });
+
+    return new AWS.SQS({ sslEnabled: false });
+  }
+
+  async beforePackageInitialize() {
+    this.serverless.cli.log('Frigg Serverless Plugin: Pre-package hook');
+
+    const fs = require('fs');
+    const path = require('path');
+    const basePath = this.serverless.config.servicePath || process.cwd();
+
+    const dirManager = new EsbuildDirectoryManager(fs, path);
+    dirManager.ensureDirectory(basePath);
+  }
+
+  init() {
+    const fs = require('fs');
+    const path = require('path');
+    const basePath = this.serverless.config.servicePath || process.cwd();
+
+    const dirManager = new EsbuildDirectoryManager(fs, path);
+    const esbuildDir = dirManager.ensureDirectory(basePath);
+    console.log(`Created ${esbuildDir} directory for serverless-esbuild`);
+  }
+
   afterPackage() {
-    console.log("After package hook called");
-    // // const queues = Object.keys(infrastructure.custom)
-    // //     .filter((key) => key.endsWith('Queue'))
-    // //     .map((key) => infrastructure.custom[key]);
-    // // console.log('Queues to be created:', queues);
-    // //
-    // // const endpointUrl = 'http://localhost:4566'; // Assuming localstack is running on port 4
-    // // const region = 'us-east-1';
-    // // const command = 'aws';
-    // // queues.forEach((queue) => {
-    // //     const args = [
-    // //         '--endpoint-url',
-    // //         endpointUrl,
-    // //         'sqs',
-    // //         'create-queue',
-    // //         '--queue-name',
-    // //         queue,
-    // //         '--region',
-    // //         region,
-    // //         '--output',
-    // //         'table',
-    // //     ];
-    // //
-    // //     const childProcess = spawn(command, args, {
-    // //         cwd: backendPath,
-    // //         stdio: 'inherit',
-    // //     });
-    // //     childProcess.on('error', (error) => {
-    // //         console.error(`Error executing command: ${error.message}`);
-    // //     });
-    // //
-    // //     childProcess.on('close', (code) => {
-    // //         if (code !== 0) {
-    // //             console.log(`Child process exited with code ${code}`);
-    // //         }
-    // //     });
-    // });
+    console.log('After package hook called');
   }
+
   beforeDeploy() {
-    console.log("Before deploy hook called");
+    console.log('Before deploy hook called');
   }
 }
 

package/index.test.js

@@ -0,0 +1,296 @@
+const FriggServerlessPlugin = require('./index');
+
+jest.mock('./lib/queue-environment-mapper');
+jest.mock('./lib/localstack-queue-service');
+jest.mock('./lib/esbuild-directory-manager');
+
+const { QueueEnvironmentMapper } = require('./lib/queue-environment-mapper');
+const { LocalStackQueueService } = require('./lib/localstack-queue-service');
+const { EsbuildDirectoryManager } = require('./lib/esbuild-directory-manager');
+
+describe('FriggServerlessPlugin', () => {
+  let plugin;
+  let mockServerless;
+  let mockOptions;
+
+  beforeEach(() => {
+    mockServerless = {
+      config: { servicePath: '/test/path' },
+      cli: { log: jest.fn() },
+      service: {
+        custom: {},
+        provider: { environment: {} },
+      },
+      processedInput: { commands: [] },
+      getProvider: jest.fn().mockReturnValue({}),
+      extendConfiguration: jest.fn(),
+    };
+
+    mockOptions = { stage: 'test' };
+
+    EsbuildDirectoryManager.mockImplementation(() => ({
+      ensureDirectory: jest.fn().mockReturnValue('/test/path/.esbuild/.serverless'),
+    }));
+
+    jest.clearAllMocks();
+  });
+
+  describe('Constructor', () => {
+    it('should initialize with serverless instance and options', () => {
+      plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+
+      expect(plugin.serverless).toBe(mockServerless);
+      expect(plugin.options).toBe(mockOptions);
+      expect(plugin.hooks).toBeDefined();
+    });
+
+    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');
+    });
+
+    it('should create esbuild directory on construction', () => {
+      const mockEnsureDir = jest.fn().mockReturnValue('/test/.esbuild/.serverless');
+      EsbuildDirectoryManager.mockImplementation(() => ({
+        ensureDirectory: mockEnsureDir,
+      }));
+
+      plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+
+      expect(mockEnsureDir).toHaveBeenCalledWith('/test/path');
+    });
+  });
+
+  describe('asyncInit', () => {
+    it('should log initialization messages', async () => {
+      plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+      const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+
+      await plugin.asyncInit();
+
+      expect(mockServerless.cli.log).toHaveBeenCalledWith('Initializing Frigg Serverless Plugin...');
+      expect(consoleLogSpy).toHaveBeenCalledWith('Hello from Frigg Serverless Plugin!');
+
+      consoleLogSpy.mockRestore();
+    });
+
+    it('should run in online mode when not offline', async () => {
+      plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+      mockServerless.processedInput.commands = ['deploy'];
+
+      const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+
+      await plugin.asyncInit();
+
+      expect(consoleLogSpy).toHaveBeenCalledWith('Running in online mode, doing nothing');
+      consoleLogSpy.mockRestore();
+    });
+
+    it('should setup offline queues when in offline mode', async () => {
+      plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+      mockServerless.processedInput.commands = ['offline'];
+      mockServerless.service.custom = { AsanaQueue: 'test-queue' };
+
+      const mockMapper = {
+        createMapping: jest.fn().mockReturnValue({ AsanaQueue: 'ASANA_QUEUE_URL' }),
+        getEnvironmentKey: jest.fn().mockReturnValue('ASANA_QUEUE_URL'),
+      };
+      QueueEnvironmentMapper.mockImplementation(() => mockMapper);
+
+      const mockQueueService = {
+        createQueues: jest.fn().mockResolvedValue([
+          { key: 'AsanaQueue', url: 'http://localhost:4566/queue' },
+        ]),
+      };
+      LocalStackQueueService.mockImplementation(() => mockQueueService);
+
+      const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+
+      await plugin.asyncInit();
+
+      expect(consoleLogSpy).toHaveBeenCalledWith('Running in offline mode. Making queues!');
+      expect(mockQueueService.createQueues).toHaveBeenCalled();
+      expect(mockServerless.extendConfiguration).toHaveBeenCalledWith(
+        ['provider', 'environment', 'ASANA_QUEUE_URL'],
+        'http://localhost:4566/queue'
+      );
+
+      consoleLogSpy.mockRestore();
+    });
+  });
+
+  describe('setupOfflineQueues', () => {
+    it('should orchestrate queue creation and environment configuration', async () => {
+      plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+      mockServerless.service.custom = {
+        AsanaQueue: 'test-asana-queue',
+        SlackQueue: 'test-slack-queue',
+      };
+
+      const mockMapper = {
+        createMapping: jest.fn().mockReturnValue({
+          AsanaQueue: 'ASANA_QUEUE_URL',
+          SlackQueue: 'SLACK_QUEUE_URL',
+        }),
+        getEnvironmentKey: jest.fn()
+          .mockReturnValueOnce('ASANA_QUEUE_URL')
+          .mockReturnValueOnce('SLACK_QUEUE_URL'),
+      };
+      QueueEnvironmentMapper.mockImplementation(() => mockMapper);
+
+      const mockQueueService = {
+        createQueues: jest.fn().mockResolvedValue([
+          { key: 'AsanaQueue', url: 'http://localhost:4566/asana' },
+          { key: 'SlackQueue', url: 'http://localhost:4566/slack' },
+        ]),
+      };
+      LocalStackQueueService.mockImplementation(() => mockQueueService);
+
+      await plugin.setupOfflineQueues();
+
+      expect(mockMapper.createMapping).toHaveBeenCalled();
+      expect(mockQueueService.createQueues).toHaveBeenCalled();
+      expect(mockServerless.extendConfiguration).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  describe('extractQueueDefinitions', () => {
+    it('should extract queue definitions from custom config', () => {
+      plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+      mockServerless.service.custom = {
+        AsanaQueue: 'test-asana-queue',
+        someOtherConfig: 'something-else',
+        SlackQueue: 'test-slack-queue',
+      };
+
+      const queues = plugin.extractQueueDefinitions();
+
+      expect(queues).toEqual([
+        { key: 'AsanaQueue', name: 'test-asana-queue' },
+        { key: 'SlackQueue', name: 'test-slack-queue' },
+      ]);
+    });
+
+    it('should return empty array when no queues defined', () => {
+      plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+      mockServerless.service.custom = { someConfig: 'value' };
+
+      const queues = plugin.extractQueueDefinitions();
+
+      expect(queues).toEqual([]);
+    });
+
+    it('should attach Properties from matching CloudFormation resources', () => {
+      plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+      mockServerless.service.custom = {
+        HubspotQueue: 'svc--dev-HubspotQueue',
+      };
+      mockServerless.service.resources = {
+        Resources: {
+          HubspotQueue: {
+            Type: 'AWS::SQS::Queue',
+            Properties: {
+              QueueName: 'svc--dev-HubspotQueue',
+              VisibilityTimeout: 1800,
+              MessageRetentionPeriod: 345600,
+              RedrivePolicy: {
+                maxReceiveCount: 3,
+                deadLetterTargetArn: 'arn:aws:sqs:us-east-1:x:dlq',
+              },
+            },
+          },
+        },
+      };
+
+      const queues = plugin.extractQueueDefinitions();
+
+      expect(queues).toHaveLength(1);
+      expect(queues[0]).toEqual({
+        key: 'HubspotQueue',
+        name: 'svc--dev-HubspotQueue',
+        properties: {
+          QueueName: 'svc--dev-HubspotQueue',
+          VisibilityTimeout: 1800,
+          MessageRetentionPeriod: 345600,
+          RedrivePolicy: {
+            maxReceiveCount: 3,
+            deadLetterTargetArn: 'arn:aws:sqs:us-east-1:x:dlq',
+          },
+        },
+      });
+    });
+
+    it('should omit properties when resources.Resources is absent', () => {
+      plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+      mockServerless.service.custom = { LegacyQueue: 'legacy-queue' };
+      mockServerless.service.resources = undefined;
+
+      const queues = plugin.extractQueueDefinitions();
+
+      expect(queues).toEqual([{ key: 'LegacyQueue', name: 'legacy-queue' }]);
+    });
+
+    it('should ignore non-SQS CloudFormation resources with matching logical IDs', () => {
+      plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+      mockServerless.service.custom = { MisnamedQueue: 'misnamed-queue' };
+      mockServerless.service.resources = {
+        Resources: {
+          MisnamedQueue: {
+            Type: 'AWS::SNS::Topic',
+            Properties: { TopicName: 'not-an-sqs-queue' },
+          },
+        },
+      };
+
+      const queues = plugin.extractQueueDefinitions();
+
+      expect(queues).toEqual([
+        { key: 'MisnamedQueue', name: 'misnamed-queue' },
+      ]);
+    });
+  });
+
+  describe('Hooks', () => {
+    it('should execute init hook', () => {
+      plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+      const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+
+      plugin.init();
+
+      expect(consoleLogSpy).toHaveBeenCalled();
+      consoleLogSpy.mockRestore();
+    });
+
+    it('should execute beforePackageInitialize hook', async () => {
+      plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+
+      await plugin.beforePackageInitialize();
+
+      expect(mockServerless.cli.log).toHaveBeenCalledWith('Frigg Serverless Plugin: Pre-package hook');
+    });
+
+    it('should execute afterPackage hook', () => {
+      plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+      const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+
+      plugin.afterPackage();
+
+      expect(consoleLogSpy).toHaveBeenCalledWith('After package hook called');
+      consoleLogSpy.mockRestore();
+    });
+
+    it('should execute beforeDeploy hook', () => {
+      plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+      const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+
+      plugin.beforeDeploy();
+
+      expect(consoleLogSpy).toHaveBeenCalledWith('Before deploy hook called');
+      consoleLogSpy.mockRestore();
+    });
+  });
+});

package/lib/esbuild-directory-manager.js

@@ -0,0 +1,27 @@
+/**
+ * Infrastructure Service - ESBuild Directory Management
+ *
+ * Ensures .esbuild/.serverless directory exists to prevent ENOENT errors.
+ */
+class EsbuildDirectoryManager {
+  constructor(fs, path) {
+    this.fs = fs;
+    this.path = path;
+  }
+
+  /**
+   * @param {string} basePath - Base service path
+   * @returns {string} Created directory path
+   */
+  ensureDirectory(basePath) {
+    const esbuildDir = this.path.join(basePath, '.esbuild', '.serverless');
+
+    if (!this.fs.existsSync(esbuildDir)) {
+      this.fs.mkdirSync(esbuildDir, { recursive: true });
+    }
+
+    return esbuildDir;
+  }
+}
+
+module.exports = { EsbuildDirectoryManager };

package/lib/esbuild-directory-manager.test.js

@@ -0,0 +1,65 @@
+const { EsbuildDirectoryManager } = require('./esbuild-directory-manager');
+
+describe('EsbuildDirectoryManager', () => {
+  let manager;
+  let mockFs;
+  let mockPath;
+
+  beforeEach(() => {
+    mockFs = {
+      existsSync: jest.fn(),
+      mkdirSync: jest.fn(),
+    };
+    mockPath = {
+      join: jest.fn((...args) => args.join('/')),
+    };
+    manager = new EsbuildDirectoryManager(mockFs, mockPath);
+  });
+
+  describe('ensureDirectory', () => {
+    it('should create directory if it does not exist', () => {
+      mockFs.existsSync.mockReturnValue(false);
+
+      const result = manager.ensureDirectory('/test/path');
+
+      expect(mockPath.join).toHaveBeenCalledWith('/test/path', '.esbuild', '.serverless');
+      expect(mockFs.existsSync).toHaveBeenCalledWith('/test/path/.esbuild/.serverless');
+      expect(mockFs.mkdirSync).toHaveBeenCalledWith('/test/path/.esbuild/.serverless', {
+        recursive: true,
+      });
+      expect(result).toBe('/test/path/.esbuild/.serverless');
+    });
+
+    it('should not create directory if it already exists', () => {
+      mockFs.existsSync.mockReturnValue(true);
+
+      const result = manager.ensureDirectory('/test/path');
+
+      expect(mockFs.existsSync).toHaveBeenCalledWith('/test/path/.esbuild/.serverless');
+      expect(mockFs.mkdirSync).not.toHaveBeenCalled();
+      expect(result).toBe('/test/path/.esbuild/.serverless');
+    });
+
+    it('should handle different base paths', () => {
+      mockFs.existsSync.mockReturnValue(false);
+
+      manager.ensureDirectory('/different/base');
+
+      expect(mockPath.join).toHaveBeenCalledWith('/different/base', '.esbuild', '.serverless');
+      expect(mockFs.mkdirSync).toHaveBeenCalledWith('/different/base/.esbuild/.serverless', {
+        recursive: true,
+      });
+    });
+
+    it('should propagate fs errors', () => {
+      mockFs.existsSync.mockReturnValue(false);
+      mockFs.mkdirSync.mockImplementation(() => {
+        throw new Error('Permission denied');
+      });
+
+      expect(() => {
+        manager.ensureDirectory('/test/path');
+      }).toThrow('Permission denied');
+    });
+  });
+});

package/lib/localstack-queue-service.js

@@ -0,0 +1,149 @@
+/**
+ * Infrastructure Service - LocalStack Queue Management
+ *
+ * Handles SQS queue creation in LocalStack for offline development.
+ *
+ * On deployed AWS, CloudFormation applies queue properties
+ * (VisibilityTimeout, MessageRetentionPeriod, RedrivePolicy) from the
+ * `Resources` block in serverless.yml. LocalStack gets those same
+ * properties here so local emulation matches production behavior —
+ * otherwise the queue defaults to a 30s VisibilityTimeout which re-
+ * delivers in-flight messages while a long-running queue worker is
+ * still processing them.
+ */
+class LocalStackQueueService {
+  constructor(sqsClient) {
+    this.sqs = sqsClient;
+  }
+
+  /**
+   * Whitelist of CloudFormation `AWS::SQS::Queue` Properties that map
+   * onto SQS `CreateQueue` Attributes. Everything else (tags, inline
+   * refs, etc.) is dropped on the way to LocalStack.
+   * @private
+   */
+  static PROPERTY_ATTRIBUTE_KEYS = [
+    'DelaySeconds',
+    'MaximumMessageSize',
+    'MessageRetentionPeriod',
+    'ReceiveMessageWaitTimeSeconds',
+    'VisibilityTimeout',
+    'RedrivePolicy',
+    'RedriveAllowPolicy',
+    'KmsMasterKeyId',
+    'KmsDataKeyReusePeriodSeconds',
+    'SqsManagedSseEnabled',
+    'FifoQueue',
+    'ContentBasedDeduplication',
+    'DeduplicationScope',
+    'FifoThroughputLimit',
+  ];
+
+  /**
+   * Serialize a CloudFormation `Properties` object into the
+   * `Attributes` shape the SQS `CreateQueue` API accepts (string
+   * values only; object values like `RedrivePolicy` get JSON-encoded).
+   *
+   * Attributes whose value still contains an unresolved CloudFormation
+   * intrinsic (`Fn::GetAtt`, `Ref`, `Fn::Sub`, …) are DROPPED rather
+   * than stringified. Example: integration-builder.js emits
+   * `RedrivePolicy.deadLetterTargetArn: {'Fn::GetAtt': [...]}`, which
+   * CloudFormation resolves to a real ARN in AWS but is still a raw
+   * intrinsic object at local plugin-time. Forwarding that JSON blob
+   * to SQS `CreateQueue` would fail (`deadLetterTargetArn` must be a
+   * valid ARN string) or produce malformed config. Dropping the
+   * attribute gives local parity on every other queue property
+   * (notably `VisibilityTimeout`, which is the main reason this code
+   * exists) while leaving the DLQ association intentionally un-wired
+   * locally — matching the pre-PR behavior for that one attribute.
+   * @private
+   */
+  _propertiesToAttributes(properties = {}) {
+    const attributes = {};
+    for (const key of LocalStackQueueService.PROPERTY_ATTRIBUTE_KEYS) {
+      const value = properties[key];
+      if (value === undefined || value === null) continue;
+      if (LocalStackQueueService._containsUnresolvedIntrinsic(value)) {
+        console.warn(
+          `[frigg-plugin] Skipping queue attribute "${key}" because it contains an unresolved CloudFormation intrinsic. ` +
+            `Deployed AWS will apply it via CloudFormation; local emulation will fall back to the AWS default for this attribute.`
+        );
+        continue;
+      }
+      attributes[key] =
+        typeof value === 'object' ? JSON.stringify(value) : String(value);
+    }
+    return attributes;
+  }
+
+  /**
+   * Recursively checks whether a value still contains a CloudFormation
+   * intrinsic function key (`Fn::*` or `Ref`). Such values are unsafe
+   * to pass through to SQS `CreateQueue` — AWS's runtime API doesn't
+   * understand CloudFormation intrinsics; they're only valid inside
+   * serverless.yml / CloudFormation templates.
+   * @private
+   */
+  static _containsUnresolvedIntrinsic(value) {
+    if (value === null || value === undefined) return false;
+    if (typeof value !== 'object') return false;
+    if (Array.isArray(value)) {
+      return value.some((v) =>
+        LocalStackQueueService._containsUnresolvedIntrinsic(v)
+      );
+    }
+    for (const key of Object.keys(value)) {
+      if (key === 'Ref' || key.startsWith('Fn::')) return true;
+      if (
+        LocalStackQueueService._containsUnresolvedIntrinsic(value[key])
+      ) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * @param {string} queueName - Name of queue to create
+   * @param {Object} [attributes] - SQS CreateQueue Attributes (already
+   *   stringified); missing/empty attributes fall back to AWS defaults.
+   * @returns {Promise<string>} Queue URL
+   */
+  async createQueue(queueName, attributes) {
+    return new Promise((resolve, reject) => {
+      const params = { QueueName: queueName };
+      if (attributes && Object.keys(attributes).length > 0) {
+        params.Attributes = attributes;
+      }
+      this.sqs.createQueue(params, (err, data) => {
+        if (err) {
+          reject(new Error(`Failed to create queue ${queueName}: ${err.message}`));
+        } else {
+          resolve(data.QueueUrl);
+        }
+      });
+    });
+  }
+
+  /**
+   * @param {Array<{key: string, name: string, properties?: Object}>} queues
+   *   Queue definitions. `properties` mirrors the CloudFormation
+   *   `AWS::SQS::Queue` Properties block; extracted by the plugin from
+   *   `serverless.service.resources.Resources`.
+   * @returns {Promise<Array<{key: string, url: string}>>} Created queues with URLs
+   */
+  async createQueues(queues) {
+    const results = await Promise.all(
+      queues.map(async (queue) => {
+        const attributes = this._propertiesToAttributes(queue.properties);
+        const url = await this.createQueue(queue.name, attributes);
+        console.log(`Queue ${queue.name} created successfully. URL: ${url}`);
+        return { key: queue.key, url };
+      })
+    );
+
+    return results;
+  }
+}
+
+module.exports = { LocalStackQueueService };

package/lib/localstack-queue-service.test.js

@@ -0,0 +1,280 @@
+const { LocalStackQueueService } = require('./localstack-queue-service');
+
+describe('LocalStackQueueService', () => {
+  let service;
+  let mockSQS;
+
+  beforeEach(() => {
+    mockSQS = {
+      createQueue: jest.fn(),
+    };
+    service = new LocalStackQueueService(mockSQS);
+  });
+
+  describe('createQueue', () => {
+    it('should create queue and return URL on success', async () => {
+      const queueUrl = 'http://localhost:4566/000000000000/test-queue';
+      mockSQS.createQueue.mockImplementation((params, callback) => {
+        callback(null, { QueueUrl: queueUrl });
+      });
+
+      const result = await service.createQueue('test-queue');
+
+      expect(result).toBe(queueUrl);
+      expect(mockSQS.createQueue).toHaveBeenCalledWith(
+        { QueueName: 'test-queue' },
+        expect.any(Function)
+      );
+    });
+
+    it('should pass Attributes when provided', async () => {
+      mockSQS.createQueue.mockImplementation((params, callback) => {
+        callback(null, { QueueUrl: 'url' });
+      });
+
+      await service.createQueue('test-queue', {
+        VisibilityTimeout: '1800',
+        MessageRetentionPeriod: '345600',
+      });
+
+      expect(mockSQS.createQueue).toHaveBeenCalledWith(
+        {
+          QueueName: 'test-queue',
+          Attributes: {
+            VisibilityTimeout: '1800',
+            MessageRetentionPeriod: '345600',
+          },
+        },
+        expect.any(Function)
+      );
+    });
+
+    it('should omit Attributes when empty', async () => {
+      mockSQS.createQueue.mockImplementation((params, callback) => {
+        callback(null, { QueueUrl: 'url' });
+      });
+
+      await service.createQueue('test-queue', {});
+
+      expect(mockSQS.createQueue).toHaveBeenCalledWith(
+        { QueueName: 'test-queue' },
+        expect.any(Function)
+      );
+    });
+
+    it('should reject with error on failure', async () => {
+      const error = new Error('SQS Error');
+      mockSQS.createQueue.mockImplementation((params, callback) => {
+        callback(error);
+      });
+
+      await expect(service.createQueue('test-queue')).rejects.toThrow(
+        'Failed to create queue test-queue: SQS Error'
+      );
+    });
+  });
+
+  describe('_propertiesToAttributes', () => {
+    it('maps CloudFormation Properties onto SQS Attributes and stringifies', () => {
+      const attrs = service._propertiesToAttributes({
+        VisibilityTimeout: 1800,
+        MessageRetentionPeriod: 345600,
+        RedrivePolicy: {
+          maxReceiveCount: 3,
+          deadLetterTargetArn: 'arn:aws:sqs:us-east-1:x:dlq',
+        },
+        QueueName: 'should-be-dropped',
+        Tags: [{ Key: 'ignored', Value: 'yes' }],
+      });
+
+      expect(attrs).toEqual({
+        VisibilityTimeout: '1800',
+        MessageRetentionPeriod: '345600',
+        RedrivePolicy: JSON.stringify({
+          maxReceiveCount: 3,
+          deadLetterTargetArn: 'arn:aws:sqs:us-east-1:x:dlq',
+        }),
+      });
+    });
+
+    it('skips undefined and null values', () => {
+      const attrs = service._propertiesToAttributes({
+        VisibilityTimeout: 60,
+        MessageRetentionPeriod: undefined,
+        KmsMasterKeyId: null,
+      });
+      expect(attrs).toEqual({ VisibilityTimeout: '60' });
+    });
+
+    it('returns an empty object when properties are missing', () => {
+      expect(service._propertiesToAttributes()).toEqual({});
+    });
+
+    it('drops attributes containing unresolved CloudFormation intrinsics', () => {
+      const warnSpy = jest.spyOn(console, 'warn').mockImplementation();
+      const attrs = service._propertiesToAttributes({
+        VisibilityTimeout: 1800,
+        RedrivePolicy: {
+          maxReceiveCount: 3,
+          deadLetterTargetArn: {
+            'Fn::GetAtt': ['InternalErrorQueue', 'Arn'],
+          },
+        },
+      });
+
+      // VisibilityTimeout survives; RedrivePolicy is dropped because
+      // deadLetterTargetArn is still an unresolved Fn::GetAtt intrinsic
+      // (real AWS resolves it via CloudFormation; LocalStack cannot).
+      expect(attrs).toEqual({ VisibilityTimeout: '1800' });
+      expect(attrs).not.toHaveProperty('RedrivePolicy');
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Skipping queue attribute "RedrivePolicy"')
+      );
+      warnSpy.mockRestore();
+    });
+
+    it('drops attributes with Ref intrinsics', () => {
+      jest.spyOn(console, 'warn').mockImplementation();
+      const attrs = service._propertiesToAttributes({
+        VisibilityTimeout: 60,
+        KmsMasterKeyId: { Ref: 'MyKmsKey' },
+      });
+      expect(attrs).toEqual({ VisibilityTimeout: '60' });
+    });
+
+    it('detects intrinsics nested deep inside objects and arrays', () => {
+      expect(
+        LocalStackQueueService._containsUnresolvedIntrinsic({
+          a: { b: [{ c: { 'Fn::Sub': '${AWS::Region}' } }] },
+        })
+      ).toBe(true);
+      expect(
+        LocalStackQueueService._containsUnresolvedIntrinsic({
+          a: { b: [{ c: 'hello' }] },
+        })
+      ).toBe(false);
+      expect(LocalStackQueueService._containsUnresolvedIntrinsic(null)).toBe(false);
+      expect(LocalStackQueueService._containsUnresolvedIntrinsic('str')).toBe(false);
+    });
+
+    it('retains resolved RedrivePolicy (ARN already a string)', () => {
+      const attrs = service._propertiesToAttributes({
+        RedrivePolicy: {
+          maxReceiveCount: 3,
+          deadLetterTargetArn: 'arn:aws:sqs:us-east-1:x:dlq',
+        },
+      });
+      expect(attrs.RedrivePolicy).toBe(
+        JSON.stringify({
+          maxReceiveCount: 3,
+          deadLetterTargetArn: 'arn:aws:sqs:us-east-1:x:dlq',
+        })
+      );
+    });
+  });
+
+  describe('createQueues', () => {
+    it('should create multiple queues and return results', async () => {
+      mockSQS.createQueue.mockImplementation((params, callback) => {
+        const url = `http://localhost:4566/000000000000/${params.QueueName}`;
+        callback(null, { QueueUrl: url });
+      });
+
+      const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+
+      const queues = [
+        { key: 'AsanaQueue', name: 'test-asana-queue' },
+        { key: 'SlackQueue', name: 'test-slack-queue' },
+      ];
+
+      const results = await service.createQueues(queues);
+
+      expect(results).toHaveLength(2);
+      expect(results[0]).toEqual({
+        key: 'AsanaQueue',
+        url: 'http://localhost:4566/000000000000/test-asana-queue',
+      });
+      expect(results[1]).toEqual({
+        key: 'SlackQueue',
+        url: 'http://localhost:4566/000000000000/test-slack-queue',
+      });
+
+      expect(consoleLogSpy).toHaveBeenCalledTimes(2);
+      consoleLogSpy.mockRestore();
+    });
+
+    it('forwards CloudFormation Properties as SQS Attributes', async () => {
+      const captured = [];
+      mockSQS.createQueue.mockImplementation((params, callback) => {
+        captured.push(params);
+        callback(null, { QueueUrl: 'url' });
+      });
+      jest.spyOn(console, 'log').mockImplementation();
+
+      await service.createQueues([
+        {
+          key: 'HubspotQueue',
+          name: 'my-service--dev-HubspotQueue',
+          properties: {
+            QueueName: 'my-service--dev-HubspotQueue',
+            VisibilityTimeout: 1800,
+            MessageRetentionPeriod: 345600,
+            RedrivePolicy: {
+              maxReceiveCount: 3,
+              deadLetterTargetArn: 'arn:aws:sqs:us-east-1:x:dlq',
+            },
+          },
+        },
+      ]);
+
+      expect(captured[0]).toEqual({
+        QueueName: 'my-service--dev-HubspotQueue',
+        Attributes: {
+          VisibilityTimeout: '1800',
+          MessageRetentionPeriod: '345600',
+          RedrivePolicy: JSON.stringify({
+            maxReceiveCount: 3,
+            deadLetterTargetArn: 'arn:aws:sqs:us-east-1:x:dlq',
+          }),
+        },
+      });
+    });
+
+    it('creates queues with defaults when properties are missing (back-compat)', async () => {
+      const captured = [];
+      mockSQS.createQueue.mockImplementation((params, callback) => {
+        captured.push(params);
+        callback(null, { QueueUrl: 'url' });
+      });
+      jest.spyOn(console, 'log').mockImplementation();
+
+      await service.createQueues([
+        { key: 'LegacyQueue', name: 'legacy-queue' },
+      ]);
+
+      expect(captured[0]).toEqual({ QueueName: 'legacy-queue' });
+    });
+
+    it('should handle empty queue array', async () => {
+      const results = await service.createQueues([]);
+      expect(results).toEqual([]);
+    });
+
+    it('should reject if any queue creation fails', async () => {
+      mockSQS.createQueue.mockImplementation((params, callback) => {
+        if (params.QueueName === 'failing-queue') {
+          callback(new Error('Failed'));
+        } else {
+          callback(null, { QueueUrl: 'http://localhost:4566/queue' });
+        }
+      });
+
+      const queues = [
+        { key: 'SuccessQueue', name: 'success-queue' },
+        { key: 'FailQueue', name: 'failing-queue' },
+      ];
+
+      await expect(service.createQueues(queues)).rejects.toThrow('Failed to create queue failing-queue');
+    });
+  });
+});

package/lib/queue-environment-mapper.js

@@ -0,0 +1,44 @@
+/**
+ * Domain Service - Queue to Environment Variable Mapper
+ *
+ * Maps queue keys to environment variable names using naming convention.
+ * Pattern: AsanaQueue -> ASANA_QUEUE_URL
+ */
+class QueueEnvironmentMapper {
+  /**
+   * @param {Array<{key: string, name: string}>} queues - Queue definitions
+   * @returns {Object} Map of queue keys to environment variable names
+   */
+  createMapping(queues) {
+    const mapping = {};
+
+    queues.forEach(queue => {
+      const baseName = queue.key.replace(/Queue$/, '');
+      const envVarName = `${baseName.toUpperCase()}_QUEUE_URL`;
+      mapping[queue.key] = envVarName;
+    });
+
+    return mapping;
+  }
+
+  /**
+   * @param {string} queueKey - Queue key to look up
+   * @param {Object} mapping - Environment variable mapping
+   * @returns {string} Environment variable name
+   * @throws {Error} If no mapping found
+   */
+  getEnvironmentKey(queueKey, mapping) {
+    const envKey = mapping[queueKey];
+
+    if (!envKey) {
+      throw new Error(
+        `No environment variable mapping found for queue "${queueKey}". ` +
+        `Expected pattern: {QueueName}Queue -> {QUEUENAME}_QUEUE_URL`
+      );
+    }
+
+    return envKey;
+  }
+}
+
+module.exports = { QueueEnvironmentMapper };

package/lib/queue-environment-mapper.test.js

@@ -0,0 +1,74 @@
+const { QueueEnvironmentMapper } = require('./queue-environment-mapper');
+
+describe('QueueEnvironmentMapper', () => {
+  let mapper;
+
+  beforeEach(() => {
+    mapper = new QueueEnvironmentMapper();
+  });
+
+  describe('createMapping', () => {
+    it('should map single queue key to environment variable name', () => {
+      const queues = [{ key: 'AsanaQueue', name: 'test-asana-queue' }];
+      const result = mapper.createMapping(queues);
+
+      expect(result).toEqual({
+        AsanaQueue: 'ASANA_QUEUE_URL',
+      });
+    });
+
+    it('should map multiple queue keys to environment variable names', () => {
+      const queues = [
+        { key: 'AsanaQueue', name: 'test-asana-queue' },
+        { key: 'SlackQueue', name: 'test-slack-queue' },
+        { key: 'HubspotQueue', name: 'test-hubspot-queue' },
+      ];
+      const result = mapper.createMapping(queues);
+
+      expect(result).toEqual({
+        AsanaQueue: 'ASANA_QUEUE_URL',
+        SlackQueue: 'SLACK_QUEUE_URL',
+        HubspotQueue: 'HUBSPOT_QUEUE_URL',
+      });
+    });
+
+    it('should handle empty queue array', () => {
+      const result = mapper.createMapping([]);
+      expect(result).toEqual({});
+    });
+
+    it('should preserve case in base name conversion', () => {
+      const queues = [{ key: 'MyCustomQueue', name: 'test-queue' }];
+      const result = mapper.createMapping(queues);
+
+      expect(result).toEqual({
+        MyCustomQueue: 'MYCUSTOM_QUEUE_URL',
+      });
+    });
+  });
+
+  describe('getEnvironmentKey', () => {
+    it('should return environment variable name for valid queue key', () => {
+      const mapping = { AsanaQueue: 'ASANA_QUEUE_URL' };
+      const result = mapper.getEnvironmentKey('AsanaQueue', mapping);
+
+      expect(result).toBe('ASANA_QUEUE_URL');
+    });
+
+    it('should throw error for missing queue key', () => {
+      const mapping = { AsanaQueue: 'ASANA_QUEUE_URL' };
+
+      expect(() => {
+        mapper.getEnvironmentKey('InvalidQueue', mapping);
+      }).toThrow('No environment variable mapping found for queue "InvalidQueue"');
+    });
+
+    it('should throw error with helpful message pattern', () => {
+      const mapping = {};
+
+      expect(() => {
+        mapper.getEnvironmentKey('TestQueue', mapping);
+      }).toThrow('Expected pattern: {QueueName}Queue -> {QUEUENAME}_QUEUE_URL');
+    });
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@friggframework/serverless-plugin",
-  "version": "2.0.0-next.8",
+  "version": "2.0.0-next.81",
   "description": "Plugin to help dynamically load frigg resources",
   "main": "index.js",
   "scripts": {
@@ -11,5 +11,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "60b7a6f92954ad165186861a35fba66e40f60a42"
+  "gitHead": "f928679326fe06cc56ac46e97cf268fe8f8e823e"
 }