linkgress-orm 0.2.7 → 0.2.9

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
@@ -1907,11 +1907,11 @@ class SelectQueryBuilder {
                     updateSql += ` ${fromClause}`;
                 }
                 updateSql += ` WHERE ${fullWhereClause}`;
-                const { sql, params } = queryBuilder.buildReturningWithNavigation(updateSql, values, returning, navigationInfo);
+                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
@@ -2054,35 +2054,68 @@ 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);
+                        // Also extract the navigation path from the collection builder
+                        // so we can add the necessary joins to reach the collection's source table
+                        const collectionBuilder = field;
+                        if (collectionBuilder.navigationPath && Array.isArray(collectionBuilder.navigationPath)) {
+                            for (const navJoin of collectionBuilder.navigationPath) {
+                                if (navJoin.alias && navJoin.alias !== this.schema.name) {
+                                    allTableAliases.add(navJoin.alias);
+                                }
+                            }
+                        }
+                        // Also add the source table alias
+                        if (collectionBuilder.sourceTable && collectionBuilder.sourceTable !== this.schema.name) {
+                            allTableAliases.add(collectionBuilder.sourceTable);
+                        }
+                    }
+                    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
@@ -2093,6 +2126,7 @@ 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);
@@ -2111,22 +2145,82 @@ class SelectQueryBuilder {
         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) {
-                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}"`);
+        // Build a map of table name -> alias for collection subquery rewriting
+        // This allows us to rewrite collection subqueries to use the correct joined aliases
+        const tableToAlias = new Map();
+        tableToAlias.set(this.schema.name, '__mutation__'); // Main table uses mutation CTE
+        for (const join of navigationInfo.joins) {
+            tableToAlias.set(join.targetTable, join.alias);
+        }
+        // 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 joined tables from the main query
+                        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 all table references to use correct aliases
+                            const rewrittenJoinClause = this.rewriteCollectionTableReferences(cteResult.joinClause, tableToAlias);
+                            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 all table references
+                            const rewrittenExpr = this.rewriteCollectionTableReferences(cteResult.selectExpression, tableToAlias);
+                            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);
+                    }
                 }
             }
-        }
+        };
+        processSelection(selection);
         // Include foreign keys needed for joins - only for joins from main table
         for (const join of navigationInfo.joins) {
             // Only add FK to mainTableColumns if the join source is the main table
@@ -2137,6 +2231,19 @@ class SelectQueryBuilder {
                 }
             }
         }
+        // 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
         const cteReturningCols = Array.from(mainTableColumns).map(col => `"${col}"`).join(', ');
         // Add RETURNING to the mutation SQL for CTE
@@ -2166,6 +2273,10 @@ class SelectQueryBuilder {
             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}
@@ -2173,47 +2284,99 @@ class SelectQueryBuilder {
 SELECT ${selectParts.join(', ')}
 FROM "__mutation__"
 ${joinClauses.join('\n')}`;
-        return { sql, params: mutationParams };
+        return { sql, params: allParams, nestedPaths };
+    }
+    /**
+     * Rewrite table references in a collection subquery to use the correct aliases
+     * from the main query's JOINs. This handles multi-level navigation where the
+     * collection is accessed through intermediate joined tables.
+     *
+     * @param expression - The SQL expression (join clause or select expression) to rewrite
+     * @param tableToAlias - Map of table names to their aliases in the main query
+     * @returns The rewritten expression with all table references updated
+     * @internal
+     */
+    rewriteCollectionTableReferences(expression, tableToAlias) {
+        let result = expression;
+        // Rewrite each table reference to use the correct alias
+        // Pattern: "tableName"."columnName" -> "alias"."columnName"
+        for (const [tableName, alias] of tableToAlias) {
+            const pattern = new RegExp(`"${tableName}"\\."`, 'g');
+            result = result.replace(pattern, `"${alias}"."`);
+        }
+        return result;
     }
     /**
      * 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;