@relq/orm 0.1.3 → 0.1.4

package/dist/cjs/{core → pg}/helpers/ConnectedDeleteBuilder.cjs

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConnectedDeleteBuilder = void 0;
-const methods_1 = require("./methods.cjs");
+const condition_collector_1 = require("../condition/condition-collector.cjs");
+const methods_1 = require("../../core/helpers/methods.cjs");
 const ReturningExecutor_1 = require("./ReturningExecutor.cjs");
-const capability_guard_1 = require("./capability-guard.cjs");
-const table_accessor_1 = require("../shared/table-accessor.cjs");
+const capability_guard_1 = require("../../core/helpers/capability-guard.cjs");
+const table_accessor_1 = require("../../core/shared/table-accessor.cjs");
+const relq_errors_1 = require("../../shared/errors/relq-errors.cjs");
 class ConnectedDeleteBuilder {
     builder;
     relq;
@@ -35,7 +37,21 @@ class ConnectedDeleteBuilder {
             return column;
         });
     }
-    where(callback) {
+    where(callbackOrCondition) {
+        if (callbackOrCondition instanceof condition_collector_1.ConditionCollector) {
+            const conditionTable = callbackOrCondition._tableName;
+            if (conditionTable) {
+                const matches = conditionTable === this.schemaKey || conditionTable === this.tableName;
+                if (!matches) {
+                    const queryTable = this.schemaKey || this.tableName;
+                    throw new relq_errors_1.RelqBuilderError(`Condition was created for table '${conditionTable}' but is being used on '${queryTable}'. ` +
+                        `Create the condition with db.where('${queryTable}') instead.`);
+                }
+            }
+            this.builder.where(callbackOrCondition);
+            return this;
+        }
+        const callback = callbackOrCondition;
         this.builder.where((q) => {
             q._tables = (0, table_accessor_1.createTableAccessor)(this.relq, this.relq.schema);
             return callback(q);
@@ -53,9 +69,13 @@ class ConnectedDeleteBuilder {
         }
         return result.metadata.rowCount ?? 0;
     }
-    returning(columns) {
-        if (columns === null) {
-            return this;
+    returning(...args) {
+        let columns;
+        if (args.length === 1) {
+            columns = args[0];
+        }
+        else {
+            columns = args;
         }
         (0, capability_guard_1.requireCapability)(this.relq, 'returning', 'RETURNING clause', 'Use a SELECT query after the DELETE to retrieve deleted data');
         this.builder.returning(columns);

package/dist/cjs/{core → pg}/helpers/ConnectedInsertBuilder.cjs

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConnectedInsertBuilder = void 0;
-const condition_collector_1 = require("../../condition/condition-collector.cjs");
-const methods_1 = require("./methods.cjs");
+const condition_collector_1 = require("../condition/condition-collector.cjs");
+const methods_1 = require("../../core/helpers/methods.cjs");
 const ReturningExecutor_1 = require("./ReturningExecutor.cjs");
-const capability_guard_1 = require("./capability-guard.cjs");
+const capability_guard_1 = require("../../core/helpers/capability-guard.cjs");
 class ConnectedInsertBuilder {
     builder;
     relq;
@@ -90,8 +90,12 @@ class ConnectedInsertBuilder {
     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 rows = this.builder.insertData;
+        if (rows.length > 0) {
+            internalRelq.validateData(this.builder.tableName, rows[0], 'insert');
+            if (rows.length > 1) {
+                internalRelq.validateData(this.builder.tableName, rows[rows.length - 1], 'insert');
+            }
         }
         const sql = this.builder.toString();
         const result = await internalRelq.executeRun(sql);
@@ -100,9 +104,13 @@ class ConnectedInsertBuilder {
         }
         return result.metadata.rowCount ?? 0;
     }
-    returning(columns) {
-        if (columns === null) {
-            return this;
+    returning(...args) {
+        let columns;
+        if (args.length === 1) {
+            columns = args[0];
+        }
+        else {
+            columns = args;
         }
         (0, capability_guard_1.requireCapability)(this.relq, 'returning', 'RETURNING clause', 'Use a SELECT query after the INSERT to retrieve inserted data');
         this.builder.returning(columns);

package/dist/cjs/{core → pg}/helpers/ConnectedInsertFromSelectBuilder.cjs

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConnectedInsertFromSelectBuilder = void 0;
-const methods_1 = require("./methods.cjs");
+const methods_1 = require("../../core/helpers/methods.cjs");
 const ReturningExecutor_1 = require("./ReturningExecutor.cjs");
-const capability_guard_1 = require("./capability-guard.cjs");
+const capability_guard_1 = require("../../core/helpers/capability-guard.cjs");
 class ConnectedInsertFromSelectBuilder {
     builder;
     relq;
@@ -54,9 +54,13 @@ class ConnectedInsertFromSelectBuilder {
         }
         return result.metadata.rowCount ?? 0;
     }
-    returning(columns) {
-        if (columns === null) {
-            return this;
+    returning(...args) {
+        let columns;
+        if (args.length === 1) {
+            columns = args[0];
+        }
+        else {
+            columns = args;
         }
         (0, capability_guard_1.requireCapability)(this.relq, 'returning', 'RETURNING clause', 'Use a SELECT query after the INSERT to retrieve inserted data');
         this.builder.returning(columns);

package/dist/cjs/{core → pg}/helpers/ConnectedQueryBuilder.cjs

@@ -1,13 +1,13 @@
 "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 insert_from_select_builder_1 = require("../../insert/insert-from-select-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 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 insert_from_select_builder_1 = require("../insert/insert-from-select-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");
@@ -15,9 +15,10 @@ const ConnectedInsertBuilder_1 = require("./ConnectedInsertBuilder.cjs");
 const ConnectedInsertFromSelectBuilder_1 = require("./ConnectedInsertFromSelectBuilder.cjs");
 const ConnectedSelectBuilder_1 = require("./ConnectedSelectBuilder.cjs");
 const ConnectedUpdateBuilder_1 = require("./ConnectedUpdateBuilder.cjs");
-const methods_1 = require("./methods.cjs");
+const methods_1 = require("../../core/helpers/methods.cjs");
 const PaginateBuilder_1 = require("./PaginateBuilder.cjs");
-const table_accessor_1 = require("../shared/table-accessor.cjs");
+const table_accessor_1 = require("../../core/shared/table-accessor.cjs");
+const relq_errors_1 = require("../../shared/errors/relq-errors.cjs");
 const query_convenience_1 = require("./query-convenience.cjs");
 class ConnectedQueryBuilder {
     tableName;
@@ -45,12 +46,12 @@ class ConnectedQueryBuilder {
         if (columns !== undefined) {
             if (Array.isArray(columns)) {
                 if (columns.length === 0) {
-                    throw new Error('select() requires at least one column. Use .select() without arguments for SELECT *');
+                    throw new relq_errors_1.RelqBuilderError('select() requires at least one column', { builder: 'select', hint: 'Use .select() without arguments for SELECT *' });
                 }
             }
             else if (typeof columns === 'string') {
                 if (columns === '' || columns === '*') {
-                    throw new Error(`Invalid column name: "${columns}". Use .select() without arguments for SELECT *, or specify column names`);
+                    throw new relq_errors_1.RelqBuilderError(`Invalid column name: "${columns}"`, { builder: 'select', hint: 'Use .select() without arguments for SELECT *, or pass valid column names' });
                 }
             }
         }
@@ -84,8 +85,8 @@ class ConnectedQueryBuilder {
             return new ConnectedInsertBuilder_1.ConnectedInsertBuilder(builder, this.relq, this.tableName, this.schemaKey);
         }
         const builder = new insert_builder_1.InsertBuilder(this.tableName, rows[0]);
-        for (let i = 1; i < rows.length; i++) {
-            builder.addRow(rows[i]);
+        if (rows.length > 1) {
+            builder.addRows(rows.slice(1));
         }
         return new ConnectedInsertBuilder_1.ConnectedInsertBuilder(builder, this.relq, this.tableName, this.schemaKey);
     }
@@ -136,11 +137,5 @@ class ConnectedQueryBuilder {
     async createWith(options) {
         return (0, query_convenience_1.executeCreateWith)(this.ctx, options.data, options.with);
     }
-    async softDelete(filter) {
-        return (0, query_convenience_1.executeSoftDelete)(this.ctx, filter);
-    }
-    async restore(filter) {
-        return (0, query_convenience_1.executeRestore)(this.ctx, filter);
-    }
 }
 exports.ConnectedQueryBuilder = ConnectedQueryBuilder;

package/dist/cjs/pg/helpers/ConnectedRawQueryBuilder.cjs

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectedRawQueryBuilder = void 0;
+const raw_1 = require("../raw/index.cjs");
+const methods_1 = require("../../core/helpers/methods.cjs");
+class ConnectedRawQueryBuilder {
+    params;
+    relq;
+    builder;
+    constructor(query, params, relq) {
+        this.params = params;
+        this.relq = relq;
+        const convertedQuery = this.convertPlaceholders(query);
+        this.builder = new raw_1.RawQueryBuilder(convertedQuery, this.params);
+    }
+    convertPlaceholders(query) {
+        let index = 0;
+        return query.replace(/\?/g, () => `$${++index}`);
+    }
+    async all() {
+        const sql = this.builder.toString();
+        const { result, duration } = await this.relq[methods_1.INTERNAL].executeRawQuery(sql);
+        return {
+            data: result.rows,
+            metadata: { rowCount: result.rowCount, command: result.command, duration, fields: result.fields },
+        };
+    }
+    async get() {
+        const sql = this.builder.toString();
+        const { result, duration } = await this.relq[methods_1.INTERNAL].executeRawQuery(sql);
+        const row = result.rows[0] || null;
+        return {
+            data: row,
+            metadata: { rowCount: result.rowCount, command: result.command, duration, fields: result.fields },
+        };
+    }
+    async getMany(count) {
+        const sql = this.builder.toString();
+        const limitedSql = sql.toUpperCase().includes('LIMIT')
+            ? sql
+            : `${sql} LIMIT ${count}`;
+        const { result, duration } = await this.relq[methods_1.INTERNAL].executeRawQuery(limitedSql);
+        return {
+            data: result.rows,
+            metadata: { rowCount: result.rowCount, command: result.command, duration, fields: result.fields },
+        };
+    }
+    async run() {
+        const sql = this.builder.toString();
+        const { result, duration } = await this.relq[methods_1.INTERNAL].executeRawQuery(sql);
+        return {
+            success: true,
+            metadata: { rowCount: result.rowCount, command: result.command, duration, fields: result.fields },
+        };
+    }
+    async count() {
+        const sql = this.builder.toString();
+        const { result, duration } = await this.relq[methods_1.INTERNAL].executeRawQuery(sql);
+        const row = result.rows[0];
+        const count = row ? Number(Object.values(row)[0]) || 0 : 0;
+        return {
+            count,
+            metadata: { rowCount: result.rowCount, command: result.command, duration, fields: result.fields },
+        };
+    }
+}
+exports.ConnectedRawQueryBuilder = ConnectedRawQueryBuilder;

package/dist/cjs/{core → pg}/helpers/ConnectedSelectBuilder.cjs

@@ -1,28 +1,35 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConnectedSelectBuilder = void 0;
-const methods_1 = require("./methods.cjs");
+const condition_collector_1 = require("../condition/condition-collector.cjs");
+const methods_1 = require("../../core/helpers/methods.cjs");
 const select_joins_1 = require("./select-joins.cjs");
 const select_pagination_1 = require("./select-pagination.cjs");
-const capability_guard_1 = require("./capability-guard.cjs");
-const table_accessor_1 = require("../shared/table-accessor.cjs");
-const sql_expression_1 = require("../../select/sql-expression.cjs");
-const table_proxy_1 = require("../../select/table-proxy.cjs");
-const fk_resolver_1 = require("../../utils/fk-resolver.cjs");
+const capability_guard_1 = require("../../core/helpers/capability-guard.cjs");
+const table_accessor_1 = require("../../core/shared/table-accessor.cjs");
+const sql_expression_1 = require("../select/sql-expression.cjs");
+const table_proxy_1 = require("../select/table-proxy.cjs");
+const fk_resolver_1 = require("../utils/fk-resolver.cjs");
+const relq_errors_1 = require("../../shared/errors/relq-errors.cjs");
+const pg_format_1 = __importDefault(require("../../shared/pg-format.cjs"));
 class ConnectedSelectBuilder {
     builder;
     relq;
     tableName;
-    columns;
     schemaKey;
-    constructor(builder, relq, tableName, columns, schemaKey) {
+    constructor(builder, relq, tableName, _columns, schemaKey) {
         this.builder = builder;
         this.relq = relq;
         this.tableName = tableName;
-        this.columns = columns;
         this.schemaKey = schemaKey;
         this.setupColumnResolver();
     }
+    get _sourceTableKey() {
+        return this.schemaKey || this.tableName;
+    }
     get joinCtx() {
         return { relq: this.relq, builder: this.builder, tableName: this.tableName, schemaKey: this.schemaKey };
     }
@@ -57,6 +64,24 @@ class ConnectedSelectBuilder {
             const transformed = { ...row };
             for (const join of joins) {
                 const alias = join.alias;
+                if (join.flat && join.selectColumns) {
+                    const capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+                    const prefix = join.flat.prefix || alias;
+                    const joinedTableDef = internal.getTableDef(join.schemaKey || alias) || internal.getTableDef(join.table);
+                    const tableColumns = joinedTableDef ? (joinedTableDef.$columns || joinedTableDef) : null;
+                    for (const col of join.selectColumns) {
+                        const flatKey = `${prefix}${capitalize(col.property)}`;
+                        if (transformed[flatKey] != null && tableColumns) {
+                            const colDef = tableColumns[col.property];
+                            const sqlType = colDef?.$sqlType || (typeof colDef?.$type === 'string' ? colDef.$type : undefined);
+                            if (sqlType) {
+                                transformed[flatKey] = this.coerceValue(transformed[flatKey], sqlType.toLowerCase());
+                            }
+                        }
+                    }
+                    delete transformed[alias];
+                    continue;
+                }
                 const nestedData = transformed[alias];
                 if (nestedData === null || nestedData === undefined) {
                     continue;
@@ -116,7 +141,21 @@ class ConnectedSelectBuilder {
                 return value;
         }
     }
-    where(callback) {
+    where(callbackOrCondition) {
+        if (callbackOrCondition instanceof condition_collector_1.ConditionCollector) {
+            const conditionTable = callbackOrCondition._tableName;
+            if (conditionTable) {
+                const matches = conditionTable === this.schemaKey || conditionTable === this.tableName;
+                if (!matches) {
+                    const queryTable = this.schemaKey || this.tableName;
+                    throw new relq_errors_1.RelqBuilderError(`Condition was created for table '${conditionTable}' but is being used on '${queryTable}'. ` +
+                        `Create the condition with db.where('${queryTable}') instead.`);
+                }
+            }
+            this.builder.where(callbackOrCondition);
+            return this;
+        }
+        const callback = callbackOrCondition;
         this.builder.where((q) => {
             q._tables = (0, table_accessor_1.createTableAccessor)(this.relq, this.relq.schema);
             return callback(q);
@@ -160,21 +199,73 @@ class ConnectedSelectBuilder {
         const agg = new sql_expression_1.AggregateFunctions();
         const internal = this.relq[methods_1.INTERNAL];
         const schema = internal.getSchema() || {};
+        const relations = internal.getRelations();
         const sourceSchemaKey = this.schemaKey || this.tableName;
         const sourceAlias = this.builder.getTableIdentifier();
+        const accessedTables = new Set();
         const tableProxies = new Proxy({}, {
             get(_, tableKey) {
                 if (typeof tableKey === 'symbol')
                     return undefined;
-                const tableDef = schema[tableKey];
-                const tableName = tableDef?.$name || tableKey;
-                const alias = tableKey === sourceSchemaKey ? sourceAlias : tableKey;
-                return (0, table_proxy_1.createTableProxy)(tableName, alias, tableDef);
+                const key = tableKey;
+                const tableDef = schema[key];
+                const tableName = tableDef?.$name || key;
+                if (key === sourceSchemaKey) {
+                    return (0, table_proxy_1.createTableProxy)(tableName, sourceAlias, tableDef);
+                }
+                accessedTables.add(key);
+                return (0, table_proxy_1.createTableProxy)(tableName, key, tableDef);
             }
         });
         const expressions = callback(agg, tableProxies);
+        const sourceExprs = [];
+        const externalExprs = new Map();
         for (const [alias, expr] of Object.entries(expressions)) {
-            this.builder.addIncludeExpression(alias, expr.sql);
+            let targetTable = null;
+            for (const tableKey of accessedTables) {
+                if (expr.sql.includes(`"${tableKey}".`)) {
+                    targetTable = tableKey;
+                    break;
+                }
+            }
+            if (targetTable) {
+                if (!externalExprs.has(targetTable)) {
+                    externalExprs.set(targetTable, []);
+                }
+                externalExprs.get(targetTable).push({ alias, sql: expr.sql });
+            }
+            else {
+                sourceExprs.push({ alias, sql: expr.sql });
+            }
+        }
+        for (const e of sourceExprs) {
+            this.builder.addIncludeExpression(e.alias, e.sql);
+        }
+        for (const [tableKey, exprs] of externalExprs) {
+            const tableDef = schema[tableKey];
+            const sqlTableName = tableDef?.$name || tableKey;
+            const existingJoins = this.builder.getStructuredJoins();
+            const alreadyJoined = existingJoins.some(j => j.table === sqlTableName || j.schemaKey === tableKey || j.alias === tableKey);
+            if (alreadyJoined) {
+                for (const e of exprs) {
+                    this.builder.addIncludeExpression(e.alias, e.sql);
+                }
+                continue;
+            }
+            const fk = (0, fk_resolver_1.resolveForeignKey)(relations, schema, sourceSchemaKey, tableKey);
+            if (!fk) {
+                throw new relq_errors_1.RelqBuilderError(`include() references table "${tableKey}" but no foreign key relationship exists between "${sourceSchemaKey}" and "${tableKey}". Define the relationship in your relations config.`, { builder: 'include', hint: `Add a relation from "${sourceSchemaKey}" to "${tableKey}" in pgRelations().` });
+            }
+            const lateralAlias = `${tableKey}_agg`;
+            const innerSelects = exprs.map(e => {
+                const unqualifiedSql = e.sql.replace(new RegExp(`"${tableKey}"\\.`, 'g'), '');
+                return `${unqualifiedSql} AS ${pg_format_1.default.ident(e.alias)}`;
+            }).join(', ');
+            const lateralSql = `LEFT JOIN LATERAL (SELECT ${innerSelects} FROM ${pg_format_1.default.ident(sqlTableName)} WHERE ${pg_format_1.default.ident(fk.toColumn)} = ${pg_format_1.default.ident(sourceAlias)}.${pg_format_1.default.ident(fk.fromColumn)}) AS ${pg_format_1.default.ident(lateralAlias)} ON true`;
+            this.builder.addRawJoin(lateralSql);
+            for (const e of exprs) {
+                this.builder.addIncludeExpression(e.alias, `(ARRAY_AGG(${pg_format_1.default.ident(lateralAlias)}.${pg_format_1.default.ident(e.alias)}))[1]`);
+            }
         }
         return this;
     }
@@ -194,6 +285,15 @@ class ConnectedSelectBuilder {
         (0, select_joins_1.executeTypeSafeJoin)(this.joinCtx, 'INNER JOIN', tableOrAlias, callback);
         return this;
     }
+    crossJoin(tableOrAlias) {
+        const [tableKey, alias] = Array.isArray(tableOrAlias) ? tableOrAlias : [tableOrAlias, tableOrAlias];
+        const internal = this.relq[methods_1.INTERNAL];
+        const tableDef = internal.getTableDef(tableKey);
+        const tableSqlName = tableDef?.$name || tableKey;
+        this.builder.crossJoin(tableSqlName);
+        this.builder.addStructuredJoin({ table: tableSqlName, alias, type: 'CROSS JOIN', schemaKey: tableKey });
+        return this;
+    }
     joinSubquery(alias, subquery, onClause) {
         const subquerySQL = typeof subquery === 'string' ? subquery : subquery.toString();
         this.builder.addRawJoin(`JOIN (${subquerySQL}) AS "${alias}" ON ${onClause}`);
@@ -238,14 +338,12 @@ class ConnectedSelectBuilder {
         const schema = internal.getSchema();
         const relations = internal.getRelations();
         if (!schema || !relations) {
-            throw new Error(`Cannot use .withMany('${table}') without schema and relations config. ` +
-                `Use .leftJoinMany() with an explicit callback instead.`);
+            throw new relq_errors_1.RelqBuilderError(`Cannot use .withMany('${table}') without schema and relations config. Pass relations when creating Relq: new Relq(schema, dialect, { relations }).`, { builder: 'withMany', hint: `Use .leftJoinMany() with an explicit callback instead.` });
         }
         const sourceKey = this.schemaKey || this.tableName;
         const fk = (0, fk_resolver_1.resolveForeignKey)(relations, schema, sourceKey, table);
         if (!fk) {
-            throw new Error(`No FK relationship found between "${sourceKey}" and "${table}". ` +
-                `Use .leftJoinMany() with explicit join conditions instead.`);
+            throw new relq_errors_1.RelqBuilderError(`No foreign key relationship found between "${sourceKey}" and "${table}". Define the relationship in your relations config.`, { builder: 'withMany', hint: `Use .leftJoinMany() with explicit join conditions instead.` });
         }
         (0, select_joins_1.executeTypeSafeJoinMany)(this.joinCtx, 'LEFT JOIN', table, (on, right, left) => {
             const rightCol = right[fk.toColumn];
@@ -288,6 +386,10 @@ class ConnectedSelectBuilder {
         this.builder.forUpdateSkipLocked();
         return this;
     }
+    forUpdateNoWait() {
+        this.builder.forUpdateNoWait();
+        return this;
+    }
     forShare() {
         this.builder.forShare();
         return this;
@@ -314,12 +416,6 @@ class ConnectedSelectBuilder {
         }
         return transformedData;
     }
-    async value(column) {
-        this.builder.limit(1);
-        const sql = this.builder.toString();
-        const result = await this.relq[methods_1.INTERNAL].executeSelectOne(sql, this.tableName);
-        return result.data?.[column] ?? null;
-    }
     async each(callback, options = {}) {
         (0, capability_guard_1.requireCapability)(this.relq, 'cursors', 'Cursor-based iteration (each)', 'Use pagination() instead of each() for row-by-row processing');
         return (0, select_pagination_1.executeCursorEach)(this.paginationCtx, callback, options);

package/dist/cjs/{core → pg}/helpers/ConnectedTransactionBuilder.cjs

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransactionClient = void 0;
 exports.executeTransaction = executeTransaction;
 const ConnectedRawQueryBuilder_1 = require("./ConnectedRawQueryBuilder.cjs");
-const table_accessor_1 = require("../shared/table-accessor.cjs");
-const methods_1 = require("./methods.cjs");
+const table_accessor_1 = require("../../core/shared/table-accessor.cjs");
+const methods_1 = require("../../core/helpers/methods.cjs");
 class TransactionClient {
     client;
     relq;
@@ -23,6 +23,15 @@ class TransactionClient {
     raw(query, ...params) {
         return new ConnectedRawQueryBuilder_1.ConnectedRawQueryBuilder(query, params, this);
     }
+    async savepoint(name) {
+        await this.client.query(`SAVEPOINT "${name}"`);
+    }
+    async rollbackTo(name) {
+        await this.client.query(`ROLLBACK TO SAVEPOINT "${name}"`);
+    }
+    async releaseSavepoint(name) {
+        await this.client.query(`RELEASE SAVEPOINT "${name}"`);
+    }
     get [methods_1.INTERNAL]() {
         const parentInternal = this.relq[methods_1.INTERNAL];
         const queryViaClient = async (sql) => {
@@ -70,6 +79,7 @@ class TransactionClient {
                 return { success: true, metadata: buildMetadata(result, duration) };
             },
             transformToDbColumns: parentInternal.transformToDbColumns,
+            executeRawQuery: queryViaClient,
             transformFromDbColumns: parentInternal.transformFromDbColumns,
             transformResultsFromDb: parentInternal.transformResultsFromDb,
             hasColumnMapping: parentInternal.hasColumnMapping,
@@ -82,11 +92,31 @@ class TransactionClient {
     }
 }
 exports.TransactionClient = TransactionClient;
-async function executeTransaction(relq, callback) {
+async function executeTransaction(relq, callback, options) {
     await relq.ensureInitialized();
     const { client, release } = await relq[methods_1.INTERNAL].getClientForCursor();
     try {
-        await client.query('BEGIN');
+        let beginSql = 'BEGIN';
+        const parts = [];
+        if (options?.isolation) {
+            parts.push(`ISOLATION LEVEL ${options.isolation}`);
+        }
+        if (options?.readOnly === true) {
+            parts.push('READ ONLY');
+        }
+        else if (options?.readOnly === false) {
+            parts.push('READ WRITE');
+        }
+        if (options?.deferrable === true) {
+            parts.push('DEFERRABLE');
+        }
+        else if (options?.deferrable === false) {
+            parts.push('NOT DEFERRABLE');
+        }
+        if (parts.length > 0) {
+            beginSql += ' ' + parts.join(' ');
+        }
+        await client.query(beginSql);
         const tx = new TransactionClient(client, relq);
         const result = await callback(tx);
         await client.query('COMMIT');

package/dist/cjs/{core → pg}/helpers/ConnectedUpdateBuilder.cjs

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConnectedUpdateBuilder = void 0;
-const methods_1 = require("./methods.cjs");
+const condition_collector_1 = require("../condition/condition-collector.cjs");
+const methods_1 = require("../../core/helpers/methods.cjs");
 const ReturningExecutor_1 = require("./ReturningExecutor.cjs");
-const capability_guard_1 = require("./capability-guard.cjs");
-const table_accessor_1 = require("../shared/table-accessor.cjs");
+const capability_guard_1 = require("../../core/helpers/capability-guard.cjs");
+const table_accessor_1 = require("../../core/shared/table-accessor.cjs");
+const relq_errors_1 = require("../../shared/errors/relq-errors.cjs");
 class ConnectedUpdateBuilder {
     builder;
     relq;
@@ -48,7 +50,21 @@ class ConnectedUpdateBuilder {
             return { type: baseType, isArray };
         });
     }
-    where(callback) {
+    where(callbackOrCondition) {
+        if (callbackOrCondition instanceof condition_collector_1.ConditionCollector) {
+            const conditionTable = callbackOrCondition._tableName;
+            if (conditionTable) {
+                const matches = conditionTable === this.schemaKey || conditionTable === this.tableName;
+                if (!matches) {
+                    const queryTable = this.schemaKey || this.tableName;
+                    throw new relq_errors_1.RelqBuilderError(`Condition was created for table '${conditionTable}' but is being used on '${queryTable}'. ` +
+                        `Create the condition with db.where('${queryTable}') instead.`);
+                }
+            }
+            this.builder.where(callbackOrCondition);
+            return this;
+        }
+        const callback = callbackOrCondition;
         this.builder.where((q) => {
             q._tables = (0, table_accessor_1.createTableAccessor)(this.relq, this.relq.schema);
             return callback(q);
@@ -67,9 +83,13 @@ class ConnectedUpdateBuilder {
         }
         return result.metadata.rowCount ?? 0;
     }
-    returning(columns) {
-        if (columns === null) {
-            return this;
+    returning(...args) {
+        let columns;
+        if (args.length === 1) {
+            columns = args[0];
+        }
+        else {
+            columns = args;
         }
         (0, capability_guard_1.requireCapability)(this.relq, 'returning', 'RETURNING clause', 'Use a SELECT query after the UPDATE to retrieve modified data');
         this.builder.returning(columns);

package/dist/cjs/{core → pg}/helpers/PaginateBuilder.cjs

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PaginateBuilder = void 0;
-const count_builder_1 = require("../../count/count-builder.cjs");
+const count_builder_1 = require("../count/count-builder.cjs");
 const relq_errors_1 = require("../../shared/errors/relq-errors.cjs");
-const select_builder_1 = require("../../select/select-builder.cjs");
-const methods_1 = require("./methods.cjs");
+const select_builder_1 = require("../select/select-builder.cjs");
+const methods_1 = require("../../core/helpers/methods.cjs");
 class PaginateBuilder {
     relq;
     tableName;

package/dist/cjs/{core → pg}/helpers/ReturningExecutor.cjs

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReturningExecutor = void 0;
-const insert_builder_1 = require("../../insert/insert-builder.cjs");
-const update_builder_1 = require("../../update/update-builder.cjs");
-const methods_1 = require("./methods.cjs");
+const insert_builder_1 = require("../insert/insert-builder.cjs");
+const update_builder_1 = require("../update/update-builder.cjs");
+const methods_1 = require("../../core/helpers/methods.cjs");
 class ReturningExecutor {
     builder;
     relq;