sqs-consumer 5.4.0 → 5.7.0

package/src/consumer.ts

@@ -9,8 +9,8 @@ import { SQSError, TimeoutError } from './errors';
 const debug = Debug('sqs-consumer');
 
 type ReceieveMessageResponse = PromiseResult<SQS.Types.ReceiveMessageResult, AWSError>;
-type SQSMessage = SQS.Types.Message;
 type ReceiveMessageRequest = SQS.Types.ReceiveMessageRequest;
+export type SQSMessage = SQS.Types.Message;
 
 const requiredOptions = [
   'queueUrl',
@@ -44,9 +44,13 @@ function assertOptions(options: ConsumerOptions): void {
   if (options.batchSize > 10 || options.batchSize < 1) {
     throw new Error('SQS batchSize option must be between 1 and 10.');
   }
+
+  if (options.heartbeatInterval && !(options.heartbeatInterval < options.visibilityTimeout)) {
+    throw new Error('heartbeatInterval must be less than visibilityTimeout.');
+  }
 }
 
-function isConnectionError(err: Error): Boolean {
+function isConnectionError(err: Error): boolean {
   if (err instanceof SQSError) {
     return (err.statusCode === 403 || err.code === 'CredentialsError' || err.code === 'UnknownEndpoint');
   }
@@ -80,13 +84,26 @@ export interface ConsumerOptions {
   authenticationErrorTimeout?: number;
   pollingWaitTimeMs?: number;
   terminateVisibilityTimeout?: boolean;
+  heartbeatInterval?: number;
   sqs?: SQS;
   region?: string;
   handleMessageTimeout?: number;
+  shouldDeleteMessages?: boolean;
   handleMessage?(message: SQSMessage): Promise<void>;
   handleMessageBatch?(messages: SQSMessage[]): Promise<void>;
 }
 
+interface Events {
+  'response_processed': [];
+  'empty': [];
+  'message_received': [SQSMessage];
+  'message_processed': [SQSMessage];
+  'error': [Error, void | SQSMessage | SQSMessage[]];
+  'timeout_error': [Error, SQSMessage];
+  'processing_error': [Error, SQSMessage];
+  'stopped': [];
+}
+
 export class Consumer extends EventEmitter {
   private queueUrl: string;
   private handleMessage: (message: SQSMessage) => Promise<void>;
@@ -101,7 +118,9 @@ export class Consumer extends EventEmitter {
   private authenticationErrorTimeout: number;
   private pollingWaitTimeMs: number;
   private terminateVisibilityTimeout: boolean;
+  private heartbeatInterval: number;
   private sqs: SQS;
+  private shouldDeleteMessages: boolean;
 
   constructor(options: ConsumerOptions) {
     super();
@@ -116,9 +135,11 @@ export class Consumer extends EventEmitter {
     this.batchSize = options.batchSize || 1;
     this.visibilityTimeout = options.visibilityTimeout;
     this.terminateVisibilityTimeout = options.terminateVisibilityTimeout || false;
-    this.waitTimeSeconds = options.waitTimeSeconds || 20;
-    this.authenticationErrorTimeout = options.authenticationErrorTimeout || 10000;
-    this.pollingWaitTimeMs = options.pollingWaitTimeMs || 0;
+    this.heartbeatInterval = options.heartbeatInterval;
+    this.waitTimeSeconds = options.waitTimeSeconds ?? 20;
+    this.authenticationErrorTimeout = options.authenticationErrorTimeout ?? 10000;
+    this.pollingWaitTimeMs = options.pollingWaitTimeMs ?? 0;
+    this.shouldDeleteMessages = options.shouldDeleteMessages ?? true;
 
     this.sqs = options.sqs || new SQS({
       region: options.region || process.env.AWS_REGION || 'eu-west-1'
@@ -127,6 +148,18 @@ export class Consumer extends EventEmitter {
     autoBind(this);
   }
 
+  emit<T extends keyof Events>(event: T, ...args: Events[T]) {
+    return super.emit(event, ...args);
+  }
+
+  on<T extends keyof Events>(event: T, listener: (...args: Events[T]) => void): this {
+    return super.on(event, listener);
+  }
+
+  once<T extends keyof Events>(event: T, listener: (...args: Events[T]) => void): this {
+    return super.once(event, listener);
+  }
+
   public get isRunning(): boolean {
     return !this.stopped;
   }
@@ -170,7 +203,13 @@ export class Consumer extends EventEmitter {
   private async processMessage(message: SQSMessage): Promise<void> {
     this.emit('message_received', message);
 
+    let heartbeat;
     try {
+      if (this.heartbeatInterval) {
+        heartbeat = this.startHeartbeat(async () => {
+          return this.changeVisibilityTimeout(message, this.visibilityTimeout);
+        });
+      }
       await this.executeHandler(message);
       await this.deleteMessage(message);
       this.emit('message_processed', message);
@@ -178,12 +217,10 @@ export class Consumer extends EventEmitter {
       this.emitError(err, message);
 
       if (this.terminateVisibilityTimeout) {
-        try {
-          await this.terminateVisabilityTimeout(message);
-        } catch (err) {
-          this.emit('error', err, message);
-        }
+        await this.changeVisibilityTimeout(message, 0);
       }
+    } finally {
+      clearInterval(heartbeat);
     }
   }
 
@@ -198,6 +235,10 @@ export class Consumer extends EventEmitter {
   }
 
   private async deleteMessage(message: SQSMessage): Promise<void> {
+    if (!this.shouldDeleteMessages) {
+      debug('Skipping message delete since shouldDeleteMessages is set to false');
+      return;
+    }
     debug('Deleting message %s', message.MessageId);
 
     const deleteParams = {
@@ -230,7 +271,7 @@ export class Consumer extends EventEmitter {
     } catch (err) {
       if (err instanceof TimeoutError) {
         err.message = `Message handler timed out after ${this.handleMessageTimeout}ms: Operation timed out.`;
-      } else {
+      } else if (err instanceof Error) {
         err.message = `Unexpected message handler failure: ${err.message}`;
       }
       throw err;
@@ -239,14 +280,18 @@ export class Consumer extends EventEmitter {
     }
   }
 
-  private async terminateVisabilityTimeout(message: SQSMessage): Promise<PromiseResult<any, AWSError>> {
-    return this.sqs
-      .changeMessageVisibility({
-        QueueUrl: this.queueUrl,
-        ReceiptHandle: message.ReceiptHandle,
-        VisibilityTimeout: 0
-      })
-      .promise();
+  private async changeVisibilityTimeout(message: SQSMessage, timeout: number): Promise<PromiseResult<any, AWSError>> {
+    try {
+      return await this.sqs
+        .changeMessageVisibility({
+          QueueUrl: this.queueUrl,
+          ReceiptHandle: message.ReceiptHandle,
+          VisibilityTimeout: timeout
+        })
+        .promise();
+    } catch (err) {
+      this.emit('error', toSQSError(err, `Error changing visibility timeout: ${err.message}`), message);
+    }
   }
 
   private emitError(err: Error, message: SQSMessage): void {
@@ -286,7 +331,7 @@ export class Consumer extends EventEmitter {
         }
         return;
       }).then(() => {
-      setTimeout(this.poll, currentPollingTimeout);
+        setTimeout(this.poll, currentPollingTimeout);
       }).catch((err) => {
         this.emit('error', err);
       });
@@ -297,7 +342,13 @@ export class Consumer extends EventEmitter {
       this.emit('message_received', message);
     });
 
+    let heartbeat;
     try {
+      if (this.heartbeatInterval) {
+        heartbeat = this.startHeartbeat(async () => {
+          return this.changeVisabilityTimeoutBatch(messages, this.visibilityTimeout);
+        });
+      }
       await this.executeBatchHandler(messages);
       await this.deleteMessageBatch(messages);
       messages.forEach((message) => {
@@ -307,21 +358,23 @@ export class Consumer extends EventEmitter {
       this.emit('error', err, messages);
 
       if (this.terminateVisibilityTimeout) {
-        try {
-          await this.terminateVisabilityTimeoutBatch(messages);
-        } catch (err) {
-          this.emit('error', err, messages);
-        }
+        await this.changeVisabilityTimeoutBatch(messages, 0);
       }
+    } finally {
+      clearInterval(heartbeat);
     }
   }
 
   private async deleteMessageBatch(messages: SQSMessage[]): Promise<void> {
+    if (!this.shouldDeleteMessages) {
+      debug('Skipping message delete since shouldDeleteMessages is set to false');
+      return;
+    }
     debug('Deleting messages %s', messages.map((msg) => msg.MessageId).join(' ,'));
 
     const deleteParams = {
       QueueUrl: this.queueUrl,
-      Entries: messages.map(message => ({
+      Entries: messages.map((message) => ({
         Id: message.MessageId,
         ReceiptHandle: message.ReceiptHandle
       }))
@@ -345,18 +398,27 @@ export class Consumer extends EventEmitter {
     }
   }
 
-  private async terminateVisabilityTimeoutBatch(messages: SQSMessage[]): Promise<PromiseResult<any, AWSError>> {
+  private async changeVisabilityTimeoutBatch(messages: SQSMessage[], timeout: number): Promise<PromiseResult<any, AWSError>> {
     const params = {
       QueueUrl: this.queueUrl,
       Entries: messages.map((message) => ({
         Id: message.MessageId,
         ReceiptHandle: message.ReceiptHandle,
-        VisibilityTimeout: 0
+        VisibilityTimeout: timeout
       }))
     };
-    return this.sqs
-      .changeMessageVisibilityBatch(params)
-      .promise();
+    try {
+      return await this.sqs
+        .changeMessageVisibilityBatch(params)
+        .promise();
+    } catch (err) {
+      this.emit('error', toSQSError(err, `Error changing visibility timeout: ${err.message}`), messages);
+    }
   }
 
+  private startHeartbeat(heartbeatFn: () => void): NodeJS.Timeout {
+    return setInterval(() => {
+      heartbeatFn();
+    }, this.heartbeatInterval * 1000);
+  }
 }

package/src/errors.ts

@@ -13,7 +13,7 @@ class SQSError extends Error {
 }
 
 class TimeoutError extends Error {
-  constructor(message: string = 'Operation timed out.') {
+  constructor(message = 'Operation timed out.') {
     super(message);
     this.message = message;
     this.name = 'TimeoutError';

package/src/index.ts

@@ -1 +1 @@
-export { Consumer, ConsumerOptions } from './consumer';
+export { SQSMessage, Consumer, ConsumerOptions } from './consumer';