linkgress-orm 0.4.56 → 0.4.58

package/dist/query/query-builder.js

@@ -2491,7 +2491,7 @@ class SelectQueryBuilder {
             // Qualify columns with table name when using USING clause to avoid ambiguity
             const hasJoins = whereJoins.length > 0;
             const returningClause = returning !== 'count'
-                ? queryBuilder.buildUpdateDeleteReturningClause(returning, hasJoins)
+                ? queryBuilder.buildUpdateDeleteReturningClause(returning, hasJoins, { paramCounter: whereParams.length + 1, params: whereParams })
                 : undefined;
             let sql = `DELETE FROM ${qualifiedTableName}`;
             if (usingClause) {
@@ -2511,7 +2511,7 @@ class SelectQueryBuilder {
             if (!returningClause) {
                 return undefined;
             }
-            return queryBuilder.mapDeleteReturningResults(result.rows, returning);
+            return queryBuilder.mapDeleteReturningResults(result.rows, returning, returningClause.fragmentMappers);
         };
         return {
             then(onfulfilled, onrejected) {
@@ -2650,7 +2650,7 @@ class SelectQueryBuilder {
             // Qualify columns with table name when using FROM clause to avoid ambiguity
             const hasJoins = whereJoins.length > 0;
             const returningClause = returning !== 'count'
-                ? queryBuilder.buildUpdateDeleteReturningClause(returning, hasJoins)
+                ? queryBuilder.buildUpdateDeleteReturningClause(returning, hasJoins, { paramCounter: values.length + 1, params: values })
                 : undefined;
             let sql = `UPDATE ${qualifiedTableName} SET ${setClauses.join(', ')}`;
             if (fromClause) {
@@ -2670,7 +2670,77 @@ class SelectQueryBuilder {
             if (!returningClause) {
                 return undefined;
             }
-            return queryBuilder.mapDeleteReturningResults(result.rows, returning);
+            return queryBuilder.mapDeleteReturningResults(result.rows, returning, returningClause.fragmentMappers);
+        };
+        /**
+         * Compile the UPDATE into `{ sql, params }` WITHOUT executing — the
+         * standard-path assembly (same SET/WHERE/FROM semantics as execution,
+         * SqlFragment values and fragment-capable RETURNING included; navigation
+         * RETURNING is not supported here). Used to ride the statement as a
+         * data-modifying CTE (`DbCteBuilder.withMutation`).
+         */
+        const compileUpdate = (returning) => {
+            if (!queryBuilder.whereCond) {
+                throw new Error('Update requires a WHERE condition. Use where() before update().');
+            }
+            const whereJoins = [];
+            queryBuilder.detectAndAddJoinsFromCondition(queryBuilder.whereCond, whereJoins);
+            const resolvedData = typeof data === 'function'
+                ? data(queryBuilder._createMockRow())
+                : data;
+            const setClauses = [];
+            const values = [];
+            let paramIndex = 1;
+            for (const [key, value] of Object.entries(resolvedData)) {
+                const column = queryBuilder.schema.columns[key];
+                if (column) {
+                    const config = column.build();
+                    if (value instanceof conditions_1.SqlFragment) {
+                        const sqlBuildContext = {
+                            paramCounter: paramIndex,
+                            params: values,
+                        };
+                        const fragmentSql = value.buildSql(sqlBuildContext);
+                        paramIndex = sqlBuildContext.paramCounter;
+                        setClauses.push(`"${config.name}" = ${fragmentSql}`);
+                        continue;
+                    }
+                    setClauses.push(`"${config.name}" = $${paramIndex++}`);
+                    values.push(config.mapper ? config.mapper.toDriver(value) : value);
+                }
+            }
+            if (setClauses.length === 0) {
+                throw new Error('No valid columns to update');
+            }
+            const condBuilder = new conditions_1.ConditionBuilder();
+            const { sql: whereSql, params: whereParams } = condBuilder.build(queryBuilder.whereCond, paramIndex);
+            values.push(...whereParams);
+            const qualifiedTableName = queryBuilder.getQualifiedTableName(queryBuilder.schema.name, queryBuilder.schema.schema);
+            let fromClause = '';
+            const joinConditions = [];
+            for (const join of whereJoins) {
+                const sourceTable = join.sourceAlias || queryBuilder.schema.name;
+                const joinTableName = queryBuilder.getQualifiedTableName(join.targetTable, join.targetSchema);
+                fromClause = fromClause ? `${fromClause}, ${joinTableName} AS "${join.alias}"` : `FROM ${joinTableName} AS "${join.alias}"`;
+                for (let i = 0; i < join.foreignKeys.length; i++) {
+                    joinConditions.push(`${(0, join_utils_1.formatJoinValue)(sourceTable, join.foreignKeys[i])} = ${(0, join_utils_1.formatJoinValue)(join.alias, join.matches[i])}`);
+                }
+            }
+            const fullWhereClause = joinConditions.length > 0
+                ? `${joinConditions.join(' AND ')} AND ${whereSql}`
+                : whereSql;
+            const returningClause = returning != null
+                ? queryBuilder.buildUpdateDeleteReturningClause(returning, whereJoins.length > 0, { paramCounter: values.length + 1, params: values })
+                : null;
+            let sql = `UPDATE ${qualifiedTableName} SET ${setClauses.join(', ')}`;
+            if (fromClause) {
+                sql += ` ${fromClause}`;
+            }
+            sql += ` WHERE ${fullWhereClause}`;
+            if (returningClause) {
+                sql += ` RETURNING ${returningClause.sql}`;
+            }
+            return { sql, params: values };
         };
         return {
             then(onfulfilled, onrejected) {
@@ -2683,6 +2753,9 @@ class SelectQueryBuilder {
                     }
                 };
             },
+            toStatement(selector) {
+                return compileUpdate(selector);
+            },
             returning(selector) {
                 const returningConfig = selector ?? true;
                 return {
@@ -2697,9 +2770,12 @@ class SelectQueryBuilder {
      * Build RETURNING clause for delete/update operations
      * @param returning - The returning configuration
      * @param qualifyWithTable - If true, qualify column names with the main table name (needed for DELETE with USING)
+     * @param paramContext - Statement parameter state (params array + next $n). Required when the
+     *                       selector contains SqlFragments — their parameters append here, which is
+     *                       positionally correct because RETURNING is last in the statement text.
      * @internal
      */
-    buildUpdateDeleteReturningClause(returning, qualifyWithTable = false) {
+    buildUpdateDeleteReturningClause(returning, qualifyWithTable = false, paramContext) {
         if (returning === undefined) {
             return null;
         }
@@ -2717,22 +2793,39 @@ class SelectQueryBuilder {
         if (typeof selection === 'object' && selection !== null) {
             const columns = [];
             const sqlParts = [];
+            let fragmentMappers;
             for (const [alias, field] of Object.entries(selection)) {
-                if (field && typeof field === 'object' && '__dbColumnName' in field) {
+                if (field instanceof conditions_1.SqlFragment) {
+                    // Raw fragment under its selector key (the key is the alias — a
+                    // fragment-side .as() is ignored here). Params append to the
+                    // statement's array; headline use case: PG18 `old."col"` capture.
+                    if (!paramContext) {
+                        throw new Error(`Returning selector field "${alias}" is a SqlFragment, which this mutation path does not support`);
+                    }
+                    const fragmentSql = field.buildSql(paramContext);
+                    columns.push(alias);
+                    sqlParts.push(`${fragmentSql} AS "${alias}"`);
+                    fragmentMappers = fragmentMappers ?? new Map();
+                    fragmentMappers.set(alias, field.getMapper());
+                }
+                else if (field && typeof field === 'object' && '__dbColumnName' in field) {
                     const dbName = field.__dbColumnName;
                     columns.push(alias);
                     sqlParts.push(`${tablePrefix}"${dbName}" AS "${alias}"`);
                 }
             }
-            return { sql: sqlParts.join(', '), columns };
+            return { sql: sqlParts.join(', '), columns, fragmentMappers };
         }
         return null;
     }
     /**
      * Map row results for delete/update RETURNING clause
+     * @param fragmentMappers - Per-alias mapWith mappers for SqlFragment selector fields; a
+     *                          fragment alias bypasses the schema-column mapper scan entirely
+     *                          (its value is the fragment's, not any column's).
      * @internal
      */
-    mapDeleteReturningResults(rows, returning) {
+    mapDeleteReturningResults(rows, returning, fragmentMappers) {
         if (returning === true) {
             // Full entity mapping - apply fromDriver mappers
             return rows.map(row => {
@@ -2750,6 +2843,11 @@ class SelectQueryBuilder {
         return rows.map(row => {
             const mapped = {};
             for (const [key, value] of Object.entries(row)) {
+                if (fragmentMappers?.has(key)) {
+                    const fragmentMapper = fragmentMappers.get(key);
+                    mapped[key] = fragmentMapper?.fromDriver ? fragmentMapper.fromDriver(value) : value;
+                    continue;
+                }
                 // Try to find column by alias or name
                 const colEntry = Object.entries(this.schema.columns).find(([propName, col]) => {
                     const config = col.build();
@@ -2833,6 +2931,13 @@ class SelectQueryBuilder {
                             allTableAliases.add(collectionBuilder.sourceTable);
                         }
                     }
+                    else if (field instanceof conditions_1.SqlFragment) {
+                        // Raw SQL fragment — rendered verbatim by the plain returning-clause
+                        // builder; it never implies navigation. Without this skip it would
+                        // fall into the nested-object branch and derail the whole selector
+                        // onto the CTE navigation path. (v1: FieldRefs inside returning
+                        // fragments are unsupported — reference columns as raw quoted SQL.)
+                    }
                     else if (!Array.isArray(field)) {
                         // Nested plain object - recurse into it
                         nestedObjects.set(fieldPath, field);