linkgress-orm 0.2.4 → 0.2.5

package/dist/query/query-builder.js

@@ -1728,14 +1728,63 @@ class SelectQueryBuilder {
             if (!queryBuilder.whereCond) {
                 throw new Error('Delete requires a WHERE condition. Use where() before delete().');
             }
+            // Detect navigation property joins from WHERE condition
+            const whereJoins = [];
+            queryBuilder.detectAndAddJoinsFromCondition(queryBuilder.whereCond, whereJoins);
             const condBuilder = new conditions_1.ConditionBuilder();
             const { sql: whereSql, params: whereParams } = condBuilder.build(queryBuilder.whereCond, 1);
-            // Build RETURNING clause (not needed for count-only)
+            const qualifiedTableName = queryBuilder.getQualifiedTableName(queryBuilder.schema.name, queryBuilder.schema.schema);
+            // Build USING clause for navigation properties (PostgreSQL syntax for DELETE with JOINs)
+            let usingClause = '';
+            let joinConditions = [];
+            for (const join of whereJoins) {
+                const sourceTable = join.sourceAlias || queryBuilder.schema.name;
+                const joinTableName = queryBuilder.getQualifiedTableName(join.targetTable, join.targetSchema);
+                if (usingClause) {
+                    usingClause += `, ${joinTableName} AS "${join.alias}"`;
+                }
+                else {
+                    usingClause = `USING ${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
+                let deleteSql = `DELETE FROM ${qualifiedTableName}`;
+                if (usingClause) {
+                    deleteSql += ` ${usingClause}`;
+                }
+                deleteSql += ` WHERE ${fullWhereClause}`;
+                const { sql, params } = 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);
+            }
+            // Standard RETURNING (no navigation properties)
+            // Qualify columns with table name when using USING clause to avoid ambiguity
+            const hasJoins = whereJoins.length > 0;
             const returningClause = returning !== 'count'
-                ? queryBuilder.buildDeleteReturningClause(returning)
+                ? queryBuilder.buildUpdateDeleteReturningClause(returning, hasJoins)
                 : undefined;
-            const qualifiedTableName = queryBuilder.getQualifiedTableName(queryBuilder.schema.name, queryBuilder.schema.schema);
-            let sql = `DELETE FROM ${qualifiedTableName} WHERE ${whereSql}`;
+            let sql = `DELETE FROM ${qualifiedTableName}`;
+            if (usingClause) {
+                sql += ` ${usingClause}`;
+            }
+            sql += ` WHERE ${fullWhereClause}`;
             if (returningClause) {
                 sql += ` RETURNING ${returningClause.sql}`;
             }
@@ -1820,11 +1869,24 @@ class SelectQueryBuilder {
             const condBuilder = new conditions_1.ConditionBuilder();
             const { sql: whereSql, params: whereParams } = condBuilder.build(queryBuilder.whereCond, paramIndex);
             values.push(...whereParams);
-            // Build RETURNING clause (not needed for count-only)
+            const qualifiedTableName = queryBuilder.getQualifiedTableName(queryBuilder.schema.name, queryBuilder.schema.schema);
+            // 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);
+                const result = queryBuilder.executor
+                    ? await queryBuilder.executor.query(sql, params)
+                    : await queryBuilder.client.query(sql, params);
+                return queryBuilder.mapReturningResultsWithNavigation(result.rows, returning, navigationInfo.navigationFields);
+            }
+            // Standard RETURNING (no navigation properties)
             const returningClause = returning !== 'count'
-                ? queryBuilder.buildDeleteReturningClause(returning)
+                ? queryBuilder.buildUpdateDeleteReturningClause(returning)
                 : undefined;
-            const qualifiedTableName = queryBuilder.getQualifiedTableName(queryBuilder.schema.name, queryBuilder.schema.schema);
             let sql = `UPDATE ${qualifiedTableName} SET ${setClauses.join(', ')} WHERE ${whereSql}`;
             if (returningClause) {
                 sql += ` RETURNING ${returningClause.sql}`;
@@ -1864,16 +1926,19 @@ 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)
      * @internal
      */
-    buildDeleteReturningClause(returning) {
+    buildUpdateDeleteReturningClause(returning, qualifyWithTable = false) {
         if (returning === undefined) {
             return null;
         }
+        const tablePrefix = qualifyWithTable ? `"${this.schema.name}".` : '';
         if (returning === true) {
             // Return all columns
             const columns = Object.values(this.schema.columns).map(col => col.build().name);
-            const sql = columns.map(name => `"${name}"`).join(', ');
+            const sql = columns.map(name => `${tablePrefix}"${name}"`).join(', ');
             return { sql, columns };
         }
         // Selector function - extract selected columns
@@ -1887,7 +1952,7 @@ class SelectQueryBuilder {
                 if (field && typeof field === 'object' && '__dbColumnName' in field) {
                     const dbName = field.__dbColumnName;
                     columns.push(alias);
-                    sqlParts.push(`"${dbName}" AS "${alias}"`);
+                    sqlParts.push(`${tablePrefix}"${dbName}" AS "${alias}"`);
                 }
             }
             return { sql: sqlParts.join(', '), columns };
@@ -1934,6 +1999,197 @@ class SelectQueryBuilder {
             return mapped;
         });
     }
+    /**
+     * Detect if a RETURNING selector uses navigation properties
+     * Returns navigation info if found, null otherwise
+     * @internal
+     */
+    detectNavigationInReturning(returning) {
+        if (returning === true) {
+            // Full entity returning doesn't need navigation support
+            return null;
+        }
+        // Analyze the returning selector
+        const mockRow = this._createMockRow();
+        const selectedMock = this.selector(mockRow);
+        const selection = returning(selectedMock);
+        if (typeof selection !== 'object' || selection === null) {
+            return null;
+        }
+        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);
+                        }
+                    }
+                }
+            }
+        }
+        if (navigationFields.size === 0) {
+            return null;
+        }
+        // Resolve navigation joins
+        const joins = [];
+        this.resolveJoinsForTableAliases(allTableAliases, joins);
+        return { hasNavigation: true, selection, joins, navigationFields };
+    }
+    /**
+     * Build RETURNING clause with navigation property support using CTE
+     * @internal
+     */
+    buildReturningWithNavigation(mutationSql, mutationParams, returning, navigationInfo) {
+        // Build the CTE wrapping the mutation
+        // First, collect all columns needed from the main table in the mutation's RETURNING
+        const mainTableColumns = new Set();
+        const selectParts = [];
+        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}"`);
+                }
+            }
+        }
+        // We also need to include foreign keys for joins that aren't already in the selection
+        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
+                }
+            }
+        }
+        // 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
+        const mutationWithReturning = `${mutationSql} RETURNING ${cteReturningCols}`;
+        // 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) {
+                    joinConditions.push(`"__mutation__"."${fkDbCol}" = "${join.alias}"."${match}"`);
+                }
+                else {
+                    // Source is another joined table
+                    joinConditions.push(`"${join.sourceAlias}"."${fk}" = "${join.alias}"."${match}"`);
+                }
+            }
+            const joinType = join.isMandatory ? 'INNER JOIN' : 'LEFT JOIN';
+            joinClauses.push(`${joinType} ${qualifiedJoinTable} AS "${join.alias}" ON ${joinConditions.join(' AND ')}`);
+        }
+        // Build the final CTE query
+        const sql = `WITH "__mutation__" AS (
+  ${mutationWithReturning}
+)
+SELECT ${selectParts.join(', ')}
+FROM "__mutation__"
+${joinClauses.join('\n')}`;
+        return { sql, params: mutationParams };
+    }
+    /**
+     * Map RETURNING results with navigation properties
+     * Applies type mappers based on source table schemas
+     * @internal
+     */
+    mapReturningResultsWithNavigation(rows, returning, navigationFields) {
+        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;
+                        }
+                    }
+                }
+                // 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;
+        });
+    }
     /**
      * Create mock row for analysis
      * @internal