linkgress-orm 0.4.55 → 0.4.57

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,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) {
@@ -2697,9 +2697,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 +2720,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 +2770,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 +2858,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);