relq 1.0.0

package/dist/cjs/pubsub/listen-notify-builder.cjs

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotifyBuilder = exports.UnlistenBuilder = exports.ListenBuilder = void 0;
+const pg_format_1 = __importDefault(require("../../addons/pg-format.js"));
+class ListenBuilder {
+    channelName;
+    constructor(channelName) {
+        this.channelName = channelName;
+    }
+    toString() {
+        return `LISTEN ${pg_format_1.default.ident(this.channelName)}`;
+    }
+}
+exports.ListenBuilder = ListenBuilder;
+class UnlistenBuilder {
+    channelName;
+    constructor(channelName = '*') {
+        this.channelName = channelName;
+    }
+    all() {
+        this.channelName = '*';
+        return this;
+    }
+    toString() {
+        if (this.channelName === '*') {
+            return 'UNLISTEN *';
+        }
+        return `UNLISTEN ${pg_format_1.default.ident(this.channelName)}`;
+    }
+}
+exports.UnlistenBuilder = UnlistenBuilder;
+class NotifyBuilder {
+    channelName;
+    payload;
+    constructor(channelName, payload) {
+        this.channelName = channelName;
+        this.payload = payload;
+    }
+    withPayload(payload) {
+        this.payload = payload;
+        return this;
+    }
+    toString() {
+        let sql = `NOTIFY ${pg_format_1.default.ident(this.channelName)}`;
+        if (this.payload !== undefined) {
+            const payloadStr = typeof this.payload === 'string'
+                ? this.payload
+                : JSON.stringify(this.payload);
+            sql += `, ${pg_format_1.default.literal(payloadStr)}`;
+        }
+        return sql;
+    }
+}
+exports.NotifyBuilder = NotifyBuilder;

package/dist/cjs/pubsub/listener-connection.cjs

@@ -0,0 +1,180 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListenerConnection = void 0;
+const events_1 = require("events");
+const pg_1 = require("../../addons/pg.js");
+const pg_format_1 = __importDefault(require("../../addons/pg-format.js"));
+class ListenerConnection extends events_1.EventEmitter {
+    client = null;
+    config;
+    connected = false;
+    connecting = false;
+    subscriptions = new Map();
+    reconnectTimeout = null;
+    isClosing = false;
+    reconnectDelay = 1000;
+    maxReconnectDelay = 30000;
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    async subscribe(channel) {
+        if (!this.connected && !this.connecting) {
+            await this.connect();
+        }
+        else if (this.connecting) {
+            await this.waitForConnection();
+        }
+        let channelSub = this.subscriptions.get(channel);
+        if (!channelSub) {
+            channelSub = { subscribers: [], retryCount: 0 };
+            this.subscriptions.set(channel, channelSub);
+            await this.executeListen(channel);
+        }
+        const emitter = new events_1.EventEmitter();
+        channelSub.subscribers.push(emitter);
+        const subscription = {
+            on(event, listener) {
+                emitter.on(event, listener);
+                return this;
+            },
+            close: async () => {
+                emitter.removeAllListeners();
+                const sub = this.subscriptions.get(channel);
+                if (sub) {
+                    const index = sub.subscribers.indexOf(emitter);
+                    if (index !== -1) {
+                        sub.subscribers.splice(index, 1);
+                    }
+                    if (sub.subscribers.length === 0) {
+                        this.subscriptions.delete(channel);
+                        if (this.connected) {
+                            try {
+                                await this.client?.query(`UNLISTEN ${pg_format_1.default.ident(channel)}`);
+                            }
+                            catch (err) {
+                            }
+                        }
+                        if (this.subscriptions.size === 0) {
+                            await this.close();
+                        }
+                    }
+                }
+            }
+        };
+        return subscription;
+    }
+    async connect() {
+        if (this.connected || this.connecting)
+            return;
+        this.connecting = true;
+        this.isClosing = false;
+        try {
+            this.client = new pg_1.Client(this.config);
+            this.client.on('notification', (msg) => {
+                if (msg.channel && msg.payload) {
+                    this.dispatch(msg.channel, msg.payload);
+                }
+            });
+            this.client.on('error', (err) => {
+                this.emit('error', err);
+                if (!this.isClosing) {
+                    this.handleDisconnect();
+                }
+            });
+            this.client.on('end', () => {
+                if (!this.isClosing) {
+                    this.handleDisconnect();
+                }
+            });
+            await this.client.connect();
+            this.connected = true;
+            this.connecting = false;
+            this.reconnectDelay = 1000;
+            await this.resubscribeAll();
+            this.emit('connect');
+        }
+        catch (err) {
+            this.connecting = false;
+            this.handleDisconnect();
+            throw err;
+        }
+    }
+    async waitForConnection() {
+        return new Promise((resolve, reject) => {
+            const onConnect = () => {
+                cleanup();
+                resolve();
+            };
+            const onError = (err) => {
+                cleanup();
+                reject(err);
+            };
+            const cleanup = () => {
+                this.removeListener('connect', onConnect);
+                this.removeListener('error', onError);
+            };
+            this.on('connect', onConnect);
+            this.on('error', onError);
+        });
+    }
+    dispatch(channel, payload) {
+        const sub = this.subscriptions.get(channel);
+        if (sub) {
+            let data = payload;
+            try {
+                data = JSON.parse(payload);
+            }
+            catch {
+            }
+            sub.subscribers.forEach(emitter => emitter.emit('notification', data));
+        }
+    }
+    async executeListen(channel) {
+        if (this.client && this.connected) {
+            await this.client.query(`LISTEN ${pg_format_1.default.ident(channel)}`);
+        }
+    }
+    async resubscribeAll() {
+        for (const channel of this.subscriptions.keys()) {
+            try {
+                await this.executeListen(channel);
+            }
+            catch (err) {
+                console.error(`Failed to resubscribe to ${channel}:`, err);
+            }
+        }
+    }
+    handleDisconnect() {
+        this.connected = false;
+        this.client = null;
+        if (this.isClosing)
+            return;
+        if (this.reconnectTimeout)
+            clearTimeout(this.reconnectTimeout);
+        this.reconnectTimeout = setTimeout(() => {
+            console.log('Reconnecting listener...');
+            this.connect().catch(err => {
+                console.error('Reconnect failed:', err);
+                this.reconnectDelay = Math.min(this.reconnectDelay * 2, this.maxReconnectDelay);
+                this.handleDisconnect();
+            });
+        }, this.reconnectDelay);
+        this.reconnectTimeout.unref();
+    }
+    async close() {
+        this.isClosing = true;
+        if (this.reconnectTimeout)
+            clearTimeout(this.reconnectTimeout);
+        if (this.client) {
+            await this.client.end();
+            this.client = null;
+        }
+        this.connected = false;
+        this.subscriptions.clear();
+    }
+}
+exports.ListenerConnection = ListenerConnection;

package/dist/cjs/raw/index.cjs

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RawQueryBuilder = void 0;
+var raw_query_builder_1 = require("./raw-query-builder.cjs");
+Object.defineProperty(exports, "RawQueryBuilder", { enumerable: true, get: function () { return raw_query_builder_1.RawQueryBuilder; } });

package/dist/cjs/raw/raw-query-builder.cjs

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RawQueryBuilder = void 0;
+const pg_format_1 = __importDefault(require("../../addons/pg-format.js"));
+const relq_errors_1 = require("../errors/relq-errors.cjs");
+class RawQueryBuilder {
+    query;
+    params;
+    constructor(query, params = []) {
+        this.query = query;
+        this.params = params;
+    }
+    toString() {
+        if (!this.query || typeof this.query !== 'string' || this.query.trim() === '') {
+            throw new relq_errors_1.RelqQueryError(`Invalid query provided: ${this.query === null ? 'null' : this.query === undefined ? 'undefined' : 'empty string'}`, { hint: 'Provide a valid SQL query string' });
+        }
+        const result = this.params.length > 0 ? (0, pg_format_1.default)(this.query, ...this.params) : this.query;
+        if (!result || typeof result !== 'string') {
+            throw new relq_errors_1.RelqQueryError(`format() returned invalid result: ${result === null ? 'null' : result === undefined ? 'undefined' : typeof result}`, { sql: this.query });
+        }
+        return result;
+    }
+}
+exports.RawQueryBuilder = RawQueryBuilder;

package/dist/cjs/schema/index.cjs

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultPrivilegesBuilder = exports.DropOwnedBuilder = exports.ReassignOwnedBuilder = exports.SetRoleBuilder = exports.DropRoleBuilder = exports.AlterRoleBuilder = exports.CreateRoleBuilder = exports.RevokeBuilder = exports.GrantBuilder = exports.DropSchemaBuilder = exports.CreateSchemaBuilder = void 0;
+var schema_builder_1 = require("./schema-builder.cjs");
+Object.defineProperty(exports, "CreateSchemaBuilder", { enumerable: true, get: function () { return schema_builder_1.CreateSchemaBuilder; } });
+Object.defineProperty(exports, "DropSchemaBuilder", { enumerable: true, get: function () { return schema_builder_1.DropSchemaBuilder; } });
+Object.defineProperty(exports, "GrantBuilder", { enumerable: true, get: function () { return schema_builder_1.GrantBuilder; } });
+Object.defineProperty(exports, "RevokeBuilder", { enumerable: true, get: function () { return schema_builder_1.RevokeBuilder; } });
+Object.defineProperty(exports, "CreateRoleBuilder", { enumerable: true, get: function () { return schema_builder_1.CreateRoleBuilder; } });
+Object.defineProperty(exports, "AlterRoleBuilder", { enumerable: true, get: function () { return schema_builder_1.AlterRoleBuilder; } });
+Object.defineProperty(exports, "DropRoleBuilder", { enumerable: true, get: function () { return schema_builder_1.DropRoleBuilder; } });
+Object.defineProperty(exports, "SetRoleBuilder", { enumerable: true, get: function () { return schema_builder_1.SetRoleBuilder; } });
+Object.defineProperty(exports, "ReassignOwnedBuilder", { enumerable: true, get: function () { return schema_builder_1.ReassignOwnedBuilder; } });
+Object.defineProperty(exports, "DropOwnedBuilder", { enumerable: true, get: function () { return schema_builder_1.DropOwnedBuilder; } });
+Object.defineProperty(exports, "DefaultPrivilegesBuilder", { enumerable: true, get: function () { return schema_builder_1.DefaultPrivilegesBuilder; } });