@relq/orm 0.1.0

package/dist/cjs/insert/conflict-builder.cjs

@@ -0,0 +1,213 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConflictBuilder = void 0;
+exports.createExcludedProxy = createExcludedProxy;
+exports.createRowProxy = createRowProxy;
+exports.createSqlHelpers = createSqlHelpers;
+exports.buildConflictUpdateSql = buildConflictUpdateSql;
+const pg_format_1 = __importDefault(require("../shared/pg-format.cjs"));
+function isColumnRef(value) {
+    return typeof value === 'object' && value !== null && value.__type === 'column_ref';
+}
+function isSqlExpression(value) {
+    return typeof value === 'object' && value !== null && value.__type === 'sql_expression';
+}
+function createExcludedProxy() {
+    return new Proxy({}, {
+        get(_target, prop) {
+            return { __type: 'column_ref', table: 'EXCLUDED', column: prop };
+        }
+    });
+}
+function createRowProxy(tableName) {
+    return new Proxy({}, {
+        get(_target, prop) {
+            return { __type: 'column_ref', table: tableName, column: prop };
+        }
+    });
+}
+function columnRefToSql(ref) {
+    return (0, pg_format_1.default)('%I.%I', ref.table, ref.column);
+}
+function resolveColumnRef(ref, columnResolver) {
+    if (!columnResolver)
+        return ref;
+    return { ...ref, column: columnResolver(ref.column) };
+}
+function valueToSql(value, columnResolver) {
+    if (isColumnRef(value)) {
+        return columnRefToSql(resolveColumnRef(value, columnResolver));
+    }
+    if (isSqlExpression(value)) {
+        return value.sql;
+    }
+    if (typeof value === 'number' || typeof value === 'bigint') {
+        return String(value);
+    }
+    return (0, pg_format_1.default)('%L', value);
+}
+function createSqlHelpers(currentColumn, tableName, columnResolver) {
+    const resolve = (col) => columnResolver ? columnResolver(col) : col;
+    const resolvedColumn = resolve(currentColumn);
+    const expr = (sql) => ({ __type: 'sql_expression', sql });
+    return {
+        increment(amount) {
+            return expr(`${(0, pg_format_1.default)('%I.%I', tableName, resolvedColumn)} + ${amount}`);
+        },
+        add(a, b) {
+            return expr(`${valueToSql(a, columnResolver)} + ${valueToSql(b, columnResolver)}`);
+        },
+        subtract(a, b) {
+            return expr(`${valueToSql(a, columnResolver)} - ${valueToSql(b, columnResolver)}`);
+        },
+        multiply(a, b) {
+            return expr(`${valueToSql(a, columnResolver)} * ${valueToSql(b, columnResolver)}`);
+        },
+        divide(a, b) {
+            return expr(`${valueToSql(a, columnResolver)} / ${valueToSql(b, columnResolver)}`);
+        },
+        modulo(a, b) {
+            return expr(`${valueToSql(a, columnResolver)} % ${valueToSql(b, columnResolver)}`);
+        },
+        coalesce(...values) {
+            return expr(`COALESCE(${values.map(v => valueToSql(v, columnResolver)).join(', ')})`);
+        },
+        greatest(...values) {
+            return expr(`GREATEST(${values.map(v => valueToSql(v, columnResolver)).join(', ')})`);
+        },
+        least(...values) {
+            return expr(`LEAST(${values.map(v => valueToSql(v, columnResolver)).join(', ')})`);
+        },
+        nullif(a, b) {
+            return expr(`NULLIF(${valueToSql(a, columnResolver)}, ${valueToSql(b, columnResolver)})`);
+        },
+        abs(value) {
+            return expr(`ABS(${valueToSql(value, columnResolver)})`);
+        },
+        ceil(value) {
+            return expr(`CEIL(${valueToSql(value, columnResolver)})`);
+        },
+        floor(value) {
+            return expr(`FLOOR(${valueToSql(value, columnResolver)})`);
+        },
+        round(value, decimals) {
+            if (decimals !== undefined) {
+                return expr(`ROUND(${valueToSql(value, columnResolver)}, ${decimals})`);
+            }
+            return expr(`ROUND(${valueToSql(value, columnResolver)})`);
+        },
+        concat(...values) {
+            return expr(`CONCAT(${values.map(v => valueToSql(v, columnResolver)).join(', ')})`);
+        },
+        lower(value) {
+            return expr(`LOWER(${valueToSql(value, columnResolver)})`);
+        },
+        upper(value) {
+            return expr(`UPPER(${valueToSql(value, columnResolver)})`);
+        },
+        trim(value) {
+            return expr(`TRIM(${valueToSql(value, columnResolver)})`);
+        },
+        now() {
+            return expr('NOW()');
+        },
+        currentDate() {
+            return expr('CURRENT_DATE');
+        },
+        currentTimestamp() {
+            return expr('CURRENT_TIMESTAMP');
+        }
+    };
+}
+class ConflictBuilder {
+    _action = 'nothing';
+    _updateData = {};
+    _whereClause;
+    _tableName;
+    _columnResolver;
+    constructor(tableName) {
+        this._tableName = tableName;
+    }
+    setColumnResolver(resolver) {
+        this._columnResolver = resolver;
+        return this;
+    }
+    doNothing() {
+        this._action = 'nothing';
+        this._updateData = {};
+        return this;
+    }
+    doUpdate(values) {
+        this._action = 'update';
+        const excludedProxy = createExcludedProxy();
+        const rowProxy = createRowProxy(this._tableName);
+        for (const [column, value] of Object.entries(values)) {
+            if (typeof value === 'function') {
+                const fn = value;
+                const sqlHelpers = createSqlHelpers(column, this._tableName, this._columnResolver);
+                let result;
+                if (fn.length === 1) {
+                    result = fn(excludedProxy);
+                }
+                else if (fn.length === 2) {
+                    result = fn(excludedProxy, sqlHelpers);
+                }
+                else {
+                    result = fn(excludedProxy, sqlHelpers, rowProxy);
+                }
+                this._updateData[column] = result;
+            }
+            else {
+                this._updateData[column] = value;
+            }
+        }
+        return this;
+    }
+    where(condition) {
+        this._whereClause = condition;
+        return this;
+    }
+    get action() {
+        return this._action;
+    }
+    get updateData() {
+        return this._updateData;
+    }
+    get whereClause() {
+        return this._whereClause;
+    }
+    get tableName() {
+        return this._tableName;
+    }
+}
+exports.ConflictBuilder = ConflictBuilder;
+function buildConflictUpdateSql(updateData, tableName, columnResolver) {
+    const resolve = (col) => columnResolver ? columnResolver(col) : col;
+    const setClauses = [];
+    for (const [column, value] of Object.entries(updateData)) {
+        const resolvedCol = resolve(column);
+        if (isColumnRef(value)) {
+            const resolvedRef = resolveColumnRef(value, columnResolver);
+            setClauses.push(`${(0, pg_format_1.default)('%I', resolvedCol)} = ${columnRefToSql(resolvedRef)}`);
+        }
+        else if (isSqlExpression(value)) {
+            setClauses.push(`${(0, pg_format_1.default)('%I', resolvedCol)} = ${value.sql}`);
+        }
+        else if (Array.isArray(value)) {
+            if (value.length === 0) {
+                setClauses.push(`${(0, pg_format_1.default)('%I', resolvedCol)} = ARRAY[]::jsonb[]`);
+            }
+            else {
+                const jsonValues = value.map(v => (0, pg_format_1.default)('%L', JSON.stringify(v))).join(',');
+                setClauses.push(`${(0, pg_format_1.default)('%I', resolvedCol)} = ARRAY[${jsonValues}]::jsonb[]`);
+            }
+        }
+        else {
+            setClauses.push((0, pg_format_1.default)('%I = %L', resolvedCol, value));
+        }
+    }
+    return setClauses.join(', ');
+}

package/dist/cjs/insert/index.cjs

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

package/dist/cjs/insert/insert-builder.cjs

@@ -0,0 +1,320 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InsertBuilder = void 0;
+const pg_format_1 = __importDefault(require("../shared/pg-format.cjs"));
+const case_converter_1 = require("../utils/case-converter.cjs");
+const select_builder_1 = require("../select/select-builder.cjs");
+const count_builder_1 = require("../count/count-builder.cjs");
+const conflict_builder_1 = require("./conflict-builder.cjs");
+const relq_errors_1 = require("../shared/errors/relq-errors.cjs");
+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 relq_errors_1.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 relq_errors_1.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 conflict_builder_1.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 select_builder_1.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 count_builder_1.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 (0, case_converter_1.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 => (0, pg_format_1.default)('%L', JSON.stringify(v))).join(',');
+            return `ARRAY[${jsonValues}]::jsonb[]`;
+        }
+        else if (baseType === 'text' || baseType === 'varchar') {
+            const textValues = value.map(v => (0, pg_format_1.default)('%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 => (0, pg_format_1.default)('%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
+            ? (0, pg_format_1.default)(' ON CONFLICT (%I)', this.conflictColumns.map(c => this.resolveColumnName(c)))
+            : ' ON CONFLICT';
+        if (this.conflictBuilder.action === 'update') {
+            const updateSql = (0, conflict_builder_1.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 relq_errors_1.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 = (0, pg_format_1.default)(`(${placeholders})`, ...values);
+            allValuesGroups.push(formattedRow);
+        }
+        let query = (0, pg_format_1.default)('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 (0, pg_format_1.default)(' 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 }) => `${(0, pg_format_1.default)('%L', name)}, ${expr}`).join(', ');
+                return ` RETURNING (SELECT json_build_object(${jsonArgs}) FROM ${fromClause})`;
+            }
+            default:
+                return '';
+        }
+    }
+}
+exports.InsertBuilder = InsertBuilder;

package/dist/cjs/insert/insert-from-select-builder.cjs

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InsertFromSelectBuilder = void 0;
+const pg_format_1 = __importDefault(require("../shared/pg-format.cjs"));
+const conflict_builder_1 = require("./conflict-builder.cjs");
+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
+            ? (0, pg_format_1.default)(' ON CONFLICT (%I)', this.conflictColumns)
+            : ' ON CONFLICT';
+        if (this.conflictAction === 'nothing') {
+            clause += ' DO NOTHING';
+        }
+        else if (this.conflictAction === 'update' && this.conflictUpdateData) {
+            const updateSql = (0, conflict_builder_1.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 = (0, pg_format_1.default)('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 += (0, pg_format_1.default)(' RETURNING %I', resolvedReturning);
+        }
+        return query;
+    }
+}
+exports.InsertFromSelectBuilder = InsertFromSelectBuilder;

package/dist/cjs/pubsub/index.cjs

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotifyBuilder = exports.UnlistenBuilder = exports.ListenBuilder = void 0;
+var listen_notify_builder_1 = require("./listen-notify-builder.cjs");
+Object.defineProperty(exports, "ListenBuilder", { enumerable: true, get: function () { return listen_notify_builder_1.ListenBuilder; } });
+Object.defineProperty(exports, "UnlistenBuilder", { enumerable: true, get: function () { return listen_notify_builder_1.UnlistenBuilder; } });
+Object.defineProperty(exports, "NotifyBuilder", { enumerable: true, get: function () { return listen_notify_builder_1.NotifyBuilder; } });

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("../shared/pg-format.cjs"));
+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;