@fgiova/sqs-consumer 2.0.1 → 2.1.0

package/README.md

@@ -3,8 +3,8 @@
 [![NPM version](https://img.shields.io/npm/v/@fgiova/sqs-consumer.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)
+[![Maintainability](https://qlty.sh/gh/fgiova/projects/sqs-consumer/maintainability.svg)](https://qlty.sh/gh/fgiova/projects/sqs-consumer)
+[![Code Coverage](https://qlty.sh/gh/fgiova/projects/sqs-consumer/coverage.svg)](https://qlty.sh/gh/fgiova/projects/sqs-consumer)
 
 ## Description
 This module allows consuming SQS messages using @fgiova/mini-sqs-client thorough the aws-json protocol with "undici" as http agent .<br />
@@ -88,4 +88,4 @@ SQSConsumer.addHook(hookname: string, func: Function): void
 ```
 
 ## License
-Licensed under [MIT](./LICENSE).
+Licensed under [MIT](./LICENSE).

package/dist/{hooks.d.ts → cjs/hooks.d.ts}

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

package/dist/{hooks.js → cjs/hooks.js}

@@ -2,52 +2,49 @@
 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"
-        },
-    };
-    // eslint-disable-next-line @typescript-eslint/ban-types
-    hooks;
-    logger;
     constructor(logger = console) {
+        this.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",
+            },
+        };
         this.logger = logger;
         this.hooks = {
             [this.hookSymbols.onPoll.S]: [],
@@ -60,13 +57,13 @@ class Hooks {
             [this.hookSymbols.onSQSError.S]: [],
         };
     }
-    // eslint-disable-next-line @typescript-eslint/ban-types
     addHook(hook, fn) {
         const hookSymbol = this.hookSymbols[hook];
         if (!hookSymbol)
             throw new Error(`Invalid hook ${hook}`);
         this.hooks[hookSymbol.S]?.push(fn);
     }
+    // biome-ignore lint/suspicious/noExplicitAny: args can be anything
     async runHook(hook, ...args) {
         const hookSymbol = this.hookSymbols[hook];
         try {
@@ -75,13 +72,15 @@ class Hooks {
             switch (hookSymbol.type) {
                 case "boolean-return":
                     return await this.runHookWithBooleanReturn(hookSymbol, ...args);
-                case "message-return":
+                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 */
+            // biome-ignore lint/suspicious/noExplicitAny: error type is not important
         }
         catch (error) {
             error.message = `Error running hook ${hook}: ${error.message}`;
@@ -90,19 +89,25 @@ class Hooks {
             this.logger.error(error);
         }
     }
-    async runHookWithVoidReturn(hookSymbol, ...args) {
+    async runHookWithVoidReturn(hookSymbol, 
+    // biome-ignore lint/suspicious/noExplicitAny: args can be anything
+    ...args) {
         for (const fn of this.hooks[hookSymbol.S]) {
             await fn(...args);
         }
         return;
     }
-    async runHookWithMessageReturn(hookSymbol, message, ...args) {
+    async runHookWithMessageReturn(hookSymbol, message, 
+    // biome-ignore lint/suspicious/noExplicitAny: args can be anything
+    ...args) {
         for (const fn of this.hooks[hookSymbol.S]) {
             message = await fn(message, ...args);
         }
         return message;
     }
-    async runHookWithBooleanReturn(hookSymbol, ...args) {
+    async runHookWithBooleanReturn(hookSymbol, 
+    // biome-ignore lint/suspicious/noExplicitAny: args can be anything
+    ...args) {
         for (const fn of this.hooks[hookSymbol.S]) {
             const continueLoop = await fn(...args);
             if (!continueLoop) {

package/dist/{index.d.ts → cjs/index.d.ts}

@@ -1,8 +1,8 @@
-import { Signer, SignerOptions } from "@fgiova/aws-signature";
+import type { Signer, SignerOptions } from "@fgiova/aws-signature";
+import { type Message, MiniSQSClient } from "@fgiova/mini-sqs-client";
 import type { Pool } from "undici";
-import { MiniSQSClient, Message } from "@fgiova/mini-sqs-client";
-import { HookName } from "./hooks";
-import { Logger } from "./logger";
+import { type HookName } from "./hooks";
+import type { Logger } from "./logger";
 type HandlerOptions = {
     deleteMessage?: boolean;
     extendVisibilityTimeout?: boolean;

package/dist/{index.js → cjs/index.js}

@@ -4,26 +4,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SQSConsumer = void 0;
+/** biome-ignore-all lint/complexity/noBannedTypes: Function required as generic */
+const promises_1 = require("node:timers/promises");
 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"));
+// @ts-expect-error
 const unpromise_1 = require("@watchable/unpromise");
+// @ts-expect-error
+const p_map_1 = __importDefault(require("p-map"));
+const errors_1 = require("./errors");
+const hooks_1 = require("./hooks");
 class SQSConsumer {
-    queueARN;
-    handlerOptions;
-    clientOptions;
-    consumerOptions;
-    sqsClient;
-    hooks;
-    messageHandler;
-    messagesOnFly = 0;
-    running = false;
-    polling = false;
-    destroyed = false;
-    logger;
     constructor(options) {
+        this.messagesOnFly = 0;
+        this.running = false;
+        this.polling = false;
+        this.destroyed = false;
         if (!options.queueARN)
             throw new Error("queueARN is required");
         if (!options.handler || typeof options.handler !== "function")
@@ -32,20 +27,24 @@ class SQSConsumer {
         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.clientOptions = {
+            destroySigner: options.clientOptions?.destroySigner ?? true,
+        };
         this.handlerOptions = {
             deleteMessage: options.handlerOptions?.deleteMessage ?? true,
             extendVisibilityTimeout: options.handlerOptions?.extendVisibilityTimeout ?? true,
-            executionTimeout: options.handlerOptions?.executionTimeout ?? 30_000,
-            parallelExecution: options.handlerOptions?.parallelExecution ?? 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 ?? []
+            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);
+        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")
@@ -65,14 +64,14 @@ class SQSConsumer {
             await this.hooks.runHook("onSuccess", message);
             return {
                 message,
-                result
+                result,
             };
         }
         catch (e) {
             await this.hooks.runHook("onError", "onMessage", message, e);
             return {
                 message,
-                error: e
+                error: e,
             };
         }
     }
@@ -82,20 +81,18 @@ class SQSConsumer {
             if (this.handlerOptions.executionTimeout) {
                 const response = await unpromise_1.Unpromise.race([
                     handler(message),
-                    new Promise((resolve, reject) => {
+                    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),
-            ]);
+            await Promise.all([this.hooks.runHook("onHandlerSuccess", message)]);
             return handlerResult;
         }
         catch (error) {
@@ -110,16 +107,17 @@ class SQSConsumer {
     }
     haExtendVisibilityTimeout(messages, visibilityTimeout) {
         if (this.handlerOptions.extendVisibilityTimeout !== false) {
-            const processingMessages = messages.map(message => message.ReceiptHandle);
+            const processingMessages = messages.map(
+            // biome-ignore lint/style/noNonNullAssertion: ReceiptHandle must be present here
+            (message) => message.ReceiptHandle);
             return setInterval(async () => {
                 try {
                     await this.sqsClient.changeMessageVisibilityBatch(this.queueARN, processingMessages, visibilityTimeout);
-                }
-                /* c8 ignore next 3 */
+                } /* c8 ignore next 3 */
                 catch (e) {
                     await this.hooks.runHook("onSQSError", e);
                 }
-            }, (visibilityTimeout * 1000 - 5));
+            }, visibilityTimeout * 1000 - 5);
         }
         return null;
     }
@@ -128,9 +126,11 @@ class SQSConsumer {
         const candidateToRelease = [];
         for (const result of messagesResults) {
             if (result.result && this.handlerOptions.deleteMessage !== false) {
+                // biome-ignore lint/style/noNonNullAssertion: ReceiptHandle must be present here
                 candidatesToDelete.push(result.message.ReceiptHandle);
             }
             else if (result.error) {
+                // biome-ignore lint/style/noNonNullAssertion: ReceiptHandle must be present here
                 candidateToRelease.push(result.message.ReceiptHandle);
             }
             if (candidatesToDelete.length)
@@ -144,7 +144,8 @@ class SQSConsumer {
             return;
         try {
             this.polling = true;
-            const visibilityTimeout = this.consumerOptions.visibilityTimeout;
+            /* c8 ignore next 1 */
+            const visibilityTimeout = this.consumerOptions.visibilityTimeout ?? 30;
             const messagesResult = await this.sqsClient.receiveMessage(this.queueARN, {
                 WaitTimeSeconds: this.consumerOptions.waitTimeSeconds,
                 MaxNumberOfMessages: this.consumerOptions.itemsPerRequest,
@@ -158,7 +159,7 @@ class SQSConsumer {
             await this.hooks.runHook("onPoll", messages);
             if (messages.length) {
                 const haTimeout = this.haExtendVisibilityTimeout(messages, visibilityTimeout);
-                this.messagesOnFly += (messages.length - totalMessages);
+                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);
@@ -212,7 +213,6 @@ class SQSConsumer {
             this.destroyed = true;
         }
     }
-    // eslint-disable-next-line @typescript-eslint/ban-types
     addHook(hookName, value) {
         return this.hooks.addHook(hookName, value);
     }

package/dist/{logger.d.ts → cjs/logger.d.ts}

@@ -1,6 +1,7 @@
 /**
  * Represents a generic logger that could be a simple console, pino etc.
  */
+/** biome-ignore-all lint/suspicious/noExplicitAny: leave message logger as any */
 export interface Logger {
     trace(message?: any, ...optionalParams: any[]): void;
     debug(message?: any, ...optionalParams: any[]): void;

package/dist/esm/errors.d.mts

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

package/dist/esm/errors.mjs

@@ -0,0 +1,7 @@
+export class TimeoutError extends Error {
+    constructor(message) {
+        /* c8 ignore next 1 */
+        super(message || "Timeout Error");
+        this.name = "TimeoutError";
+    }
+}

package/dist/esm/hooks.d.mts

@@ -0,0 +1,13 @@
+import type { Logger } from "./logger.mjs";
+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<any>;
+    private runHookWithVoidReturn;
+    private runHookWithMessageReturn;
+    private runHookWithBooleanReturn;
+}

package/dist/esm/hooks.mjs

@@ -0,0 +1,116 @@
+export class Hooks {
+    constructor(logger = console) {
+        this.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",
+            },
+        };
+        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);
+    }
+    // biome-ignore lint/suspicious/noExplicitAny: args can be anything
+    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 */
+            // biome-ignore lint/suspicious/noExplicitAny: error type is not important
+        }
+        catch (error) {
+            error.message = `Error running hook ${hook}: ${error.message}`;
+            if (hookSymbol.throwable !== false)
+                throw error;
+            this.logger.error(error);
+        }
+    }
+    async runHookWithVoidReturn(hookSymbol, 
+    // biome-ignore lint/suspicious/noExplicitAny: args can be anything
+    ...args) {
+        for (const fn of this.hooks[hookSymbol.S]) {
+            await fn(...args);
+        }
+        return;
+    }
+    async runHookWithMessageReturn(hookSymbol, message, 
+    // biome-ignore lint/suspicious/noExplicitAny: args can be anything
+    ...args) {
+        for (const fn of this.hooks[hookSymbol.S]) {
+            message = await fn(message, ...args);
+        }
+        return message;
+    }
+    async runHookWithBooleanReturn(hookSymbol, 
+    // biome-ignore lint/suspicious/noExplicitAny: args can be anything
+    ...args) {
+        for (const fn of this.hooks[hookSymbol.S]) {
+            const continueLoop = await fn(...args);
+            if (!continueLoop) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

package/dist/esm/index.d.mts

@@ -0,0 +1,76 @@
+import type { Signer, SignerOptions } from "@fgiova/aws-signature";
+import { type Message, MiniSQSClient } from "@fgiova/mini-sqs-client";
+import type { Pool } from "undici";
+import { type HookName } from "./hooks.mjs";
+import type { Logger } from "./logger.mjs";
+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/esm/index.mjs

@@ -0,0 +1,213 @@
+/** biome-ignore-all lint/complexity/noBannedTypes: Function required as generic */
+import { setTimeout as setTimeoutAsync } from "node:timers/promises";
+import { MiniSQSClient } from "@fgiova/mini-sqs-client";
+// @ts-expect-error
+import { Unpromise } from "@watchable/unpromise";
+// @ts-expect-error
+import pMap from "p-map";
+import { TimeoutError } from "./errors.mjs";
+import { Hooks } from "./hooks.mjs";
+export class SQSConsumer {
+    constructor(options) {
+        this.messagesOnFly = 0;
+        this.running = false;
+        this.polling = false;
+        this.destroyed = false;
+        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(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 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 Unpromise.race([
+                    handler(message),
+                    new Promise((_resolve, reject) => {
+                        setTimeout(() => {
+                            reject(new 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 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(
+            // biome-ignore lint/style/noNonNullAssertion: ReceiptHandle must be present here
+            (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) {
+                // biome-ignore lint/style/noNonNullAssertion: ReceiptHandle must be present here
+                candidatesToDelete.push(result.message.ReceiptHandle);
+            }
+            else if (result.error) {
+                // biome-ignore lint/style/noNonNullAssertion: ReceiptHandle must be present here
+                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;
+            /* c8 ignore next 1 */
+            const visibilityTimeout = this.consumerOptions.visibilityTimeout ?? 30;
+            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 pMap(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();
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    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 setTimeoutAsync(500);
+        }
+        if (destroy) {
+            await this.sqsClient.destroy(this.clientOptions.destroySigner);
+            this.destroyed = true;
+        }
+    }
+    addHook(hookName, value) {
+        return this.hooks.addHook(hookName, value);
+    }
+}

package/dist/esm/logger.d.mts

@@ -0,0 +1,12 @@
+/**
+ * Represents a generic logger that could be a simple console, pino etc.
+ */
+/** biome-ignore-all lint/suspicious/noExplicitAny: leave message logger as any */
+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/esm/logger.mjs

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,14 +1,29 @@
 {
   "name": "@fgiova/sqs-consumer",
-  "version": "2.0.1",
-  "main": "dist/index.js",
+  "version": "2.1.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": {
-    "prebuild": "rimraf dist",
-    "build": "tsc",
-    "lint": "eslint 'src/**/*.ts'",
+    "clean": "rimraf dist",
+    "preBuild": "npm run clean",
+    "build": "esmBuilder",
+    "lint": "biome ci ./src ./test",
+    "fix": "biome check --write ./src ./test",
     "test": "tap",
     "test:debug": "tap --only --timeout=0",
     "test:coverage": "tap --coverage-report=lcovonly --coverage-report=text",
@@ -41,26 +56,25 @@
     ]
   },
   "dependencies": {
-    "@fgiova/mini-sqs-client": "^2.2.1",
+    "@fgiova/mini-sqs-client": "^3.2.0",
     "@watchable/unpromise": "^1.0.2",
-    "p-map": "^4.0.0"
+    "p-map": "^7.0.3"
   },
   "peerDependencies": {
-    "@fgiova/aws-signature": "^2.0.0"
+    "@fgiova/aws-signature": "^3.1.0"
   },
   "devDependencies": {
     "@aws-sdk/client-sqs": "^3.758.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",
+    "@tsconfig/node20": "^20.1.4",
     "@types/node": "^20.17.23",
-    "@typescript-eslint/eslint-plugin": "^6.21.0",
-    "@typescript-eslint/parser": "^6.21.0",
     "conventional-changelog-conventionalcommits": "^8.0.0",
-    "eslint": "^8.57.1",
-    "eslint-plugin-import": "^2.31.0",
     "semantic-release": "^24.2.3",
     "tap": "^21.1.0",
-    "testcontainers": "^10.18.0",
+    "testcontainers": "^11.5.1",
     "ts-node": "^10.9.2",
     "typescript": "^5.8.2"
   }