@fgiova/fastify-sqs-consumer 1.1.0 → 2.0.0

package/README.md

@@ -2,12 +2,17 @@
 [![NPM version](https://img.shields.io/npm/v/@fgiova/fastify-sqs-consumer.svg?style=flat)](https://www.npmjs.com/package/@fgiova/fastify-rest-gateway)
 ![CI workflow](https://github.com/fgiova/fastify-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/)
+[![Linted with Biome](https://img.shields.io/badge/Linted_with-Biome-60a5fa?style=flat&logo=biome)](https://biomejs.dev)
+[![Maintainability](https://qlty.sh/gh/fgiova/projects/fastify-sqs-consumer/maintainability.svg)](https://qlty.sh/gh/fgiova/projects/fastify-sqs-consumer)
+[![Code Coverage](https://qlty.sh/gh/fgiova/projects/fastify-sqs-consumer/coverage.svg)](https://qlty.sh/gh/fgiova/projects/fastify-sqs-consumer)
+
 ## Description
-This plugin for fastify 4.x allows you to consume messages from AWS SQS queues.
+This plugin for fastify 5.x (for fastify 4.x use 1.x ver) allows you to consume messages from AWS SQS queues.
 On fastify shutdown a simple wait function is called to wait for the end of the processing of the messages in progress.
 
 **Warning**<br>
-To use this plugin, you must have correctly configured your [AWS credentials](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html).
+To use this plugin, you must have correctly configured your [AWS credentials](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html).<br>
+This plugin uses [@fgiova/mini-sqs-client](https://www.npmjs.com/package/@fgiova/mini-sqs-client) and [@fgiova/sqs-consumer](https://www.npmjs.com/package/@fgiova/sqs-consumer) to interact with SQS service.
 
 ## Install
 ```bash
@@ -19,7 +24,7 @@ const fastify = require("fastify")()
 
 fastify.register(require("fastify-sqs-consumer"), [
     {
-        url: "https://sqs.us-east-1.amazonaws.com/123456789012/MyQueue",
+        arn: "arn:aws:sqs:eu-central-1:000000000000:MyQueue",
         waitTimeSeconds: 20,
         timeout: 10_000,
         batchSize: 10,
@@ -32,17 +37,19 @@ fastify.register(require("fastify-sqs-consumer"), [
 ### Options
 Options are an array of objects with the following properties (one more for each queue):
 
-| Option                 | Type      | Description                                                                                                                                                                                                                                                                                                           |
-|------------------------|-----------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| url*                   | string    | The URL of the Amazon SQS queue from which messages are received.                                                                                                                                                                                                                                                     |
-| waitTimeSeconds        | number    | The duration (in seconds, default 20s) for which the call waits for a message to arrive in the queue before returning. If a message is available, the call returns sooner than WaitTimeSeconds. If no messages are available and the wait time expires, the call returns successfully with an empty list of messages. |
-| timeout                | number    | The duration before the message is considered as failed: default 90000ms.                                                                                                                                                                                                                                             |
-| batchSize              | number    | The maximum number of messages to return. Amazon SQS never returns more messages than this value (however, fewer messages might be returned). Valid values: 1 to 10. Default: 1.                                                                                                                                      |
-| handlerFunction*       | function  | The function that will be called for each message.                                                                                                                                                                                                                                                                    |
-| messageAttributeNames  | string[]  | Array of caught message's attributes for each message                                                                                                                                                                                                                                                                 |
-| attributeNames         | string[]  | Array of caught queue's attributes for each message                                                                                                                                                                                                                                                                   |
-| events                 | object    | Events functions for the consumer (detail in next table)                                                                                                                                                                                                                                                              |
-| sqs                    | SQSClient | Initialized SQS Client (useful for testing sessions)                                                                                                                                                                                                                                                                  |
+| Option                | Type      | Description                                                                                                                                                                                                                                                                                                           |
+|-----------------------|-----------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| arn*                  | string    | The ARN of the Amazon SQS queue from which messages are received.                                                                                                                                                                                                                                                     |
+| handlerFunction*      | function  | The function that will be called for each message.                                                                                                                                                                                                                                                                    |
+| name                  | string    | An optional name for the consumer (useful for add [hooks](https://github.com/fgiova/sqs-consumer?tab=readme-ov-file#hooks) post config). If not provided, uuid is assigned.                                                                                                                                           |
+| waitTimeSeconds       | number    | The duration (in seconds, default 20s) for which the call waits for a message to arrive in the queue before returning. If a message is available, the call returns sooner than WaitTimeSeconds. If no messages are available and the wait time expires, the call returns successfully with an empty list of messages. |
+| timeout               | number    | The duration before the message is considered as failed: default 90000ms.                                                                                                                                                                                                                                             |
+| batchSize             | number    | The maximum number of messages to return. Amazon SQS never returns more messages than this value (however, fewer messages might be returned). Valid values: 1 to 10. Default: 1.                                                                                                                                      |
+| messageAttributeNames | string[]  | Array of caught message's attributes for each message                                                                                                                                                                                                                                                                 |
+| events                | object    | Events functions for the consumer (detail in next table)                                                                                                                                                                                                                                                              |
+| sqs                   | SQSClient | Initialized SQS Client (useful for testing sessions)                                                                                                                                                                                                                                                                  |
+
+* required
 
 ### handlerFunction
 
@@ -52,19 +59,17 @@ Otherwise, the message is deleted from the queue.
 
 #### Events
 
-| Event name        | Arguments                         | Description                                                                                                                                          |
-|-------------------|-----------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------|
-| error             | error Object                      | Fired when a general error occurs                                                                                                                    |
-| processingError   | error Object, message SQS.Message | Fired when an error occurs pending message handling                                                                                                  |
-| timeoutError      | error Object, message SQS.Message | Fired when processing of message exceed timeout duration<br/> If function return false message are discarded, otherwise message is bounced to queue. |
-| messageReceived   | message SQS.Message               | Fired when message is received                                                                                                                       |
-| messageProcessed  | message SQS.Message               | Fired when message is successfully processed                                                                                                         |
-| responseProcessed | void                              | Fired after one batch of items (up to batchSize) has been successfully processed.                                                                    |
-| stopped           | void                              | Fired when the consumer finally stops its work.                                                                                                      |
-| empty             | void                              | Fired when the queue is empty (All messages have been consumed).                                                                                     |
+| 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     |
 
 ## License
 Licensed under [MIT](./LICENSE).
-
-### Acknowledgements
-This project is kindly sponsored by: isendu Srl [www.isendu.com](https://www.isendu.com)

package/dist/cjs/index.d.ts

@@ -0,0 +1,23 @@
+import type { Message, MiniSQSClient } from "@fgiova/mini-sqs-client";
+import { type HooksOptions, SQSConsumer } from "@fgiova/sqs-consumer";
+import type { FastifyInstance } from "fastify";
+declare module "fastify" {
+    interface FastifyInstance {
+        sqsConsumers: Record<string, SQSConsumer>;
+    }
+}
+declare function sqsConsumerPlugin(fastify: FastifyInstance, options: {
+    arn: string;
+    name?: string;
+    handlerFunction: (message: Message, fastify: FastifyInstance) => Promise<unknown>;
+    timeout?: number;
+    waitTimeSeconds?: number;
+    batchSize?: number;
+    messageAttributeNames?: string[];
+    attributeNames?: string[];
+    events?: HooksOptions;
+    parallelExecution?: boolean;
+    sqs?: MiniSQSClient;
+}[], done: (err?: Error) => void): void;
+declare const _default: typeof sqsConsumerPlugin;
+export = _default;

package/dist/cjs/index.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const node_crypto_1 = require("node:crypto");
+const sqs_consumer_1 = require("@fgiova/sqs-consumer");
+const fastify_plugin_1 = __importDefault(require("fastify-plugin"));
+function createConsumer(fastify, queueArn, handlerFunction, meta, timeout = 90000, waitTimeSeconds = 20, batchSize = 1, attributeNames = [], messageAttributeNames = [], parallelExecution, hooks, sqs) {
+    return new sqs_consumer_1.SQSConsumer({
+        queueARN: queueArn,
+        autostart: false,
+        consumerOptions: {
+            waitTimeSeconds,
+            itemsPerRequest: batchSize,
+            attributeNames,
+            messageAttributeNames,
+            visibilityTimeout: timeout / 1000,
+        },
+        handlerOptions: {
+            executionTimeout: timeout,
+            parallelExecution,
+        },
+        hooks,
+        clientOptions: {
+            sqsClient: sqs,
+        },
+        handler: async function handleMessageFunction(message) {
+            meta.pendingMessages++;
+            try {
+                await handlerFunction(message, fastify);
+                meta.pendingMessages--;
+            }
+            catch (e) {
+                meta.pendingMessages--;
+                fastify.log.error(e);
+                throw e;
+            }
+            return;
+        },
+    });
+}
+function sqsConsumerPlugin(fastify, options, done) {
+    const metaData = {
+        pendingMessages: 0,
+    };
+    const consumers = {};
+    fastify.decorate("sqsConsumers", consumers);
+    for (const handler of options) {
+        const { name, arn: queueArn, handlerFunction, timeout, waitTimeSeconds, batchSize, attributeNames, messageAttributeNames, events, sqs, parallelExecution, } = handler;
+        try {
+            consumers[name || (0, node_crypto_1.randomUUID)()] = createConsumer(fastify, queueArn, handlerFunction, metaData, timeout, waitTimeSeconds, batchSize, attributeNames, messageAttributeNames, parallelExecution, events, sqs);
+        } /* c8 ignore next 3 */
+        catch (e) {
+            fastify.log.error(e);
+        }
+    }
+    fastify.addHook("onReady", (done) => {
+        for (const consumer of Object.values(consumers)) {
+            consumer.start().catch((e) => fastify.log.error(e));
+        }
+        done();
+    });
+    let allStopped = false;
+    fastify.addHook("onClose", async (fastify) => {
+        const arrayConsumers = Object.values(consumers);
+        for (const consumer of arrayConsumers) {
+            await consumer.stop();
+        }
+        const interval = setInterval(() => {
+            const isRunning = arrayConsumers.some((consumer) => consumer.isRunning);
+            /* c8 ignore next 5 */
+            if (isRunning) {
+                fastify.log.debug("[fastify-sqs-consumer] Some consumers still running... please wait");
+                return null;
+            }
+            else if (!allStopped) {
+                allStopped = true;
+                fastify.log.debug("[fastify-sqs-consumer] All consumers are stopped");
+            }
+            if (metaData.pendingMessages <= 0) {
+                clearInterval(interval);
+                return done();
+            }
+            else {
+                fastify.log.debug(`[fastify-sqs-consumer] ${metaData.pendingMessages} pending messages`);
+            }
+        }, 50);
+    });
+    done();
+}
+module.exports = (0, fastify_plugin_1.default)(sqsConsumerPlugin, {
+    name: "fastify-sqs-consumer",
+    fastify: ">=5.x",
+});

package/dist/esm/index.d.mts

@@ -0,0 +1,23 @@
+import type { Message, MiniSQSClient } from "@fgiova/mini-sqs-client";
+import { type HooksOptions, SQSConsumer } from "@fgiova/sqs-consumer";
+import type { FastifyInstance } from "fastify";
+declare module "fastify" {
+    interface FastifyInstance {
+        sqsConsumers: Record<string, SQSConsumer>;
+    }
+}
+declare function sqsConsumerPlugin(fastify: FastifyInstance, options: {
+    arn: string;
+    name?: string;
+    handlerFunction: (message: Message, fastify: FastifyInstance) => Promise<unknown>;
+    timeout?: number;
+    waitTimeSeconds?: number;
+    batchSize?: number;
+    messageAttributeNames?: string[];
+    attributeNames?: string[];
+    events?: HooksOptions;
+    parallelExecution?: boolean;
+    sqs?: MiniSQSClient;
+}[], done: (err?: Error) => void): void;
+declare const _default: typeof sqsConsumerPlugin;
+export = _default;

package/dist/esm/index.mjs

@@ -0,0 +1,86 @@
+import { randomUUID } from "node:crypto";
+import { SQSConsumer } from "@fgiova/sqs-consumer";
+import fp from "fastify-plugin";
+function createConsumer(fastify, queueArn, handlerFunction, meta, timeout = 90000, waitTimeSeconds = 20, batchSize = 1, attributeNames = [], messageAttributeNames = [], parallelExecution, hooks, sqs) {
+    return new SQSConsumer({
+        queueARN: queueArn,
+        autostart: false,
+        consumerOptions: {
+            waitTimeSeconds,
+            itemsPerRequest: batchSize,
+            attributeNames,
+            messageAttributeNames,
+            visibilityTimeout: timeout / 1000,
+        },
+        handlerOptions: {
+            executionTimeout: timeout,
+            parallelExecution,
+        },
+        hooks,
+        clientOptions: {
+            sqsClient: sqs,
+        },
+        handler: async function handleMessageFunction(message) {
+            meta.pendingMessages++;
+            try {
+                await handlerFunction(message, fastify);
+                meta.pendingMessages--;
+            }
+            catch (e) {
+                meta.pendingMessages--;
+                fastify.log.error(e);
+                throw e;
+            }
+            return;
+        },
+    });
+}
+function sqsConsumerPlugin(fastify, options, done) {
+    const metaData = {
+        pendingMessages: 0,
+    };
+    const consumers = {};
+    fastify.decorate("sqsConsumers", consumers);
+    for (const handler of options) {
+        const { name, arn: queueArn, handlerFunction, timeout, waitTimeSeconds, batchSize, attributeNames, messageAttributeNames, events, sqs, parallelExecution, } = handler;
+        try {
+            consumers[name || randomUUID()] = createConsumer(fastify, queueArn, handlerFunction, metaData, timeout, waitTimeSeconds, batchSize, attributeNames, messageAttributeNames, parallelExecution, events, sqs);
+        } /* c8 ignore next 3 */
+        catch (e) {
+            fastify.log.error(e);
+        }
+    }
+    fastify.addHook("onReady", (done) => {
+        for (const consumer of Object.values(consumers)) {
+            consumer.start().catch((e) => fastify.log.error(e));
+        }
+        done();
+    });
+    let allStopped = false;
+    fastify.addHook("onClose", async (fastify) => {
+        const arrayConsumers = Object.values(consumers);
+        for (const consumer of arrayConsumers) {
+            await consumer.stop();
+        }
+        const interval = setInterval(() => {
+            const isRunning = arrayConsumers.some((consumer) => consumer.isRunning);
+            /* c8 ignore next 5 */
+            if (isRunning) {
+                fastify.log.debug("[fastify-sqs-consumer] Some consumers still running... please wait");
+                return null;
+            }
+            else if (!allStopped) {
+                allStopped = true;
+                fastify.log.debug("[fastify-sqs-consumer] All consumers are stopped");
+            }
+            if (metaData.pendingMessages <= 0) {
+                clearInterval(interval);
+                return done();
+            }
+            else {
+                fastify.log.debug(`[fastify-sqs-consumer] ${metaData.pendingMessages} pending messages`);
+            }
+        }, 50);
+    });
+    done();
+}

package/package.json

@@ -1,18 +1,35 @@
 {
 	"name": "@fgiova/fastify-sqs-consumer",
 	"description": "sqs-consumer fastify plugin",
-	"version": "1.1.0",
-	"main": "dist/index.js",
+	"version": "2.0.0",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"import": {
+				"types": "./dist/esm/index.d.mts",
+				"default": "./dist/esm/index.mjs"
+			},
+			"require": {
+				"types": "./dist/cjs/index.d.ts",
+				"default": "./dist/cjs/index.js"
+			}
+		}
+	},
 	"files": [
 		"dist"
 	],
 	"scripts": {
-		"lint": "eslint 'src/**/*.ts'",
 		"clean": "rimraf dist",
-		"build": "tsc",
-		"test": "tap -t90 --before=test/scripts/executors/before.js --after=test/scripts/executors/after.js",
-		"test:local": "TEST_LOCAL=true tap -t90",
-		"test:debug": "tap -T -O --before=test/scripts/executors/before.js --after=test/scripts/executors/after.js"
+		"preBuild": "npm run clean",
+		"build": "esmBuilder",
+		"lint": "biome ci ./src ./test",
+		"fix": "biome check --write ./src ./test",
+		"test": "tap --timeout=90",
+		"test:debug": "tap --only --timeout=0",
+		"test:local": "TEST_LOCAL=true tap",
+		"test:local:debug": "TEST_LOCAL=true tap --only --timeout=0",
+		"test:coverage": "tap --coverage-report=lcovonly --coverage-report=text"
 	},
 	"repository": {
 		"type": "git",
@@ -32,39 +49,41 @@
 		"access": "public"
 	},
 	"engines": {
-		"node": ">=18.0.0"
+		"node": ">=20.14.1"
 	},
 	"tap": {
-		"node-arg": "--require=ts-node/register",
-		"ts": true,
-		"lines": 100,
-		"branches": 100,
-		"statements": 100,
-		"functions": 100
+		"show-full-coverage": true,
+		"before": "./test/scripts/executors/before.js",
+		"after": "./test/scripts/executors/teardown.js",
+		"exclude": [
+			"test/helpers/**/*",
+			"test/scripts/**/*"
+		]
+	},
+	"peerDependencies": {
+		"fastify": ">=5.0.0",
+		"p-map": ">=7.0.0"
 	},
 	"devDependencies": {
 		"@aws-sdk/client-sqs": "^3.398.0",
+		"@biomejs/biome": "2.2.2",
+		"@fgiova/cjs-esm-ts-builder": "^1.2.0",
 		"@semantic-release/changelog": "^6.0.3",
 		"@semantic-release/git": "^10.0.1",
-		"@types/node": "^18.17.1",
-		"@types/tap": "^15.0.5",
-		"@typescript-eslint/eslint-plugin": "^6.4.1",
-		"@typescript-eslint/parser": "^6.4.1",
-		"conventional-changelog-conventionalcommits": "^6.1.0",
-		"cross-env": "^7.0.3",
+		"@tsconfig/node20": "^20.1.6",
+		"@types/dotenv": "^6.1.1",
+		"@types/node": "^20.19.11",
+		"conventional-changelog-conventionalcommits": "^8.0.0",
 		"dotenv": "^10.0.0",
-		"eslint": "^8.1.0",
-		"eslint-plugin-import": "^2.25.2",
-		"fastify": "^4.21.0",
-		"nodemon": "^2.0.14",
-		"semantic-release": "^21.1.0",
-		"tap": "^16.3.8",
-		"testcontainers": "^10.2.1",
-		"ts-node": "^10.9.1",
+		"fastify": "^5.5.0",
+		"semantic-release": "^24.2.3",
+		"tap": "^21.1.0",
+		"testcontainers": "^11.5.1",
+		"ts-node": "^10.9.2",
 		"typescript": "^5.1.6"
 	},
 	"dependencies": {
-		"fastify-plugin": "^4.5.1",
-		"sqs-consumer": "^7.2.2"
+		"@fgiova/sqs-consumer": "^2.1.1",
+		"fastify-plugin": "^5.0.1"
 	}
 }

package/dist/index.d.ts

@@ -1,32 +0,0 @@
-import { Consumer } from "sqs-consumer";
-import type { FastifyInstance } from "fastify";
-import type { Message } from "@aws-sdk/client-sqs";
-import type { SQSClient } from "@aws-sdk/client-sqs";
-declare module "fastify" {
-    interface FastifyInstance {
-        sqsConsumers: Consumer[];
-    }
-}
-type eventsHandlers = {
-    error?: (error: Error, message: void | Message | Message[]) => void;
-    processingError?: (error: Error, message: Message) => void;
-    timeoutError?: (error: Error, message: Message) => void | boolean;
-    messageReceived?: (message: Message) => void;
-    messageProcessed?: (message: Message) => void;
-    responseProcessed?: () => void;
-    stopped?: () => void;
-    empty?: () => void;
-};
-declare function sqsConsumerPlugin(fastify: FastifyInstance, options: {
-    queueUrl: string;
-    handlerFunction: (message: Message, fastify: FastifyInstance) => Promise<any>;
-    timeout?: number;
-    waitTimeSeconds?: number;
-    batchSize?: number;
-    attributeNames?: string[];
-    messageAttributeNames?: string[];
-    events?: eventsHandlers;
-    sqs?: SQSClient;
-}[], done: any): void;
-declare const _default: typeof sqsConsumerPlugin;
-export = _default;

package/dist/index.js

@@ -1,134 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-const fastify_plugin_1 = __importDefault(require("fastify-plugin"));
-const sqs_consumer_1 = require("sqs-consumer");
-const promises_1 = require("timers/promises");
-;
-function createConsumer(fastify, queueUrl, handlerFunction, meta, timeout = 90000, waitTimeSeconds = 20, batchSize = 1, attributeNames = [], messageAttributeNames = [], events, sqs) {
-    return sqs_consumer_1.Consumer.create({
-        queueUrl,
-        handleMessageTimeout: 0,
-        waitTimeSeconds,
-        visibilityTimeout: timeout / 1000,
-        batchSize,
-        sqs,
-        attributeNames,
-        messageAttributeNames,
-        handleMessage: async function handleMessageFunction(message) {
-            meta.pendingMessages++;
-            try {
-                const result = await Promise.race([
-                    (0, promises_1.setTimeout)(timeout, "timeout"),
-                    handlerFunction(message, fastify),
-                ]);
-                if (result === "timeout") {
-                    const TimeoutError = new Error(`Message ${message.MessageId} Timeout after ${timeout}ms`);
-                    if (events?.timeoutError && typeof events.timeoutError === "function") {
-                        const timeout = events.timeoutError(TimeoutError, message);
-                        /* istanbul ignore else */
-                        if (timeout === false) {
-                            meta.pendingMessages--;
-                            return;
-                        }
-                    }
-                    throw TimeoutError;
-                }
-                meta.pendingMessages--;
-            }
-            catch (e) {
-                meta.pendingMessages--;
-                fastify.log.error(e);
-                throw e;
-            }
-            return;
-        }
-    })
-        .on("error", (err, message) => {
-        /* istanbul ignore else */
-        if (events?.error) {
-            events.error(err, message);
-        }
-        else {
-            fastify.log.error(`[fastify-sqs-consumer] ${err.message}`);
-        }
-    })
-        .on("processing_error", (err, message) => {
-        /* istanbul ignore else */
-        if (events?.processingError) {
-            events.processingError(err, message);
-        }
-        else {
-            fastify.log.error(`[fastify-sqs-consumer] ${err.message}`);
-        }
-    })
-        .on("message_received", (message) => {
-        if (events?.messageReceived)
-            events.messageReceived(message);
-    })
-        .on("message_processed", (message) => {
-        if (events?.messageProcessed)
-            events.messageProcessed(message);
-    })
-        .on("response_processed", () => {
-        if (events?.responseProcessed)
-            events.responseProcessed();
-    }).on("stopped", () => {
-        if (events?.stopped)
-            events.stopped();
-    })
-        .on("empty", () => {
-        /* istanbul ignore next */
-        if (events?.empty)
-            events.empty();
-    });
-}
-function sqsConsumerPlugin(fastify, options, done) {
-    const metaData = {
-        pendingMessages: 0
-    };
-    const consumers = [];
-    fastify.decorate("sqsConsumers", consumers);
-    for (const handler of options) {
-        const { queueUrl, handlerFunction, timeout, waitTimeSeconds, batchSize, attributeNames, messageAttributeNames, events, sqs } = handler;
-        consumers.push(createConsumer(fastify, queueUrl, handlerFunction, metaData, timeout, waitTimeSeconds, batchSize, attributeNames, messageAttributeNames, events, sqs));
-    }
-    fastify.addHook("onReady", (done) => {
-        for (const consumer of consumers) {
-            consumer.start();
-        }
-        done();
-    });
-    let allStopped = false;
-    fastify.addHook("onClose", (fastify, done) => {
-        for (const consumer of consumers) {
-            consumer.stop();
-            consumer.removeAllListeners();
-        }
-        const interval = setInterval(() => {
-            const isRunning = consumers.some((consumer) => consumer.isRunning);
-            /* istanbul ignore next */
-            if (isRunning) {
-                fastify.log.debug("[fastify-sqs-consumer] Some consumers still running... please wait");
-                return null;
-            }
-            else if (!allStopped) {
-                allStopped = true;
-                fastify.log.debug("[fastify-sqs-consumer] All consumers are stopped");
-            }
-            if (metaData.pendingMessages <= 0) {
-                clearInterval(interval);
-                return done();
-            }
-            else {
-                fastify.log.debug(`[fastify-sqs-consumer] ${metaData.pendingMessages} pending messages`);
-            }
-        }, 50);
-    });
-    done();
-}
-module.exports = (0, fastify_plugin_1.default)(sqsConsumerPlugin, {
-    name: "fastify-sqs-consumer",
-    fastify: ">=4.x"
-});