sqs-consumer 6.0.0 → 6.0.2

package/dist/bind.d.ts

@@ -0,0 +1 @@
+export declare function autoBind(obj: object): void;

package/dist/bind.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autoBind = void 0;
+function isMethod(propertyName, value) {
+    return propertyName !== 'constructor' && typeof value === 'function';
+}
+function autoBind(obj) {
+    const propertyNames = Object.getOwnPropertyNames(obj.constructor.prototype);
+    propertyNames.forEach((propertyName) => {
+        const value = obj[propertyName];
+        if (isMethod(propertyName, value)) {
+            obj[propertyName] = value.bind(obj);
+        }
+    });
+}
+exports.autoBind = autoBind;

package/dist/consumer.d.ts

@@ -0,0 +1,72 @@
+/// <reference types="node" />
+import { SQSClient, Message } from '@aws-sdk/client-sqs';
+import { EventEmitter } from 'events';
+export interface ConsumerOptions {
+    queueUrl?: string;
+    attributeNames?: string[];
+    messageAttributeNames?: string[];
+    stopped?: boolean;
+    batchSize?: number;
+    visibilityTimeout?: number;
+    waitTimeSeconds?: number;
+    authenticationErrorTimeout?: number;
+    pollingWaitTimeMs?: number;
+    terminateVisibilityTimeout?: boolean;
+    heartbeatInterval?: number;
+    sqs?: SQSClient;
+    region?: string;
+    handleMessageTimeout?: number;
+    shouldDeleteMessages?: boolean;
+    handleMessage?(message: Message): Promise<void>;
+    handleMessageBatch?(messages: Message[]): Promise<void>;
+}
+interface Events {
+    response_processed: [];
+    empty: [];
+    message_received: [Message];
+    message_processed: [Message];
+    error: [Error, void | Message | Message[]];
+    timeout_error: [Error, Message];
+    processing_error: [Error, Message];
+    stopped: [];
+}
+export declare class Consumer extends EventEmitter {
+    private queueUrl;
+    private handleMessage;
+    private handleMessageBatch;
+    private handleMessageTimeout;
+    private attributeNames;
+    private messageAttributeNames;
+    private stopped;
+    private batchSize;
+    private visibilityTimeout;
+    private waitTimeSeconds;
+    private authenticationErrorTimeout;
+    private pollingWaitTimeMs;
+    private terminateVisibilityTimeout;
+    private heartbeatInterval;
+    private sqs;
+    private shouldDeleteMessages;
+    constructor(options: ConsumerOptions);
+    emit<T extends keyof Events>(event: T, ...args: Events[T]): boolean;
+    on<T extends keyof Events>(event: T, listener: (...args: Events[T]) => void): this;
+    once<T extends keyof Events>(event: T, listener: (...args: Events[T]) => void): this;
+    get isRunning(): boolean;
+    static create(options: ConsumerOptions): Consumer;
+    start(): void;
+    stop(): void;
+    private handleSqsResponse;
+    private processMessage;
+    private receiveMessage;
+    private deleteMessage;
+    private executeHandler;
+    private changeVisibilityTimeout;
+    private emitError;
+    private poll;
+    private processMessageBatch;
+    private deleteMessageBatch;
+    private executeBatchHandler;
+    private changeVisibilityTimeoutBatch;
+    private startHeartbeat;
+}
+export {};

package/dist/consumer.js

@@ -0,0 +1,342 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Consumer = void 0;
+const client_sqs_1 = require("@aws-sdk/client-sqs");
+const debug_1 = require("debug");
+const events_1 = require("events");
+const bind_1 = require("./bind");
+const errors_1 = require("./errors");
+const debug = (0, debug_1.default)('sqs-consumer');
+const requiredOptions = [
+    'queueUrl',
+    // only one of handleMessage / handleMessagesBatch is required
+    'handleMessage|handleMessageBatch'
+];
+function createTimeout(duration) {
+    let timeout;
+    const pending = new Promise((_, reject) => {
+        timeout = setTimeout(() => {
+            reject(new errors_1.TimeoutError());
+        }, duration);
+    });
+    return [timeout, pending];
+}
+function assertOptions(options) {
+    requiredOptions.forEach((option) => {
+        const possibilities = option.split('|');
+        if (!possibilities.find((p) => options[p])) {
+            throw new Error(`Missing SQS consumer option [ ${possibilities.join(' or ')} ].`);
+        }
+    });
+    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) {
+    if (err instanceof errors_1.SQSError) {
+        return (err.statusCode === 403 ||
+            err.code === 'CredentialsError' ||
+            err.code === 'UnknownEndpoint');
+    }
+    return false;
+}
+function toSQSError(err, message) {
+    var _a, _b;
+    const sqsError = new errors_1.SQSError(message);
+    sqsError.code = err.name;
+    sqsError.statusCode = (_a = err.$metadata) === null || _a === void 0 ? void 0 : _a.httpStatusCode;
+    sqsError.retryable = (_b = err.$retryable) === null || _b === void 0 ? void 0 : _b.throttling;
+    sqsError.service = err.$service;
+    sqsError.fault = err.$fault;
+    sqsError.time = new Date();
+    return sqsError;
+}
+function hasMessages(response) {
+    return response.Messages && response.Messages.length > 0;
+}
+class Consumer extends events_1.EventEmitter {
+    constructor(options) {
+        var _a, _b, _c, _d;
+        super();
+        assertOptions(options);
+        this.queueUrl = options.queueUrl;
+        this.handleMessage = options.handleMessage;
+        this.handleMessageBatch = options.handleMessageBatch;
+        this.handleMessageTimeout = options.handleMessageTimeout;
+        this.attributeNames = options.attributeNames || [];
+        this.messageAttributeNames = options.messageAttributeNames || [];
+        this.stopped = true;
+        this.batchSize = options.batchSize || 1;
+        this.visibilityTimeout = options.visibilityTimeout;
+        this.terminateVisibilityTimeout =
+            options.terminateVisibilityTimeout || false;
+        this.heartbeatInterval = options.heartbeatInterval;
+        this.waitTimeSeconds = (_a = options.waitTimeSeconds) !== null && _a !== void 0 ? _a : 20;
+        this.authenticationErrorTimeout =
+            (_b = options.authenticationErrorTimeout) !== null && _b !== void 0 ? _b : 10000;
+        this.pollingWaitTimeMs = (_c = options.pollingWaitTimeMs) !== null && _c !== void 0 ? _c : 0;
+        this.shouldDeleteMessages = (_d = options.shouldDeleteMessages) !== null && _d !== void 0 ? _d : true;
+        this.sqs =
+            options.sqs ||
+                new client_sqs_1.SQSClient({
+                    region: options.region || process.env.AWS_REGION || 'eu-west-1'
+                });
+        (0, bind_1.autoBind)(this);
+    }
+    emit(event, ...args) {
+        return super.emit(event, ...args);
+    }
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    once(event, listener) {
+        return super.once(event, listener);
+    }
+    get isRunning() {
+        return !this.stopped;
+    }
+    static create(options) {
+        return new Consumer(options);
+    }
+    start() {
+        if (this.stopped) {
+            debug('Starting consumer');
+            this.stopped = false;
+            this.poll();
+        }
+    }
+    stop() {
+        debug('Stopping consumer');
+        this.stopped = true;
+    }
+    async handleSqsResponse(response) {
+        debug('Received SQS response');
+        debug(response);
+        if (response) {
+            if (hasMessages(response)) {
+                if (this.handleMessageBatch) {
+                    // prefer handling messages in batch when available
+                    await this.processMessageBatch(response.Messages);
+                }
+                else {
+                    await Promise.all(response.Messages.map(this.processMessage));
+                }
+                this.emit('response_processed');
+            }
+            else {
+                this.emit('empty');
+            }
+        }
+    }
+    async processMessage(message) {
+        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);
+        }
+        catch (err) {
+            this.emitError(err, message);
+            if (this.terminateVisibilityTimeout) {
+                await this.changeVisibilityTimeout(message, 0);
+            }
+        }
+        finally {
+            clearInterval(heartbeat);
+        }
+    }
+    async receiveMessage(params) {
+        try {
+            return await this.sqs.send(new client_sqs_1.ReceiveMessageCommand(params));
+        }
+        catch (err) {
+            throw toSQSError(err, `SQS receive message failed: ${err.message}`);
+        }
+    }
+    async deleteMessage(message) {
+        if (!this.shouldDeleteMessages) {
+            debug('Skipping message delete since shouldDeleteMessages is set to false');
+            return;
+        }
+        debug('Deleting message %s', message.MessageId);
+        const deleteParams = {
+            QueueUrl: this.queueUrl,
+            ReceiptHandle: message.ReceiptHandle
+        };
+        try {
+            await this.sqs.send(new client_sqs_1.DeleteMessageCommand(deleteParams));
+        }
+        catch (err) {
+            throw toSQSError(err, `SQS delete message failed: ${err.message}`);
+        }
+    }
+    async executeHandler(message) {
+        let timeout;
+        let pending;
+        try {
+            if (this.handleMessageTimeout) {
+                [timeout, pending] = createTimeout(this.handleMessageTimeout);
+                await Promise.race([this.handleMessage(message), pending]);
+            }
+            else {
+                await this.handleMessage(message);
+            }
+        }
+        catch (err) {
+            if (err instanceof errors_1.TimeoutError) {
+                err.message = `Message handler timed out after ${this.handleMessageTimeout}ms: Operation timed out.`;
+            }
+            else if (err instanceof Error) {
+                err.message = `Unexpected message handler failure: ${err.message}`;
+            }
+            throw err;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    async changeVisibilityTimeout(message, timeout) {
+        try {
+            const input = {
+                QueueUrl: this.queueUrl,
+                ReceiptHandle: message.ReceiptHandle,
+                VisibilityTimeout: timeout
+            };
+            return await this.sqs.send(new client_sqs_1.ChangeMessageVisibilityCommand(input));
+        }
+        catch (err) {
+            this.emit('error', toSQSError(err, `Error changing visibility timeout: ${err.message}`), message);
+        }
+    }
+    emitError(err, message) {
+        if (err.name === errors_1.SQSError.name) {
+            this.emit('error', err, message);
+        }
+        else if (err instanceof errors_1.TimeoutError) {
+            this.emit('timeout_error', err, message);
+        }
+        else {
+            this.emit('processing_error', err, message);
+        }
+    }
+    poll() {
+        if (this.stopped) {
+            this.emit('stopped');
+            return;
+        }
+        debug('Polling for messages');
+        const receiveParams = {
+            QueueUrl: this.queueUrl,
+            AttributeNames: this.attributeNames,
+            MessageAttributeNames: this.messageAttributeNames,
+            MaxNumberOfMessages: this.batchSize,
+            WaitTimeSeconds: this.waitTimeSeconds,
+            VisibilityTimeout: this.visibilityTimeout
+        };
+        let currentPollingTimeout = this.pollingWaitTimeMs;
+        this.receiveMessage(receiveParams)
+            .then(this.handleSqsResponse)
+            .catch((err) => {
+            this.emit('error', err);
+            if (isConnectionError(err)) {
+                debug('There was an authentication error. Pausing before retrying.');
+                currentPollingTimeout = this.authenticationErrorTimeout;
+            }
+            return;
+        })
+            .then(() => {
+            setTimeout(this.poll, currentPollingTimeout);
+        })
+            .catch((err) => {
+            this.emit('error', err);
+        });
+    }
+    async processMessageBatch(messages) {
+        messages.forEach((message) => {
+            this.emit('message_received', message);
+        });
+        let heartbeat;
+        try {
+            if (this.heartbeatInterval) {
+                heartbeat = this.startHeartbeat(async () => {
+                    return this.changeVisibilityTimeoutBatch(messages, this.visibilityTimeout);
+                });
+            }
+            await this.executeBatchHandler(messages);
+            await this.deleteMessageBatch(messages);
+            messages.forEach((message) => {
+                this.emit('message_processed', message);
+            });
+        }
+        catch (err) {
+            this.emit('error', err, messages);
+            if (this.terminateVisibilityTimeout) {
+                await this.changeVisibilityTimeoutBatch(messages, 0);
+            }
+        }
+        finally {
+            clearInterval(heartbeat);
+        }
+    }
+    async deleteMessageBatch(messages) {
+        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) => ({
+                Id: message.MessageId,
+                ReceiptHandle: message.ReceiptHandle
+            }))
+        };
+        try {
+            await this.sqs.send(new client_sqs_1.DeleteMessageBatchCommand(deleteParams));
+        }
+        catch (err) {
+            throw toSQSError(err, `SQS delete message failed: ${err.message}`);
+        }
+    }
+    async executeBatchHandler(messages) {
+        try {
+            await this.handleMessageBatch(messages);
+        }
+        catch (err) {
+            err.message = `Unexpected message handler failure: ${err.message}`;
+            throw err;
+        }
+    }
+    async changeVisibilityTimeoutBatch(messages, timeout) {
+        const params = {
+            QueueUrl: this.queueUrl,
+            Entries: messages.map((message) => ({
+                Id: message.MessageId,
+                ReceiptHandle: message.ReceiptHandle,
+                VisibilityTimeout: timeout
+            }))
+        };
+        try {
+            return await this.sqs.send(new client_sqs_1.ChangeMessageVisibilityBatchCommand(params));
+        }
+        catch (err) {
+            this.emit('error', toSQSError(err, `Error changing visibility timeout: ${err.message}`), messages);
+        }
+    }
+    startHeartbeat(heartbeatFn) {
+        return setInterval(() => {
+            heartbeatFn();
+        }, this.heartbeatInterval * 1000);
+    }
+}
+exports.Consumer = Consumer;

package/dist/errors.d.ts

@@ -0,0 +1,13 @@
+declare class SQSError extends Error {
+    code: string;
+    statusCode: number;
+    service: string;
+    time: Date;
+    retryable: boolean;
+    fault: 'client' | 'server';
+    constructor(message: string);
+}
+declare class TimeoutError extends Error {
+    constructor(message?: string);
+}
+export { SQSError, TimeoutError };

package/dist/errors.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeoutError = exports.SQSError = void 0;
+class SQSError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = this.constructor.name;
+    }
+}
+exports.SQSError = SQSError;
+class TimeoutError extends Error {
+    constructor(message = 'Operation timed out.') {
+        super(message);
+        this.message = message;
+        this.name = 'TimeoutError';
+    }
+}
+exports.TimeoutError = TimeoutError;

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Consumer = void 0;
+var consumer_1 = require("./consumer");
+Object.defineProperty(exports, "Consumer", { enumerable: true, get: function () { return consumer_1.Consumer; } });

package/dist/types.d.ts

@@ -0,0 +1,59 @@
+export type AWSError = {
+    /**
+     * Name, eg. ConditionalCheckFailedException
+     */
+    name: string;
+    /**
+     * Human-readable error response message
+     */
+    message: string;
+    /**
+     * Non-standard stacktrace
+     */
+    stack?: string;
+    /**
+     * Whether the client or server are at fault.
+     */
+    readonly $fault?: 'client' | 'server';
+    /**
+     * The service that encountered the exception.
+     */
+    readonly $service?: string;
+    /**
+     * Indicates that an error MAY be retried by the client.
+     */
+    readonly $retryable?: {
+        /**
+         * Indicates that the error is a retryable throttling error.
+         */
+        readonly throttling?: boolean;
+    };
+    $metadata?: {
+        /**
+         * The status code of the last HTTP response received for this operation.
+         */
+        httpStatusCode?: number;
+        /**
+         * A unique identifier for the last request sent for this operation. Often
+         * requested by AWS service teams to aid in debugging.
+         */
+        requestId?: string;
+        /**
+         * A secondary identifier for the last request sent. Used for debugging.
+         */
+        extendedRequestId?: string;
+        /**
+         * A tertiary identifier for the last request sent. Used for debugging.
+         */
+        cfId?: string;
+        /**
+         * The number of times this operation was attempted.
+         */
+        attempts?: number;
+        /**
+         * The total amount of time (in milliseconds) that was spent waiting between
+         * retry attempts.
+         */
+        totalRetryDelay?: number;
+    };
+};

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sqs-consumer",
-  "version": "6.0.0",
+  "version": "6.0.2",
   "description": "Build SQS-based Node applications without the boilerplate",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -8,7 +8,7 @@
     "build": "npm run clean && tsc",
     "watch": "tsc --watch",
     "clean": "rm -fr dist/*",
-    "prepublish": "npm run build",
+    "prepare": "npm run build",
     "pretest": "npm run build",
     "test": "mocha --recursive --full-trace --exit",
     "coverage": "nyc mocha && nyc report --reporter=html && nyc report --reporter=json-summary",