relq 1.0.0

package/dist/cjs/indexing/create-index-builder.cjs

@@ -0,0 +1,187 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateIndexBuilder = void 0;
+const pg_format_1 = __importDefault(require("../../addons/pg-format.js"));
+class CreateIndexBuilder {
+    tableName;
+    indexName;
+    indexType;
+    columns = [];
+    expressionIndex;
+    whereClause;
+    includeColumns = [];
+    withOptions = {};
+    concurrentFlag = false;
+    ifNotExistsFlag = false;
+    uniqueFlag = false;
+    tablespaceValue;
+    operatorClass;
+    constructor(tableName, indexName) {
+        this.tableName = tableName;
+        this.indexName = indexName;
+    }
+    btree(columns) {
+        this.indexType = 'BTREE';
+        this.columns = this.normalizeColumns(columns);
+        return this;
+    }
+    hash(column) {
+        this.indexType = 'HASH';
+        this.columns = [{ column }];
+        return this;
+    }
+    gin(columns, opClass) {
+        this.indexType = 'GIN';
+        this.columns = columns.map(col => ({ column: col }));
+        if (opClass) {
+            this.operatorClass = opClass;
+        }
+        return this;
+    }
+    gist(columns, opClass) {
+        this.indexType = 'GIST';
+        this.columns = columns.map(col => ({ column: col }));
+        if (opClass) {
+            this.operatorClass = opClass;
+        }
+        return this;
+    }
+    brin(columns, pagesPerRange) {
+        this.indexType = 'BRIN';
+        this.columns = columns.map(col => ({ column: col }));
+        if (pagesPerRange) {
+            this.withOptions.pages_per_range = pagesPerRange;
+        }
+        return this;
+    }
+    spgist(columns) {
+        this.indexType = 'SPGIST';
+        this.columns = columns.map(col => ({ column: col }));
+        return this;
+    }
+    bloom(columns, options) {
+        this.indexType = 'BLOOM';
+        this.columns = columns.map(col => ({ column: col }));
+        if (options) {
+            this.withOptions = { ...this.withOptions, ...options };
+        }
+        return this;
+    }
+    unique() {
+        this.uniqueFlag = true;
+        return this;
+    }
+    where(condition) {
+        this.whereClause = condition;
+        return this;
+    }
+    partial(condition) {
+        return this.where(condition);
+    }
+    include(...columns) {
+        this.includeColumns.push(...columns);
+        return this;
+    }
+    with(options) {
+        this.withOptions = { ...this.withOptions, ...options };
+        return this;
+    }
+    concurrently() {
+        this.concurrentFlag = true;
+        return this;
+    }
+    ifNotExists() {
+        this.ifNotExistsFlag = true;
+        return this;
+    }
+    tablespace(name) {
+        this.tablespaceValue = name;
+        return this;
+    }
+    expression(expr) {
+        this.expressionIndex = expr;
+        return this;
+    }
+    fillfactor(percent) {
+        this.withOptions.fillfactor = percent;
+        return this;
+    }
+    normalizeColumns(columns) {
+        return columns.map(col => {
+            if (typeof col === 'string') {
+                return { column: col };
+            }
+            return col;
+        });
+    }
+    formatColumn(col) {
+        let result = pg_format_1.default.ident(col.column);
+        if (col.collation) {
+            result += ` COLLATE ${pg_format_1.default.ident(col.collation)}`;
+        }
+        if (col.opclass) {
+            result += ` ${col.opclass}`;
+        }
+        else if (this.operatorClass && this.columns.length === 1) {
+            result += ` ${this.operatorClass}`;
+        }
+        if (col.order) {
+            result += ` ${col.order}`;
+        }
+        if (col.nulls) {
+            result += ` NULLS ${col.nulls}`;
+        }
+        return result;
+    }
+    toString() {
+        let sql = 'CREATE';
+        if (this.uniqueFlag) {
+            sql += ' UNIQUE';
+        }
+        sql += ' INDEX';
+        if (this.concurrentFlag) {
+            sql += ' CONCURRENTLY';
+        }
+        if (this.ifNotExistsFlag) {
+            sql += ' IF NOT EXISTS';
+        }
+        sql += ` ${pg_format_1.default.ident(this.indexName)} ON ${pg_format_1.default.ident(this.tableName)}`;
+        if (this.indexType && this.indexType !== 'BTREE') {
+            sql += ` USING ${this.indexType}`;
+        }
+        if (this.expressionIndex) {
+            sql += ` (${this.expressionIndex})`;
+        }
+        else if (this.columns.length > 0) {
+            const columnDefs = this.columns.map(col => this.formatColumn(col));
+            if ((this.indexType === 'GIN' || this.indexType === 'GIST') &&
+                this.operatorClass &&
+                this.columns.length > 1) {
+                sql += ` (${columnDefs.join(', ')}) ${this.operatorClass}`;
+            }
+            else {
+                sql += ` (${columnDefs.join(', ')})`;
+            }
+        }
+        if (this.includeColumns.length > 0) {
+            sql += ` INCLUDE (${this.includeColumns.map(c => pg_format_1.default.ident(c)).join(', ')})`;
+        }
+        if (Object.keys(this.withOptions).length > 0) {
+            const options = Object.entries(this.withOptions)
+                .map(([key, value]) => `${key} = ${typeof value === 'boolean' ? (value ? 'on' : 'off') : value}`)
+                .join(', ');
+            sql += ` WITH (${options})`;
+        }
+        if (this.tablespaceValue) {
+            sql += ` TABLESPACE ${pg_format_1.default.ident(this.tablespaceValue)}`;
+        }
+        if (this.whereClause) {
+            sql += ` WHERE ${this.whereClause}`;
+        }
+        return sql;
+    }
+}
+exports.CreateIndexBuilder = CreateIndexBuilder;

package/dist/cjs/indexing/drop-index-builder.cjs

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReindexBuilder = exports.DropIndexBuilder = void 0;
+const pg_format_1 = __importDefault(require("../../addons/pg-format.js"));
+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 += ` ${pg_format_1.default.ident(this.indexName)}`;
+        if (this.cascadeFlag) {
+            sql += ' CASCADE';
+        }
+        return sql;
+    }
+}
+exports.DropIndexBuilder = DropIndexBuilder;
+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 ${pg_format_1.default.ident(this.tablespaceValue)}`);
+        if (options.length > 0) {
+            sql += ` (${options.join(', ')})`;
+        }
+        sql += ` ${this.target}`;
+        if (this.target !== 'SYSTEM') {
+            sql += ` ${pg_format_1.default.ident(this.name)}`;
+        }
+        return sql;
+    }
+}
+exports.ReindexBuilder = ReindexBuilder;

package/dist/cjs/indexing/index-types.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/indexing/index.cjs

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReindexBuilder = exports.DropIndexBuilder = exports.CreateIndexBuilder = void 0;
+var create_index_builder_1 = require("./create-index-builder.cjs");
+Object.defineProperty(exports, "CreateIndexBuilder", { enumerable: true, get: function () { return create_index_builder_1.CreateIndexBuilder; } });
+var drop_index_builder_1 = require("./drop-index-builder.cjs");
+Object.defineProperty(exports, "DropIndexBuilder", { enumerable: true, get: function () { return drop_index_builder_1.DropIndexBuilder; } });
+Object.defineProperty(exports, "ReindexBuilder", { enumerable: true, get: function () { return drop_index_builder_1.ReindexBuilder; } });

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

@@ -0,0 +1,173 @@
+"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("../../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';
+}
+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 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 (0, pg_format_1.default)('%L', value);
+}
+function createSqlHelpers(currentColumn, tableName) {
+    return {
+        increment(amount) {
+            return {
+                __type: 'sql_expression',
+                sql: `${(0, pg_format_1.default)('%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})`
+            };
+        }
+    };
+}
+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;
+    }
+}
+exports.ConflictBuilder = ConflictBuilder;
+function buildConflictUpdateSql(updateData, tableName) {
+    const setClauses = [];
+    for (const [column, value] of Object.entries(updateData)) {
+        if (isColumnRef(value)) {
+            setClauses.push(`${(0, pg_format_1.default)('%I', column)} = ${columnRefToSql(value)}`);
+        }
+        else if (isSqlExpression(value)) {
+            setClauses.push(`${(0, pg_format_1.default)('%I', column)} = ${value.sql}`);
+        }
+        else if (Array.isArray(value)) {
+            if (value.length === 0) {
+                setClauses.push(`${(0, pg_format_1.default)('%I', column)} = 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', column)} = ARRAY[${jsonValues}]::jsonb[]`);
+            }
+        }
+        else {
+            setClauses.push((0, pg_format_1.default)('%I = %L', column, 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; } });