linkgress-orm 0.2.6 → 0.2.7

package/dist/query/query-builder.js

@@ -1847,6 +1847,9 @@ class SelectQueryBuilder {
             if (!queryBuilder.whereCond) {
                 throw new Error('Update requires a WHERE condition. Use where() before update().');
             }
+            // Detect navigation property joins from WHERE condition
+            const whereJoins = [];
+            queryBuilder.detectAndAddJoinsFromCondition(queryBuilder.whereCond, whereJoins);
             // Build SET clause
             const setClauses = [];
             const values = [];
@@ -1870,13 +1873,40 @@ class SelectQueryBuilder {
             const { sql: whereSql, params: whereParams } = condBuilder.build(queryBuilder.whereCond, paramIndex);
             values.push(...whereParams);
             const qualifiedTableName = queryBuilder.getQualifiedTableName(queryBuilder.schema.name, queryBuilder.schema.schema);
+            // Build FROM clause for navigation properties (PostgreSQL syntax for UPDATE with JOINs)
+            let fromClause = '';
+            let joinConditions = [];
+            for (const join of whereJoins) {
+                const sourceTable = join.sourceAlias || queryBuilder.schema.name;
+                const joinTableName = queryBuilder.getQualifiedTableName(join.targetTable, join.targetSchema);
+                if (fromClause) {
+                    fromClause += `, ${joinTableName} AS "${join.alias}"`;
+                }
+                else {
+                    fromClause = `FROM ${joinTableName} AS "${join.alias}"`;
+                }
+                // Build ON conditions as part of WHERE clause
+                for (let i = 0; i < join.foreignKeys.length; i++) {
+                    const fk = join.foreignKeys[i];
+                    const match = join.matches[i];
+                    joinConditions.push(`"${sourceTable}"."${fk}" = "${join.alias}"."${match}"`);
+                }
+            }
+            // Combine join conditions with the original WHERE clause
+            const fullWhereClause = joinConditions.length > 0
+                ? `${joinConditions.join(' AND ')} AND ${whereSql}`
+                : whereSql;
             // Check if RETURNING uses navigation properties
             const navigationInfo = returning && returning !== 'count' && returning !== true
                 ? queryBuilder.detectNavigationInReturning(returning)
                 : null;
             if (navigationInfo) {
                 // Use CTE-based approach for navigation properties in RETURNING
-                const updateSql = `UPDATE ${qualifiedTableName} SET ${setClauses.join(', ')} WHERE ${whereSql}`;
+                let updateSql = `UPDATE ${qualifiedTableName} SET ${setClauses.join(', ')}`;
+                if (fromClause) {
+                    updateSql += ` ${fromClause}`;
+                }
+                updateSql += ` WHERE ${fullWhereClause}`;
                 const { sql, params } = queryBuilder.buildReturningWithNavigation(updateSql, values, returning, navigationInfo);
                 const result = queryBuilder.executor
                     ? await queryBuilder.executor.query(sql, params)
@@ -1884,10 +1914,16 @@ class SelectQueryBuilder {
                 return queryBuilder.mapReturningResultsWithNavigation(result.rows, returning, navigationInfo.navigationFields);
             }
             // Standard RETURNING (no navigation properties)
+            // Qualify columns with table name when using FROM clause to avoid ambiguity
+            const hasJoins = whereJoins.length > 0;
             const returningClause = returning !== 'count'
-                ? queryBuilder.buildUpdateDeleteReturningClause(returning)
+                ? queryBuilder.buildUpdateDeleteReturningClause(returning, hasJoins)
                 : undefined;
-            let sql = `UPDATE ${qualifiedTableName} SET ${setClauses.join(', ')} WHERE ${whereSql}`;
+            let sql = `UPDATE ${qualifiedTableName} SET ${setClauses.join(', ')}`;
+            if (fromClause) {
+                sql += ` ${fromClause}`;
+            }
+            sql += ` WHERE ${fullWhereClause}`;
             if (returningClause) {
                 sql += ` RETURNING ${returningClause.sql}`;
             }
@@ -2060,6 +2096,21 @@ class SelectQueryBuilder {
         const mockRow = this._createMockRow();
         const selectedMock = this.selector(mockRow);
         const selection = returning(selectedMock);
+        // Helper to get FK db column name from a schema
+        const getFkDbColumnName = (sourceSchema, fkPropName) => {
+            const colEntry = Object.entries(sourceSchema.columns).find(([propName, _]) => propName === fkPropName);
+            if (colEntry) {
+                const config = colEntry[1].build();
+                return config.name;
+            }
+            return fkPropName; // Fallback to property name
+        };
+        // Build a map of alias -> source table name for FK lookups
+        const aliasToSourceTable = new Map();
+        aliasToSourceTable.set(this.schema.name, this.schema.name);
+        for (const join of navigationInfo.joins) {
+            aliasToSourceTable.set(join.alias, join.targetTable);
+        }
         // For each selected field, determine if it's from main table or navigation
         for (const [alias, field] of Object.entries(selection)) {
             if (field && typeof field === 'object' && '__dbColumnName' in field) {
@@ -2076,31 +2127,13 @@ class SelectQueryBuilder {
                 }
             }
         }
-        // We also need to include foreign keys for joins that aren't already in the selection
+        // Include foreign keys needed for joins - only for joins from main table
         for (const join of navigationInfo.joins) {
-            for (const fk of join.foreignKeys) {
-                // Find the db column name for this foreign key
-                const colEntry = Object.entries(this.schema.columns).find(([propName, _]) => propName === fk);
-                if (colEntry) {
-                    const config = colEntry[1].build();
-                    const dbColName = config.name;
-                    mainTableColumns.add(dbColName);
-                }
-                else {
-                    // FK might be the db column name directly
-                    mainTableColumns.add(fk);
-                }
-            }
-        }
-        // Also include foreign keys from intermediate joins (join to another join)
-        for (const join of navigationInfo.joins) {
-            if (join.sourceAlias && join.sourceAlias !== this.schema.name) {
-                // This join comes from another join, we need to include those FK columns too
-                // Find the source join
-                const sourceJoin = navigationInfo.joins.find(j => j.alias === join.sourceAlias);
-                if (sourceJoin) {
-                    // We need the source table's FK columns in our RETURNING if the source is the main table
-                    // But if source is itself a navigation, we handle it in the outer SELECT
+            // Only add FK to mainTableColumns if the join source is the main table
+            if (join.sourceAlias === this.schema.name || !join.sourceAlias) {
+                for (const fk of join.foreignKeys) {
+                    const fkDbCol = getFkDbColumnName(this.schema, fk);
+                    mainTableColumns.add(fkDbCol);
                 }
             }
         }
@@ -2111,27 +2144,23 @@ class SelectQueryBuilder {
         // Build the JOINs for the outer SELECT
         const joinClauses = [];
         for (const join of navigationInfo.joins) {
-            const sourceAlias = join.sourceAlias === this.schema.name ? '__mutation__' : `"${join.sourceAlias}"`;
             const qualifiedJoinTable = this.getQualifiedTableName(join.targetTable, join.targetSchema);
             // Find the db column names for the foreign keys
             const joinConditions = [];
             for (let i = 0; i < join.foreignKeys.length; i++) {
                 const fk = join.foreignKeys[i];
                 const match = join.matches[i] || 'id';
-                // Convert property name to db column name for FK
-                let fkDbCol = fk;
-                const colEntry = Object.entries(this.schema.columns).find(([propName, _]) => propName === fk);
-                if (colEntry) {
-                    const config = colEntry[1].build();
-                    fkDbCol = config.name;
-                }
-                // For source that's the mutation CTE
                 if (join.sourceAlias === this.schema.name || !join.sourceAlias) {
+                    // FK is on main table - look up db column name from main schema
+                    const fkDbCol = getFkDbColumnName(this.schema, fk);
                     joinConditions.push(`"__mutation__"."${fkDbCol}" = "${join.alias}"."${match}"`);
                 }
                 else {
-                    // Source is another joined table
-                    joinConditions.push(`"${join.sourceAlias}"."${fk}" = "${join.alias}"."${match}"`);
+                    // FK is on an intermediate joined table - look up from its schema
+                    const sourceTableName = aliasToSourceTable.get(join.sourceAlias);
+                    const sourceSchema = sourceTableName && this.schemaRegistry ? this.schemaRegistry.get(sourceTableName) : undefined;
+                    const fkDbCol = sourceSchema ? getFkDbColumnName(sourceSchema, fk) : fk;
+                    joinConditions.push(`"${join.sourceAlias}"."${fkDbCol}" = "${join.alias}"."${match}"`);
                 }
             }
             const joinType = join.isMandatory ? 'INNER JOIN' : 'LEFT JOIN';