@relq/orm 0.1.3 → 0.1.4

package/dist/esm/{core → pg}/helpers/ConnectedDeleteBuilder.js

@@ -1,7 +1,9 @@
-import { INTERNAL } from "./methods.js";
+import { ConditionCollector } from "../condition/condition-collector.js";
+import { INTERNAL } from "../../core/helpers/methods.js";
 import { ReturningExecutor } from "./ReturningExecutor.js";
-import { requireCapability } from "./capability-guard.js";
-import { createTableAccessor } from "../shared/table-accessor.js";
+import { requireCapability } from "../../core/helpers/capability-guard.js";
+import { createTableAccessor } from "../../core/shared/table-accessor.js";
+import { RelqBuilderError } from "../../shared/errors/relq-errors.js";
 export class ConnectedDeleteBuilder {
     builder;
     relq;
@@ -32,7 +34,21 @@ export class ConnectedDeleteBuilder {
             return column;
         });
     }
-    where(callback) {
+    where(callbackOrCondition) {
+        if (callbackOrCondition instanceof 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 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 = createTableAccessor(this.relq, this.relq.schema);
             return callback(q);
@@ -50,9 +66,13 @@ export 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;
         }
         requireCapability(this.relq, 'returning', 'RETURNING clause', 'Use a SELECT query after the DELETE to retrieve deleted data');
         this.builder.returning(columns);

package/dist/esm/{core → pg}/helpers/ConnectedInsertBuilder.js

@@ -1,7 +1,7 @@
-import { ConditionCollector, buildConditionsSQL } from "../../condition/condition-collector.js";
-import { debugLog, INTERNAL } from "./methods.js";
+import { ConditionCollector, buildConditionsSQL } from "../condition/condition-collector.js";
+import { debugLog, INTERNAL } from "../../core/helpers/methods.js";
 import { ReturningExecutor } from "./ReturningExecutor.js";
-import { requireCapability } from "./capability-guard.js";
+import { requireCapability } from "../../core/helpers/capability-guard.js";
 export class ConnectedInsertBuilder {
     builder;
     relq;
@@ -87,8 +87,12 @@ export class ConnectedInsertBuilder {
     async run(withMetadata) {
         debugLog(this.relq[INTERNAL]?.config, `ConnectedInsertBuilder.run called for table: ${this.builder.tableName}`);
         const internalRelq = this.relq[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);
@@ -97,9 +101,13 @@ export 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;
         }
         requireCapability(this.relq, 'returning', 'RETURNING clause', 'Use a SELECT query after the INSERT to retrieve inserted data');
         this.builder.returning(columns);

package/dist/esm/{core → pg}/helpers/ConnectedInsertFromSelectBuilder.js

@@ -1,6 +1,6 @@
-import { debugLog, INTERNAL } from "./methods.js";
+import { debugLog, INTERNAL } from "../../core/helpers/methods.js";
 import { ReturningExecutor } from "./ReturningExecutor.js";
-import { requireCapability } from "./capability-guard.js";
+import { requireCapability } from "../../core/helpers/capability-guard.js";
 export class ConnectedInsertFromSelectBuilder {
     builder;
     relq;
@@ -51,9 +51,13 @@ export 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;
         }
         requireCapability(this.relq, 'returning', 'RETURNING clause', 'Use a SELECT query after the INSERT to retrieve inserted data');
         this.builder.returning(columns);

package/dist/esm/{core → pg}/helpers/ConnectedQueryBuilder.js

@@ -1,10 +1,10 @@
-import { CountBuilder } from "../../count/count-builder.js";
-import { DeleteBuilder } from "../../delete/delete-builder.js";
-import { InsertBuilder } from "../../insert/insert-builder.js";
-import { InsertFromSelectBuilder } from "../../insert/insert-from-select-builder.js";
-import { AggregateQueryBuilder } from "../../select/aggregate-builder.js";
-import { SelectBuilder } from "../../select/select-builder.js";
-import { UpdateBuilder } from "../../update/update-builder.js";
+import { CountBuilder } from "../count/count-builder.js";
+import { DeleteBuilder } from "../delete/delete-builder.js";
+import { InsertBuilder } from "../insert/insert-builder.js";
+import { InsertFromSelectBuilder } from "../insert/insert-from-select-builder.js";
+import { AggregateQueryBuilder } from "../select/aggregate-builder.js";
+import { SelectBuilder } from "../select/select-builder.js";
+import { UpdateBuilder } from "../update/update-builder.js";
 import { ConnectedAggregateBuilder } from "./ConnectedAggregateBuilder.js";
 import { ConnectedCountBuilder } from "./ConnectedCountBuilder.js";
 import { ConnectedDeleteBuilder } from "./ConnectedDeleteBuilder.js";
@@ -12,10 +12,11 @@ import { ConnectedInsertBuilder } from "./ConnectedInsertBuilder.js";
 import { ConnectedInsertFromSelectBuilder } from "./ConnectedInsertFromSelectBuilder.js";
 import { ConnectedSelectBuilder } from "./ConnectedSelectBuilder.js";
 import { ConnectedUpdateBuilder } from "./ConnectedUpdateBuilder.js";
-import { INTERNAL } from "./methods.js";
+import { INTERNAL } from "../../core/helpers/methods.js";
 import { PaginateBuilder } from "./PaginateBuilder.js";
-import { createTableAccessor } from "../shared/table-accessor.js";
-import { executeFindById, executeFindOne, executeFindMany, executeExists, executeUpsert, executeCreateWith, executeSoftDelete, executeRestore, getPrimaryKeyColumn } from "./query-convenience.js";
+import { createTableAccessor } from "../../core/shared/table-accessor.js";
+import { RelqBuilderError } from "../../shared/errors/relq-errors.js";
+import { executeFindById, executeFindOne, executeFindMany, executeExists, executeUpsert, executeCreateWith, getPrimaryKeyColumn } from "./query-convenience.js";
 export class ConnectedQueryBuilder {
     tableName;
     relq;
@@ -42,12 +43,12 @@ export 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 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 RelqBuilderError(`Invalid column name: "${columns}"`, { builder: 'select', hint: 'Use .select() without arguments for SELECT *, or pass valid column names' });
                 }
             }
         }
@@ -81,8 +82,8 @@ export class ConnectedQueryBuilder {
             return new ConnectedInsertBuilder(builder, this.relq, this.tableName, this.schemaKey);
         }
         const builder = new 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(builder, this.relq, this.tableName, this.schemaKey);
     }
@@ -133,10 +134,4 @@ export class ConnectedQueryBuilder {
     async createWith(options) {
         return executeCreateWith(this.ctx, options.data, options.with);
     }
-    async softDelete(filter) {
-        return executeSoftDelete(this.ctx, filter);
-    }
-    async restore(filter) {
-        return executeRestore(this.ctx, filter);
-    }
 }

package/dist/esm/pg/helpers/ConnectedRawQueryBuilder.js

@@ -0,0 +1,63 @@
+import { RawQueryBuilder } from "../raw/index.js";
+import { INTERNAL } from "../../core/helpers/methods.js";
+export class ConnectedRawQueryBuilder {
+    params;
+    relq;
+    builder;
+    constructor(query, params, relq) {
+        this.params = params;
+        this.relq = relq;
+        const convertedQuery = this.convertPlaceholders(query);
+        this.builder = new 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[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[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[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[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[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 },
+        };
+    }
+}

package/dist/esm/{core → pg}/helpers/ConnectedSelectBuilder.js

@@ -1,25 +1,29 @@
-import { INTERNAL } from "./methods.js";
+import { ConditionCollector } from "../condition/condition-collector.js";
+import { INTERNAL } from "../../core/helpers/methods.js";
 import { executeTypeSafeJoin, executeTypeSafeJoinMany, executeTypeSafeJoinManyThrough } from "./select-joins.js";
 import { executeCursorEach, executePagination } from "./select-pagination.js";
-import { requireCapability } from "./capability-guard.js";
-import { createTableAccessor } from "../shared/table-accessor.js";
-import { AggregateFunctions } from "../../select/sql-expression.js";
-import { createTableProxy } from "../../select/table-proxy.js";
-import { resolveForeignKey } from "../../utils/fk-resolver.js";
+import { requireCapability } from "../../core/helpers/capability-guard.js";
+import { createTableAccessor } from "../../core/shared/table-accessor.js";
+import { AggregateFunctions } from "../select/sql-expression.js";
+import { createTableProxy } from "../select/table-proxy.js";
+import { resolveForeignKey } from "../utils/fk-resolver.js";
+import { RelqBuilderError } from "../../shared/errors/relq-errors.js";
+import format from "../../shared/pg-format.js";
 export 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 };
     }
@@ -54,6 +58,24 @@ export 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;
@@ -113,7 +135,21 @@ export class ConnectedSelectBuilder {
                 return value;
         }
     }
-    where(callback) {
+    where(callbackOrCondition) {
+        if (callbackOrCondition instanceof 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 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 = createTableAccessor(this.relq, this.relq.schema);
             return callback(q);
@@ -157,21 +193,73 @@ export class ConnectedSelectBuilder {
         const agg = new AggregateFunctions();
         const internal = this.relq[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 createTableProxy(tableName, alias, tableDef);
+                const key = tableKey;
+                const tableDef = schema[key];
+                const tableName = tableDef?.$name || key;
+                if (key === sourceSchemaKey) {
+                    return createTableProxy(tableName, sourceAlias, tableDef);
+                }
+                accessedTables.add(key);
+                return 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 = resolveForeignKey(relations, schema, sourceSchemaKey, tableKey);
+            if (!fk) {
+                throw new 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 ${format.ident(e.alias)}`;
+            }).join(', ');
+            const lateralSql = `LEFT JOIN LATERAL (SELECT ${innerSelects} FROM ${format.ident(sqlTableName)} WHERE ${format.ident(fk.toColumn)} = ${format.ident(sourceAlias)}.${format.ident(fk.fromColumn)}) AS ${format.ident(lateralAlias)} ON true`;
+            this.builder.addRawJoin(lateralSql);
+            for (const e of exprs) {
+                this.builder.addIncludeExpression(e.alias, `(ARRAY_AGG(${format.ident(lateralAlias)}.${format.ident(e.alias)}))[1]`);
+            }
         }
         return this;
     }
@@ -191,6 +279,15 @@ export class ConnectedSelectBuilder {
         executeTypeSafeJoin(this.joinCtx, 'INNER JOIN', tableOrAlias, callback);
         return this;
     }
+    crossJoin(tableOrAlias) {
+        const [tableKey, alias] = Array.isArray(tableOrAlias) ? tableOrAlias : [tableOrAlias, tableOrAlias];
+        const internal = this.relq[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}`);
@@ -235,14 +332,12 @@ export 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 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 = 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 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.` });
         }
         executeTypeSafeJoinMany(this.joinCtx, 'LEFT JOIN', table, (on, right, left) => {
             const rightCol = right[fk.toColumn];
@@ -285,6 +380,10 @@ export class ConnectedSelectBuilder {
         this.builder.forUpdateSkipLocked();
         return this;
     }
+    forUpdateNoWait() {
+        this.builder.forUpdateNoWait();
+        return this;
+    }
     forShare() {
         this.builder.forShare();
         return this;
@@ -311,12 +410,6 @@ export class ConnectedSelectBuilder {
         }
         return transformedData;
     }
-    async value(column) {
-        this.builder.limit(1);
-        const sql = this.builder.toString();
-        const result = await this.relq[INTERNAL].executeSelectOne(sql, this.tableName);
-        return result.data?.[column] ?? null;
-    }
     async each(callback, options = {}) {
         requireCapability(this.relq, 'cursors', 'Cursor-based iteration (each)', 'Use pagination() instead of each() for row-by-row processing');
         return executeCursorEach(this.paginationCtx, callback, options);

package/dist/esm/{core → pg}/helpers/ConnectedTransactionBuilder.js

@@ -1,6 +1,6 @@
 import { ConnectedRawQueryBuilder } from "./ConnectedRawQueryBuilder.js";
-import { createTableAccessor } from "../shared/table-accessor.js";
-import { INTERNAL } from "./methods.js";
+import { createTableAccessor } from "../../core/shared/table-accessor.js";
+import { INTERNAL } from "../../core/helpers/methods.js";
 export class TransactionClient {
     client;
     relq;
@@ -19,6 +19,15 @@ export class TransactionClient {
     raw(query, ...params) {
         return new 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 [INTERNAL]() {
         const parentInternal = this.relq[INTERNAL];
         const queryViaClient = async (sql) => {
@@ -66,6 +75,7 @@ export class TransactionClient {
                 return { success: true, metadata: buildMetadata(result, duration) };
             },
             transformToDbColumns: parentInternal.transformToDbColumns,
+            executeRawQuery: queryViaClient,
             transformFromDbColumns: parentInternal.transformFromDbColumns,
             transformResultsFromDb: parentInternal.transformResultsFromDb,
             hasColumnMapping: parentInternal.hasColumnMapping,
@@ -77,11 +87,31 @@ export class TransactionClient {
         };
     }
 }
-export async function executeTransaction(relq, callback) {
+export async function executeTransaction(relq, callback, options) {
     await relq.ensureInitialized();
     const { client, release } = await relq[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/esm/{core → pg}/helpers/ConnectedUpdateBuilder.js

@@ -1,7 +1,9 @@
-import { INTERNAL } from "./methods.js";
+import { ConditionCollector } from "../condition/condition-collector.js";
+import { INTERNAL } from "../../core/helpers/methods.js";
 import { ReturningExecutor } from "./ReturningExecutor.js";
-import { requireCapability } from "./capability-guard.js";
-import { createTableAccessor } from "../shared/table-accessor.js";
+import { requireCapability } from "../../core/helpers/capability-guard.js";
+import { createTableAccessor } from "../../core/shared/table-accessor.js";
+import { RelqBuilderError } from "../../shared/errors/relq-errors.js";
 export class ConnectedUpdateBuilder {
     builder;
     relq;
@@ -45,7 +47,21 @@ export class ConnectedUpdateBuilder {
             return { type: baseType, isArray };
         });
     }
-    where(callback) {
+    where(callbackOrCondition) {
+        if (callbackOrCondition instanceof 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 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 = createTableAccessor(this.relq, this.relq.schema);
             return callback(q);
@@ -64,9 +80,13 @@ export 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;
         }
         requireCapability(this.relq, 'returning', 'RETURNING clause', 'Use a SELECT query after the UPDATE to retrieve modified data');
         this.builder.returning(columns);

package/dist/esm/{core → pg}/helpers/PaginateBuilder.js

@@ -1,7 +1,7 @@
-import { CountBuilder } from "../../count/count-builder.js";
+import { CountBuilder } from "../count/count-builder.js";
 import { RelqQueryError } from "../../shared/errors/relq-errors.js";
-import { SelectBuilder } from "../../select/select-builder.js";
-import { INTERNAL } from "./methods.js";
+import { SelectBuilder } from "../select/select-builder.js";
+import { INTERNAL } from "../../core/helpers/methods.js";
 export class PaginateBuilder {
     relq;
     tableName;

package/dist/esm/{core → pg}/helpers/ReturningExecutor.js

@@ -1,6 +1,6 @@
-import { InsertBuilder } from "../../insert/insert-builder.js";
-import { UpdateBuilder } from "../../update/update-builder.js";
-import { INTERNAL } from "./methods.js";
+import { InsertBuilder } from "../insert/insert-builder.js";
+import { UpdateBuilder } from "../update/update-builder.js";
+import { INTERNAL } from "../../core/helpers/methods.js";
 export class ReturningExecutor {
     builder;
     relq;