@friggframework/serverless-plugin 2.0.0-next.80 → 2.0.0-next.82

package/index.js

@@ -66,12 +66,37 @@ class FriggServerlessPlugin {
   }
 
   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) => ({
-        key,
-        name: this.serverless.service.custom[key],
-      }));
+      .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() {

package/index.test.js

@@ -183,6 +183,75 @@ describe('FriggServerlessPlugin', () => {
 
       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', () => {

package/lib/localstack-queue-service.js

@@ -2,19 +2,120 @@
  * 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) {
+  async createQueue(queueName, attributes) {
     return new Promise((resolve, reject) => {
-      this.sqs.createQueue({ QueueName: queueName }, (err, data) => {
+      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 {
@@ -25,13 +126,17 @@ class LocalStackQueueService {
   }
 
   /**
-   * @param {Array<{key: string, name: string}>} queues - Queue definitions
+   * @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 url = await this.createQueue(queue.name);
+        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 };
       })

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

@@ -27,6 +27,41 @@ describe('LocalStackQueueService', () => {
       );
     });
 
+    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) => {
@@ -39,6 +74,105 @@ describe('LocalStackQueueService', () => {
     });
   });
 
+  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) => {
@@ -69,6 +203,58 @@ describe('LocalStackQueueService', () => {
       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([]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@friggframework/serverless-plugin",
-  "version": "2.0.0-next.80",
+  "version": "2.0.0-next.82",
   "description": "Plugin to help dynamically load frigg resources",
   "main": "index.js",
   "scripts": {
@@ -11,5 +11,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "7a66dfcb02143941411ff26aaee866afc1473df8"
+  "gitHead": "765f34d4ea2b2861f4a1723f8b319bfef9a5aea8"
 }