linkgress-orm 0.2.6 → 0.2.8

package/dist/query/query-builder.js

@@ -1768,11 +1768,11 @@ class SelectQueryBuilder {
                     deleteSql += ` ${usingClause}`;
                 }
                 deleteSql += ` WHERE ${fullWhereClause}`;
-                const { sql, params } = queryBuilder.buildReturningWithNavigation(deleteSql, whereParams, returning, navigationInfo);
+                const { sql, params, nestedPaths } = queryBuilder.buildReturningWithNavigation(deleteSql, whereParams, returning, navigationInfo);
                 const result = queryBuilder.executor
                     ? await queryBuilder.executor.query(sql, params)
                     : await queryBuilder.client.query(sql, params);
-                return queryBuilder.mapReturningResultsWithNavigation(result.rows, returning, navigationInfo.navigationFields);
+                return queryBuilder.mapReturningResultsWithNavigation(result.rows, returning, navigationInfo.navigationFields, nestedPaths);
             }
             // Standard RETURNING (no navigation properties)
             // Qualify columns with table name when using USING clause to avoid ambiguity
@@ -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,24 +1873,57 @@ 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}`;
-                const { sql, params } = queryBuilder.buildReturningWithNavigation(updateSql, values, returning, navigationInfo);
+                let updateSql = `UPDATE ${qualifiedTableName} SET ${setClauses.join(', ')}`;
+                if (fromClause) {
+                    updateSql += ` ${fromClause}`;
+                }
+                updateSql += ` WHERE ${fullWhereClause}`;
+                const { sql, params, nestedPaths } = queryBuilder.buildReturningWithNavigation(updateSql, values, returning, navigationInfo);
                 const result = queryBuilder.executor
                     ? await queryBuilder.executor.query(sql, params)
                     : await queryBuilder.client.query(sql, params);
-                return queryBuilder.mapReturningResultsWithNavigation(result.rows, returning, navigationInfo.navigationFields);
+                return queryBuilder.mapReturningResultsWithNavigation(result.rows, returning, navigationInfo.navigationFields, nestedPaths);
             }
             // 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}`;
             }
@@ -2018,35 +2054,54 @@ class SelectQueryBuilder {
         }
         const navigationFields = new Map();
         const allTableAliases = new Set();
-        // Check each field in the selection for navigation properties
-        for (const [alias, field] of Object.entries(selection)) {
-            if (field && typeof field === 'object' && '__dbColumnName' in field && '__tableAlias' in field) {
-                const tableAlias = field.__tableAlias;
-                if (tableAlias && tableAlias !== this.schema.name) {
-                    allTableAliases.add(tableAlias);
-                    navigationFields.set(alias, {
-                        tableAlias,
-                        dbColumnName: field.__dbColumnName,
-                        schemaTable: field.__sourceTable,
-                    });
-                }
-                // Also collect intermediate navigation aliases for multi-level navigation
-                if ('__navigationAliases' in field && Array.isArray(field.__navigationAliases)) {
-                    for (const navAlias of field.__navigationAliases) {
-                        if (navAlias && navAlias !== this.schema.name) {
-                            allTableAliases.add(navAlias);
+        const nestedObjects = new Map();
+        const collectionFields = new Map();
+        // Recursively collect field refs and table aliases from selection
+        const collectFieldRefs = (obj, path = '') => {
+            for (const [key, field] of Object.entries(obj)) {
+                const fieldPath = path ? `${path}.${key}` : key;
+                if (field && typeof field === 'object') {
+                    if ('__dbColumnName' in field) {
+                        // Direct field reference (either main table or navigation)
+                        const tableAlias = field.__tableAlias;
+                        if (tableAlias && tableAlias !== this.schema.name) {
+                            // Navigation field
+                            allTableAliases.add(tableAlias);
+                            navigationFields.set(fieldPath, {
+                                tableAlias,
+                                dbColumnName: field.__dbColumnName,
+                                schemaTable: field.__sourceTable,
+                            });
+                        }
+                        // Also collect intermediate navigation aliases for multi-level navigation
+                        if ('__navigationAliases' in field && Array.isArray(field.__navigationAliases)) {
+                            for (const navAlias of field.__navigationAliases) {
+                                if (navAlias && navAlias !== this.schema.name) {
+                                    allTableAliases.add(navAlias);
+                                }
+                            }
                         }
                     }
+                    else if (field instanceof CollectionQueryBuilder) {
+                        // CollectionQueryBuilder (.toList(), .firstOrDefault())
+                        collectionFields.set(fieldPath, field);
+                    }
+                    else if (!Array.isArray(field)) {
+                        // Nested plain object - recurse into it
+                        nestedObjects.set(fieldPath, field);
+                        collectFieldRefs(field, fieldPath);
+                    }
                 }
             }
-        }
-        if (navigationFields.size === 0) {
+        };
+        collectFieldRefs(selection);
+        if (navigationFields.size === 0 && nestedObjects.size === 0 && collectionFields.size === 0) {
             return null;
         }
         // Resolve navigation joins
         const joins = [];
         this.resolveJoinsForTableAliases(allTableAliases, joins);
-        return { hasNavigation: true, selection, joins, navigationFields };
+        return { hasNavigation: true, selection, joins, navigationFields, nestedObjects, collectionFields };
     }
     /**
      * Build RETURNING clause with navigation property support using CTE
@@ -2057,51 +2112,115 @@ class SelectQueryBuilder {
         // First, collect all columns needed from the main table in the mutation's RETURNING
         const mainTableColumns = new Set();
         const selectParts = [];
+        const nestedPaths = new Set();
         const mockRow = this._createMockRow();
         const selectedMock = this.selector(mockRow);
         const selection = returning(selectedMock);
-        // 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) {
-                const tableAlias = field.__tableAlias;
-                const dbColumnName = field.__dbColumnName;
-                if (!tableAlias || tableAlias === this.schema.name) {
-                    // Main table column - add to CTE RETURNING and final SELECT
-                    mainTableColumns.add(dbColumnName);
-                    selectParts.push(`"__mutation__"."${dbColumnName}" AS "${alias}"`);
-                }
-                else {
-                    // Navigation column - will be joined in outer query
-                    selectParts.push(`"${tableAlias}"."${dbColumnName}" AS "${alias}"`);
+        // 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);
+        }
+        // Track collection subqueries for LATERAL JOINs
+        const collectionSubqueries = [];
+        let lateralCounter = 0;
+        // Track all params including those from collection subqueries
+        const allParams = [...mutationParams];
+        let currentParamCounter = mutationParams.length + 1;
+        // Build a QueryContext for collection subquery building
+        const buildCollectionContext = () => ({
+            ctes: new Map(),
+            cteCounter: lateralCounter,
+            paramCounter: currentParamCounter,
+            allParams: allParams,
+            collectionStrategy: 'lateral',
+        });
+        // Recursively process selection to build SELECT parts
+        const processSelection = (obj, path = '') => {
+            for (const [key, field] of Object.entries(obj)) {
+                const fieldPath = path ? `${path}.${key}` : key;
+                if (field && typeof field === 'object') {
+                    if ('__dbColumnName' in field) {
+                        // Direct field reference
+                        const tableAlias = field.__tableAlias;
+                        const dbColumnName = field.__dbColumnName;
+                        if (!tableAlias || tableAlias === this.schema.name) {
+                            mainTableColumns.add(dbColumnName);
+                            selectParts.push(`"__mutation__"."${dbColumnName}" AS "${fieldPath}"`);
+                        }
+                        else {
+                            selectParts.push(`"${tableAlias}"."${dbColumnName}" AS "${fieldPath}"`);
+                        }
+                    }
+                    else if (field instanceof CollectionQueryBuilder) {
+                        // CollectionQueryBuilder (.toList(), .firstOrDefault())
+                        // Build a correlated subquery that references __mutation__ instead of the source table
+                        const collectionBuilder = field;
+                        const context = buildCollectionContext();
+                        // Build the CTE/subquery using lateral strategy
+                        const cteResult = collectionBuilder.buildCTE(context);
+                        lateralCounter = context.cteCounter;
+                        currentParamCounter = context.paramCounter; // Track new param index after collection subquery
+                        // The lateral strategy returns either:
+                        // 1. A correlated subquery in selectExpression (no join needed)
+                        // 2. A LATERAL JOIN with joinClause and selectExpression
+                        if (cteResult.joinClause && cteResult.joinClause.trim()) {
+                            // LATERAL JOIN needed - rewrite to reference __mutation__ instead of source table
+                            const rewrittenJoinClause = this.rewriteCollectionJoinForMutation(cteResult.joinClause, this.schema.name, '__mutation__');
+                            collectionSubqueries.push({
+                                fieldPath,
+                                lateralAlias: cteResult.tableName || `lateral_${lateralCounter - 1}`,
+                                joinClause: rewrittenJoinClause,
+                                selectExpression: cteResult.selectExpression || `"${cteResult.tableName}".data`,
+                            });
+                            selectParts.push(`${cteResult.selectExpression || `"${cteResult.tableName}".data`} AS "${fieldPath}"`);
+                        }
+                        else if (cteResult.selectExpression) {
+                            // Correlated subquery in SELECT - rewrite source table references
+                            const rewrittenExpr = this.rewriteCollectionExprForMutation(cteResult.selectExpression, this.schema.name, '__mutation__');
+                            selectParts.push(`${rewrittenExpr} AS "${fieldPath}"`);
+                        }
+                    }
+                    else if (!Array.isArray(field)) {
+                        // Nested plain object - recurse into it and mark as nested path
+                        nestedPaths.add(fieldPath);
+                        processSelection(field, fieldPath);
+                    }
                 }
             }
-        }
-        // We also need to include foreign keys for joins that aren't already in the selection
+        };
+        processSelection(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);
+            // 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);
                 }
             }
         }
-        // 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
-                }
+        // Include 'id' column if there are collection subqueries (needed for correlation)
+        if (collectionSubqueries.length > 0 || (navigationInfo.collectionFields && navigationInfo.collectionFields.size > 0)) {
+            // Find the 'id' column db name
+            const idColEntry = Object.entries(this.schema.columns).find(([propName, _]) => propName === 'id');
+            if (idColEntry) {
+                const idDbCol = idColEntry[1].build().name;
+                mainTableColumns.add(idDbCol);
+            }
+            else {
+                // Fallback to 'id' if not found in schema
+                mainTableColumns.add('id');
             }
         }
         // Build RETURNING clause for CTE with all needed columns from main table
@@ -2111,32 +2230,32 @@ 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';
             joinClauses.push(`${joinType} ${qualifiedJoinTable} AS "${join.alias}" ON ${joinConditions.join(' AND ')}`);
         }
+        // Add LATERAL JOINs for collections
+        for (const collection of collectionSubqueries) {
+            joinClauses.push(collection.joinClause);
+        }
         // Build the final CTE query
         const sql = `WITH "__mutation__" AS (
   ${mutationWithReturning}
@@ -2144,47 +2263,95 @@ class SelectQueryBuilder {
 SELECT ${selectParts.join(', ')}
 FROM "__mutation__"
 ${joinClauses.join('\n')}`;
-        return { sql, params: mutationParams };
+        return { sql, params: allParams, nestedPaths };
+    }
+    /**
+     * Rewrite a LATERAL JOIN clause to reference __mutation__ instead of the source table
+     * @internal
+     */
+    rewriteCollectionJoinForMutation(joinClause, sourceTable, mutationAlias) {
+        const sourcePattern = new RegExp(`"${sourceTable}"\\."`, 'g');
+        return joinClause.replace(sourcePattern, `"${mutationAlias}"."`);
+    }
+    /**
+     * Rewrite a correlated subquery expression to reference __mutation__ instead of the source table
+     * @internal
+     */
+    rewriteCollectionExprForMutation(expression, sourceTable, mutationAlias) {
+        const sourcePattern = new RegExp(`"${sourceTable}"\\."`, 'g');
+        return expression.replace(sourcePattern, `"${mutationAlias}"."`);
     }
     /**
      * Map RETURNING results with navigation properties
      * Applies type mappers based on source table schemas
+     * Reconstructs nested objects from flat column paths
      * @internal
      */
-    mapReturningResultsWithNavigation(rows, returning, navigationFields) {
+    mapReturningResultsWithNavigation(rows, returning, navigationFields, nestedPaths) {
         return rows.map(row => {
             const mapped = {};
             for (const [key, value] of Object.entries(row)) {
-                // Check if this is a navigation field
-                const navInfo = navigationFields.get(key);
-                if (navInfo && navInfo.schemaTable && this.schemaRegistry) {
-                    // Try to get mapper from the navigation target's schema
-                    const targetSchema = this.schemaRegistry.get(navInfo.schemaTable);
-                    if (targetSchema) {
-                        // Find the column and its mapper
-                        const colEntry = Object.entries(targetSchema.columns).find(([_, col]) => {
-                            const config = col.build();
-                            return config.name === navInfo.dbColumnName;
-                        });
-                        if (colEntry) {
-                            const config = colEntry[1].build();
-                            mapped[key] = config.mapper ? config.mapper.fromDriver(value) : value;
-                            continue;
+                // Handle nested paths (e.g., "invoicingPartner.id" -> { invoicingPartner: { id: value } })
+                if (key.includes('.')) {
+                    const parts = key.split('.');
+                    let current = mapped;
+                    for (let i = 0; i < parts.length - 1; i++) {
+                        if (!current[parts[i]]) {
+                            current[parts[i]] = {};
                         }
+                        current = current[parts[i]];
                     }
-                }
-                // Try to find column by alias or name in main schema
-                const colEntry = Object.entries(this.schema.columns).find(([propName, col]) => {
-                    const config = col.build();
-                    return propName === key || config.name === key;
-                });
-                if (colEntry) {
-                    const [, col] = colEntry;
-                    const config = col.build();
-                    mapped[key] = config.mapper ? config.mapper.fromDriver(value) : value;
+                    const finalKey = parts[parts.length - 1];
+                    // Check if this is a navigation field
+                    const navInfo = navigationFields.get(key);
+                    if (navInfo && navInfo.schemaTable && this.schemaRegistry) {
+                        const targetSchema = this.schemaRegistry.get(navInfo.schemaTable);
+                        if (targetSchema) {
+                            const colEntry = Object.entries(targetSchema.columns).find(([_, col]) => {
+                                const config = col.build();
+                                return config.name === navInfo.dbColumnName;
+                            });
+                            if (colEntry) {
+                                const config = colEntry[1].build();
+                                current[finalKey] = config.mapper ? config.mapper.fromDriver(value) : value;
+                                continue;
+                            }
+                        }
+                    }
+                    current[finalKey] = value;
                 }
                 else {
-                    mapped[key] = value;
+                    // Check if this is a navigation field
+                    const navInfo = navigationFields.get(key);
+                    if (navInfo && navInfo.schemaTable && this.schemaRegistry) {
+                        // Try to get mapper from the navigation target's schema
+                        const targetSchema = this.schemaRegistry.get(navInfo.schemaTable);
+                        if (targetSchema) {
+                            // Find the column and its mapper
+                            const colEntry = Object.entries(targetSchema.columns).find(([_, col]) => {
+                                const config = col.build();
+                                return config.name === navInfo.dbColumnName;
+                            });
+                            if (colEntry) {
+                                const config = colEntry[1].build();
+                                mapped[key] = config.mapper ? config.mapper.fromDriver(value) : value;
+                                continue;
+                            }
+                        }
+                    }
+                    // Try to find column by alias or name in main schema
+                    const colEntry = Object.entries(this.schema.columns).find(([propName, col]) => {
+                        const config = col.build();
+                        return propName === key || config.name === key;
+                    });
+                    if (colEntry) {
+                        const [, col] = colEntry;
+                        const config = col.build();
+                        mapped[key] = config.mapper ? config.mapper.fromDriver(value) : value;
+                    }
+                    else {
+                        mapped[key] = value;
+                    }
                 }
             }
             return mapped;