relq 1.0.0

package/dist/esm/indexing/drop-index-builder.js

@@ -0,0 +1,81 @@
+import format from "../../addons/pg-format.js";
+export class DropIndexBuilder {
+    indexName;
+    ifExistsFlag = false;
+    cascadeFlag = false;
+    concurrentlyFlag = false;
+    constructor(indexName) {
+        this.indexName = indexName;
+    }
+    ifExists() {
+        this.ifExistsFlag = true;
+        return this;
+    }
+    cascade() {
+        this.cascadeFlag = true;
+        return this;
+    }
+    restrict() {
+        this.cascadeFlag = false;
+        return this;
+    }
+    concurrently() {
+        this.concurrentlyFlag = true;
+        return this;
+    }
+    toString() {
+        let sql = 'DROP INDEX';
+        if (this.concurrentlyFlag) {
+            sql += ' CONCURRENTLY';
+        }
+        if (this.ifExistsFlag) {
+            sql += ' IF EXISTS';
+        }
+        sql += ` ${format.ident(this.indexName)}`;
+        if (this.cascadeFlag) {
+            sql += ' CASCADE';
+        }
+        return sql;
+    }
+}
+export class ReindexBuilder {
+    target;
+    name;
+    concurrentlyFlag = false;
+    tablespaceValue;
+    verboseFlag = false;
+    constructor(target, name) {
+        this.target = target;
+        this.name = name;
+    }
+    concurrently() {
+        this.concurrentlyFlag = true;
+        return this;
+    }
+    tablespace(name) {
+        this.tablespaceValue = name;
+        return this;
+    }
+    verbose() {
+        this.verboseFlag = true;
+        return this;
+    }
+    toString() {
+        let sql = 'REINDEX';
+        const options = [];
+        if (this.concurrentlyFlag)
+            options.push('CONCURRENTLY');
+        if (this.verboseFlag)
+            options.push('VERBOSE');
+        if (this.tablespaceValue)
+            options.push(`TABLESPACE ${format.ident(this.tablespaceValue)}`);
+        if (options.length > 0) {
+            sql += ` (${options.join(', ')})`;
+        }
+        sql += ` ${this.target}`;
+        if (this.target !== 'SYSTEM') {
+            sql += ` ${format.ident(this.name)}`;
+        }
+        return sql;
+    }
+}

package/dist/esm/indexing/index-types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/indexing/index.js

@@ -0,0 +1,2 @@
+export { CreateIndexBuilder } from "./create-index-builder.js";
+export { DropIndexBuilder, ReindexBuilder } from "./drop-index-builder.js";

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

@@ -0,0 +1,162 @@
+import format from "../../addons/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 valueToSql(value) {
+    if (isColumnRef(value)) {
+        return columnRefToSql(value);
+    }
+    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) {
+    return {
+        increment(amount) {
+            return {
+                __type: 'sql_expression',
+                sql: `${format('%I.%I', tableName, currentColumn)} + ${amount}`
+            };
+        },
+        add(a, b) {
+            return {
+                __type: 'sql_expression',
+                sql: `${valueToSql(a)} + ${valueToSql(b)}`
+            };
+        },
+        subtract(a, b) {
+            return {
+                __type: 'sql_expression',
+                sql: `${valueToSql(a)} - ${valueToSql(b)}`
+            };
+        },
+        coalesce(...values) {
+            const sqlValues = values.map(v => valueToSql(v)).join(', ');
+            return {
+                __type: 'sql_expression',
+                sql: `COALESCE(${sqlValues})`
+            };
+        },
+        raw(sql) {
+            return { __type: 'sql_expression', sql };
+        },
+        greatest(...values) {
+            const sqlValues = values.map(v => valueToSql(v)).join(', ');
+            return {
+                __type: 'sql_expression',
+                sql: `GREATEST(${sqlValues})`
+            };
+        },
+        least(...values) {
+            const sqlValues = values.map(v => valueToSql(v)).join(', ');
+            return {
+                __type: 'sql_expression',
+                sql: `LEAST(${sqlValues})`
+            };
+        }
+    };
+}
+export class ConflictBuilder {
+    _action = 'nothing';
+    _updateData = {};
+    _whereClause;
+    _tableName;
+    constructor(tableName) {
+        this._tableName = tableName;
+    }
+    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);
+                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) {
+    const setClauses = [];
+    for (const [column, value] of Object.entries(updateData)) {
+        if (isColumnRef(value)) {
+            setClauses.push(`${format('%I', column)} = ${columnRefToSql(value)}`);
+        }
+        else if (isSqlExpression(value)) {
+            setClauses.push(`${format('%I', column)} = ${value.sql}`);
+        }
+        else if (Array.isArray(value)) {
+            if (value.length === 0) {
+                setClauses.push(`${format('%I', column)} = ARRAY[]::jsonb[]`);
+            }
+            else {
+                const jsonValues = value.map(v => format('%L', JSON.stringify(v))).join(',');
+                setClauses.push(`${format('%I', column)} = ARRAY[${jsonValues}]::jsonb[]`);
+            }
+        }
+        else {
+            setClauses.push(format('%I = %L', column, value));
+        }
+    }
+    return setClauses.join(', ');
+}

package/dist/esm/insert/index.js

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

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

@@ -0,0 +1,247 @@
+import format from "../../addons/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 "../errors/relq-errors.js";
+export class InsertBuilder {
+    tableName;
+    insertData;
+    conflictColumns;
+    conflictBuilder;
+    returningClause;
+    _case = 'keep-case';
+    _convertCase = '2snake';
+    originalColumns;
+    constructor(tableName, data) {
+        this.tableName = tableName;
+        this.insertData = [data];
+        this.originalColumns = Object.keys(data).sort();
+    }
+    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) {
+        if (this.insertData.length === 0) {
+            this.originalColumns = Object.keys(row).sort();
+        }
+        else {
+            this.validateColumns(row);
+        }
+        this.insertData.push(row);
+        return this;
+    }
+    addRows(rows) {
+        if (rows.length === 0)
+            return this;
+        if (this.insertData.length === 0) {
+            this.originalColumns = Object.keys(rows[0]).sort();
+        }
+        for (const row of rows) {
+            this.validateColumns(row);
+        }
+        this.insertData.push(...rows);
+        return this;
+    }
+    clear() {
+        this.insertData = [];
+        this.originalColumns = [];
+        return this;
+    }
+    get total() {
+        return this.insertData.length;
+    }
+    onConflict(columns, callback) {
+        this.conflictColumns = Array.isArray(columns) ? columns : [columns];
+        this.conflictBuilder = new ConflictBuilder(this.tableName);
+        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;
+    }
+    formatArrayValue(value) {
+        if (value.length === 0)
+            return 'ARRAY[]::jsonb[]';
+        const jsonValues = value.map(v => format('%L', JSON.stringify(v))).join(',');
+        return `ARRAY[${jsonValues}]::jsonb[]`;
+    }
+    processRowValues(row, originalColumns) {
+        const processedValues = [];
+        const placeholderTypes = [];
+        for (const colName of originalColumns) {
+            const value = row[colName];
+            if (Array.isArray(value)) {
+                processedValues.push(this.formatArrayValue(value));
+                placeholderTypes.push('%s');
+            }
+            else {
+                processedValues.push(value);
+                placeholderTypes.push('%L');
+            }
+        }
+        return { values: processedValues, placeholders: placeholderTypes.join(', ') };
+    }
+    buildConflictClause() {
+        if (!this.conflictColumns || !this.conflictBuilder)
+            return '';
+        if (this.insertData.length > 1) {
+            throw new RelqBuilderError('ON CONFLICT (upsert) is not supported with multiple row inserts', { builder: 'InsertBuilder', hint: 'Use single row insert for upsert operations' });
+        }
+        let clause = format(' ON CONFLICT (%I)', this.conflictColumns);
+        if (this.conflictBuilder.action === 'update') {
+            const updateSql = buildConflictUpdateSql(this.conflictBuilder.updateData, this.tableName);
+            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.convertColumnName(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':
+                return format(' RETURNING %I', this.returningClause.columns);
+            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 '';
+        }
+    }
+}