consumer-pgmq 1.0.2 → 1.0.4

package/README.md

@@ -54,9 +54,8 @@ if you use read consume type, the pool size is the number of messages will get a
 import { config } from "dotenv"
 config()
 
-import Consumer from '../src/consumer';
+import { SupabaseQueueDriver, Consumer } from "consumer-pgmq"
 import { createClient, SupabaseClient } from '@supabase/supabase-js';
-import SupabaseQueueDriver from '../src/queueDriver/SupabaseQueueDriver';
 
 
 const supabase = createClient(
@@ -142,8 +141,7 @@ start()
 import { config } from "dotenv"
 config()
 
-import Consumer from '../src/consumer';
-import PostgresQueueDriver from '../src/queueDriver/PostgresQueueDriver';
+import { Consumer, PostgresQueueDriver } from "consumer-pgmq"
 import timersPromises from "node:timers/promises";
 import knex from 'knex'
 
@@ -160,7 +158,7 @@ async function start() {
         }
     });
 
-    const postgresQueueDriver = new PostgresQueueDriver(connection)
+    const postgresQueueDriver = new PostgresQueueDriver(connection, "schema_name_here")
 
     const consumer = new Consumer(
         {

package/dist/consumer.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const events_1 = require("events");
+const READ = "read";
+/**
+ * The consumer class.
+ */
+class Consumer extends events_1.EventEmitter {
+    constructor(options, callback, client) {
+        super();
+        this.options = options;
+        this.callback = callback;
+        this.client = client;
+    }
+    /**
+     * Get the message
+     * @returns Promise<{ data: Message[], error: any }>
+     * @private
+     */
+    async getMessage() {
+        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, error };
+        }
+        const { data, error } = await this.client.pop(this.options.queueName);
+        return { data: data, error };
+    }
+    /**
+     * @param data
+     * @returns Promise<void>
+     * @private
+     */
+    async deleteMessage(data, signal) {
+        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
+     */
+    async pollMessage() {
+        let promises = [];
+        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) {
+            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();
+    }
+}
+exports.default = Consumer;

package/dist/index.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SupabaseQueueDriver = exports.PostgresQueueDriver = exports.Consumer = void 0;
+const consumer_1 = __importDefault(require("./consumer"));
+exports.Consumer = consumer_1.default;
+const PostgresQueueDriver_1 = __importDefault(require("./queueDriver/PostgresQueueDriver"));
+exports.PostgresQueueDriver = PostgresQueueDriver_1.default;
+const SupabaseQueueDriver_1 = __importDefault(require("./queueDriver/SupabaseQueueDriver"));
+exports.SupabaseQueueDriver = SupabaseQueueDriver_1.default;

package/dist/queueDriver/PostgresQueueDriver.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class PostgresQueueDriver {
+    constructor(connection, schema = "public") {
+        this.connection = connection;
+        this.schema = schema;
+    }
+    /**
+     * 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, visibilityTime, totalMessages) {
+        try {
+            const register = await this.connection.raw(`
+                SELECT * FROM ${this.schema}.read(
+                    queue_name => ?,
+                    vt         => ?,
+                    qty        => ?
+                );
+                `, [queueName, visibilityTime, totalMessages]);
+            if (!register.rows) {
+                return { data: [], error: null };
+            }
+            return { data: register.rows, 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) {
+        try {
+            const register = await this.connection.raw(`
+                SELECT * FROM ${this.schema}.pop(
+                    queue_name => ?
+                );
+                `, [queueName]);
+            if (!register.rows) {
+                return { data: [], error: null };
+            }
+            return { data: register.rows, 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, messageID) {
+        try {
+            await this.connection.raw(`
+            SELECT * FROM ${this.schema}.delete(
+                queue_name => ?,
+                msg_id     => ?
+            );
+            `, [queueName, messageID]);
+            return { error: null };
+        }
+        catch (error) {
+            return { error };
+        }
+    }
+}
+exports.default = PostgresQueueDriver;

package/dist/queueDriver/SupabaseQueueDriver.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class SupabaseQueueDriver {
+    constructor(supabase) {
+        this.supabase = supabase;
+    }
+    /**
+     * 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, visibilityTime, totalMessages) {
+        const { data, error } = await this.supabase.rpc("read", {
+            queue_name: queueName,
+            sleep_seconds: visibilityTime,
+            n: totalMessages
+        });
+        return { data: data, error };
+    }
+    /**
+     * Pop the message
+     * @param queueName The name of the queue
+     * @returns Promise<{ data: Message[], error: any }>
+     */
+    async pop(queueName) {
+        const { data, error } = await this.supabase.rpc("pop", {
+            queue_name: queueName,
+        });
+        return { data: data, error };
+    }
+    /**
+     * Delete the message
+     * @param queueName The name of the queue
+     * @param messageID The message ID
+     * @returns Promise<{ error: any }>
+     */
+    async delete(queueName, messageID) {
+        const { error } = await this.supabase.rpc("delete", {
+            queue_name: queueName,
+            message_id: messageID
+        });
+        return { error };
+    }
+}
+exports.default = SupabaseQueueDriver;

package/dist/type.js

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

package/package.json

@@ -1,14 +1,16 @@
 {
   "name": "consumer-pgmq",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "The consumer of Supabase pgmq",
   "main": "dist/index.js",
   "type": "commonjs",
   "scripts": {
+    "build": "tsc",
     "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"
+    "test": "jest ./tests/*.spec.ts --detectOpenHandles",
+    "prepublishOnly": "pnpm run build"
   },
   "keywords": [
     "supabase",
@@ -30,5 +32,8 @@
     "jest": "^30.1.1",
     "knex": "^3.1.0",
     "pg": "^8.16.3"
+  },
+  "engines": {
+    "node": ">=20.0.0"
   }
 }