@relq/orm 0.1.0

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

@@ -0,0 +1,81 @@
+import format from "../shared/pg-format.js";
+import { ConditionCollector, buildConditionsSQL, buildConditionSQL } from "../condition/condition-collector.js";
+export class CountBuilder {
+    tableName;
+    countGroups = [];
+    whereConditions = [];
+    constructor(tableName) {
+        this.tableName = tableName;
+    }
+    group(name, callback, options) {
+        const conditionBuilder = new ConditionCollector();
+        callback(conditionBuilder);
+        let aggregateFunction = 'COUNT';
+        let column;
+        if (options) {
+            if (options.distinct) {
+                aggregateFunction = 'COUNT_DISTINCT';
+                column = options.distinct;
+            }
+            else if (options.sum) {
+                aggregateFunction = 'SUM';
+                column = options.sum;
+            }
+            else if (options.avg) {
+                aggregateFunction = 'AVG';
+                column = options.avg;
+            }
+            else if (options.min) {
+                aggregateFunction = 'MIN';
+                column = options.min;
+            }
+            else if (options.max) {
+                aggregateFunction = 'MAX';
+                column = options.max;
+            }
+        }
+        this.countGroups.push({
+            name,
+            conditions: conditionBuilder.getConditions(),
+            aggregateFunction,
+            column
+        });
+        return this;
+    }
+    where(callback) {
+        const conditionBuilder = new ConditionCollector();
+        callback(conditionBuilder);
+        this.whereConditions.push(...conditionBuilder.getConditions());
+        return this;
+    }
+    toString() {
+        let selectColumns = [];
+        if (this.countGroups.length > 0) {
+            selectColumns = this.countGroups.map(group => this.buildGroupSQL(group));
+        }
+        else {
+            selectColumns.push('COUNT(*) AS count');
+        }
+        let query = format('SELECT %s FROM %I', selectColumns.join(', '), this.tableName);
+        if (this.whereConditions.length > 0) {
+            query += ' WHERE ' + buildConditionsSQL(this.whereConditions);
+        }
+        return query;
+    }
+    buildGroupSQL(group) {
+        const conditionsSQL = group.conditions.map(condition => buildConditionSQL(condition)).join(' AND ');
+        let aggregateColumn = '*';
+        if (group.column) {
+            aggregateColumn = group.aggregateFunction === 'COUNT_DISTINCT'
+                ? format('DISTINCT %I', group.column)
+                : format.ident(group.column);
+        }
+        const funcName = group.aggregateFunction === 'COUNT_DISTINCT' ? 'COUNT' : group.aggregateFunction;
+        if (group.conditions.length > 0) {
+            return format('%s(%s) FILTER (WHERE %s) AS %I', funcName, aggregateColumn, conditionsSQL, group.name);
+        }
+        else {
+            return format('%s(%s) AS %I', funcName, aggregateColumn, group.name);
+        }
+    }
+}

package/dist/esm/count/index.js

@@ -0,0 +1 @@
+export { CountBuilder } from "./count-builder.js";

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

@@ -0,0 +1,169 @@
+import format from "../shared/pg-format.js";
+import { ConditionCollector, buildConditionsSQL } from "../condition/condition-collector.js";
+import { SelectBuilder } from "../select/select-builder.js";
+import { CountBuilder } from "../count/count-builder.js";
+export class DeleteBuilder {
+    tableName;
+    whereConditions = [];
+    returningClause;
+    columnResolver;
+    constructor(tableName) {
+        this.tableName = tableName;
+    }
+    setColumnResolver(resolver) {
+        this.columnResolver = resolver;
+        return this;
+    }
+    resolveColumnName(name) {
+        if (this.columnResolver) {
+            return this.columnResolver(name);
+        }
+        return name;
+    }
+    transformConditionColumns(conditions) {
+        if (!this.columnResolver) {
+            return conditions;
+        }
+        return conditions.map(cond => {
+            if (cond.method === 'or' || cond.method === 'and') {
+                return {
+                    ...cond,
+                    values: this.transformConditionColumns(cond.values)
+                };
+            }
+            if (!cond.column || cond.method === 'raw') {
+                return cond;
+            }
+            if (cond.column.includes('.')) {
+                const [tableRef, colName] = cond.column.split('.');
+                return {
+                    ...cond,
+                    column: `${tableRef}.${this.columnResolver(colName)}`
+                };
+            }
+            return {
+                ...cond,
+                column: this.columnResolver(cond.column)
+            };
+        });
+    }
+    where(callback) {
+        const conditionBuilder = new ConditionCollector();
+        callback(conditionBuilder);
+        this.whereConditions.push(...conditionBuilder.getConditions());
+        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;
+    }
+    toString() {
+        let query = format('DELETE FROM %I', this.tableName);
+        if (this.whereConditions.length > 0) {
+            const transformedConditions = this.transformConditionColumns(this.whereConditions);
+            query += ' WHERE ' + buildConditionsSQL(transformedConditions);
+        }
+        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/delete/index.js

@@ -0,0 +1 @@
+export { DeleteBuilder } from "./delete-builder.js";

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

@@ -0,0 +1,95 @@
+export class ExplainBuilder {
+    query;
+    options;
+    constructor(query, options = {}) {
+        this.query = query;
+        this.options = options;
+    }
+    analyze(enable = true) {
+        this.options.analyze = enable;
+        return this;
+    }
+    verbose(enable = true) {
+        this.options.verbose = enable;
+        return this;
+    }
+    costs(enable = true) {
+        this.options.costs = enable;
+        return this;
+    }
+    settings(enable = true) {
+        this.options.settings = enable;
+        return this;
+    }
+    buffers(enable = true) {
+        this.options.buffers = enable;
+        if (enable) {
+            this.options.analyze = true;
+        }
+        return this;
+    }
+    timing(enable = true) {
+        this.options.timing = enable;
+        if (enable) {
+            this.options.analyze = true;
+        }
+        return this;
+    }
+    summary(enable = true) {
+        this.options.summary = enable;
+        return this;
+    }
+    wal(enable = true) {
+        this.options.wal = enable;
+        if (enable) {
+            this.options.analyze = true;
+        }
+        return this;
+    }
+    format(format) {
+        this.options.format = format;
+        return this;
+    }
+    toString() {
+        const options = [];
+        if (this.options.analyze) {
+            options.push('ANALYZE');
+        }
+        if (this.options.verbose) {
+            options.push('VERBOSE');
+        }
+        if (this.options.costs === false) {
+            options.push('COSTS FALSE');
+        }
+        else if (this.options.costs === true) {
+            options.push('COSTS TRUE');
+        }
+        if (this.options.settings) {
+            options.push('SETTINGS');
+        }
+        if (this.options.buffers) {
+            options.push('BUFFERS');
+        }
+        if (this.options.timing === false) {
+            options.push('TIMING FALSE');
+        }
+        else if (this.options.timing === true) {
+            options.push('TIMING TRUE');
+        }
+        if (this.options.summary) {
+            options.push('SUMMARY');
+        }
+        if (this.options.wal) {
+            options.push('WAL');
+        }
+        if (this.options.format) {
+            options.push(`FORMAT ${this.options.format}`);
+        }
+        let sql = 'EXPLAIN';
+        if (options.length > 0) {
+            sql += ` (${options.join(', ')})`;
+        }
+        sql += ' ' + this.query;
+        return sql;
+    }
+}

package/dist/esm/explain/index.js

@@ -0,0 +1 @@
+export { ExplainBuilder } from "./explain-builder.js";

package/dist/esm/index.js

@@ -0,0 +1,7 @@
+export { Relq } from "./core/relq-client.js";
+export { RelqPostgres } from "./core/pg-family/pg-client/index.js";
+export { RelqNile } from "./core/pg-family/nile-client/index.js";
+export { RelqDsql } from "./core/pg-family/dsql-client/index.js";
+export { RelqCockroachDB } from "./core/pg-family/cockroachdb-client/index.js";
+export { RelqError, RelqConnectionError, RelqQueryError, RelqTransactionError, RelqConfigError, RelqTimeoutError, RelqPoolError, isRelqError, isRelqConnectionError, isRelqQueryError, } from "../shared/errors/relq-errors.js";
+export { format as pg_format } from "./utils/index.js";

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

@@ -0,0 +1,202 @@
+import format from "../shared/pg-format.js";
+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';
+}
+export function createExcludedProxy() {
+    return new Proxy({}, {
+        get(_target, prop) {
+            return { __type: 'column_ref', table: 'EXCLUDED', column: prop };
+        }
+    });
+}
+export function createRowProxy(tableName) {
+    return new Proxy({}, {
+        get(_target, prop) {
+            return { __type: 'column_ref', table: tableName, column: prop };
+        }
+    });
+}
+function columnRefToSql(ref) {
+    return format('%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 format('%L', value);
+}
+export 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(`${format('%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');
+        }
+    };
+}
+export 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;
+    }
+}
+export 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(`${format('%I', resolvedCol)} = ${columnRefToSql(resolvedRef)}`);
+        }
+        else if (isSqlExpression(value)) {
+            setClauses.push(`${format('%I', resolvedCol)} = ${value.sql}`);
+        }
+        else if (Array.isArray(value)) {
+            if (value.length === 0) {
+                setClauses.push(`${format('%I', resolvedCol)} = ARRAY[]::jsonb[]`);
+            }
+            else {
+                const jsonValues = value.map(v => format('%L', JSON.stringify(v))).join(',');
+                setClauses.push(`${format('%I', resolvedCol)} = ARRAY[${jsonValues}]::jsonb[]`);
+            }
+        }
+        else {
+            setClauses.push(format('%I = %L', resolvedCol, value));
+        }
+    }
+    return setClauses.join(', ');
+}

package/dist/esm/insert/index.js

@@ -0,0 +1 @@
+export { InsertBuilder } from "./insert-builder.js";