consumer-pgmq 3.0.0 → 3.1.1

package/README.md

@@ -11,6 +11,7 @@ This project is a consumer of Supabase/Postgresql queue(using pgmq extension) to
    - Pop consume type is when the consumer gets the message and the message is deleted from queue.
 - Support for both Supabase and Postgresql
 - Support for both visibility time and pool size
+- Support to control the limit of consumers running at once. PS: is focus on Postgres queue driver, is helpful when you have a weak database where no allow to have a lot of connections.
 
 ## Installation
 
@@ -43,10 +44,16 @@ if you use read consume type, the pool size is the number of messages will get a
 - enabledPolling: The enabled polling. PS: if true, the consumer will poll the message, if false, the consumer will consume the message one time and stop. PS: is required to the versions more than 1.0.5.
 - queueNameDlq: The name of the dead letter queue. PS: recommended to set the same name of the queue, but suffix with '_dlq'. For example: **messages_dlq**
 - totalRetriesBeforeSendToDlq: The total retries before send to dlq. For example: if you set totalRetriesBeforeSendToDlq equal 2, the message will be sent to dlq if the handler fails 2 times, so the third time the message will be sent to dlq and remove the main queue to avoid infinite retries.
+- enableControlConsumer: The enable control consumer. PS: if true, you can control the number of consumers running at once, because your Postgres database is weak and can be a problem to have a lot of connections. 
+    - Warning:
+        - You need to execute SQL to create the table 'workers' and you can use **schema.sql** file for it.
+        -  If you need to increase the number of workers you can insert new registers on table 'workers'.
+        - Each register on table workers will represent a process running as consumer(worker). PS: status column can be 'idle' or 'working'. The **idle** means is waiting to be allocate by a consumer and the **working** means was allocated by a consumer.
 
 ## Extra points to know when use the dlq feature
 - The dead letter queue no work If you setted the consumerType option with value 'pop', because the pop get the message and remove from queue at same time, so if failed when you are processing you lose the message.
 - Recommendation no set lower value to the option 'visibilityTime' if you are using the dead letter queue feature. For example: set visibilityTime value lower than 30 seconds, because if the message wasn't delete and the message be available again the consumer application can consume the message again.
+- On Postgresql queue driver when you enable the option 'isCustomQueueImplementation', means you created the custom table to work as queue. PS: in this case you need to use the **schema.sql** file to create a queue table, if you dont want jobs and jobs_dlq as table name you can change in the **schema.sql** file.
 
 ## Events
 
@@ -228,6 +235,82 @@ async function start() {
 start()
 ```
 
+- Consuming messages from Postgresql queue has option enabledControlConsumer and isCustomQueueImplementation enable on Postgres queue driver:
+
+```js
+import { config } from "dotenv"
+config()
+
+import Consumer from '../src/consumer';
+import PostgresQueueDriver from '../src/queueDriver/PostgresQueueDriver';
+
+import { Client } from 'pg'
+
+async function start() {
+
+    const pgClient = new Client({
+        host: process.env.POSTGRES_HOST,
+        database: process.env.POSTGRES_DATABASE,
+        password: process.env.POSTGRES_PASSWORD,
+        port: Number(process.env.POSTGRES_PORT),
+        user: process.env.POSTGRES_USER,
+        ssl: true,
+    })
+
+    await pgClient.connect()
+
+
+    const postgresQueueDriver = new PostgresQueueDriver(
+        pgClient, "public", true
+    )
+
+    const consumer = new Consumer(
+        {
+            queueName: 'jobs',
+            visibilityTime: 30,
+            consumeType: "read",
+            poolSize: 8,
+            timeMsWaitBeforeNextPolling: 1000,
+            enabledPolling: true,
+            queueNameDlq: "jobs_dlq",
+            totalRetriesBeforeSendToDlq: 2,
+            enableControlConsumer: true
+        },
+        async function (message: { [key: string]: any }, signal): Promise<void> {
+            console.log(message)
+        },
+        postgresQueueDriver
+    );
+
+    for (let index = 0; index < 100; index++) {
+        await postgresQueueDriver.send("jobs", {
+            message: `Message ${index}`,
+            id: index
+        })
+    }
+
+    consumer.on("send-to-dlq", (message: { [key: string]: any }) => {
+        console.log("Send to DLQ =>", message)
+    })
+
+    consumer.on('error', (err: Error) => {
+        console.error('Error consuming message:', err.message);
+    });
+
+    await consumer.start();
+
+    process.on("SIGINT", async () => {
+        await consumer.freeConsumer()
+        await pgClient.end()
+        process.exit(0)
+    })
+
+}
+
+start()
+```
+
+
 
 
 

package/dist/consumer.js

@@ -9,6 +9,7 @@ class Consumer extends events_1.EventEmitter {
     constructor(options, callback, client) {
         super();
         this.setTimeoutId = null;
+        this.id = null;
         this.options = options;
         this.callback = callback;
         this.client = client;
@@ -121,7 +122,17 @@ class Consumer extends events_1.EventEmitter {
      * @public
      */
     async start() {
+        if (this.options.enableControlConsumer) {
+            const { id } = await this.client.allocateConsumer();
+            this.id = id;
+        }
         await this.pollMessage();
     }
+    async freeConsumer() {
+        if (this.id) {
+            console.log("passed on here");
+            await this.client.freeConsumer(this.id);
+        }
+    }
 }
 exports.default = Consumer;

package/dist/queueDriver/PostgresQueueDriver.js

@@ -1,9 +1,54 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 class PostgresQueueDriver {
-    constructor(connection, schema = "public") {
+    constructor(connection, schema = "public", isCustomQueueImplementation = true) {
         this.connection = connection;
         this.schema = schema;
+        this.isCustomQueueImplementation = isCustomQueueImplementation;
+    }
+    /**
+     * Allocate the consumer
+     * @returns Promise<{ id: string; }>
+     */
+    async allocateConsumer() {
+        const register = await this.connection.query(`
+            WITH next_workers AS (
+            SELECT id
+            FROM workers as w
+            WHERE
+                status = 'idle'
+            LIMIT 1
+            FOR UPDATE SKIP LOCKED
+        )
+        UPDATE workers
+        SET status = 'working',
+            updated_at = now()
+        FROM next_workers
+        WHERE workers.id = next_workers.id   
+        RETURNING workers.*;    
+        `);
+        if (register.rows.length == 0) {
+            throw new Error("No available consumer(worker) to allocate");
+        }
+        return { id: register.rows[0].id };
+    }
+    async freeConsumer(id) {
+        try {
+            await this.connection.query(`UPDATE workers set status = 'idle' WHERE id = $1`, [id]);
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async sendCustomQueue(queueName, message) {
+        try {
+            const query = `INSERT INTO ${this.schema}.${queueName}(payload) VALUES($1)`;
+            await this.connection.query(query, [JSON.stringify(message)]);
+            return { error: null };
+        }
+        catch (error) {
+            return { error };
+        }
     }
     /**
      * Send the message
@@ -12,6 +57,9 @@ class PostgresQueueDriver {
      * @returns Promise<{ error: any }>
      */
     async send(queueName, message) {
+        if (this.isCustomQueueImplementation) {
+            return this.sendCustomQueue(queueName, message);
+        }
         try {
             await this.connection.query(`
             SELECT * FROM ${this.schema}.send(
@@ -26,6 +74,51 @@ class PostgresQueueDriver {
             return { error };
         }
     }
+    async getCustomQueue(queueName, visibilityTime, totalMessages) {
+        try {
+            const register = await this.connection.query(`
+                WITH next_job AS (
+                SELECT id
+                FROM ${queueName} as jobs
+                WHERE
+                    (
+                        status = 'pending'
+                        OR (status = 'in_progress' AND visible_at <= now())
+                    )
+                ORDER BY created_at
+                LIMIT $1
+                FOR UPDATE SKIP LOCKED
+            )
+            UPDATE jobs
+            SET status = 'in_progress',
+                updated_at = now(),
+                visible_at = now() + interval '${visibilityTime} seconds',
+                retry_count = retry_count + 1
+            FROM next_job
+            WHERE jobs.id = next_job.id   
+            RETURNING jobs.*;
+        `, [
+                totalMessages,
+            ]);
+            if (!register.rows) {
+                return { data: [], error: null };
+            }
+            const items = [];
+            for (const row of register.rows) {
+                items.push({
+                    msg_id: row.id,
+                    read_ct: row.retry_count,
+                    enqueued_at: row.created_at,
+                    vt: row.visible_at,
+                    message: row.payload, // Assuming the message content is stored in a column named 'payload' or '
+                });
+            }
+            return { data: items, error: null };
+        }
+        catch (error) {
+            return { data: [], error };
+        }
+    }
     /**
      * Get the message
      * @param queueName The name of the queue
@@ -34,6 +127,9 @@ class PostgresQueueDriver {
      * @returns Promise<{ data: Message[], error: any }>
      */
     async get(queueName, visibilityTime, totalMessages) {
+        if (this.isCustomQueueImplementation) {
+            return this.getCustomQueue(queueName, visibilityTime, totalMessages);
+        }
         try {
             const register = await this.connection.query(`
                 SELECT * FROM ${this.schema}.read(
@@ -57,6 +153,13 @@ class PostgresQueueDriver {
      * @returns Promise<{ data: Message[], error: any }>
      */
     async pop(queueName) {
+        if (this.isCustomQueueImplementation) {
+            const result = await this.getCustomQueue(queueName, 30, 1);
+            if (result.data && result.data[0]) {
+                await this.delete(queueName, result.data[0].msg_id);
+            }
+            return result;
+        }
         try {
             const register = await this.connection.query(`
                 SELECT * FROM ${this.schema}.pop(
@@ -72,6 +175,12 @@ class PostgresQueueDriver {
             return { data: [], error };
         }
     }
+    async deleteCustomQueue(queueName, messageID) {
+        await this.connection.query(`
+            DELETE FROM     ${queueName}
+            WHERE id = $1;`, [messageID]);
+        return { error: null };
+    }
     /**
      * Delete the message
      * @param queueName The name of the queue
@@ -80,6 +189,9 @@ class PostgresQueueDriver {
      */
     async delete(queueName, messageID) {
         try {
+            if (this.isCustomQueueImplementation) {
+                return this.deleteCustomQueue(queueName, messageID);
+            }
             await this.connection.query(`
             SELECT * FROM ${this.schema}.delete(
                 queue_name => $1,

package/dist/queueDriver/SupabaseQueueDriver.js

@@ -56,5 +56,11 @@ class SupabaseQueueDriver {
         });
         return { error };
     }
+    allocateConsumer() {
+        throw new Error("method logic no implemented");
+    }
+    freeConsumer(id) {
+        throw new Error("method logic no implemented");
+    }
 }
 exports.default = SupabaseQueueDriver;

package/examples/consumerPostgresDriver.ts

@@ -14,41 +14,43 @@ async function start() {
         password: process.env.POSTGRES_PASSWORD,
         port: Number(process.env.POSTGRES_PORT),
         user: process.env.POSTGRES_USER,
-        ssl: false,
+        ssl: true,
     })
 
     await pgClient.connect()
 
 
     const postgresQueueDriver = new PostgresQueueDriver(
-        pgClient, "pgmq"
+        pgClient, "public", true
     )
 
-
     const consumer = new Consumer(
         {
-            queueName: 'subscriptions',
+            queueName: 'jobs',
             visibilityTime: 30,
             consumeType: "read",
             poolSize: 8,
             timeMsWaitBeforeNextPolling: 1000,
             enabledPolling: true,
-            queueNameDlq: "subscriptions_dlq",
-            totalRetriesBeforeSendToDlq: 2
+            queueNameDlq: "jobs_dlq",
+            totalRetriesBeforeSendToDlq: 2,
+            enableControlConsumer: true
         },
         async function (message: { [key: string]: any }, signal): Promise<void> {
             console.log(message)
-            throw new Error("Error in message")
-            // const url = "https://jsonplaceholder.typicode.com/todos/1";
-            // await timersPromises.setTimeout(100, null, { signal });
-            // console.log("Fetching data...");
-            // const response = await fetch(url, { signal });
-            // const todo = await response.json();
-            // console.log("Todo:", todo);
         },
         postgresQueueDriver
     );
 
+    for (let index = 0; index < 100; index++) {
+        await postgresQueueDriver.send("jobs", {
+            message: `Message ${index}`,
+            id: index
+        })
+    }
+
+    console.log("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@")
+
     consumer.on("send-to-dlq", (message: { [key: string]: any }) => {
         console.log("Send to DLQ =>", message)
     })
@@ -60,6 +62,7 @@ async function start() {
     await consumer.start();
 
     process.on("SIGINT", async () => {
+        await consumer.freeConsumer()
         await pgClient.end()
         process.exit(0)
     })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "consumer-pgmq",
-  "version": "3.0.0",
+  "version": "3.1.1",
   "description": "The consumer of Supabase pgmq",
   "main": "dist/index.js",
   "type": "commonjs",
@@ -24,6 +24,7 @@
     "@types/jest": "^30.0.0",
     "@types/pg": "^8.15.5",
     "ts-jest": "^29.4.1",
+    "ts-node": "^10.9.2",
     "ts-node-dev": "^2.0.0",
     "typescript": "^5.9.2"
   },

package/schema.sql

@@ -0,0 +1,134 @@
+
+CREATE TYPE job_status AS ENUM ('pending', 'in_progress');
+
+CREATE TYPE worker_status AS ENUM ('idle', 'working');
+
+CREATE TABLE workers (
+    id SERIAL PRIMARY KEY,
+    status worker_status NOT NULL DEFAULT 'idle', -- Tracks the job lifecycle
+    created_at TIMESTAMP DEFAULT now(),
+    updated_at TIMESTAMP DEFAULT now()
+);
+
+CREATE TABLE jobs (
+    id SERIAL PRIMARY KEY,
+    status job_status NOT NULL DEFAULT 'pending', -- Tracks the job lifecycle
+    payload JSONB, -- Chose payload as `jsonb` but could have gone with `bytea` instead.
+    visible_at TIMESTAMP DEFAULT now(), -- SQS visibility timeout (will come back to this later)
+    retry_count INT DEFAULT 0, -- Tracks retry attempts
+    created_at TIMESTAMP DEFAULT now(),
+    updated_at TIMESTAMP DEFAULT now()
+);
+
+CREATE TABLE jobs_dlq (
+    id SERIAL PRIMARY KEY,
+    status job_status NOT NULL DEFAULT 'pending', -- Tracks the job lifecycle
+    payload JSONB, -- Chose payload as `jsonb` but could have gone with `bytea` instead.
+    visible_at TIMESTAMP DEFAULT now(), -- SQS visibility timeout (will come back to this later)
+    retry_count INT DEFAULT 0, -- Tracks retry attempts
+    created_at TIMESTAMP DEFAULT now(),
+    updated_at TIMESTAMP DEFAULT now()
+);
+
+
+WITH next_workers AS (
+            SELECT id
+            FROM workers as w
+            WHERE
+                status = 'idle'
+            LIMIT 1
+            FOR UPDATE SKIP LOCKED
+        )
+        UPDATE workers
+        SET status = 'working',
+            updated_at = now()
+        FROM next_workers
+        WHERE workers.id = next_workers.id   
+        RETURNING workers.*;
+
+CREATE INDEX ON public.workers (status);
+
+insert into workers(status) 
+    values ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle'),
+    ('idle');
+
+    

package/src/consumer.ts

@@ -24,6 +24,8 @@ class Consumer extends EventEmitter {
 
     private setTimeoutId: NodeJS.Timeout | null = null;
 
+    private id: string | null = null;
+
     constructor(
         options: Options,
         callback: HandlerCallback,
@@ -174,8 +176,21 @@ class Consumer extends EventEmitter {
      * @public
      */
     async start() {
+        if (this.options.enableControlConsumer) {
+            const { id } = await this.client.allocateConsumer()
+            this.id = id
+        }
+
+
         await this.pollMessage();
     }
+
+    async freeConsumer() {
+        if (this.id) {
+            console.log("passed on here")
+            await this.client.freeConsumer(this.id)
+        }
+    }
 }
 
 

package/src/queueDriver/PostgresQueueDriver.ts

@@ -7,8 +7,61 @@ class PostgresQueueDriver implements QueueDriver {
     constructor(
         private connection: Client,
         private schema: string = "public",
+        private isCustomQueueImplementation = true
     ) { }
 
+    /**
+     * Allocate the consumer
+     * @returns Promise<{ id: string; }>
+     */
+    async allocateConsumer(): Promise<{ id: string; }> {
+        const register = await this.connection.query(`
+            WITH next_workers AS (
+            SELECT id
+            FROM workers as w
+            WHERE
+                status = 'idle'
+            LIMIT 1
+            FOR UPDATE SKIP LOCKED
+        )
+        UPDATE workers
+        SET status = 'working',
+            updated_at = now()
+        FROM next_workers
+        WHERE workers.id = next_workers.id   
+        RETURNING workers.*;    
+        `)
+
+        if (register.rows.length == 0) {
+            throw new Error("No available consumer(worker) to allocate");
+        }
+
+        return { id: register.rows[0].id };
+    }
+
+
+    async freeConsumer(id: string): Promise<void> {
+        try {
+            await this.connection.query(`UPDATE workers set status = 'idle' WHERE id = $1`, [id])
+        } catch (error) {
+            throw error
+        }
+    }
+
+
+    private async sendCustomQueue(
+        queueName: string,
+        message: { [key: string]: any; }
+    ) {
+        try {
+            const query = `INSERT INTO ${this.schema}.${queueName}(payload) VALUES($1)`
+            await this.connection.query(query, [JSON.stringify(message)])
+            return { error: null };
+        } catch (error) {
+            return { error };
+        }
+    }
+
     /**
      * Send the message
      * @param queueName The name of the queue
@@ -19,6 +72,10 @@ class PostgresQueueDriver implements QueueDriver {
         queueName: string,
         message: { [key: string]: any; },
     ): Promise<{ error: any; }> {
+        if (this.isCustomQueueImplementation) {
+            return this.sendCustomQueue(queueName, message)
+        }
+
         try {
             await this.connection.query(`
             SELECT * FROM ${this.schema}.send(
@@ -35,6 +92,61 @@ class PostgresQueueDriver implements QueueDriver {
         }
     }
 
+    private async getCustomQueue(
+        queueName: string,
+        visibilityTime: number,
+        totalMessages: number
+    ): Promise<{ data: Message[]; error: any; }> {
+        try {
+            const register = await this.connection.query(
+                `
+                WITH next_job AS (
+                SELECT id
+                FROM ${queueName} as jobs
+                WHERE
+                    (
+                        status = 'pending'
+                        OR (status = 'in_progress' AND visible_at <= now())
+                    )
+                ORDER BY created_at
+                LIMIT $1
+                FOR UPDATE SKIP LOCKED
+            )
+            UPDATE jobs
+            SET status = 'in_progress',
+                updated_at = now(),
+                visible_at = now() + interval '${visibilityTime} seconds',
+                retry_count = retry_count + 1
+            FROM next_job
+            WHERE jobs.id = next_job.id   
+            RETURNING jobs.*;
+        `,
+                [
+                    totalMessages,
+                ]
+            );
+
+            if (!register.rows) {
+                return { data: [], error: null };
+            }
+
+            const items: Message[] = [];
+            for (const row of register.rows) {
+                items.push({
+                    msg_id: row.id,
+                    read_ct: row.retry_count,
+                    enqueued_at: row.created_at,
+                    vt: row.visible_at,
+                    message: row.payload, // Assuming the message content is stored in a column named 'payload' or '
+                });
+            }
+
+            return { data: items, error: null };
+        } catch (error) {
+            return { data: [], error };
+        }
+    }
+
     /**
      * Get the message
      * @param queueName The name of the queue
@@ -43,6 +155,10 @@ class PostgresQueueDriver implements QueueDriver {
      * @returns Promise<{ data: Message[], error: any }>
      */
     async get(queueName: string, visibilityTime: number, totalMessages: number): Promise<{ data: Message[]; error: any; }> {
+        if (this.isCustomQueueImplementation) {
+            return this.getCustomQueue(queueName, visibilityTime, totalMessages);
+        }
+
         try {
             const register = await this.connection.query(`
                 SELECT * FROM ${this.schema}.read(
@@ -70,6 +186,13 @@ class PostgresQueueDriver implements QueueDriver {
      * @returns Promise<{ data: Message[], error: any }>
      */
     async pop(queueName: string): Promise<{ data: Message[]; error: any; }> {
+        if (this.isCustomQueueImplementation) {
+            const result = await this.getCustomQueue(queueName, 30, 1);
+            if (result.data && result.data[0]) {
+                await this.delete(queueName, result.data[0].msg_id);
+            }
+            return result
+        }
         try {
             const register = await this.connection.query(`
                 SELECT * FROM ${this.schema}.pop(
@@ -89,6 +212,14 @@ class PostgresQueueDriver implements QueueDriver {
 
     }
 
+    private async deleteCustomQueue(queueName: string, messageID: number) {
+        await this.connection.query(`
+            DELETE FROM     ${queueName}
+            WHERE id = $1;`, [messageID]
+        )
+        return { error: null };
+    }
+
     /**
      * Delete the message
      * @param queueName The name of the queue
@@ -97,6 +228,9 @@ class PostgresQueueDriver implements QueueDriver {
      */
     async delete(queueName: string, messageID: number): Promise<{ error: any; }> {
         try {
+            if (this.isCustomQueueImplementation) {
+                return this.deleteCustomQueue(queueName, messageID)
+            }
             await this.connection.query(`
             SELECT * FROM ${this.schema}.delete(
                 queue_name => $1,

package/src/queueDriver/SupabaseQueueDriver.ts

@@ -67,6 +67,14 @@ class SupabaseQueueDriver implements QueueDriver {
         return { error };
     }
 
+    allocateConsumer(): Promise<{ id: string; }> {
+        throw new Error("method logic no implemented")
+    }
+
+    freeConsumer(id: string): Promise<void> {
+        throw new Error("method logic no implemented")
+    }
+
 }
 
 export default SupabaseQueueDriver;

package/src/type.ts

@@ -40,6 +40,11 @@ interface Options {
      * The total retries before send the message to DLQ. PS: if set queueNameDlq, this option is required
      */
     totalRetriesBeforeSendToDlq?: number;
+
+    /**
+     * The enable control consumer. PS: if true, set the allocate a consumer from table workers, because that way you can control the number of consumers(workers)
+     */
+    enableControlConsumer?: boolean;
 }
 
 /**
@@ -119,6 +124,10 @@ interface QueueDriver {
         queueName: string,
         messageID: number
     ): Promise<{ error: any }>;
+
+    allocateConsumer(): Promise<{ id: string }>;
+
+    freeConsumer(id: string): Promise<void>;
 }
 
 export type { Options, HandlerCallback, Message, QueueDriver }

package/tests/consumer.spec.ts

@@ -18,6 +18,8 @@ describe('Consumer', () => {
             pop: jest.fn(),
             delete: jest.fn(),
             send: jest.fn(),
+            allocateConsumer: jest.fn(),
+            freeConsumer: jest.fn()
         }
         jest.useFakeTimers();
     })
@@ -188,8 +190,6 @@ describe('Consumer', () => {
         )
     })
 
-
-
     it('Should not process message if read method does not return any message second polling', async () => {
         queueDriver.get.mockResolvedValueOnce({ data: [message], error: null })
         queueDriver.delete.mockResolvedValueOnce({ error: null })
@@ -397,8 +397,35 @@ describe('Consumer', () => {
 
         await consumer.start()
 
+        expect(queueDriver.allocateConsumer).toHaveBeenCalledTimes(0)
         expect(onError).toHaveBeenCalled()
         expect((onError.mock.calls[0][0] as Error).message)
             .toBe('visibilityTime is required for read')
     })
+
+
+    it('Should call allocateConsumer when option enableControlConsumer is true', async () => {
+        queueDriver.allocateConsumer.mockResolvedValue({ id: '1' })
+        const consumer = new Consumer(
+            { queueName: 'q', consumeType: 'read', enableControlConsumer: true } as Options,
+            async () => { },
+            queueDriver
+        )
+
+        await consumer.start()
+
+        expect(queueDriver.allocateConsumer).toHaveBeenCalled()
+    })
+
+
+    it('Should call freeConsumer when option enableControlConsumer is true and process exit', async () => {
+        queueDriver.allocateConsumer.mockResolvedValue({ id: '1' })
+        const consumer = new Consumer(
+            { queueName: 'q', consumeType: 'read', enableControlConsumer: true } as Options,
+            async () => { },
+            queueDriver
+        )
+
+        await consumer.start()
+    })
 })