linkgress-orm 0.1.21 → 0.1.23

package/dist/query/query-builder.js

@@ -1086,7 +1086,7 @@ class SelectQueryBuilder {
     async executeSinglePhase(selectionResult, context, tracer) {
         // Build the query
         tracer.startPhase('queryBuild');
-        const { sql, params } = tracer.trace('buildQuery', () => this.buildQuery(selectionResult, context));
+        const { sql, params, nestedPaths } = tracer.trace('buildQuery', () => this.buildQuery(selectionResult, context));
         tracer.endPhase();
         // Execute using executor if available, otherwise use client directly
         tracer.startPhase('queryExecution');
@@ -1098,9 +1098,14 @@ class SelectQueryBuilder {
         if (this.executor?.getOptions().rawResult) {
             return result.rows;
         }
-        // Transform results
+        // Reconstruct nested objects from flat row data (if any)
         tracer.startPhase('resultProcessing');
-        const transformed = tracer.trace('transformResults', () => this.transformResults(result.rows, selectionResult), { rowCount: result.rows.length });
+        let rows = result.rows;
+        if (nestedPaths.size > 0) {
+            rows = tracer.trace('reconstructNestedObjects', () => rows.map(row => this.reconstructNestedObjects(row, nestedPaths)), { rowCount: rows.length });
+        }
+        // Transform results
+        const transformed = tracer.trace('transformResults', () => this.transformResults(rows, selectionResult), { rowCount: rows.length });
         tracer.endPhase();
         return transformed;
     }
@@ -1229,9 +1234,34 @@ class SelectQueryBuilder {
                     selectedFieldsSQL = fieldParts.join(', ');
                 }
                 // Build ORDER BY
-                let orderBySQL = orderByFields.length > 0
-                    ? ` ORDER BY ${orderByFields.map(({ field, direction }) => `"${field}" ${direction}`).join(', ')}`
-                    : ` ORDER BY "id" DESC`;
+                let orderBySQL;
+                const targetSchema = builderAny.targetTableSchema;
+                if (orderByFields.length > 0) {
+                    const colNameMap = targetSchema ? getColumnNameMapForSchema(targetSchema) : null;
+                    orderBySQL = ` ORDER BY ${orderByFields.map(({ field, direction }) => {
+                        const dbColumnName = colNameMap?.get(field) ?? field;
+                        return `"${dbColumnName}" ${direction}`;
+                    }).join(', ')}`;
+                }
+                else {
+                    // Find primary key column from schema, fallback to "id" if not found
+                    let pkColumn = null;
+                    if (targetSchema) {
+                        for (const colBuilder of Object.values(targetSchema.columns)) {
+                            const config = colBuilder.build();
+                            if (config.primaryKey) {
+                                pkColumn = config.name;
+                                break;
+                            }
+                        }
+                    }
+                    if (pkColumn) {
+                        orderBySQL = ` ORDER BY "${pkColumn}" DESC`;
+                    }
+                    else {
+                        orderBySQL = ' ';
+                    }
+                }
                 const collectionSQL = `SELECT "${foreignKey}" as parent_id, ${selectedFieldsSQL} FROM "${targetTable}" WHERE "${foreignKey}" IN (SELECT "__pk_id" FROM ${baseTempTable})${orderBySQL}`;
                 sqls.push(collectionSQL);
             }
@@ -1865,6 +1895,129 @@ class SelectQueryBuilder {
      * Detect navigation property references in selection and add necessary JOINs
      * Supports multi-level navigation like task.level.createdBy
      */
+    /**
+     * Try to build flat SQL SELECT parts for a nested object containing FieldRefs.
+     * Uses path-encoded aliases (e.g., __nested__address__street) for JS-side reconstruction.
+     * This is more performant than json_build_object() as it avoids JSON serialization overhead.
+     *
+     * @param obj The nested object from the selector
+     * @param context Query context for parameter tracking
+     * @param joins Array to add necessary JOINs
+     * @param selectParts Array to add SELECT parts to
+     * @param pathPrefix Current path prefix for alias encoding (e.g., "__nested__address")
+     * @param nestedPaths Set to track all nested paths for reconstruction
+     * @returns true if handled as nested object, false if not a valid nested object
+     */
+    tryBuildFlatNestedSelect(obj, context, joins, selectParts, pathPrefix, nestedPaths) {
+        if (!obj || typeof obj !== 'object' || Array.isArray(obj)) {
+            return false;
+        }
+        const entries = Object.entries(obj);
+        if (entries.length === 0) {
+            return false;
+        }
+        // First pass: check if this object contains any CollectionQueryBuilder instances
+        // If so, this is NOT a plain nested object and needs special handling elsewhere
+        for (const [, nestedValue] of entries) {
+            if (nestedValue instanceof CollectionQueryBuilder) {
+                return false; // Contains collections - let the main loop handle this
+            }
+            if (nestedValue && typeof nestedValue === 'object' && '__collectionResult' in nestedValue) {
+                return false; // Contains collection result marker
+            }
+        }
+        // Track this path as a nested object
+        nestedPaths.add(pathPrefix);
+        for (const [nestedKey, nestedValue] of entries) {
+            const fieldPath = `${pathPrefix}__${nestedKey}`;
+            if (nestedValue instanceof conditions_1.SqlFragment) {
+                // SQL Fragment - build the SQL expression
+                const sqlBuildContext = {
+                    paramCounter: context.paramCounter,
+                    params: context.allParams,
+                };
+                const fragmentSql = nestedValue.buildSql(sqlBuildContext);
+                context.paramCounter = sqlBuildContext.paramCounter;
+                selectParts.push(`${fragmentSql} as "${fieldPath}"`);
+            }
+            else if (typeof nestedValue === 'object' && nestedValue !== null && '__dbColumnName' in nestedValue) {
+                // FieldRef - extract table alias and column name
+                const tableAlias = ('__tableAlias' in nestedValue && nestedValue.__tableAlias)
+                    ? nestedValue.__tableAlias
+                    : this.schema.name;
+                const columnName = nestedValue.__dbColumnName;
+                // Add JOIN if needed for navigation fields
+                if (tableAlias !== this.schema.name) {
+                    const relConfig = this.schema.relations[tableAlias];
+                    if (relConfig && !joins.find(j => j.alias === tableAlias)) {
+                        let targetSchema;
+                        if (relConfig.targetTableBuilder) {
+                            const targetTableSchema = relConfig.targetTableBuilder.build();
+                            targetSchema = targetTableSchema.schema;
+                        }
+                        joins.push({
+                            alias: tableAlias,
+                            targetTable: relConfig.targetTable,
+                            targetSchema,
+                            foreignKeys: relConfig.foreignKeys || [relConfig.foreignKey || ''],
+                            matches: relConfig.matches || [],
+                            isMandatory: relConfig.isMandatory ?? false,
+                        });
+                    }
+                }
+                selectParts.push(`"${tableAlias}"."${columnName}" as "${fieldPath}"`);
+            }
+            else if (typeof nestedValue === 'object' && nestedValue !== null && !Array.isArray(nestedValue)) {
+                // Recursively handle deeper nested objects
+                const handled = this.tryBuildFlatNestedSelect(nestedValue, context, joins, selectParts, fieldPath, nestedPaths);
+                if (!handled) {
+                    // Not a valid nested object structure - return false to let caller handle
+                    return false;
+                }
+            }
+            else if (nestedValue === undefined || nestedValue === null) {
+                selectParts.push(`NULL as "${fieldPath}"`);
+            }
+            else {
+                // Literal value (string, number, boolean)
+                selectParts.push(`$${context.paramCounter++} as "${fieldPath}"`);
+                context.allParams.push(nestedValue);
+            }
+        }
+        return true;
+    }
+    /**
+     * Reconstruct nested objects from flat row data with path-encoded column names.
+     * Transforms { "__nested__address__street": "Main St", "__nested__address__city": "NYC" }
+     * into { address: { street: "Main St", city: "NYC" } }
+     */
+    reconstructNestedObjects(row, nestedPaths) {
+        if (nestedPaths.size === 0) {
+            return row;
+        }
+        const result = {};
+        const nestedPrefix = '__nested__';
+        for (const [key, value] of Object.entries(row)) {
+            if (key.startsWith(nestedPrefix)) {
+                // This is a nested field - parse the path and set the value
+                const pathParts = key.substring(nestedPrefix.length).split('__');
+                let current = result;
+                for (let i = 0; i < pathParts.length - 1; i++) {
+                    const part = pathParts[i];
+                    if (!(part in current)) {
+                        current[part] = {};
+                    }
+                    current = current[part];
+                }
+                current[pathParts[pathParts.length - 1]] = value;
+            }
+            else {
+                // Regular field
+                result[key] = value;
+            }
+        }
+        return result;
+    }
     detectAndAddJoinsFromSelection(selection, joins) {
         if (!selection || typeof selection !== 'object') {
             return;
@@ -2035,6 +2188,7 @@ class SelectQueryBuilder {
         const selectParts = [];
         const collectionFields = [];
         const joins = [];
+        const nestedPaths = new Set(); // Track nested object paths for JS-side reconstruction
         // Scan selection for navigation property references and add JOINs
         this.detectAndAddJoinsFromSelection(selection, joins);
         // Scan WHERE condition for navigation property references and add JOINs
@@ -2253,6 +2407,13 @@ class SelectQueryBuilder {
                                 continue;
                             }
                         }
+                        // Check if this is a plain nested object containing FieldRefs
+                        // e.g., address: { street: p.street, city: p.city }
+                        // Use flat select with path-encoded aliases for better performance
+                        const handled = this.tryBuildFlatNestedSelect(value, context, joins, selectParts, `__nested__${key}`, nestedPaths);
+                        if (handled) {
+                            continue;
+                        }
                     }
                     // Otherwise, treat as literal value
                     selectParts.push(`$${context.paramCounter++} as "${key}"`);
@@ -2318,6 +2479,8 @@ class SelectQueryBuilder {
         // Build ORDER BY clause
         let orderByClause = '';
         if (this.orderByFields.length > 0) {
+            // Performance: Pre-compute column name map for ORDER BY lookups
+            const colNameMap = getColumnNameMapForSchema(this.schema);
             const orderParts = this.orderByFields.map(({ field, direction }) => {
                 // Check if the field is in the selection (after a select() call)
                 // If so, reference it as an alias, otherwise use table.column notation
@@ -2327,7 +2490,9 @@ class SelectQueryBuilder {
                 }
                 else {
                     // Field is not in the selection, use table.column notation
-                    return `"${this.schema.name}"."${field}" ${direction}`;
+                    // Look up the database column name from the schema
+                    const dbColumnName = colNameMap.get(field) ?? field;
+                    return `"${this.schema.name}"."${dbColumnName}" ${direction}`;
                 }
             });
             orderByClause = `ORDER BY ${orderParts.join(', ')}`;
@@ -2422,6 +2587,7 @@ class SelectQueryBuilder {
         return {
             sql: finalQuery,
             params: context.allParams,
+            nestedPaths,
         };
     }
     /**
@@ -3851,17 +4017,34 @@ class CollectionQueryBuilder {
             localParams.push(...params);
             context.allParams.push(...params);
         }
-        // Step 3: Build ORDER BY clause SQL (without ORDER BY keyword)
+        // Step 3: Build ORDER BY clauses SQL (without ORDER BY keyword)
+        // We need two versions:
+        // - orderByClause: uses database column names (for subquery ORDER BY on raw table)
+        // - orderByClauseAlias: uses property names/aliases (for json_agg ORDER BY on aliased subquery output)
+        // Note: orderByFields[].field already contains the database column name (from parseOrderBy using __dbColumnName)
         let orderByClause;
+        let orderByClauseAlias;
         if (this.orderByFields.length > 0) {
-            // Performance: Pre-compute column name map for ORDER BY lookups
-            const colNameMap = this.targetTableSchema ? getColumnNameMapForSchema(this.targetTableSchema) : null;
-            const orderParts = this.orderByFields.map(({ field, direction }) => {
-                // Look up the database column name from the cached map if available
-                const dbColumnName = colNameMap?.get(field) ?? field;
-                return `"${dbColumnName}" ${direction}`;
+            // Build reverse lookup: db column name -> property name
+            let dbToPropertyMap = null;
+            if (this.targetTableSchema) {
+                dbToPropertyMap = new Map();
+                for (const [propName, colBuilder] of Object.entries(this.targetTableSchema.columns)) {
+                    const config = colBuilder.build();
+                    dbToPropertyMap.set(config.name, propName);
+                }
+            }
+            const orderPartsDb = this.orderByFields.map(({ field, direction }) => {
+                // field is already the database column name
+                return `"${field}" ${direction}`;
+            });
+            const orderPartsAlias = this.orderByFields.map(({ field, direction }) => {
+                // Look up the property name from the db column name
+                const propertyName = dbToPropertyMap?.get(field) ?? field;
+                return `"${propertyName}" ${direction}`;
             });
-            orderByClause = orderParts.join(', ');
+            orderByClause = orderPartsDb.join(', ');
+            orderByClauseAlias = orderPartsAlias.join(', ');
         }
         // Step 4: Determine aggregation type and field
         let aggregationType;
@@ -3922,6 +4105,7 @@ class CollectionQueryBuilder {
             whereClause,
             whereParams, // Pass WHERE clause parameters
             orderByClause,
+            orderByClauseAlias, // For json_agg ORDER BY which uses aliases
             limitValue: this.limitValue,
             offsetValue: this.offsetValue,
             isDistinct: this.isDistinct,