linkgress-orm 0.1.19 → 0.1.20

package/dist/query/query-builder.js

@@ -2675,26 +2675,58 @@ class SelectQueryBuilder {
         // Use pre-cached column metadata from target schema
         // This avoids repeated column.build() calls for each item
         const columnCache = targetSchema.columnMetadataCache;
-        if (!columnCache || columnCache.size === 0) {
-            // Fallback for schemas without cache (shouldn't happen, but be safe)
-            return items.map(item => {
-                const transformedItem = {};
-                for (const [key, value] of Object.entries(item)) {
-                    const column = targetSchema.columns[key];
-                    if (column) {
-                        const config = column.build();
-                        transformedItem[key] = config.mapper
-                            ? config.mapper.fromDriver(value)
-                            : value;
-                    }
-                    else {
-                        transformedItem[key] = value;
+        // Build alias-to-field-info mapping from selected field configs
+        // This allows us to find the correct mapper when:
+        // 1. alias differs from property name (e.g., reservationExpiry: i.expiresAt)
+        // 2. field comes from navigation (e.g., customerBirthdate: i.userEshop.birthdate)
+        const selectedFieldConfigs = collectionBuilder.getSelectedFieldConfigs();
+        const aliasToFieldInfo = new Map();
+        if (selectedFieldConfigs) {
+            for (const field of selectedFieldConfigs) {
+                if (field.propertyName) {
+                    aliasToFieldInfo.set(field.alias, {
+                        propertyName: field.propertyName,
+                        sourceTable: field.sourceTable,
+                    });
+                }
+            }
+        }
+        // Pre-build mapper cache for all fields (including navigation fields)
+        // This avoids repeated schema lookups per item
+        const mapperCache = new Map(); // alias -> mapper
+        for (const [alias, fieldInfo] of aliasToFieldInfo) {
+            let mapper = null;
+            const schemaRegistry = collectionBuilder.getSchemaRegistry() || this.schemaRegistry;
+            if (fieldInfo.sourceTable && schemaRegistry) {
+                // Navigation field - look up mapper from the source table's schema
+                const navSchema = schemaRegistry.get(fieldInfo.sourceTable);
+                if (navSchema?.columnMetadataCache) {
+                    const cached = navSchema.columnMetadataCache.get(fieldInfo.propertyName);
+                    if (cached?.hasMapper) {
+                        mapper = cached.mapper;
                     }
                 }
-                return transformedItem;
-            });
+            }
+            else {
+                // Regular field from target schema
+                const cached = columnCache?.get(fieldInfo.propertyName);
+                if (cached?.hasMapper) {
+                    mapper = cached.mapper;
+                }
+            }
+            if (mapper) {
+                mapperCache.set(alias, mapper);
+            }
+        }
+        // Also add direct property matches from target schema (when no alias mapping)
+        if (columnCache) {
+            for (const [propertyName, cached] of columnCache) {
+                if (!mapperCache.has(propertyName) && cached.hasMapper) {
+                    mapperCache.set(propertyName, cached.mapper);
+                }
+            }
         }
-        // Optimized path using cached metadata and while(i--) loop
+        // Transform items using pre-built mapper cache
         const results = new Array(items.length);
         let i = items.length;
         while (i--) {
@@ -2702,9 +2734,9 @@ class SelectQueryBuilder {
             const transformedItem = {};
             for (const key in item) {
                 const value = item[key];
-                const cached = columnCache.get(key);
-                if (cached && cached.hasMapper) {
-                    transformedItem[key] = cached.mapper.fromDriver(value);
+                const mapper = mapperCache.get(key);
+                if (mapper) {
+                    transformedItem[key] = mapper.fromDriver(value);
                 }
                 else {
                     transformedItem[key] = value;
@@ -2964,13 +2996,15 @@ exports.SelectQueryBuilder = SelectQueryBuilder;
  * Reference query builder for single navigation (many-to-one, one-to-one)
  */
 class ReferenceQueryBuilder {
-    constructor(relationName, targetTable, foreignKeys, matches, isMandatory, targetTableSchema, schemaRegistry) {
+    constructor(relationName, targetTable, foreignKeys, matches, isMandatory, targetTableSchema, schemaRegistry, navigationPath, sourceAlias) {
         this.relationName = relationName;
         this.targetTable = targetTable;
         this.foreignKeys = foreignKeys;
         this.matches = matches;
         this.isMandatory = isMandatory;
         this.schemaRegistry = schemaRegistry;
+        this.navigationPath = navigationPath || [];
+        this.sourceAlias = sourceAlias || '';
         // Prefer registry lookup (has full relations) over passed schema
         if (this.schemaRegistry) {
             this.targetTableSchema = this.schemaRegistry.get(targetTable);
@@ -3036,6 +3070,7 @@ class ReferenceQueryBuilder {
                     columnMappers[colName] = config.mapper;
                 }
             }
+            const sourceTable = this.targetTable; // Actual table name for schema lookup
             for (const [colName, dbColumnName] of columnNameMap) {
                 const mapper = columnMappers[colName];
                 Object.defineProperty(mock, colName, {
@@ -3045,7 +3080,8 @@ class ReferenceQueryBuilder {
                             cached = fieldRefCache[colName] = {
                                 __fieldName: colName,
                                 __dbColumnName: dbColumnName,
-                                __tableAlias: tableAlias, // Mark which table this belongs to
+                                __tableAlias: tableAlias, // Alias for SQL generation
+                                __sourceTable: sourceTable, // Actual table name for mapper lookup
                                 __mapper: mapper, // Include mapper for toDriver transformation in conditions
                             };
                         }
@@ -3055,6 +3091,23 @@ class ReferenceQueryBuilder {
                     configurable: true,
                 });
             }
+            // Build extended navigation path for nested collections
+            // Only build navigation path if we have a sourceAlias (meaning we're inside a collection's selector)
+            // If sourceAlias is empty, we're in the main query and references are joined in the FROM clause
+            let extendedNavPath = [];
+            if (this.sourceAlias) {
+                // Build the current navigation step to include in path for nested collections
+                // This represents the join from sourceAlias to this.relationName (this.targetTable)
+                const currentNavStep = {
+                    alias: this.relationName,
+                    targetTable: this.targetTable,
+                    foreignKeys: this.foreignKeys,
+                    matches: this.matches.length > 0 ? this.matches : ['id'], // Default to 'id' if not specified
+                    isMandatory: this.isMandatory,
+                    sourceAlias: this.sourceAlias,
+                };
+                extendedNavPath = [...this.navigationPath, currentNavStep];
+            }
             // Add navigation properties (both collections and references)
             if (this.targetTableSchema.relations) {
                 for (const [relName, relConfig] of Object.entries(this.targetTableSchema.relations)) {
@@ -3072,8 +3125,10 @@ class ReferenceQueryBuilder {
                         Object.defineProperty(mock, relName, {
                             get: () => {
                                 const fk = relConfig.foreignKey || relConfig.foreignKeys?.[0] || '';
-                                return new CollectionQueryBuilder(relName, relConfig.targetTable, fk, this.targetTable, nestedTargetSchema, // Pass the target schema directly
-                                this.schemaRegistry // Pass schema registry for nested resolution
+                                return new CollectionQueryBuilder(relName, relConfig.targetTable, fk, this.relationName, // Use alias (relationName) for correlation in lateral joins
+                                nestedTargetSchema, // Pass the target schema directly
+                                this.schemaRegistry, // Pass schema registry for nested resolution
+                                extendedNavPath // Pass navigation path for intermediate joins (empty if main query)
                                 );
                             },
                             enumerable: false,
@@ -3087,7 +3142,9 @@ class ReferenceQueryBuilder {
                         Object.defineProperty(mock, relName, {
                             get: () => {
                                 const refBuilder = new ReferenceQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKeys || [relConfig.foreignKey || ''], relConfig.matches || [], relConfig.isMandatory ?? false, nestedTargetSchema, // Pass the target schema directly
-                                this.schemaRegistry // Pass schema registry for nested resolution
+                                this.schemaRegistry, // Pass schema registry for nested resolution
+                                extendedNavPath, // Pass navigation path for nested collections
+                                this.sourceAlias ? this.relationName : '' // Only set source if tracking path
                                 );
                                 return refBuilder.createMockTargetRow();
                             },
@@ -3110,7 +3167,7 @@ exports.ReferenceQueryBuilder = ReferenceQueryBuilder;
  * Collection query builder for nested queries
  */
 class CollectionQueryBuilder {
-    constructor(relationName, targetTable, foreignKey, sourceTable, targetTableSchema, schemaRegistry) {
+    constructor(relationName, targetTable, foreignKey, sourceTable, targetTableSchema, schemaRegistry, navigationPath) {
         this.orderByFields = [];
         this.isMarkedAsList = false;
         this.isDistinct = false;
@@ -3120,6 +3177,7 @@ class CollectionQueryBuilder {
         this.foreignKey = foreignKey;
         this.sourceTable = sourceTable;
         this.schemaRegistry = schemaRegistry;
+        this.navigationPath = navigationPath || [];
         // Prefer registry lookup (has full relations) over passed schema
         if (this.schemaRegistry) {
             const registrySchema = this.schemaRegistry.get(targetTable);
@@ -3136,7 +3194,8 @@ class CollectionQueryBuilder {
      * Select specific fields from collection items
      */
     select(selector) {
-        const newBuilder = new CollectionQueryBuilder(this.relationName, this.targetTable, this.foreignKey, this.sourceTable, this.targetTableSchema, this.schemaRegistry // Pass schema registry for nested navigation resolution
+        const newBuilder = new CollectionQueryBuilder(this.relationName, this.targetTable, this.foreignKey, this.sourceTable, this.targetTableSchema, this.schemaRegistry, // Pass schema registry for nested navigation resolution
+        this.navigationPath // Pass navigation path for intermediate joins
         );
         newBuilder.selector = selector;
         newBuilder.whereCond = this.whereCond;
@@ -3186,7 +3245,8 @@ class CollectionQueryBuilder {
             const columnNameMap = getColumnNameMapForSchema(this.targetTableSchema);
             // Performance: Lazy-cache FieldRef objects
             const fieldRefCache = {};
-            // Add columns
+            // Add columns - include tableAlias for unambiguous column references in WHERE clauses
+            const tableAlias = this.targetTable;
             for (const [colName, dbColumnName] of columnNameMap) {
                 Object.defineProperty(mock, colName, {
                     get() {
@@ -3195,6 +3255,7 @@ class CollectionQueryBuilder {
                             cached = fieldRefCache[colName] = {
                                 __fieldName: colName,
                                 __dbColumnName: dbColumnName,
+                                __tableAlias: tableAlias, // Include table alias for unambiguous references
                             };
                         }
                         return cached;
@@ -3215,6 +3276,7 @@ class CollectionQueryBuilder {
                                 const fk = relConfig.foreignKey || relConfig.foreignKeys?.[0] || '';
                                 return new CollectionQueryBuilder(relName, relConfig.targetTable, fk, this.targetTable, undefined, // Don't pass schema, force registry lookup
                                 this.schemaRegistry // Pass schema registry for nested resolution
+                                // No navigation path needed here - direct collection access from parent
                                 );
                             },
                             enumerable: false,
@@ -3229,7 +3291,9 @@ class CollectionQueryBuilder {
                                 // Don't call build() - it returns schema without relations
                                 // Instead, pass undefined and let ReferenceQueryBuilder look it up from registry
                                 const refBuilder = new ReferenceQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKeys || [relConfig.foreignKey || ''], relConfig.matches || [], relConfig.isMandatory ?? false, undefined, // Don't pass schema, force registry lookup
-                                this.schemaRegistry // Pass schema registry for nested resolution
+                                this.schemaRegistry, // Pass schema registry for nested resolution
+                                [], // Empty navigation path - this is the first reference in the chain
+                                this.targetTable // Source alias is this collection's target table
                                 );
                                 return refBuilder.createMockTargetRow();
                             },
@@ -3368,6 +3432,18 @@ class CollectionQueryBuilder {
     getTargetTableSchema() {
         return this.targetTableSchema;
     }
+    /**
+     * Get selected field configs (for mapper lookup during transformation)
+     */
+    getSelectedFieldConfigs() {
+        return this._selectedFieldConfigs;
+    }
+    /**
+     * Get schema registry (for mapper lookup during transformation of navigation fields)
+     */
+    getSchemaRegistry() {
+        return this.schemaRegistry;
+    }
     /**
      * Check if this collection uses array aggregation (for flattened results)
      */
@@ -3653,7 +3729,9 @@ class CollectionQueryBuilder {
                     cteCounter: context.cteCounter,
                 };
                 const nestedResult = field.buildCTE(nestedCtx, client);
+                // Sync both counters back - cteCounter for CTE naming, paramCounter for parameter numbering
                 context.cteCounter = nestedCtx.cteCounter;
+                context.paramCounter = nestedCtx.paramCounter;
                 // For CTE/LATERAL strategy, we need to track the nested join
                 // The nested aggregation needs to be joined in the outer collection's subquery
                 if (nestedResult.tableName) {
@@ -3687,11 +3765,13 @@ class CollectionQueryBuilder {
                 // FieldRef object - use database column name with optional table alias
                 const dbColumnName = field.__dbColumnName;
                 const tableAlias = field.__tableAlias;
+                const fieldName = field.__fieldName; // Property name for mapper lookup
+                const sourceTable = field.__sourceTable; // Actual table name for schema lookup
                 // If tableAlias differs from the target table, it's a navigation property reference
                 if (tableAlias && tableAlias !== this.targetTable) {
-                    return { alias, expression: `"${tableAlias}"."${dbColumnName}"` };
+                    return { alias, expression: `"${tableAlias}"."${dbColumnName}"`, propertyName: fieldName, sourceTable };
                 }
-                return { alias, expression: `"${dbColumnName}"` };
+                return { alias, expression: `"${dbColumnName}"`, propertyName: fieldName };
             }
             else if (typeof field === 'string') {
                 // Simple string reference (for backward compatibility)
@@ -3722,9 +3802,11 @@ class CollectionQueryBuilder {
                 // Single field selection - use the field name as both alias and expression
                 const field = selectedFields;
                 const dbColumnName = field.__dbColumnName;
+                const fieldName = field.__fieldName; // Property name for mapper lookup
                 selectedFieldConfigs.push({
                     alias: dbColumnName,
                     expression: `"${dbColumnName}"`,
+                    propertyName: fieldName,
                 });
             }
             else {
@@ -3743,6 +3825,7 @@ class CollectionQueryBuilder {
                     selectedFieldConfigs.push({
                         alias: colName,
                         expression: `"${dbColumnName}"`,
+                        propertyName: colName, // Same as alias when selecting all fields
                     });
                 }
             }
@@ -3754,6 +3837,8 @@ class CollectionQueryBuilder {
                 });
             }
         }
+        // Cache selected field configs for mapper lookup during transformation
+        this._selectedFieldConfigs = selectedFieldConfigs;
         // Step 2: Build WHERE clause SQL (without WHERE keyword)
         let whereClause;
         let whereParams;
@@ -3820,6 +3905,12 @@ class CollectionQueryBuilder {
             const selectedFields = this.selector(mockItem);
             this.detectNavigationJoins(selectedFields, navigationJoins, this.targetTable, this.targetTableSchema);
         }
+        // Step 5b: Merge navigation path joins (for intermediate tables in navigation chains)
+        // These joins are needed when accessing a collection through a chain like:
+        // oi.productPrice.product.resort.productIntegrationDefinitions
+        // The navigation path contains joins for productPrice, product, resort
+        // which must be included in the lateral subquery for correlation
+        const allNavigationJoins = [...this.navigationPath, ...navigationJoins];
         // Step 6: Build CollectionAggregationConfig object
         const config = {
             relationName: this.relationName,
@@ -3839,7 +3930,7 @@ class CollectionQueryBuilder {
             arrayField,
             defaultValue,
             counter: context.cteCounter++,
-            navigationJoins: navigationJoins.length > 0 ? navigationJoins : undefined,
+            navigationJoins: allNavigationJoins.length > 0 ? allNavigationJoins : undefined,
         };
         // Step 6: Call the strategy
         const result = strategy.buildAggregation(config, context, client);