relq 1.0.37 → 1.0.38

package/dist/cjs/condition/condition-collector.cjs

@@ -178,6 +178,13 @@ class ConditionCollector {
     }
 }
 exports.ConditionCollector = ConditionCollector;
+function formatColumn(column) {
+    if (column.includes('.')) {
+        const parts = column.split('.');
+        return parts.map(p => pg_format_1.default.ident(p)).join('.');
+    }
+    return pg_format_1.default.ident(column);
+}
 function buildConditionSQL(condition) {
     const { method, column, values } = condition;
     if (method.startsWith('jsonb_')) {
@@ -198,73 +205,74 @@ function buildConditionSQL(condition) {
     if (method.startsWith('network_')) {
         return (0, network_condition_builder_1.buildNetworkConditionSQL)(condition);
     }
+    const col = column ? formatColumn(column) : '';
     switch (method) {
         case 'equal':
             if (Array.isArray(values) && values.length > 1) {
-                return (0, pg_format_1.default)('%I IN %L', column, values);
+                return `${col} IN ${(0, pg_format_1.default)('%L', values)}`;
             }
-            return (0, pg_format_1.default)('%I = %L', column, Array.isArray(values) ? values[0] : values);
+            return `${col} = ${(0, pg_format_1.default)('%L', Array.isArray(values) ? values[0] : values)}`;
         case 'notEqual':
             if (Array.isArray(values) && values.length > 1) {
-                return (0, pg_format_1.default)('%I NOT IN %L', column, values);
+                return `${col} NOT IN ${(0, pg_format_1.default)('%L', values)}`;
             }
-            return (0, pg_format_1.default)('%I != %L', column, Array.isArray(values) ? values[0] : values);
+            return `${col} != ${(0, pg_format_1.default)('%L', Array.isArray(values) ? values[0] : values)}`;
         case 'lessThan':
-            return (0, pg_format_1.default)('%I < %L', column, Array.isArray(values) ? values[0] : values);
+            return `${col} < ${(0, pg_format_1.default)('%L', Array.isArray(values) ? values[0] : values)}`;
         case 'lessThanEqual':
-            return (0, pg_format_1.default)('%I <= %L', column, Array.isArray(values) ? values[0] : values);
+            return `${col} <= ${(0, pg_format_1.default)('%L', Array.isArray(values) ? values[0] : values)}`;
         case 'greaterThan':
-            return (0, pg_format_1.default)('%I > %L', column, Array.isArray(values) ? values[0] : values);
+            return `${col} > ${(0, pg_format_1.default)('%L', Array.isArray(values) ? values[0] : values)}`;
         case 'greaterThanEqual':
-            return (0, pg_format_1.default)('%I >= %L', column, Array.isArray(values) ? values[0] : values);
+            return `${col} >= ${(0, pg_format_1.default)('%L', Array.isArray(values) ? values[0] : values)}`;
         case 'isNull':
-            return (0, pg_format_1.default)('%I IS NULL', column);
+            return `${col} IS NULL`;
         case 'isNotNull':
-            return (0, pg_format_1.default)('%I IS NOT NULL', column);
+            return `${col} IS NOT NULL`;
         case 'between': {
             const [start, end] = values;
-            return (0, pg_format_1.default)('%I BETWEEN %L AND %L', column, start, end);
+            return `${col} BETWEEN ${(0, pg_format_1.default)('%L', start)} AND ${(0, pg_format_1.default)('%L', end)}`;
         }
         case 'notBetween': {
             const [notStart, notEnd] = values;
-            return (0, pg_format_1.default)('%I NOT BETWEEN %L AND %L', column, notStart, notEnd);
+            return `${col} NOT BETWEEN ${(0, pg_format_1.default)('%L', notStart)} AND ${(0, pg_format_1.default)('%L', notEnd)}`;
         }
         case 'startsWith':
-            return (0, pg_format_1.default)('%I LIKE %L', column, `${values}%`);
+            return `${col} LIKE ${(0, pg_format_1.default)('%L', `${values}%`)}`;
         case 'notStartsWith':
-            return (0, pg_format_1.default)('%I NOT LIKE %L', column, `${values}%`);
+            return `${col} NOT LIKE ${(0, pg_format_1.default)('%L', `${values}%`)}`;
         case 'endsWith':
-            return (0, pg_format_1.default)('%I LIKE %L', column, `%${values}`);
+            return `${col} LIKE ${(0, pg_format_1.default)('%L', `%${values}`)}`;
         case 'notEndsWith':
-            return (0, pg_format_1.default)('%I NOT LIKE %L', column, `%${values}`);
+            return `${col} NOT LIKE ${(0, pg_format_1.default)('%L', `%${values}`)}`;
         case 'contains':
-            return (0, pg_format_1.default)('%I LIKE %L', column, `%${values}%`);
+            return `${col} LIKE ${(0, pg_format_1.default)('%L', `%${values}%`)}`;
         case 'notContains':
-            return (0, pg_format_1.default)('%I NOT LIKE %L', column, `%${values}%`);
+            return `${col} NOT LIKE ${(0, pg_format_1.default)('%L', `%${values}%`)}`;
         case 'like':
-            return (0, pg_format_1.default)('%I LIKE %L', column, values);
+            return `${col} LIKE ${(0, pg_format_1.default)('%L', values)}`;
         case 'notLike':
-            return (0, pg_format_1.default)('%I NOT LIKE %L', column, values);
+            return `${col} NOT LIKE ${(0, pg_format_1.default)('%L', values)}`;
         case 'ilike':
-            return (0, pg_format_1.default)('%I ILIKE %L', column, values);
+            return `${col} ILIKE ${(0, pg_format_1.default)('%L', values)}`;
         case 'in': {
             const valueList = Array.isArray(values) ? values : [values];
             const formattedValues = valueList.map(v => (0, pg_format_1.default)('%L', v)).join(', ');
-            return (0, pg_format_1.default)('%I IN (%s)', column, formattedValues);
+            return `${col} IN (${formattedValues})`;
         }
         case 'notIn': {
             const valueList = Array.isArray(values) ? values : [values];
             const formattedValues = valueList.map(v => (0, pg_format_1.default)('%L', v)).join(', ');
-            return (0, pg_format_1.default)('%I NOT IN (%s)', column, formattedValues);
+            return `${col} NOT IN (${formattedValues})`;
         }
         case 'exists':
-            return (0, pg_format_1.default)('EXISTS (%s)', values);
+            return `EXISTS (${values})`;
         case 'notExists':
-            return (0, pg_format_1.default)('NOT EXISTS (%s)', values);
+            return `NOT EXISTS (${values})`;
         case 'search':
-            return (0, pg_format_1.default)('to_tsvector(%I) @@ plainto_tsquery(%L)', column, values);
+            return `to_tsvector(${col}) @@ plainto_tsquery(${(0, pg_format_1.default)('%L', values)})`;
         case 'notSearch':
-            return (0, pg_format_1.default)('NOT (to_tsvector(%I) @@ plainto_tsquery(%L))', column, values);
+            return `NOT (to_tsvector(${col}) @@ plainto_tsquery(${(0, pg_format_1.default)('%L', values)}))`;
         case 'or': {
             const orConditions = values;
             return `(${orConditions.map(c => buildConditionSQL(c)).join(' OR ')})`;

package/dist/cjs/core/helpers/ConnectedAggregateBuilder.cjs

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectedAggregateBuilder = void 0;
+const methods_1 = require("./methods.cjs");
+class ConnectedAggregateBuilder {
+    builder;
+    relq;
+    tableName;
+    constructor(builder, relq, tableName) {
+        this.builder = builder;
+        this.relq = relq;
+        this.tableName = tableName;
+    }
+    mapColumn(column) {
+        const transformed = this.relq[methods_1.INTERNAL].transformToDbColumns(this.tableName, { [column]: true });
+        return Object.keys(transformed)[0] || column;
+    }
+    groupBy(...columns) {
+        const dbColumns = columns.map(col => this.mapColumn(col));
+        this.builder.groupBy(...dbColumns);
+        return this;
+    }
+    count(alias) {
+        this.builder.count(alias);
+        return this;
+    }
+    countColumn(column, alias) {
+        this.builder.countColumn(this.mapColumn(column), alias);
+        return this;
+    }
+    countDistinct(column, alias) {
+        this.builder.countDistinct(this.mapColumn(column), alias);
+        return this;
+    }
+    sum(column, alias) {
+        this.builder.sum(this.mapColumn(column), alias);
+        return this;
+    }
+    avg(column, alias) {
+        this.builder.avg(this.mapColumn(column), alias);
+        return this;
+    }
+    min(column, alias) {
+        this.builder.min(this.mapColumn(column), alias);
+        return this;
+    }
+    max(column, alias) {
+        this.builder.max(this.mapColumn(column), alias);
+        return this;
+    }
+    arrayAgg(column, alias) {
+        this.builder.arrayAgg(this.mapColumn(column), alias);
+        return this;
+    }
+    stringAgg(column, delimiter, alias) {
+        this.builder.stringAgg(this.mapColumn(column), delimiter || ', ', alias);
+        return this;
+    }
+    jsonAgg(column, alias) {
+        this.builder.jsonAgg(this.mapColumn(column), alias);
+        return this;
+    }
+    jsonbAgg(column, alias) {
+        this.builder.jsonbAgg(this.mapColumn(column), alias);
+        return this;
+    }
+    boolAnd(column, alias) {
+        this.builder.boolAnd(this.mapColumn(column), alias);
+        return this;
+    }
+    boolOr(column, alias) {
+        this.builder.boolOr(this.mapColumn(column), alias);
+        return this;
+    }
+    where(callback) {
+        this.builder.where(callback);
+        return this;
+    }
+    having(callback) {
+        this.builder.having(callback);
+        return this;
+    }
+    orderBy(column, direction = 'ASC') {
+        this.builder.orderBy(this.mapColumn(column), direction);
+        return this;
+    }
+    limit(count) {
+        this.builder.limit(count);
+        return this;
+    }
+    offset(count) {
+        this.builder.offset(count);
+        return this;
+    }
+    toString() {
+        return this.builder.toString();
+    }
+    async all() {
+        const sql = this.builder.toString();
+        const result = await this.relq[methods_1.INTERNAL].executeSelect(sql, this.tableName);
+        const numericAliases = this.builder.getNumericAliases();
+        if (numericAliases.length > 0) {
+            for (const row of result.data) {
+                for (const alias of numericAliases) {
+                    if (alias in row && typeof row[alias] === 'string') {
+                        row[alias] = Number(row[alias]);
+                    }
+                }
+            }
+        }
+        return result.data;
+    }
+    async get() {
+        this.builder.limit(1);
+        const sql = this.builder.toString();
+        const result = await this.relq[methods_1.INTERNAL].executeSelectOne(sql, this.tableName);
+        const numericAliases = this.builder.getNumericAliases();
+        if (numericAliases.length > 0 && result.data) {
+            for (const alias of numericAliases) {
+                if (alias in result.data && typeof result.data[alias] === 'string') {
+                    result.data[alias] = Number(result.data[alias]);
+                }
+            }
+        }
+        return result.data;
+    }
+}
+exports.ConnectedAggregateBuilder = ConnectedAggregateBuilder;

package/dist/cjs/core/helpers/ConnectedCTEBuilder.cjs

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectedCTEBuilder = void 0;
+const methods_1 = require("./methods.cjs");
+class ConnectedCTEBuilder {
+    relq;
+    ctes = [];
+    constructor(relq) {
+        this.relq = relq;
+    }
+    with(name, query) {
+        const queryStr = typeof query === 'string' ? query : query.toString();
+        this.ctes.push({ name, query: queryStr });
+        return this;
+    }
+    withMaterialized(name, query) {
+        const queryStr = typeof query === 'string' ? query : query.toString();
+        this.ctes.push({ name, query: `MATERIALIZED (${queryStr})` });
+        return this;
+    }
+    async query(sql) {
+        const cteClause = this.buildCTEClause();
+        const fullSql = `${cteClause} ${sql}`;
+        const result = await this.relq[methods_1.INTERNAL].executeQuery(fullSql);
+        return {
+            data: result.result.rows,
+            rowCount: result.result.rowCount ?? 0
+        };
+    }
+    async all(sql) {
+        const result = await this.query(sql);
+        return result.data;
+    }
+    async get(sql) {
+        const result = await this.query(sql);
+        return result.data[0] ?? null;
+    }
+    buildCTEClause() {
+        if (this.ctes.length === 0)
+            return '';
+        const cteStrings = this.ctes.map(cte => {
+            if (cte.query.startsWith('MATERIALIZED')) {
+                return `"${cte.name}" AS ${cte.query}`;
+            }
+            return `"${cte.name}" AS (${cte.query})`;
+        });
+        return `WITH ${cteStrings.join(', ')}`;
+    }
+    toSQL(mainQuery) {
+        return `${this.buildCTEClause()} ${mainQuery}`;
+    }
+}
+exports.ConnectedCTEBuilder = ConnectedCTEBuilder;

package/dist/cjs/core/helpers/ConnectedCountBuilder.cjs

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectedCountBuilder = void 0;
+const methods_1 = require("./methods.cjs");
+class ConnectedCountBuilder {
+    builder;
+    relq;
+    tableName;
+    groupNames = [];
+    constructor(builder, relq, tableName) {
+        this.builder = builder;
+        this.relq = relq;
+        this.tableName = tableName;
+    }
+    group(name, callback, options) {
+        this.groupNames.push(name);
+        this.builder.group(name, (q) => {
+            const wrapped = this.wrapConditionBuilder(q);
+            return callback(wrapped);
+        }, options);
+        return this;
+    }
+    where(callback) {
+        this.builder.where((q) => {
+            const wrapped = this.wrapConditionBuilder(q);
+            return callback(wrapped);
+        });
+        return this;
+    }
+    wrapConditionBuilder(originalBuilder) {
+        const relq = this.relq;
+        const tableName = this.tableName;
+        return new Proxy(originalBuilder, {
+            get(target, prop) {
+                const original = target[prop];
+                if (typeof original === 'function') {
+                    return function (column, ...args) {
+                        const transformed = relq[methods_1.INTERNAL].transformToDbColumns(tableName, { [column]: true });
+                        const dbColumn = Object.keys(transformed)[0] || column;
+                        return original.call(target, dbColumn, ...args);
+                    };
+                }
+                return original;
+            }
+        });
+    }
+    toString() {
+        return this.builder.toString();
+    }
+    async execute() {
+        const sql = this.builder.toString();
+        return this.relq[methods_1.INTERNAL].executeCount(sql);
+    }
+    async get() {
+        const sql = this.builder.toString();
+        const result = await this.relq[methods_1.INTERNAL].executeQuery(sql);
+        const row = result.result.rows[0];
+        if (this.groupNames.length === 0) {
+            return (Number(row?.count) ?? 0);
+        }
+        const counts = {};
+        for (const name of this.groupNames) {
+            counts[name] = Number(row?.[name] ?? 0);
+        }
+        return counts;
+    }
+}
+exports.ConnectedCountBuilder = ConnectedCountBuilder;

package/dist/cjs/core/helpers/ConnectedDeleteBuilder.cjs

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectedDeleteBuilder = void 0;
+const methods_1 = require("./methods.cjs");
+const ReturningExecutor_1 = require("./ReturningExecutor.cjs");
+class ConnectedDeleteBuilder {
+    builder;
+    relq;
+    constructor(builder, relq) {
+        this.builder = builder;
+        this.relq = relq;
+    }
+    where(callback) {
+        this.builder.where(callback);
+        return this;
+    }
+    toString() {
+        return this.builder.toString();
+    }
+    async run(withMetadata) {
+        const sql = this.builder.toString();
+        const result = await this.relq[methods_1.INTERNAL].executeRun(sql);
+        if (withMetadata) {
+            return result;
+        }
+        return result.metadata.rowCount ?? 0;
+    }
+    returning(columns) {
+        this.builder.returning(columns);
+        return new ReturningExecutor_1.ReturningExecutor(this.builder, this.relq);
+    }
+}
+exports.ConnectedDeleteBuilder = ConnectedDeleteBuilder;

package/dist/cjs/core/helpers/ConnectedInsertBuilder.cjs

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectedInsertBuilder = void 0;
+const methods_1 = require("./methods.cjs");
+const ReturningExecutor_1 = require("./ReturningExecutor.cjs");
+class ConnectedInsertBuilder {
+    builder;
+    relq;
+    constructor(builder, relq) {
+        this.builder = builder;
+        this.relq = relq;
+    }
+    addRow(row) {
+        this.builder.addRow(row);
+        return this;
+    }
+    addRows(rows) {
+        this.builder.addRows(rows);
+        return this;
+    }
+    clear() {
+        this.builder.clear();
+        return this;
+    }
+    get total() {
+        return this.builder.total;
+    }
+    onConflict(columns, callback) {
+        const cols = Array.isArray(columns) ? columns : [columns];
+        this.builder.onConflict(cols, (conflictBuilder) => {
+            callback(conflictBuilder);
+        });
+        return this;
+    }
+    toString() {
+        return this.builder.toString();
+    }
+    async run(withMetadata) {
+        (0, methods_1.debugLog)(this.relq[methods_1.INTERNAL]?.config, `ConnectedInsertBuilder.run called for table: ${this.builder.tableName}`);
+        const internalRelq = this.relq[methods_1.INTERNAL];
+        for (const row of this.builder.insertData) {
+            internalRelq.validateData(this.builder.tableName, row, 'insert');
+        }
+        const sql = this.builder.toString();
+        const result = await internalRelq.executeRun(sql);
+        if (withMetadata) {
+            return result;
+        }
+        return result.metadata.rowCount ?? 0;
+    }
+    returning(columns) {
+        this.builder.returning(columns);
+        return new ReturningExecutor_1.ReturningExecutor(this.builder, this.relq);
+    }
+}
+exports.ConnectedInsertBuilder = ConnectedInsertBuilder;

package/dist/cjs/core/helpers/ConnectedQueryBuilder.cjs

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectedQueryBuilder = void 0;
+const count_builder_1 = require("../../count/count-builder.cjs");
+const delete_builder_1 = require("../../delete/delete-builder.cjs");
+const insert_builder_1 = require("../../insert/insert-builder.cjs");
+const aggregate_builder_1 = require("../../select/aggregate-builder.cjs");
+const select_builder_1 = require("../../select/select-builder.cjs");
+const update_builder_1 = require("../../update/update-builder.cjs");
+const ConnectedAggregateBuilder_1 = require("./ConnectedAggregateBuilder.cjs");
+const ConnectedCountBuilder_1 = require("./ConnectedCountBuilder.cjs");
+const ConnectedDeleteBuilder_1 = require("./ConnectedDeleteBuilder.cjs");
+const ConnectedInsertBuilder_1 = require("./ConnectedInsertBuilder.cjs");
+const ConnectedSelectBuilder_1 = require("./ConnectedSelectBuilder.cjs");
+const ConnectedUpdateBuilder_1 = require("./ConnectedUpdateBuilder.cjs");
+const methods_1 = require("./methods.cjs");
+const PaginateBuilder_1 = require("./PaginateBuilder.cjs");
+class ConnectedQueryBuilder {
+    tableName;
+    relq;
+    schemaKey;
+    constructor(tableName, relq, schemaKey) {
+        this.tableName = tableName;
+        this.relq = relq;
+        this.schemaKey = schemaKey;
+    }
+    select(columns) {
+        let dbColumns = columns;
+        if (columns && this.relq[methods_1.INTERNAL].hasColumnMapping()) {
+            if (Array.isArray(columns)) {
+                dbColumns = columns.map(col => {
+                    if (Array.isArray(col)) {
+                        const transformed = this.relq[methods_1.INTERNAL].transformToDbColumns(this.tableName, { [col[0]]: true });
+                        return [Object.keys(transformed)[0], col[1]];
+                    }
+                    else {
+                        const transformed = this.relq[methods_1.INTERNAL].transformToDbColumns(this.tableName, { [col]: true });
+                        return Object.keys(transformed)[0];
+                    }
+                });
+            }
+            else {
+                const transformed = this.relq[methods_1.INTERNAL].transformToDbColumns(this.tableName, { [columns]: true });
+                dbColumns = Object.keys(transformed)[0];
+            }
+        }
+        const builder = new select_builder_1.SelectBuilder(this.tableName, dbColumns);
+        return new ConnectedSelectBuilder_1.ConnectedSelectBuilder(builder, this.relq, this.tableName, columns, this.schemaKey);
+    }
+    insert(data) {
+        const builder = new insert_builder_1.InsertBuilder(this.tableName, data);
+        return new ConnectedInsertBuilder_1.ConnectedInsertBuilder(builder, this.relq);
+    }
+    update(data) {
+        const builder = new update_builder_1.UpdateBuilder(this.tableName, data);
+        return new ConnectedUpdateBuilder_1.ConnectedUpdateBuilder(builder, this.relq);
+    }
+    delete() {
+        const builder = new delete_builder_1.DeleteBuilder(this.tableName);
+        return new ConnectedDeleteBuilder_1.ConnectedDeleteBuilder(builder, this.relq);
+    }
+    count() {
+        const builder = new count_builder_1.CountBuilder(this.tableName);
+        return new ConnectedCountBuilder_1.ConnectedCountBuilder(builder, this.relq, this.tableName);
+    }
+    aggregate() {
+        const builder = new aggregate_builder_1.AggregateQueryBuilder(this.tableName);
+        return new ConnectedAggregateBuilder_1.ConnectedAggregateBuilder(builder, this.relq, this.tableName);
+    }
+    async findById(id) {
+        const pkColumn = this.getPrimaryKeyColumn();
+        const dbColumn = this.relq[methods_1.INTERNAL].transformToDbColumns(this.tableName, { [pkColumn]: id });
+        const dbColName = Object.keys(dbColumn)[0];
+        const builder = new select_builder_1.SelectBuilder(this.tableName, ['*']);
+        builder.where(q => q.equal(dbColName, id));
+        builder.limit(1);
+        const sql = builder.toString();
+        const result = await this.relq[methods_1.INTERNAL].executeSelectOne(sql, this.tableName);
+        return result.data;
+    }
+    async findOne(filter) {
+        const builder = new select_builder_1.SelectBuilder(this.tableName, ['*']);
+        const dbFilter = this.relq[methods_1.INTERNAL].transformToDbColumns(this.tableName, filter);
+        builder.where(q => {
+            for (const [col, val] of Object.entries(dbFilter)) {
+                q.equal(col, val);
+            }
+            return q;
+        });
+        builder.limit(1);
+        const sql = builder.toString();
+        const result = await this.relq[methods_1.INTERNAL].executeSelectOne(sql, this.tableName);
+        return result.data;
+    }
+    async findMany(filter) {
+        const builder = new select_builder_1.SelectBuilder(this.tableName, ['*']);
+        const dbFilter = this.relq[methods_1.INTERNAL].transformToDbColumns(this.tableName, filter);
+        builder.where(q => {
+            for (const [col, val] of Object.entries(dbFilter)) {
+                q.equal(col, val);
+            }
+            return q;
+        });
+        const sql = builder.toString();
+        const result = await this.relq[methods_1.INTERNAL].executeSelect(sql, this.tableName);
+        return result.data;
+    }
+    async exists(filter) {
+        const builder = new count_builder_1.CountBuilder(this.tableName);
+        const dbFilter = this.relq[methods_1.INTERNAL].transformToDbColumns(this.tableName, filter);
+        builder.where(q => {
+            for (const [col, val] of Object.entries(dbFilter)) {
+                q.equal(col, val);
+            }
+            return q;
+        });
+        const sql = builder.toString();
+        const result = await this.relq[methods_1.INTERNAL].executeCount(sql);
+        return result.count > 0;
+    }
+    async upsert(options) {
+        const dbCreate = this.relq[methods_1.INTERNAL].transformToDbColumns(this.tableName, options.create);
+        const dbUpdate = this.relq[methods_1.INTERNAL].transformToDbColumns(this.tableName, options.update);
+        const dbWhere = this.relq[methods_1.INTERNAL].transformToDbColumns(this.tableName, options.where);
+        const conflictColumn = Object.keys(dbWhere)[0];
+        const builder = new insert_builder_1.InsertBuilder(this.tableName, dbCreate);
+        builder.onConflict(conflictColumn, cb => cb.doUpdate(dbUpdate));
+        builder.returning(['*']);
+        const sql = builder.toString();
+        const result = await this.relq[methods_1.INTERNAL].executeQuery(sql);
+        const transformed = this.relq[methods_1.INTERNAL].transformResultsFromDb(this.tableName, result.result.rows);
+        return transformed[0];
+    }
+    async insertMany(rows) {
+        if (rows.length === 0)
+            return [];
+        const firstDbRow = this.relq[methods_1.INTERNAL].transformToDbColumns(this.tableName, rows[0]);
+        const builder = new insert_builder_1.InsertBuilder(this.tableName, firstDbRow);
+        for (let i = 1; i < rows.length; i++) {
+            const dbRow = this.relq[methods_1.INTERNAL].transformToDbColumns(this.tableName, rows[i]);
+            builder.addRow(dbRow);
+        }
+        builder.returning(['*']);
+        const sql = builder.toString();
+        const result = await this.relq[methods_1.INTERNAL].executeQuery(sql);
+        return this.relq[methods_1.INTERNAL].transformResultsFromDb(this.tableName, result.result.rows);
+    }
+    paginate(options = {}) {
+        return new PaginateBuilder_1.PaginateBuilder(this.relq, this.tableName, options.columns, options.where, options.orderBy);
+    }
+    async softDelete(filter) {
+        const dbFilter = this.relq[methods_1.INTERNAL].transformToDbColumns(this.tableName, filter);
+        const builder = new update_builder_1.UpdateBuilder(this.tableName, { deleted_at: new Date() });
+        builder.where(q => {
+            for (const [col, val] of Object.entries(dbFilter)) {
+                q.equal(col, val);
+            }
+            return q;
+        });
+        builder.returning(['*']);
+        const sql = builder.toString();
+        const result = await this.relq[methods_1.INTERNAL].executeQuery(sql);
+        if (result.result.rows.length === 0)
+            return null;
+        const transformed = this.relq[methods_1.INTERNAL].transformResultsFromDb(this.tableName, result.result.rows);
+        return transformed[0];
+    }
+    async restore(filter) {
+        const dbFilter = this.relq[methods_1.INTERNAL].transformToDbColumns(this.tableName, filter);
+        const builder = new update_builder_1.UpdateBuilder(this.tableName, { deleted_at: null });
+        builder.where(q => {
+            for (const [col, val] of Object.entries(dbFilter)) {
+                q.equal(col, val);
+            }
+            return q;
+        });
+        builder.returning(['*']);
+        const sql = builder.toString();
+        const result = await this.relq[methods_1.INTERNAL].executeQuery(sql);
+        if (result.result.rows.length === 0)
+            return null;
+        const transformed = this.relq[methods_1.INTERNAL].transformResultsFromDb(this.tableName, result.result.rows);
+        return transformed[0];
+    }
+    getPrimaryKeyColumn() {
+        const schema = this.relq.schema;
+        if (schema && schema[this.tableName]) {
+            const tableSchema = schema[this.tableName];
+            for (const [colName, colDef] of Object.entries(tableSchema)) {
+                if (colDef && typeof colDef === 'object' &&
+                    ('$primaryKey' in colDef ||
+                        colDef.config?.$primaryKey === true)) {
+                    return colName;
+                }
+            }
+        }
+        return 'id';
+    }
+}
+exports.ConnectedQueryBuilder = ConnectedQueryBuilder;