relq 1.0.0

package/dist/esm/introspect/index.js

@@ -0,0 +1,224 @@
+function mapTypeToCode(sqlType) {
+    const type = sqlType.toUpperCase().trim();
+    if (type === 'SERIAL')
+        return 'serial()';
+    if (type === 'SMALLSERIAL')
+        return 'smallserial()';
+    if (type === 'BIGSERIAL')
+        return 'bigserial()';
+    if (type === 'SMALLINT' || type === 'INT2')
+        return 'smallint()';
+    if (type === 'INTEGER' || type === 'INT' || type === 'INT4')
+        return 'integer()';
+    if (type === 'BIGINT' || type === 'INT8')
+        return 'bigint()';
+    if (type === 'REAL' || type === 'FLOAT4')
+        return 'real()';
+    if (type === 'DOUBLE PRECISION' || type === 'FLOAT8')
+        return 'doublePrecision()';
+    const numericMatch = type.match(/^NUMERIC\((\d+)(?:,\s*(\d+))?\)$/);
+    if (numericMatch) {
+        return numericMatch[2]
+            ? `numeric(${numericMatch[1]}, ${numericMatch[2]})`
+            : `numeric(${numericMatch[1]})`;
+    }
+    if (type === 'NUMERIC' || type === 'DECIMAL')
+        return 'numeric()';
+    const varcharMatch = type.match(/^VARCHAR\((\d+)\)$/);
+    if (varcharMatch)
+        return `varchar(${varcharMatch[1]})`;
+    if (type === 'VARCHAR')
+        return 'varchar()';
+    const charMatch = type.match(/^CHAR\((\d+)\)$/);
+    if (charMatch)
+        return `char(${charMatch[1]})`;
+    if (type === 'CHAR')
+        return 'char()';
+    if (type === 'TEXT')
+        return 'text()';
+    if (type === 'BOOLEAN' || type === 'BOOL')
+        return 'boolean()';
+    if (type === 'DATE')
+        return 'date()';
+    if (type === 'TIME')
+        return 'time()';
+    if (type === 'TIMETZ' || type === 'TIME WITH TIME ZONE')
+        return 'timetz()';
+    if (type === 'TIMESTAMP')
+        return 'timestamp()';
+    if (type === 'TIMESTAMPTZ' || type === 'TIMESTAMP WITH TIME ZONE')
+        return 'timestamptz()';
+    if (type === 'INTERVAL')
+        return 'interval()';
+    if (type === 'UUID')
+        return 'uuid()';
+    if (type === 'JSON')
+        return 'json()';
+    if (type === 'JSONB')
+        return 'jsonb()';
+    if (type === 'BYTEA')
+        return 'bytea()';
+    const arrayMatch = type.match(/^(.+)\[\]$/);
+    if (arrayMatch) {
+        const baseType = mapTypeToCode(arrayMatch[1]);
+        return `${baseType.slice(0, -1)}.array()`;
+    }
+    const vectorMatch = type.match(/^VECTOR\((\d+)\)$/);
+    if (vectorMatch)
+        return `vector(${vectorMatch[1]})`;
+    if (type === 'VECTOR')
+        return 'vector()';
+    if (type.startsWith('GEOMETRY'))
+        return 'geometry()';
+    if (type.startsWith('GEOGRAPHY'))
+        return 'geography()';
+    if (type === 'INET')
+        return 'inet()';
+    if (type === 'CIDR')
+        return 'cidr()';
+    if (type === 'MACADDR')
+        return 'macaddr()';
+    if (type === 'TSVECTOR')
+        return 'tsvector()';
+    if (type === 'TSQUERY')
+        return 'tsquery()';
+    return `sql\`${sqlType.toLowerCase()}\``;
+}
+function parseCreateTable(sql) {
+    const tableMatch = sql.match(/CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?["']?(\w+)["']?\s*\(([\s\S]+)\)/i);
+    if (!tableMatch)
+        return null;
+    const tableName = tableMatch[1];
+    const columnsStr = tableMatch[2];
+    const columns = [];
+    const tableConstraints = [];
+    const parts = [];
+    let depth = 0;
+    let current = '';
+    for (const char of columnsStr) {
+        if (char === '(')
+            depth++;
+        else if (char === ')')
+            depth--;
+        else if (char === ',' && depth === 0) {
+            parts.push(current.trim());
+            current = '';
+            continue;
+        }
+        current += char;
+    }
+    if (current.trim())
+        parts.push(current.trim());
+    const primaryKeyColumns = new Set();
+    const uniqueColumns = new Set();
+    const foreignKeys = new Map();
+    for (const part of parts) {
+        const trimmed = part.trim();
+        const pkMatch = trimmed.match(/^PRIMARY\s+KEY\s*\(([^)]+)\)/i);
+        if (pkMatch) {
+            const cols = pkMatch[1].split(',').map(c => c.trim().replace(/["']/g, ''));
+            cols.forEach(c => primaryKeyColumns.add(c));
+            continue;
+        }
+        const uqMatch = trimmed.match(/^UNIQUE\s*\(([^)]+)\)/i);
+        if (uqMatch) {
+            const cols = uqMatch[1].split(',').map(c => c.trim().replace(/["']/g, ''));
+            cols.forEach(c => uniqueColumns.add(c));
+            continue;
+        }
+        const fkMatch = trimmed.match(/^FOREIGN\s+KEY\s*\((\w+)\)\s*REFERENCES\s+["']?(\w+)["']?\s*\((\w+)\)/i);
+        if (fkMatch) {
+            foreignKeys.set(fkMatch[1], { table: fkMatch[2], column: fkMatch[3] });
+            continue;
+        }
+    }
+    for (const part of parts) {
+        const trimmed = part.trim();
+        if (/^(PRIMARY\s+KEY|UNIQUE|FOREIGN\s+KEY|CHECK|CONSTRAINT)/i.test(trimmed)) {
+            continue;
+        }
+        const colMatch = trimmed.match(/^["']?(\w+)["']?\s+(\w+(?:\([^)]*\))?(?:\[\])?)/i);
+        if (!colMatch)
+            continue;
+        const name = colMatch[1];
+        const dataType = colMatch[2].toUpperCase();
+        const rest = trimmed.slice(colMatch[0].length).trim();
+        const isPrimaryKey = primaryKeyColumns.has(name) || /PRIMARY\s+KEY/i.test(rest);
+        const isUnique = uniqueColumns.has(name) || /UNIQUE/i.test(rest);
+        const isNullable = !/NOT\s+NULL/i.test(rest) && !isPrimaryKey;
+        let references = foreignKeys.get(name) || null;
+        const refMatch = rest.match(/REFERENCES\s+["']?(\w+)["']?\s*\((\w+)\)/i);
+        if (refMatch) {
+            references = { table: refMatch[1], column: refMatch[2] };
+        }
+        let defaultValue = null;
+        const defaultMatch = rest.match(/DEFAULT\s+(.+?)(?:\s+(?:NOT\s+NULL|UNIQUE|PRIMARY|REFERENCES|CHECK)|$)/i);
+        if (defaultMatch) {
+            let val = defaultMatch[1].trim();
+            if (val.endsWith(','))
+                val = val.slice(0, -1);
+            defaultValue = val;
+        }
+        if (isPrimaryKey && primaryKeyColumns.size === 0) {
+            primaryKeyColumns.add(name);
+        }
+        columns.push({
+            name,
+            dataType,
+            typeCode: mapTypeToCode(dataType),
+            isNullable,
+            isPrimaryKey,
+            isUnique,
+            defaultValue,
+            references,
+        });
+    }
+    return {
+        name: tableName,
+        columns,
+        indexes: [],
+    };
+}
+export function parseSqlToDefineTable(sql) {
+    const tables = [];
+    const createTableRegex = /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?["']?(\w+)["']?\s*\([^;]+\);?/gi;
+    let match;
+    while ((match = createTableRegex.exec(sql)) !== null) {
+        const parsed = parseCreateTable(match[0]);
+        if (parsed) {
+            tables.push(parsed);
+        }
+    }
+    return tables;
+}
+export function generateCode(tables) {
+    const parts = [
+        "import { defineTable, serial, integer, bigint, varchar, text, boolean, uuid, jsonb, json, timestamp, timestamptz, date, numeric, vector } from 'relq/schema-builder';",
+        '',
+    ];
+    for (const table of tables) {
+        const columns = table.columns.map(col => {
+            const mods = [col.typeCode];
+            if (col.isPrimaryKey)
+                mods.push('.primaryKey()');
+            if (!col.isNullable && !col.isPrimaryKey)
+                mods.push('.notNull()');
+            if (col.isUnique && !col.isPrimaryKey)
+                mods.push('.unique()');
+            if (col.references)
+                mods.push(`.references('${col.references.table}', '${col.references.column}')`);
+            if (col.defaultValue)
+                mods.push(`.default(${col.defaultValue})`);
+            return `    ${col.name}: ${mods.join('')},`;
+        });
+        parts.push(`export const ${table.name} = defineTable('${table.name}', {`);
+        parts.push(...columns);
+        parts.push('});');
+        parts.push('');
+    }
+    return parts.join('\n');
+}
+export async function introspect(sql) {
+    const tables = parseSqlToDefineTable(sql);
+    return generateCode(tables);
+}

package/dist/esm/maintenance/index.js

@@ -0,0 +1 @@
+export { VacuumBuilder, AnalyzeBuilder } from "./vacuum-builder.js";

package/dist/esm/maintenance/vacuum-builder.js

@@ -0,0 +1,158 @@
+import format from "../../addons/pg-format.js";
+export class VacuumBuilder {
+    tables = [];
+    columns = new Map();
+    options = {};
+    constructor(tables) {
+        if (tables) {
+            this.tables = Array.isArray(tables) ? tables : [tables];
+        }
+    }
+    full(enable = true) {
+        this.options.full = enable;
+        return this;
+    }
+    freeze(enable = true) {
+        this.options.freeze = enable;
+        return this;
+    }
+    verbose(enable = true) {
+        this.options.verbose = enable;
+        return this;
+    }
+    analyze(enable = true) {
+        this.options.analyze = enable;
+        return this;
+    }
+    disablePageSkipping(enable = true) {
+        this.options.disablePageSkipping = enable;
+        return this;
+    }
+    skipLocked(enable = true) {
+        this.options.skipLocked = enable;
+        return this;
+    }
+    indexCleanup(value = true) {
+        this.options.indexCleanup = value;
+        return this;
+    }
+    truncate(enable = true) {
+        this.options.truncate = enable;
+        return this;
+    }
+    parallel(workers) {
+        this.options.parallel = workers;
+        return this;
+    }
+    columnsFor(table, columns) {
+        this.columns.set(table, columns);
+        return this;
+    }
+    toString() {
+        const parts = [];
+        if (this.options.full) {
+            parts.push('FULL');
+        }
+        if (this.options.freeze) {
+            parts.push('FREEZE');
+        }
+        if (this.options.verbose) {
+            parts.push('VERBOSE');
+        }
+        if (this.options.analyze) {
+            parts.push('ANALYZE');
+        }
+        const optionsList = [];
+        if (this.options.disablePageSkipping) {
+            optionsList.push('DISABLE_PAGE_SKIPPING');
+        }
+        if (this.options.skipLocked) {
+            optionsList.push('SKIP_LOCKED');
+        }
+        if (this.options.indexCleanup !== undefined) {
+            const value = typeof this.options.indexCleanup === 'boolean'
+                ? (this.options.indexCleanup ? 'ON' : 'OFF')
+                : this.options.indexCleanup;
+            optionsList.push(`INDEX_CLEANUP ${value}`);
+        }
+        if (this.options.truncate !== undefined) {
+            optionsList.push(`TRUNCATE ${this.options.truncate ? 'ON' : 'OFF'}`);
+        }
+        if (this.options.parallel !== undefined) {
+            optionsList.push(`PARALLEL ${this.options.parallel}`);
+        }
+        let sql = 'VACUUM';
+        if (parts.length > 0) {
+            sql += ' ' + parts.join(' ');
+        }
+        if (optionsList.length > 0) {
+            sql += ` (${optionsList.join(', ')})`;
+        }
+        if (this.tables.length > 0) {
+            const tableStrs = this.tables.map(table => {
+                let tableStr = format.ident(table);
+                if (this.columns.has(table)) {
+                    const cols = this.columns.get(table);
+                    tableStr += ` (${cols.map(c => format.ident(c)).join(', ')})`;
+                }
+                return tableStr;
+            });
+            sql += ' ' + tableStrs.join(', ');
+        }
+        return sql;
+    }
+}
+export class AnalyzeBuilder {
+    tables = [];
+    columnsMap = new Map();
+    verboseFlag = false;
+    skipLockedFlag = false;
+    constructor(tables) {
+        if (tables) {
+            this.tables = Array.isArray(tables) ? tables : [tables];
+        }
+    }
+    verbose(enable = true) {
+        this.verboseFlag = enable;
+        return this;
+    }
+    skipLocked(enable = true) {
+        this.skipLockedFlag = enable;
+        return this;
+    }
+    columns(columns) {
+        if (this.tables.length > 0) {
+            this.columnsMap.set(this.tables[0], columns);
+        }
+        return this;
+    }
+    columnsFor(table, columns) {
+        this.columnsMap.set(table, columns);
+        return this;
+    }
+    toString() {
+        let sql = 'ANALYZE';
+        if (this.verboseFlag) {
+            sql += ' VERBOSE';
+        }
+        const options = [];
+        if (this.skipLockedFlag) {
+            options.push('SKIP_LOCKED');
+        }
+        if (options.length > 0) {
+            sql += ` (${options.join(', ')})`;
+        }
+        if (this.tables.length > 0) {
+            const tableStrs = this.tables.map(table => {
+                let tableStr = format.ident(table);
+                if (this.columnsMap.has(table)) {
+                    const cols = this.columnsMap.get(table);
+                    tableStr += ` (${cols.map(c => format.ident(c)).join(', ')})`;
+                }
+                return tableStr;
+            });
+            sql += ' ' + tableStrs.join(', ');
+        }
+        return sql;
+    }
+}

package/dist/esm/pubsub/index.js

@@ -0,0 +1 @@
+export { ListenBuilder, UnlistenBuilder, NotifyBuilder } from "./listen-notify-builder.js";

package/dist/esm/pubsub/listen-notify-builder.js

@@ -0,0 +1,48 @@
+import format from "../../addons/pg-format.js";
+export class ListenBuilder {
+    channelName;
+    constructor(channelName) {
+        this.channelName = channelName;
+    }
+    toString() {
+        return `LISTEN ${format.ident(this.channelName)}`;
+    }
+}
+export class UnlistenBuilder {
+    channelName;
+    constructor(channelName = '*') {
+        this.channelName = channelName;
+    }
+    all() {
+        this.channelName = '*';
+        return this;
+    }
+    toString() {
+        if (this.channelName === '*') {
+            return 'UNLISTEN *';
+        }
+        return `UNLISTEN ${format.ident(this.channelName)}`;
+    }
+}
+export class NotifyBuilder {
+    channelName;
+    payload;
+    constructor(channelName, payload) {
+        this.channelName = channelName;
+        this.payload = payload;
+    }
+    withPayload(payload) {
+        this.payload = payload;
+        return this;
+    }
+    toString() {
+        let sql = `NOTIFY ${format.ident(this.channelName)}`;
+        if (this.payload !== undefined) {
+            const payloadStr = typeof this.payload === 'string'
+                ? this.payload
+                : JSON.stringify(this.payload);
+            sql += `, ${format.literal(payloadStr)}`;
+        }
+        return sql;
+    }
+}

package/dist/esm/pubsub/listener-connection.js

@@ -0,0 +1,173 @@
+import { EventEmitter } from 'events';
+import { Client } from "../../addons/pg.js";
+import format from "../../addons/pg-format.js";
+export class ListenerConnection extends 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 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 ${format.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 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 ${format.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();
+    }
+}

package/dist/esm/raw/index.js

@@ -0,0 +1 @@
+export { RawQueryBuilder } from "./raw-query-builder.js";

package/dist/esm/raw/raw-query-builder.js

@@ -0,0 +1,20 @@
+import format from "../../addons/pg-format.js";
+import { RelqQueryError } from "../errors/relq-errors.js";
+export 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 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 ? format(this.query, ...this.params) : this.query;
+        if (!result || typeof result !== 'string') {
+            throw new RelqQueryError(`format() returned invalid result: ${result === null ? 'null' : result === undefined ? 'undefined' : typeof result}`, { sql: this.query });
+        }
+        return result;
+    }
+}

package/dist/esm/schema/index.js

@@ -0,0 +1 @@
+export { CreateSchemaBuilder, DropSchemaBuilder, GrantBuilder, RevokeBuilder, CreateRoleBuilder, AlterRoleBuilder, DropRoleBuilder, SetRoleBuilder, ReassignOwnedBuilder, DropOwnedBuilder, DefaultPrivilegesBuilder } from "./schema-builder.js";