@fgiova/sqs-consumer 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Francesco Giovannini
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,91 @@
+# SQS consumer using undici
+
+[![NPM version](https://img.shields.io/npm/v/@fgiova/mini-sqs-client.svg?style=flat)](https://www.npmjs.com/package/@fgiova/sqs-consumer)
+![CI workflow](https://github.com/fgiova/sqs-consumer/actions/workflows/node.js.yml/badge.svg)
+[![TypeScript](https://img.shields.io/badge/%3C%2F%3E-TypeScript-%230074c1.svg)](http://www.typescriptlang.org/)
+[![Maintainability](https://api.codeclimate.com/v1/badges/0c10549e75ef6c798dfd/maintainability)](https://codeclimate.com/github/fgiova/sqs-consumer/maintainability)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/0c10549e75ef6c798dfd/test_coverage)](https://codeclimate.com/github/fgiova/mini-sqs-client/test_coverage)
+
+## Description
+This module allows consuming SQS messages using @fgiova/mini-sqs-client thorough the aws-json protocol with "undici" as http agent .<br />
+The @fgiova/aws-signature module is used for signing requests to optimize performance. <br />
+
+## Installation
+```bash
+npm install @fgiova/sqs-consumer
+```
+## Usage
+
+```typescript
+import {SQSConsumer} from '@fgiova/sqs-consumer'
+
+const consumer = new SQSConsumer({
+    queueARN: "arn:aws:sqs:eu-central-1:000000000000:test-queue-hooks",
+    handler: async (message) => {
+        console.log(message.Body);
+    }
+});
+
+```
+
+## Options
+| Option          | Type                                | Default | Description                                        |
+|-----------------|-------------------------------------|---------|----------------------------------------------------|
+| queueARN        | string                              |         | The ARN of the queue to consume                    |
+| handler         | (message: Message) => Promise<void> |         | The handler function to be called for each message |
+| logger          | Logger                              | console | The logger to be used                              |
+| autoStart       | boolean                             | true    | Whether to start the consumer automatically        |
+| handlerOptions  | HandlerOptions                      |         | The options for the handler                        |
+| clientOptions   | ClientOptions                       |         | The options for the client                         |
+| consumerOptions | ConsumerOptions                     |         | The options for the consumer                       |
+| hooks           | Hooks                               |         | The hooks to be called on specific events          |
+
+### HandlerOptions
+| Option            | Type    | Default | Description                                                                                              |
+|-------------------|---------|---------|----------------------------------------------------------------------------------------------------------|
+| deleteMessage     | boolean | true    | Whether to delete the message after handling (if handler execute without any error)                      |
+| extendVisibility  | boolean | true    | Whether to extend the visibility timeout during message handling                                         |
+| excuteTimeout     | number  | 30000   | The timeout for the handler execution in ms                                                              |
+| parallelExecution | boolean | true    | If true execute handler in parallel for each batch of messages received, otherwise execute consecutively |
+
+### ClientOptions
+| Option           | Type                   | Default | Description                                                                                               |
+|------------------|------------------------|---------|-----------------------------------------------------------------------------------------------------------|
+| sqsClient        | MiniSQSClient          |         | The MiniSQSClient client to be used. If not provided, a new client will be created using the queueARN.    |
+| endpoint         | string                 |         | The endpoint to be used for the client. If not provided, the endpoint will be inferred from the queueARN. |
+| undiciOptions    | Pool.Options           |         | The options for the undici client.                                                                        |
+| signer           | Signer / SignerOptions |         | The signer to be used for signing requests. If not provided, a new singleton signer will be created.      |
+| destroySigner    | boolean                | false   | Whether to destroy the signer when the consumer is destroyed.                                             |
+
+### ConsumerOptions
+| Option                  | Type     | Default | Description                                                |
+|-------------------------|----------|---------|------------------------------------------------------------|
+| visibilityTimeout       | number   | 30      | The visibility timeout for the messages in seconds         |
+| waitTimeSeconds         | number   | 20      | The wait time for the receiveMessage call in seconds       |
+| itemsPerRequest         | number   | 10      | The maximum number of messages to be received at once      |
+| messageAttributeNames   | string[] | []      | The message attribute names to be included in the response |
+
+### Hooks
+| Option           | Type                                                                  | Description                                                          |
+|------------------|-----------------------------------------------------------------------|----------------------------------------------------------------------|
+| onPoll           | (messages: Message[]) => Promise<Message[]>                           | Called when the consumer polls for messages                          |
+| onMessage        | (message: Message) => Promise<Message>                                | Called when the consumer receives a message                          |
+| onHandle         | (message: Message) => Promise<Message>                                | Called when the consumer handles a message                           |
+| onHandlerSuccess | (message: Message) => Promise<Message>                                | Called when the consumer handles a message successfully              |
+| onHandlerTimeout | (message: Message) => Promise<Message>                                | Called when the consumer handler execution exceed executionTimeout   |
+| onHandlerError   | (message: Message, error: Error) => Promise<Boolean>                  | Called when the consumer handler execution throws an error           |
+| onSuccess        | (message: Message) => Promise<Message>                                | Called when the consumer handler execution finishes successfully     |
+| onError          | ( hook: HookName, message: Message, error: Error) => Promise<Boolean> | Called when the consumer handler execution throws an uncaught error  |
+| onSQSError       | (error: Error, message?: Message) => Promise<void>                    | Called when the consumer receives an error from the SQS service      |
+
+## API
+
+```typescript
+SQSConsumer(options: SQSConsumerOptions)
+SQSConsumer.start(): Promise<void>
+SQSConsumer.stop(destroyConsumer = false): Promise<void>
+SQSConsumer.addHook(hookname: string, func: Function): void
+```
+
+## License
+Licensed under [MIT](./LICENSE).

package/dist/errors.d.ts

@@ -0,0 +1,3 @@
+export declare class TimeoutError extends Error {
+    constructor(message?: string);
+}

package/dist/errors.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeoutError = void 0;
+class TimeoutError extends Error {
+    constructor(message) {
+        /* c8 ignore next 1 */
+        super(message || "Timeout Error");
+        this.name = "TimeoutError";
+    }
+}
+exports.TimeoutError = TimeoutError;

package/dist/hooks.d.ts

@@ -0,0 +1,14 @@
+import { Logger } from "./logger";
+import { Message } from "@fgiova/mini-sqs-client";
+export type HookName = "onPoll" | "onMessage" | "onHandlerSuccess" | "onHandlerTimeout" | "onHandlerError" | "onSuccess" | "onError" | "onSQSError";
+export declare class Hooks {
+    private readonly hookSymbols;
+    private readonly hooks;
+    private readonly logger;
+    constructor(logger?: Logger);
+    addHook(hook: HookName, fn: Function): void;
+    runHook(hook: HookName, ...args: any[]): Promise<boolean | void | Message | Message[]>;
+    private runHookWithVoidReturn;
+    private runHookWithMessageReturn;
+    private runHookWithBooleanReturn;
+}

package/dist/hooks.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hooks = void 0;
+class Hooks {
+    hookSymbols = {
+        onPoll: {
+            S: Symbol("poll"),
+            throwable: true,
+            type: "message-return"
+        },
+        onMessage: {
+            S: Symbol("message"),
+            throwable: true,
+            type: "message-return"
+        },
+        onHandlerSuccess: {
+            S: Symbol("handlerSuccess"),
+            throwable: false,
+            type: "message-return"
+        },
+        onHandlerTimeout: {
+            S: Symbol("handlerTimeout"),
+            throwable: false,
+            type: "boolean-return"
+        },
+        onHandlerError: {
+            S: Symbol("handlerError"),
+            throwable: false,
+            type: "boolean-return"
+        },
+        onSuccess: {
+            S: Symbol("success"),
+            throwable: false,
+            type: "boolean-return"
+        },
+        onError: {
+            S: Symbol("error"),
+            throwable: false,
+            type: "boolean-return"
+        },
+        onSQSError: {
+            S: Symbol("sqsError"),
+            throwable: false,
+            type: "void"
+        },
+    };
+    hooks;
+    logger;
+    constructor(logger = console) {
+        this.logger = logger;
+        this.hooks = {
+            [this.hookSymbols.onPoll.S]: [],
+            [this.hookSymbols.onMessage.S]: [],
+            [this.hookSymbols.onHandlerSuccess.S]: [],
+            [this.hookSymbols.onHandlerTimeout.S]: [],
+            [this.hookSymbols.onHandlerError.S]: [],
+            [this.hookSymbols.onSuccess.S]: [],
+            [this.hookSymbols.onError.S]: [],
+            [this.hookSymbols.onSQSError.S]: [],
+        };
+    }
+    addHook(hook, fn) {
+        const hookSymbol = this.hookSymbols[hook];
+        if (!hookSymbol)
+            throw new Error(`Invalid hook ${hook}`);
+        this.hooks[hookSymbol.S]?.push(fn);
+    }
+    async runHook(hook, ...args) {
+        const hookSymbol = this.hookSymbols[hook];
+        try {
+            if (!hookSymbol)
+                throw new Error(`Invalid hook ${hook}`);
+            switch (hookSymbol.type) {
+                case "boolean-return":
+                    return await this.runHookWithBooleanReturn(hookSymbol, ...args);
+                case "message-return":
+                    const [message, ...someArgs] = args;
+                    return await this.runHookWithMessageReturn(hookSymbol, message, ...someArgs);
+                case "void":
+                    return await this.runHookWithVoidReturn(hookSymbol, ...args);
+            }
+            /* c8 ignore next 1 */
+        }
+        catch (error) {
+            error.message = `Error running hook ${hook}: ${error.message}`;
+            if (hookSymbol.throwable !== false)
+                throw error;
+            this.logger.error(error);
+        }
+    }
+    async runHookWithVoidReturn(hookSymbol, ...args) {
+        for (const fn of this.hooks[hookSymbol.S]) {
+            await fn(...args);
+        }
+        return;
+    }
+    async runHookWithMessageReturn(hookSymbol, message, ...args) {
+        for (const fn of this.hooks[hookSymbol.S]) {
+            message = await fn(message, ...args);
+        }
+        return message;
+    }
+    async runHookWithBooleanReturn(hookSymbol, ...args) {
+        for (const fn of this.hooks[hookSymbol.S]) {
+            const continueLoop = await fn(...args);
+            if (!continueLoop) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+exports.Hooks = Hooks;

package/dist/index.d.ts

@@ -0,0 +1,76 @@
+import { Signer, SignerOptions } from "@fgiova/aws-signature";
+import type { Pool } from "undici";
+import { MiniSQSClient, Message } from "@fgiova/mini-sqs-client";
+import { HookName } from "./hooks";
+import { Logger } from "./logger";
+type HandlerOptions = {
+    deleteMessage?: boolean;
+    extendVisibilityTimeout?: boolean;
+    executionTimeout?: number;
+    parallelExecution?: boolean;
+};
+type ClientOptions = {
+    sqsClient?: MiniSQSClient;
+    endpoint?: string;
+    undiciOptions?: Pool.Options;
+    signer?: Signer | SignerOptions;
+    destroySigner?: boolean;
+};
+type ConsumerOptions = {
+    visibilityTimeout?: number;
+    waitTimeSeconds?: number;
+    itemsPerRequest?: number;
+    messageAttributeNames?: string[];
+};
+type HooksOptions = {
+    onPoll?: (messages: Message[]) => Promise<Message[]>;
+    onMessage?: (message: Message) => Promise<Message>;
+    onHandlerSuccess?: (message: Message) => Promise<Message>;
+    onHandlerTimeout?: (message: Message) => Promise<Boolean>;
+    onHandlerError?: (message: Message, error: Error) => Promise<Boolean>;
+    onSuccess?: (message: Message) => Promise<Boolean>;
+    onError?: (hook: HookName, message: Message, error: Error) => Promise<Boolean>;
+    onSQSError?: (error: Error, message?: Message) => Promise<void>;
+};
+export type SQSConsumerOptions = {
+    queueARN: string;
+    handler: (message: Message) => Promise<any>;
+    logger?: Logger;
+    autostart?: boolean;
+    handlerOptions?: HandlerOptions;
+    clientOptions?: ClientOptions;
+    consumerOptions?: ConsumerOptions;
+    hooks?: HooksOptions;
+};
+export declare class SQSConsumer {
+    private readonly queueARN;
+    private readonly handlerOptions;
+    private readonly clientOptions;
+    private readonly consumerOptions;
+    private readonly sqsClient;
+    private readonly hooks;
+    private readonly messageHandler;
+    private messagesOnFly;
+    private running;
+    private polling;
+    private destroyed;
+    private readonly logger;
+    constructor(options: SQSConsumerOptions);
+    private runOnMessageHook;
+    private runHandler;
+    private haExtendVisibilityTimeout;
+    private deleteMessages;
+    private pollMessages;
+    start(): Promise<void>;
+    stop(destroy?: boolean): Promise<void>;
+    addHook(hookName: "onPoll", value: (messages: Message[]) => Promise<Message[]>): void;
+    addHook(hookName: "onMessage", value: (message: Message) => Promise<Message>): void;
+    addHook(hookName: "onHandlerSuccess", value: (message: Message) => Promise<Message>): void;
+    addHook(hookName: "onHandlerTimeout", value: (message: Message) => Promise<Boolean>): void;
+    addHook(hookName: "onHandlerError", value: (message: Message, error: Error) => Promise<Boolean>): void;
+    addHook(hookName: "onSuccess", value: (message: Message) => Promise<Boolean>): void;
+    addHook(hookName: "onError", value: (hook: HookName, message: Message, error: Error) => Promise<Boolean>): void;
+    addHook(hookName: "onSQSError", value: (error: Error, message?: Message) => Promise<void>): void;
+    addHook(hookName: HookName, value: Function): void;
+}
+export {};

package/dist/index.js

@@ -0,0 +1,217 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQSConsumer = void 0;
+const mini_sqs_client_1 = require("@fgiova/mini-sqs-client");
+const hooks_1 = require("./hooks");
+const errors_1 = require("./errors");
+const promises_1 = require("timers/promises");
+const p_map_1 = __importDefault(require("p-map"));
+class SQSConsumer {
+    queueARN;
+    handlerOptions;
+    clientOptions;
+    consumerOptions;
+    sqsClient;
+    hooks;
+    messageHandler;
+    messagesOnFly = 0;
+    running = false;
+    polling = false;
+    destroyed = false;
+    logger;
+    constructor(options) {
+        if (!options.queueARN)
+            throw new Error("queueARN is required");
+        if (!options.handler || typeof options.handler !== "function")
+            throw new Error("handler is required and must be a function");
+        this.logger = options.logger ?? console;
+        this.hooks = new hooks_1.Hooks(this.logger);
+        this.queueARN = options.queueARN;
+        const region = this.queueARN.split(":").reverse()[2];
+        this.clientOptions = { destroySigner: options.clientOptions?.destroySigner ?? true };
+        this.handlerOptions = {
+            deleteMessage: options.handlerOptions?.deleteMessage ?? true,
+            extendVisibilityTimeout: options.handlerOptions?.extendVisibilityTimeout ?? true,
+            executionTimeout: options.handlerOptions?.executionTimeout ?? 30000,
+            parallelExecution: options.handlerOptions?.parallelExecution ?? true
+        };
+        this.consumerOptions = {
+            visibilityTimeout: options.consumerOptions?.visibilityTimeout ?? 30,
+            waitTimeSeconds: options.consumerOptions?.waitTimeSeconds ?? 20,
+            itemsPerRequest: options.consumerOptions?.itemsPerRequest ?? 10,
+            messageAttributeNames: options.consumerOptions?.messageAttributeNames ?? []
+        };
+        this.sqsClient = options.clientOptions?.sqsClient ?? new mini_sqs_client_1.MiniSQSClient(region, options.clientOptions?.endpoint, options.clientOptions?.undiciOptions, options.clientOptions?.signer);
+        if (options.hooks) {
+            for (const [key, value] of Object.entries(options.hooks)) {
+                if (typeof value !== "function")
+                    throw new Error(`${key} must be a function`);
+                this.addHook(key, value);
+            }
+        }
+        this.messageHandler = options.handler;
+        if (options.autostart !== false) {
+            void this.start();
+        }
+    }
+    async runOnMessageHook(message) {
+        try {
+            await this.hooks.runHook("onMessage", message);
+            const result = await this.runHandler(this.messageHandler, message);
+            await this.hooks.runHook("onSuccess", message);
+            return {
+                message,
+                result
+            };
+        }
+        catch (e) {
+            await this.hooks.runHook("onError", "onMessage", message, e);
+            return {
+                message,
+                error: e
+            };
+        }
+    }
+    async runHandler(handler, message) {
+        try {
+            let handlerResult;
+            if (this.handlerOptions.executionTimeout) {
+                const response = await Promise.race([
+                    handler(message),
+                    new Promise((resolve, reject) => {
+                        setTimeout(() => {
+                            reject(new errors_1.TimeoutError("Handler execution timed out"));
+                        }, this.handlerOptions.executionTimeout);
+                    })
+                ]);
+                handlerResult = response;
+            }
+            else {
+                handlerResult = await handler(message);
+            }
+            await Promise.all([
+                this.hooks.runHook("onHandlerSuccess", message),
+            ]);
+            return handlerResult;
+        }
+        catch (error) {
+            if (error instanceof errors_1.TimeoutError) {
+                await this.hooks.runHook("onHandlerTimeout", message);
+            }
+            else {
+                await this.hooks.runHook("onHandlerError", message, error);
+            }
+            throw error;
+        }
+    }
+    haExtendVisibilityTimeout(messages, visibilityTimeout) {
+        if (this.handlerOptions.extendVisibilityTimeout !== false) {
+            const processingMessages = messages.map(message => message.ReceiptHandle);
+            return setInterval(async () => {
+                try {
+                    await this.sqsClient.changeMessageVisibilityBatch(this.queueARN, processingMessages, visibilityTimeout);
+                }
+                /* c8 ignore next 3 */
+                catch (e) {
+                    await this.hooks.runHook("onSQSError", e);
+                }
+            }, (visibilityTimeout * 1000 - 5));
+        }
+        return null;
+    }
+    async deleteMessages(messagesResults) {
+        const candidatesToDelete = [];
+        const candidateToRelease = [];
+        for (const result of messagesResults) {
+            if (result.result && this.handlerOptions.deleteMessage !== false) {
+                candidatesToDelete.push(result.message.ReceiptHandle);
+            }
+            else if (result.error) {
+                candidateToRelease.push(result.message.ReceiptHandle);
+            }
+            if (candidatesToDelete.length)
+                await this.sqsClient.deleteMessageBatch(this.queueARN, candidatesToDelete);
+            if (candidateToRelease.length)
+                await this.sqsClient.changeMessageVisibilityBatch(this.queueARN, candidateToRelease, 0);
+        }
+    }
+    async pollMessages() {
+        if (!this.running)
+            return;
+        try {
+            this.polling = true;
+            const visibilityTimeout = this.consumerOptions.visibilityTimeout;
+            const messagesResult = await this.sqsClient.receiveMessage(this.queueARN, {
+                WaitTimeSeconds: this.consumerOptions.waitTimeSeconds,
+                MaxNumberOfMessages: this.consumerOptions.itemsPerRequest,
+                VisibilityTimeout: visibilityTimeout,
+                MessageAttributeNames: this.consumerOptions.messageAttributeNames,
+            });
+            /* c8 ignore next 1 */
+            const messages = messagesResult.Messages ?? [];
+            const totalMessages = messages.length;
+            this.messagesOnFly += totalMessages;
+            await this.hooks.runHook("onPoll", messages);
+            if (messages.length) {
+                const haTimeout = this.haExtendVisibilityTimeout(messages, visibilityTimeout);
+                this.messagesOnFly += (messages.length - totalMessages);
+                if (this.handlerOptions.parallelExecution !== false) {
+                    const results = await (0, p_map_1.default)(messages, async (message) => {
+                        return await this.runOnMessageHook(message);
+                    }, {
+                        concurrency: 10,
+                        stopOnError: false,
+                    });
+                    await this.deleteMessages(results);
+                    this.messagesOnFly -= messages.length;
+                }
+                else {
+                    const handlingMessages = [...messages];
+                    for (let i = 0; i < handlingMessages.length; i++) {
+                        const result = await this.runOnMessageHook(handlingMessages[i]);
+                        await this.deleteMessages([result]);
+                        messages.splice(i, 1);
+                        this.messagesOnFly -= 1;
+                    }
+                }
+                if (haTimeout)
+                    clearInterval(haTimeout);
+            }
+            else {
+                this.messagesOnFly -= totalMessages;
+            }
+        }
+        catch (e) {
+            await this.hooks.runHook("onSQSError", e);
+        }
+        this.polling = false;
+        await this.pollMessages();
+    }
+    async start() {
+        if (this.running)
+            throw new Error("Consumer is already running");
+        if (this.destroyed)
+            throw new Error("Consumer is destroyed");
+        this.running = true;
+        void this.pollMessages();
+    }
+    async stop(destroy = false) {
+        if (!this.running)
+            throw new Error("Consumer is not running");
+        this.running = false;
+        while (this.messagesOnFly > 0 || this.polling) {
+            await (0, promises_1.setTimeout)(500);
+        }
+        if (destroy) {
+            await this.sqsClient.destroy(this.clientOptions.destroySigner);
+            this.destroyed = true;
+        }
+    }
+    addHook(hookName, value) {
+        return this.hooks.addHook(hookName, value);
+    }
+}
+exports.SQSConsumer = SQSConsumer;

package/dist/logger.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Represents a generic logger that could be a simple console, pino etc.
+ */
+export interface Logger {
+    trace(message?: any, ...optionalParams: any[]): void;
+    debug(message?: any, ...optionalParams: any[]): void;
+    info(message?: any, ...optionalParams: any[]): void;
+    warn(message?: any, ...optionalParams: any[]): void;
+    error(message?: any, ...optionalParams: any[]): void;
+    [x: string]: any;
+}

package/dist/logger.js

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

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@fgiova/sqs-consumer",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "prebuild": "rimraf dist",
+    "build": "tsc",
+    "lint": "eslint 'src/**/*.ts'",
+    "test": "tap",
+    "test:debug": "tap --only --timeout=0",
+    "test:coverage": "tap --coverage-report=lcovonly --coverage-report=text",
+    "test:local": "TEST_LOCAL=true tap"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fgiova/sqs-consumer.git"
+  },
+  "author": "Francesco Giovannini <fgiova@fgiova.com>",
+  "license": "MIT",
+  "keywords": [
+    "aws",
+    "sqs",
+    "sqs-consumer"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "tap": {
+    "show-full-coverage": true,
+    "before": "./test/scripts/executors/before.js",
+    "after": "./test/scripts/executors/teardown.js",
+    "exclude": [
+      "test/helpers/**/*",
+      "test/scripts/**/*"
+    ]
+  },
+  "dependencies": {
+    "@fgiova/mini-sqs-client": "^2.2.1",
+    "p-map": "^4.0.0"
+  },
+  "peerDependencies": {
+    "@fgiova/aws-signature": "^2.0.0"
+  },
+  "devDependencies": {
+    "@aws-sdk/client-sqs": "^3.451.0",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@types/node": "^18.18.6",
+    "@typescript-eslint/eslint-plugin": "^6.4.0",
+    "@typescript-eslint/parser": "^6.4.0",
+    "conventional-changelog-conventionalcommits": "^6.1.0",
+    "eslint": "^8.47.0",
+    "eslint-plugin-import": "^2.28.1",
+    "semantic-release": "^21.0.9",
+    "tap": "^18.6.1",
+    "testcontainers": "^10.2.1",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.2.2"
+  }
+}