@relq/orm 0.1.0

package/dist/esm/insert/insert-builder.js

@@ -0,0 +1,313 @@
+import format from "../shared/pg-format.js";
+import { convertCase } from "../utils/case-converter.js";
+import { SelectBuilder } from "../select/select-builder.js";
+import { CountBuilder } from "../count/count-builder.js";
+import { ConflictBuilder, buildConflictUpdateSql } from "./conflict-builder.js";
+import { RelqBuilderError } from "../shared/errors/relq-errors.js";
+export class InsertBuilder {
+    tableName;
+    insertData;
+    conflictColumns;
+    conflictBuilder;
+    returningClause;
+    _case = 'keep-case';
+    _convertCase = '2snake';
+    originalColumns;
+    columnResolver;
+    columnTypeResolver;
+    constructor(tableName, data) {
+        this.tableName = tableName;
+        const normalized = this.normalizeData(data);
+        this.insertData = [normalized];
+        this.originalColumns = Object.keys(normalized).sort();
+    }
+    normalizeData(data) {
+        const normalized = {};
+        for (const [key, value] of Object.entries(data)) {
+            normalized[key] = value === undefined ? null : value;
+        }
+        return normalized;
+    }
+    setColumnResolver(resolver) {
+        this.columnResolver = resolver;
+        return this;
+    }
+    setColumnTypeResolver(resolver) {
+        this.columnTypeResolver = resolver;
+        return this;
+    }
+    resolveColumnName(name) {
+        if (this.columnResolver) {
+            return this.columnResolver(name);
+        }
+        return this.convertColumnName(name);
+    }
+    convertCase(type, conversionCase = '2snake') {
+        this._case = type;
+        this._convertCase = conversionCase;
+        return this;
+    }
+    validateColumns(row) {
+        const newColumns = Object.keys(row).sort();
+        if (newColumns.length !== this.originalColumns.length) {
+            throw new RelqBuilderError(`Column count mismatch: expected ${this.originalColumns.length} columns, got ${newColumns.length}`, { builder: 'InsertBuilder', hint: `Expected columns: [${this.originalColumns.join(', ')}]` });
+        }
+        for (let i = 0; i < this.originalColumns.length; i++) {
+            if (this.originalColumns[i] !== newColumns[i]) {
+                throw new RelqBuilderError('Column name mismatch: all rows must have the exact same column names', { builder: 'InsertBuilder', hint: `Expected columns: [${this.originalColumns.join(', ')}]` });
+            }
+        }
+    }
+    addRow(row) {
+        const normalized = this.normalizeData(row);
+        if (this.insertData.length === 0) {
+            this.originalColumns = Object.keys(normalized).sort();
+        }
+        else {
+            this.validateColumns(normalized);
+        }
+        this.insertData.push(normalized);
+        return this;
+    }
+    addRows(rows) {
+        if (rows.length === 0)
+            return this;
+        const normalizedRows = rows.map(row => this.normalizeData(row));
+        if (this.insertData.length === 0) {
+            this.originalColumns = Object.keys(normalizedRows[0]).sort();
+        }
+        for (const row of normalizedRows) {
+            this.validateColumns(row);
+        }
+        this.insertData.push(...normalizedRows);
+        return this;
+    }
+    clear() {
+        this.insertData = [];
+        this.originalColumns = [];
+        return this;
+    }
+    get total() {
+        return this.insertData.length;
+    }
+    _onConflict(columns, callback) {
+        this.conflictColumns = columns === null ? [] : Array.isArray(columns) ? columns : [columns];
+        this.conflictBuilder = new ConflictBuilder(this.tableName);
+        if (this.columnResolver) {
+            this.conflictBuilder.setColumnResolver(this.columnResolver);
+        }
+        if (callback) {
+            callback(this.conflictBuilder);
+        }
+        else {
+            this.conflictBuilder.doNothing();
+        }
+        return this;
+    }
+    returning(columns) {
+        if (columns === null) {
+            this.returningClause = undefined;
+        }
+        else {
+            this.returningClause = {
+                type: 'columns',
+                columns: Array.isArray(columns) ? columns : [columns]
+            };
+        }
+        return this;
+    }
+    returningSelect(callback) {
+        const builder = new SelectBuilder(this.tableName);
+        const result = callback(builder);
+        if (result === null) {
+            this.returningClause = undefined;
+        }
+        else {
+            this.returningClause = {
+                type: 'select',
+                builder: result
+            };
+        }
+        return this;
+    }
+    returningCount(callback) {
+        const builder = new CountBuilder(this.tableName);
+        const result = callback(builder);
+        if (result === null) {
+            this.returningClause = undefined;
+        }
+        else {
+            this.returningClause = {
+                type: 'count',
+                builder: result
+            };
+        }
+        return this;
+    }
+    convertColumnName(name) {
+        if (this._case === 'to-lower')
+            return name.toLowerCase();
+        if (this._case === 'to-upper')
+            return name.toUpperCase();
+        if (this._case === 'convert-case')
+            return convertCase(name, this._convertCase);
+        return name;
+    }
+    formatPostgresArray(value, baseType = 'jsonb') {
+        if (value.length === 0)
+            return `ARRAY[]::${baseType}[]`;
+        if (baseType === 'jsonb') {
+            const jsonValues = value.map(v => format('%L', JSON.stringify(v))).join(',');
+            return `ARRAY[${jsonValues}]::jsonb[]`;
+        }
+        else if (baseType === 'text' || baseType === 'varchar') {
+            const textValues = value.map(v => format('%L', String(v))).join(',');
+            return `ARRAY[${textValues}]::text[]`;
+        }
+        else if (baseType === 'integer' || baseType === 'int4' || baseType === 'bigint' || baseType === 'int8') {
+            return `ARRAY[${value.join(',')}]::${baseType}[]`;
+        }
+        else {
+            const jsonValues = value.map(v => format('%L', JSON.stringify(v))).join(',');
+            return `ARRAY[${jsonValues}]::${baseType}[]`;
+        }
+    }
+    formatJsonbValue(value) {
+        const json = JSON.stringify(value).replace(/'/g, "''");
+        return `'${json}'::jsonb`;
+    }
+    processRowValues(row, originalColumns) {
+        const processedValues = [];
+        const placeholderTypes = [];
+        for (const colName of originalColumns) {
+            const value = row[colName];
+            if (Array.isArray(value) || (value !== null && typeof value === 'object' && !(value instanceof Date))) {
+                const typeInfo = this.columnTypeResolver?.(colName);
+                if (typeInfo) {
+                    if (Array.isArray(value)) {
+                        if (typeInfo.isArray) {
+                            processedValues.push(this.formatPostgresArray(value, typeInfo.type));
+                        }
+                        else if (typeInfo.type === 'jsonb' || typeInfo.type === 'json') {
+                            processedValues.push(this.formatJsonbValue(value));
+                        }
+                        else {
+                            processedValues.push(this.formatJsonbValue(value));
+                        }
+                    }
+                    else {
+                        processedValues.push(this.formatJsonbValue(value));
+                    }
+                }
+                else {
+                    processedValues.push(this.formatJsonbValue(value));
+                }
+                placeholderTypes.push('%s');
+            }
+            else {
+                processedValues.push(value);
+                placeholderTypes.push('%L');
+            }
+        }
+        return { values: processedValues, placeholders: placeholderTypes.join(', ') };
+    }
+    buildConflictClause() {
+        if (!this.conflictBuilder)
+            return '';
+        let clause = this.conflictColumns && this.conflictColumns.length > 0
+            ? format(' ON CONFLICT (%I)', this.conflictColumns.map(c => this.resolveColumnName(c)))
+            : ' ON CONFLICT';
+        if (this.conflictBuilder.action === 'update') {
+            const updateSql = buildConflictUpdateSql(this.conflictBuilder.updateData, this.tableName, (col) => this.resolveColumnName(col));
+            clause += ` DO UPDATE SET ${updateSql}`;
+            if (this.conflictBuilder.whereClause) {
+                clause += ` WHERE ${this.conflictBuilder.whereClause}`;
+            }
+        }
+        else {
+            clause += ' DO NOTHING';
+        }
+        return clause;
+    }
+    toString() {
+        if (this.insertData.length === 0) {
+            throw new RelqBuilderError('Cannot generate INSERT query: no rows to insert', { builder: 'InsertBuilder', missing: 'data', hint: 'Add rows using addRow() or addRows() first' });
+        }
+        const originalColumns = Object.keys(this.insertData[0]);
+        const columns = originalColumns.map(name => this.resolveColumnName(name));
+        const allValuesGroups = [];
+        for (const row of this.insertData) {
+            const { values, placeholders } = this.processRowValues(row, originalColumns);
+            const formattedRow = format(`(${placeholders})`, ...values);
+            allValuesGroups.push(formattedRow);
+        }
+        let query = format('INSERT INTO %I (%I) VALUES %s', this.tableName, columns, allValuesGroups.join(', '));
+        query += this.buildConflictClause();
+        if (this.returningClause) {
+            query += this.buildReturningClause();
+        }
+        return query;
+    }
+    parseCountColumns(columnsStr) {
+        const columns = [];
+        let depth = 0;
+        let currentExpr = '';
+        let i = 0;
+        while (i < columnsStr.length) {
+            const char = columnsStr[i];
+            if (char === '(')
+                depth++;
+            else if (char === ')')
+                depth--;
+            else if (char === ',' && depth === 0) {
+                if (currentExpr.trim()) {
+                    columns.push(this.parseColumnExpr(currentExpr.trim()));
+                }
+                currentExpr = '';
+                i++;
+                continue;
+            }
+            currentExpr += char;
+            i++;
+        }
+        if (currentExpr.trim()) {
+            columns.push(this.parseColumnExpr(currentExpr.trim()));
+        }
+        return columns;
+    }
+    parseColumnExpr(expr) {
+        const asMatch = expr.match(/^(.+?)\s+AS\s+(.+)$/i);
+        if (!asMatch) {
+            return { name: 'count', expr };
+        }
+        const [, expression, alias] = asMatch;
+        const name = alias.replace(/^["']|["']$/g, '');
+        return { name, expr: expression.trim() };
+    }
+    buildReturningClause() {
+        if (!this.returningClause)
+            return '';
+        switch (this.returningClause.type) {
+            case 'columns': {
+                const resolvedColumns = this.returningClause.columns.map(col => col === '*' ? '*' : this.resolveColumnName(col));
+                return format(' RETURNING %I', resolvedColumns);
+            }
+            case 'select': {
+                const selectSQL = this.returningClause.builder.toString();
+                return ` RETURNING (${selectSQL})`;
+            }
+            case 'count': {
+                const countSQL = this.returningClause.builder.toString();
+                const selectMatch = countSQL.match(/^SELECT\s+(.+?)\s+FROM\s+(.+)$/is);
+                if (!selectMatch)
+                    return ` RETURNING (${countSQL})`;
+                const [, columnsStr, fromClause] = selectMatch;
+                const columns = this.parseCountColumns(columnsStr);
+                const jsonArgs = columns.map(({ name, expr }) => `${format('%L', name)}, ${expr}`).join(', ');
+                return ` RETURNING (SELECT json_build_object(${jsonArgs}) FROM ${fromClause})`;
+            }
+            default:
+                return '';
+        }
+    }
+}

package/dist/esm/insert/insert-from-select-builder.js

@@ -0,0 +1,79 @@
+import format from "../shared/pg-format.js";
+import { buildConflictUpdateSql } from "./conflict-builder.js";
+export class InsertFromSelectBuilder {
+    tableName;
+    columns;
+    selectSQL;
+    returningColumns;
+    columnResolver;
+    conflictColumns;
+    conflictAction;
+    conflictUpdateData;
+    conflictWhereClause;
+    constructor(tableName, columns, selectSQL) {
+        this.tableName = tableName;
+        this.columns = columns;
+        this.selectSQL = selectSQL;
+    }
+    setColumnResolver(resolver) {
+        this.columnResolver = resolver;
+        return this;
+    }
+    onConflictDoNothing(columns) {
+        this.conflictColumns = columns
+            ? (Array.isArray(columns) ? columns : [columns])
+            : undefined;
+        this.conflictAction = 'nothing';
+        return this;
+    }
+    onConflictDoUpdate(columns, updateData, whereClause) {
+        this.conflictColumns = Array.isArray(columns) ? columns : [columns];
+        this.conflictAction = 'update';
+        this.conflictUpdateData = updateData;
+        this.conflictWhereClause = whereClause;
+        return this;
+    }
+    returning(columns) {
+        if (columns === null) {
+            this.returningColumns = undefined;
+        }
+        else {
+            this.returningColumns = Array.isArray(columns) ? columns : [columns];
+        }
+        return this;
+    }
+    resolveColumnName(name) {
+        if (this.columnResolver) {
+            return this.columnResolver(name);
+        }
+        return name;
+    }
+    buildConflictClause() {
+        if (!this.conflictAction)
+            return '';
+        let clause = this.conflictColumns && this.conflictColumns.length > 0
+            ? format(' ON CONFLICT (%I)', this.conflictColumns)
+            : ' ON CONFLICT';
+        if (this.conflictAction === 'nothing') {
+            clause += ' DO NOTHING';
+        }
+        else if (this.conflictAction === 'update' && this.conflictUpdateData) {
+            const updateSql = buildConflictUpdateSql(this.conflictUpdateData, this.tableName);
+            clause += ` DO UPDATE SET ${updateSql}`;
+            if (this.conflictWhereClause) {
+                clause += ` WHERE ${this.conflictWhereClause}`;
+            }
+        }
+        return clause;
+    }
+    toString() {
+        const resolvedColumns = this.columns.map(c => this.resolveColumnName(c));
+        let query = format('INSERT INTO %I (%I) %s', this.tableName, resolvedColumns, this.selectSQL);
+        query += this.buildConflictClause();
+        if (this.returningColumns) {
+            const resolvedReturning = this.returningColumns.map(col => col === '*' ? '*' : this.resolveColumnName(col));
+            query += format(' RETURNING %I', resolvedReturning);
+        }
+        return query;
+    }
+}

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 "../shared/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 'node:events';
+import { Client } from "../addon/pg.js";
+import format from "../shared/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,2 @@
+export { RawQueryBuilder } from "./raw-query-builder.js";
+export { sql, SqlFragment } from "./sql-template.js";

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

@@ -0,0 +1,20 @@
+import format from "../shared/pg-format.js";
+import { RelqQueryError } from "../shared/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;
+    }
+}