consumer-pgmq 1.0.0

package/.github/workflows/release.yml

@@ -0,0 +1,44 @@
+name: Release
+on:
+  push:
+    branches:
+      - master
+
+permissions:
+  contents: read
+
+jobs:
+  release:
+    name: Release
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      issues: write
+      pull-requests: write
+      id-token: write
+    steps:
+      
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "lts/*"
+      
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v3
+      
+      - name: Install dependencies
+        run: pnpm install
+      
+      - name: Verify the integrity of provenance attestations and registry signatures for installed dependencies
+        run: pnpm audit signatures
+      
+      - name: Release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+        run: npx semantic-release

package/README.md

@@ -0,0 +1,31 @@
+## About
+
+This project is a consumer of Supabase/Postgresql queue(using pgmq extension) to simplify the process of consuming messages.
+
+## Features
+
+- Consumer message from Supabase queue. PS: instructions to setup https://supabase.com/blog/supabase-queues
+- Consumer message from Postgresql queue. PS: instructions to setup https://github.com/pgmq/pgmq
+- Support for both read and pop consume types
+   - Read consume type is when the consumer gets the message and the message is not deleted from queue until the callback is executed with success.
+   - 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
+
+## Installation
+
+- Using pnpm
+```bash
+pnpm install consumer-pgmq
+```
+
+- Using npm
+```bash
+npm install consumer-pgmq
+```
+- Using yarn
+```bash
+yarn add consumer-pgmq
+```
+
+

package/examples/consumerPostgresDriver.ts

@@ -0,0 +1,72 @@
+import { config } from "dotenv"
+config()
+
+import Consumer from '../src/consumer';
+import PostgresQueueDriver from '../src/queueDriver/PostgresQueueDriver';
+import timersPromises from "node:timers/promises";
+import knex from 'knex'
+
+async function start() {
+    const connection = knex({
+        client: 'pg',
+        connection: {
+            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: false
+        }
+    });
+
+    const postgresQueueDriver = new PostgresQueueDriver(connection)
+
+    const consumer = new Consumer(
+        {
+            queueName: 'subscriptions',
+            visibilityTime: 15,
+            consumeType: "read",
+            poolSize: 4,
+            timeMsWaitBeforeNextPolling: 1000
+        },
+        async function (message: { [key: string]: any }, signal): Promise<void> {
+            try {
+                console.log(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);
+            } catch (error: any) {
+                if (error.name === "AbortError") {
+                    console.log("Operation aborted");
+                } else {
+                    console.error("Error:", error);
+                }
+            }
+        },
+        postgresQueueDriver
+    );
+
+    consumer.on('finish', (message: { [key: string]: any }) => {
+        console.log('Consumed message =>', message);
+    });
+
+    consumer.on("abort-error", (err) => {
+        console.log("Abort error =>", err)
+    })
+
+    consumer.on('error', (err: Error) => {
+        if (err.message.includes("TypeError: fetch failed")) {
+            console.log(err)
+            process.exit(1);
+        }
+        console.error('Error consuming message:', err.message);
+    });
+
+    consumer.start();
+
+}
+
+start()

package/examples/consumerSupabaseDriver.ts

@@ -0,0 +1,84 @@
+import { config } from "dotenv"
+config()
+
+import Consumer from '../src/consumer';
+import { createClient, SupabaseClient } from '@supabase/supabase-js';
+import SupabaseQueueDriver from '../src/queueDriver/SupabaseQueueDriver';
+
+
+const supabase = createClient(
+    // @ts-ignore
+    process.env.SUPABASE_URL,
+    process.env.SUPABASE_ANON_KEY,
+    {
+        db: {
+            schema: 'pgmq_public'
+        }
+    }
+);
+
+const supabaseQueueDriver = new SupabaseQueueDriver(
+    supabase as unknown as SupabaseClient
+)
+
+
+import timersPromises from "node:timers/promises";
+
+async function start() {
+    for (let i = 0; i < 200; i++) {
+        await supabase.rpc("send", {
+            queue_name: "subscriptions",
+            message: { "message": `Message triggered at ${Date.now()}` }
+        });
+    }
+    console.log("Total messages sent: ", 200)
+
+    const consumer = new Consumer(
+        {
+            queueName: 'subscriptions',
+            visibilityTime: 15,
+            consumeType: "read",
+            poolSize: 4,
+            timeMsWaitBeforeNextPolling: 1000
+        },
+        async function (message: { [key: string]: any }, signal): Promise<void> {
+            try {
+                console.log(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);
+            } catch (error: any) {
+                if (error.name === "AbortError") {
+                    console.log("Operation aborted");
+                } else {
+                    console.error("Error:", error);
+                }
+            }
+        },
+        supabaseQueueDriver
+    );
+
+    consumer.on('finish', (message: { [key: string]: any }) => {
+        console.log('Consumed message =>', message);
+    });
+
+    consumer.on("abort-error", (err) => {
+        console.log("Abort error =>", err)
+    })
+
+    consumer.on('error', (err: Error) => {
+        if (err.message.includes("TypeError: fetch failed")) {
+            console.log(err)
+            process.exit(1);
+        }
+        console.error('Error consuming message:', err.message);
+    });
+
+    consumer.start();
+
+}
+
+start()

package/jest.config.js

@@ -0,0 +1,7 @@
+module.exports = {
+    preset: 'ts-jest',
+    testEnvironment: 'node',
+    transform: {
+        '^.+\\.(t|j)sx?$': 'ts-jest',
+    },
+};

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "consumer-pgmq",
+  "version": "1.0.0",
+  "description": "The consumer of Supabase pgmq",
+  "main": "dist/index.js",
+  "type": "commonjs",
+  "scripts": {
+    "start:example:postgres": "ts-node ./examples/consumerPostgresDriver.ts",
+    "start:example:supabase": "ts-node ./examples/consumerSupabaseDriver.ts",
+    "start:dev": "ts-node-dev ./src/index.ts",
+    "test": "jest ./tests/*.spec.ts --detectOpenHandles"
+  },
+  "keywords": [
+    "supabase",
+    "pgmq",
+    "consumer"
+  ],
+  "author": "Tiago Rosa da costa<tiagorosadacosta@gmail.com>",
+  "license": "MIT",
+  "packageManager": "pnpm@10.7.1",
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "ts-jest": "^29.4.1",
+    "ts-node-dev": "^2.0.0",
+    "typescript": "^5.9.2"
+  },
+  "dependencies": {
+    "@supabase/supabase-js": "^2.56.0",
+    "dotenv": "^17.2.1",
+    "jest": "^30.1.1",
+    "knex": "^3.1.0",
+    "pg": "^8.16.3"
+  }
+}

package/src/consumer.ts

@@ -0,0 +1,141 @@
+
+import { EventEmitter } from 'events';
+import { HandlerCallback, Message, Options, QueueDriver } from './type';
+
+const READ = "read";
+
+/**
+ * The consumer class.
+ */
+class Consumer extends EventEmitter {
+
+    /**
+     * The callback function to handle the message.
+     */
+    private callback: HandlerCallback
+    /**
+     * The options to configure the consumer.
+     */
+    private options: Options
+    /**
+     * The supabase client.
+     */
+    private client: QueueDriver
+
+    constructor(
+        options: Options,
+        callback: HandlerCallback,
+        client: QueueDriver,
+    ) {
+        super();
+        this.options = options;
+        this.callback = callback;
+        this.client = client;
+    }
+
+    /**
+     * Get the message
+     * @returns Promise<{ data: Message[], error: any }>
+     * @private
+     */
+    private async getMessage(): Promise<{ data: Message[], error: any }> {
+        if (this.options.consumeType === READ) {
+            if (!this.options.visibilityTime) {
+                throw new Error("visibilityTime is required for read");
+            }
+
+            const { data, error } = await this.client.get(
+                this.options.queueName, this.options.visibilityTime,
+                this.options.poolSize || 1
+            );
+
+            return { data: data as Message[], error };
+        }
+
+        const { data, error } = await this.client.pop(this.options.queueName);
+        return { data: data as Message[], error };
+    }
+
+    /**
+     * @param data 
+     * @returns Promise<void>
+     * @private
+     */
+    private async deleteMessage(data: Message, signal: AbortSignal) {
+        if (signal.aborted) {
+            return;
+        }
+
+        if (this.options.consumeType === READ) {
+            const deleteMessage = await this.client.delete(
+                this.options.queueName,
+                data.msg_id
+            );
+            if (deleteMessage.error) {
+                this.emit('error', deleteMessage.error);
+                return;
+            }
+        }
+    }
+
+    /**
+     * Poll the message
+     * @returns Promise<void>
+     * @private
+     */
+    private async pollMessage() {
+        let promises: Promise<any>[] = [];
+
+        try {
+            const { data, error } = await this.getMessage();
+            if (error) {
+                throw error;
+            }
+
+            if (data.length === 0) {
+                setTimeout(
+                    () => this.pollMessage(),
+                    (this.options.timeMsWaitBeforeNextPolling || 1000) * 10
+                );
+                return;
+            }
+
+
+            const controller = new AbortController();
+            const signal = controller.signal;
+
+            for (let i = 0; i < (data.length || 1); i++) {
+                promises.push(
+                    this.callback(data[i].message, signal).then(async () => {
+                        await this.deleteMessage(data[i], signal);
+                        this.emit('finish', data[i]);
+                    })
+                );
+            }
+
+            setTimeout(() => controller.abort(), (this.options.visibilityTime || 1) * 1000);
+            await Promise.all(promises);
+            promises = [];
+        } catch (err: any) {
+            if (err.name === "AbortError") {
+                this.emit("abort-error", err)
+            } else {
+                this.emit('error', err);
+            }
+        } finally {
+            setTimeout(() => this.pollMessage(), this.options.timeMsWaitBeforeNextPolling || 1000);
+        }
+    }
+
+    /**
+     * Start the consumer
+     * @returns Promise<void>
+     * @public
+     */
+    async start() {
+        await this.pollMessage();
+    }
+}
+
+
+export default Consumer;

package/src/index.ts

@@ -0,0 +1,3 @@
+import Consumer from './consumer';
+
+export default Consumer;

package/src/queueDriver/PostgresQueueDriver.ts

@@ -0,0 +1,88 @@
+import { Knex } from "knex";
+import { Message, QueueDriver } from "../type";
+
+class PostgresQueueDriver implements QueueDriver {
+
+    constructor(
+        private connection: Knex
+    ) { }
+
+    /**
+     * Get the message
+     * @param queueName The name of the queue
+     * @param visibilityTime The visibility time of the message
+     * @param totalMessages The total messages to get
+     * @returns Promise<{ data: Message[], error: any }>
+     */
+    async get(queueName: string, visibilityTime: number, totalMessages: number): Promise<{ data: Message[]; error: any; }> {
+        try {
+            const register = await this.connection.raw(`
+                SELECT * FROM pgmq.read(
+                    queue_name => ?,
+                    vt         => ?,
+                    qty        => ?
+                );
+                `, [queueName, visibilityTime, totalMessages]
+            )
+
+            if (!register.rows) {
+                return { data: [], error: null };
+            }
+
+            return { data: register.rows as Message[], error: null };
+        } catch (error) {
+            return { data: [], error };
+        }
+
+    }
+
+    /**
+     * Pop the message
+     * @param queueName The name of the queue
+     * @returns Promise<{ data: Message[], error: any }>
+     */
+    async pop(queueName: string): Promise<{ data: Message[]; error: any; }> {
+        try {
+            const register = await this.connection.raw(`
+                SELECT * FROM pgmq.pop(
+                    queue_name => ?
+                );
+                `, [queueName]
+            )
+
+            if (!register.rows) {
+                return { data: [], error: null };
+            }
+
+            return { data: register.rows as Message[], error: null };
+        } catch (error) {
+            return { data: [], error };
+        }
+
+    }
+
+    /**
+     * Delete the message
+     * @param queueName The name of the queue
+     * @param messageID The message ID
+     * @returns Promise<{ error: any }>
+     */
+    async delete(queueName: string, messageID: number): Promise<{ error: any; }> {
+        try {
+            await this.connection.raw(`
+            SELECT * FROM pgmq.delete(
+                queue_name => ?,
+                msg_id     => ?
+            );
+            `, [queueName, messageID]
+            )
+
+            return { error: null };
+        } catch (error) {
+            return { error };
+        }
+    }
+
+}
+
+export default PostgresQueueDriver;

package/src/queueDriver/SupabaseQueueDriver.ts

@@ -0,0 +1,57 @@
+import { Message, QueueDriver } from "../type";
+import { SupabaseClient } from '@supabase/supabase-js';
+
+class SupabaseQueueDriver implements QueueDriver {
+
+    constructor(
+        private supabase: SupabaseClient
+    ) { }
+
+    /**
+     * Get the message
+     * @param queueName The name of the queue
+     * @param visibilityTime The visibility time of the message
+     * @param totalMessages The total messages to get
+     * @returns Promise<{ data: Message[], error: any }>
+     */
+    async get(queueName: string, visibilityTime: number, totalMessages: number): Promise<{ data: Message[]; error: any; }> {
+        const { data, error } = await this.supabase.rpc("read", {
+            queue_name: queueName,
+            sleep_seconds: visibilityTime,
+            n: totalMessages
+        });
+
+        return { data: data as Message[], error };
+    }
+
+    /**
+     * Pop the message
+     * @param queueName The name of the queue
+     * @returns Promise<{ data: Message[], error: any }>
+     */
+    async pop(queueName: string): Promise<{ data: Message[]; error: any; }> {
+        const { data, error } = await this.supabase.rpc("pop", {
+            queue_name: queueName,
+        });
+
+        return { data: data as Message[], error };
+    }
+
+    /**
+     * Delete the message
+     * @param queueName The name of the queue
+     * @param messageID The message ID
+     * @returns Promise<{ error: any }>
+     */
+    async delete(queueName: string, messageID: number): Promise<{ error: any; }> {
+        const { error } = await this.supabase.rpc("delete", {
+            queue_name: queueName,
+            message_id: messageID
+        });
+
+        return { error };
+    }
+
+}
+
+export default SupabaseQueueDriver;

package/src/type.ts

@@ -0,0 +1,97 @@
+
+/*
+ * The type of consume. PS: "pop" get the message and delete it from database, "read" get the message and keep it on database
+ */
+type CONSUME_TYPE = "pop" | "read";
+
+interface Options {
+    /**
+     * The name of the queue
+     */
+    queueName: string;
+    /**
+     * The visibility time of the message. PS: is the time in seconds that the message will be invisible to other consumers
+     */
+    visibilityTime?: number;
+    /**
+     * The type of consume.
+     */
+    consumeType: CONSUME_TYPE;
+    /**
+     * The pool size. PS: the number of messages that will be consumed at the same time
+     */
+    poolSize?: number;
+    /**
+     * The time to wait before next polling. PS: the time in milliseconds
+     */
+    timeMsWaitBeforeNextPolling?: number;
+}
+
+/**
+ * The callback function to handle the message
+ * @param message The message
+ * @param signal The abort signal
+ * @returns Promise<void>
+ */
+type HandlerCallback = (message: { [key: string]: any }, signal: AbortSignal) => Promise<void>
+
+interface Message {
+    /**
+     * The message ID
+     */
+    msg_id: number;
+    /**
+     * The number of times the message has been read
+     */
+    read_ct: number;
+    /**
+     * The time the message was enqueued
+     */
+    enqueued_at: string;
+    /**
+     * The visibility time of the message
+     */
+    vt: string;
+    /**
+     * The message content
+     */
+    message: { [key: string]: any };
+}
+
+interface QueueDriver {
+
+    /**
+     * Get the message
+     * @param queueName The name of the queue
+     * @param visibilityTime The visibility time of the message
+     * @param totalMessages The total messages to get
+     * @returns Promise<{ data: Message[], error: any }>
+     */
+    get(
+        queueName: string,
+        visibilityTime: number,
+        totalMessages: number
+    ): Promise<{ data: Message[], error: any }>;
+
+    /**
+     * Pop the message
+     * @param queueName The name of the queue
+     * @returns Promise<{ data: Message[], error: any }>
+     */
+    pop(
+        queueName: string,
+    ): Promise<{ data: Message[], error: any }>;
+
+    /**
+     * Delete the message
+     * @param queueName The name of the queue
+     * @param messageID The message ID
+     * @returns Promise<{ error: any }>
+     */
+    delete(
+        queueName: string,
+        messageID: number
+    ): Promise<{ error: any }>;
+}
+
+export type { Options, HandlerCallback, Message, QueueDriver }

package/tests/consumer.spec.ts

@@ -0,0 +1,237 @@
+import Consumer from '../src/consumer'
+import { Message, QueueDriver, Options } from '../src/type'
+import timersPromises from 'node:timers/promises'
+
+describe('Consumer', () => {
+    let queueDriver: jest.Mocked<QueueDriver>
+
+    const message: Message = ({
+        msg_id: 1,
+        read_ct: 0,
+        enqueued_at: new Date().toISOString(),
+        vt: new Date().toISOString(),
+        message: { foo: 'bar' },
+    })
+
+    beforeEach(() => {
+        queueDriver = {
+            get: jest.fn(),
+            pop: jest.fn(),
+            delete: jest.fn(),
+        }
+        jest.useFakeTimers();
+    })
+
+
+    afterEach(() => {
+        jest.clearAllMocks()
+    })
+
+
+
+    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 })
+        queueDriver.get.mockResolvedValueOnce({ data: [], error: null })
+
+        const handler = jest.fn(async () => { })
+        const consumer = new Consumer(
+            {
+                queueName: 'q',
+                consumeType: 'read',
+                visibilityTime: 1,
+                poolSize: 1,
+                timeMsWaitBeforeNextPolling: 1
+            },
+            handler,
+            queueDriver
+        )
+
+        const onFinish = jest.fn()
+        consumer.on('finish', onFinish)
+
+        await consumer.start()
+
+        expect(handler).toHaveBeenCalledTimes(1)
+        expect(onFinish).toHaveBeenCalledTimes(1)
+        expect(queueDriver.delete).toHaveBeenCalledTimes(1)
+
+    })
+
+    it('Should not process message if pop method does not return any message second polling', async () => {
+        queueDriver.pop.mockResolvedValueOnce({ data: [message], error: null })
+        queueDriver.pop.mockResolvedValueOnce({ data: [], error: null })
+
+        const handler = jest.fn(async () => { })
+        const consumer = new Consumer(
+            {
+                queueName: 'q',
+                consumeType: 'pop',
+                visibilityTime: 1,
+                poolSize: 1,
+                timeMsWaitBeforeNextPolling: 1
+            },
+            handler,
+            queueDriver
+        )
+
+        const onFinish = jest.fn()
+        consumer.on('finish', onFinish)
+
+        await consumer.start()
+
+        expect(handler).toHaveBeenCalledTimes(1)
+        expect(onFinish).toHaveBeenCalledTimes(1)
+    })
+
+
+    it('Should not process message if pop method does not return any message', async () => {
+        queueDriver.pop.mockResolvedValue({ data: [], error: null })
+
+        const handler = jest.fn(async () => { })
+        const consumer = new Consumer(
+            {
+                queueName: 'q',
+                consumeType: 'pop',
+                visibilityTime: 1,
+                poolSize: 1,
+                timeMsWaitBeforeNextPolling: 1
+            },
+            handler,
+            queueDriver
+        )
+
+        const onFinish = jest.fn()
+        consumer.on('finish', onFinish)
+
+        await consumer.start()
+
+        expect(handler).not.toHaveBeenCalled()
+        expect(onFinish).not.toHaveBeenCalled()
+    })
+
+    it('Should not process message if get method does not return any message', async () => {
+        queueDriver.get.mockResolvedValue({ data: [], error: null })
+        queueDriver.delete.mockResolvedValue({ error: null })
+
+        const handler = jest.fn(async () => { })
+        const consumer = new Consumer(
+            {
+                queueName: 'q',
+                consumeType: 'read',
+                visibilityTime: 1,
+                poolSize: 1,
+                timeMsWaitBeforeNextPolling: 1
+            },
+            handler,
+            queueDriver
+        )
+
+        const onFinish = jest.fn()
+        consumer.on('finish', onFinish)
+
+        await consumer.start()
+
+        expect(handler).not.toHaveBeenCalled()
+        expect(queueDriver.delete).not.toHaveBeenCalled()
+        expect(onFinish).not.toHaveBeenCalled()
+    })
+
+
+    it('Should process message, delete it, emit finish', async () => {
+        const msg = message
+        queueDriver.get.mockResolvedValue({ data: [msg], error: null })
+        queueDriver.delete.mockResolvedValue({ error: null })
+
+        const handler = jest.fn(async () => { })
+        const consumer = new Consumer(
+            {
+                queueName: 'q',
+                consumeType: 'read',
+                visibilityTime: 1,
+                poolSize: 1,
+                timeMsWaitBeforeNextPolling: 1
+            },
+            handler,
+            queueDriver
+        )
+
+        const onFinish = jest.fn()
+        consumer.on('finish', onFinish)
+
+        await consumer.start()
+
+        expect(handler).toHaveBeenCalledWith(msg.message, expect.any(AbortSignal))
+        expect(queueDriver.delete).toHaveBeenCalledWith('q', msg.msg_id)
+        expect(onFinish).toHaveBeenCalledWith(msg)
+    })
+
+
+    it('Should process 4 messages using consumeType get', async () => {
+        const msgs = [message, message, message, message]
+        queueDriver.get.mockResolvedValue({ data: msgs, error: null })
+        queueDriver.delete.mockResolvedValue({ error: null })
+
+        const handler = jest.fn(async () => { })
+        const consumer = new Consumer(
+            {
+                queueName: 'q',
+                consumeType: 'read',
+                visibilityTime: 1,
+                poolSize: 4,
+                timeMsWaitBeforeNextPolling: 1
+            },
+            handler,
+            queueDriver
+        )
+
+        const onFinish = jest.fn()
+        consumer.on('finish', onFinish)
+
+        await consumer.start()
+
+        expect(handler).toHaveBeenCalledWith(msgs[0].message, expect.any(AbortSignal))
+        expect(queueDriver.delete).toHaveBeenCalledWith('q', msgs[0].msg_id)
+        expect(onFinish).toHaveBeenCalledWith(msgs[0])
+        expect(onFinish).toHaveBeenCalledTimes(4)
+    })
+
+    it('Should process message using consumeType is pop emits finish', async () => {
+        const msg = message
+        queueDriver.pop.mockResolvedValue({ data: [msg], error: null })
+
+        const handler = jest.fn(async () => { })
+        const consumer = new Consumer(
+            { queueName: 'q', consumeType: 'pop', timeMsWaitBeforeNextPolling: 1 } as Options,
+            handler,
+            queueDriver
+        )
+
+        const onFinish = jest.fn()
+        consumer.on('finish', onFinish)
+
+        await consumer.start()
+
+        expect(handler).toHaveBeenCalledWith(msg.message, expect.any(AbortSignal))
+        expect(queueDriver.delete).not.toHaveBeenCalled()
+        expect(onFinish).toHaveBeenCalledWith(msg)
+        expect(queueDriver.delete).toHaveBeenCalledTimes(0)
+    })
+
+    it('Should emit error when consumeType is read without visibilityTime', async () => {
+        const consumer = new Consumer(
+            { queueName: 'q', consumeType: 'read' } as Options,
+            async () => { },
+            queueDriver
+        )
+
+        const onError = jest.fn()
+        consumer.on('error', onError)
+
+        await consumer.start()
+
+        expect(onError).toHaveBeenCalled()
+        expect((onError.mock.calls[0][0] as Error).message)
+            .toBe('visibilityTime is required for read')
+    })
+})

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "es2020",
+    "module": "commonjs",
+    "outDir": "./dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules"],
+  "ts-node": {
+    "transpileOnly": true,
+    "files": true,
+    "compilerOptions": {
+      "rootDir": "."
+    }
+  }
+
+}