linkgress-orm 0.1.0 → 0.1.2

package/dist/query/grouped-query.js

@@ -83,9 +83,9 @@ class GroupedQueryBuilder {
      */
     createMockRow() {
         const mock = {};
-        // Add columns as FieldRef objects
-        for (const [colName, colBuilder] of Object.entries(this.schema.columns)) {
-            const dbColumnName = colBuilder.build().name;
+        // Add columns as FieldRef objects - use pre-computed column name map if available
+        const columnNameMap = (0, query_builder_1.getColumnNameMapForSchema)(this.schema);
+        for (const [colName, dbColumnName] of columnNameMap) {
             Object.defineProperty(mock, colName, {
                 get: () => ({
                     __fieldName: colName,
@@ -97,15 +97,11 @@ class GroupedQueryBuilder {
             });
         }
         // Add navigation properties (collections and single references)
-        const relationSchemas = new Map();
-        for (const [relName, relConfig] of Object.entries(this.schema.relations)) {
-            if (relConfig.targetTableBuilder) {
-                relationSchemas.set(relName, relConfig.targetTableBuilder.build());
-            }
-        }
-        for (const [relName, relConfig] of Object.entries(this.schema.relations)) {
+        // Performance: Use pre-computed relation entries and cached schemas
+        const relationEntries = (0, query_builder_1.getRelationEntriesForSchema)(this.schema);
+        for (const [relName, relConfig] of relationEntries) {
+            const targetSchema = (0, query_builder_1.getTargetSchemaForRelation)(this.schema, relName, relConfig);
             if (relConfig.type === 'many') {
-                const targetSchema = relationSchemas.get(relName);
                 Object.defineProperty(mock, relName, {
                     get: () => {
                         return new query_builder_1.CollectionQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKey || relConfig.foreignKeys?.[0] || '', this.schema.name, targetSchema);
@@ -115,7 +111,6 @@ class GroupedQueryBuilder {
                 });
             }
             else {
-                const targetSchema = relationSchemas.get(relName);
                 Object.defineProperty(mock, relName, {
                     get: () => {
                         const refBuilder = new query_builder_1.ReferenceQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKeys || [relConfig.foreignKey || ''], relConfig.matches || [], relConfig.isMandatory ?? false, targetSchema);
@@ -131,8 +126,8 @@ class GroupedQueryBuilder {
             if (join.isSubquery || !join.schema) {
                 continue;
             }
-            for (const [colName, colBuilder] of Object.entries(join.schema.columns)) {
-                const dbColumnName = colBuilder.build().name;
+            const joinColumnNameMap = (0, query_builder_1.getColumnNameMapForSchema)(join.schema);
+            for (const [colName, dbColumnName] of joinColumnNameMap) {
                 if (!mock[join.alias]) {
                     mock[join.alias] = {};
                 }
@@ -221,12 +216,52 @@ class GroupedSelectQueryBuilder {
         return this.transformResults(result.rows);
     }
     /**
-     * Transform database results - convert aggregate values from strings to numbers
+     * Transform database results - convert aggregate values and apply mappers
      */
     transformResults(rows) {
-        // Get the mock result to identify which fields are aggregates
+        // Get the mock result to identify which fields are aggregates and have mappers
         const mockGroup = this.createMockGroupedItem();
         const mockResult = this.resultSelector(mockGroup);
+        // Also get the original selection to track field origins for mapper lookup
+        const mockRow = this.createMockRow();
+        const mockOriginalSelection = this.originalSelector(mockRow);
+        // Build column metadata cache from schema for mapper lookup
+        const columnMetadataCache = {};
+        for (const [key, mockValue] of Object.entries(mockResult)) {
+            // Check if mockValue has getMapper (SqlFragment or aliased field with mapper)
+            if (typeof mockValue === 'object' && mockValue !== null && typeof mockValue.getMapper === 'function') {
+                const mapper = mockValue.getMapper();
+                if (mapper) {
+                    columnMetadataCache[key] = { hasMapper: true, mapper };
+                }
+            }
+            // Check if this is a FieldRef from schema column
+            else if (typeof mockValue === 'object' && mockValue !== null && '__fieldName' in mockValue) {
+                const fieldName = mockValue.__fieldName;
+                // Look up in schema
+                const column = this.schema.columns[fieldName];
+                if (column) {
+                    const config = column.build();
+                    if (config.mapper) {
+                        columnMetadataCache[key] = { hasMapper: true, mapper: config.mapper };
+                    }
+                }
+                // Also check original selection for mapper (for aliased fields like p.key.distinctDay)
+                else if (mockOriginalSelection && fieldName in mockOriginalSelection) {
+                    const origValue = mockOriginalSelection[fieldName];
+                    if (typeof origValue === 'object' && origValue !== null && '__fieldName' in origValue) {
+                        const origFieldName = origValue.__fieldName;
+                        const origColumn = this.schema.columns[origFieldName];
+                        if (origColumn) {
+                            const config = origColumn.build();
+                            if (config.mapper) {
+                                columnMetadataCache[key] = { hasMapper: true, mapper: config.mapper };
+                            }
+                        }
+                    }
+                }
+            }
+        }
         return rows.map(row => {
             const transformed = {};
             for (const [key, value] of Object.entries(row)) {
@@ -242,14 +277,81 @@ class GroupedSelectQueryBuilder {
                         transformed[key] = value;
                     }
                 }
+                // Check if this field has a mapper
+                else if (columnMetadataCache[key]?.hasMapper) {
+                    const mapper = columnMetadataCache[key].mapper;
+                    if (value === null || value === undefined) {
+                        transformed[key] = null;
+                    }
+                    else if (typeof mapper.fromDriver === 'function') {
+                        transformed[key] = mapper.fromDriver(value);
+                    }
+                    else {
+                        transformed[key] = value;
+                    }
+                }
                 else {
-                    // Non-aggregate field - keep as is
+                    // Non-aggregate field without mapper - keep as is
                     transformed[key] = value;
                 }
             }
             return transformed;
         });
     }
+    /**
+     * Get selection metadata for mapper preservation in CTEs
+     * Enhances the selection result with mapper info from original schema columns
+     * @internal
+     */
+    getSelectionMetadata() {
+        const mockGroup = this.createMockGroupedItem();
+        const mockResult = this.resultSelector(mockGroup);
+        // Get original selection to map field names back to schema columns
+        const mockRow = this.createMockRow();
+        const mockOriginalSelection = this.originalSelector(mockRow);
+        // Build enhanced metadata with mappers
+        const enhancedMetadata = {};
+        for (const [key, value] of Object.entries(mockResult)) {
+            // Check if it's a FieldRef
+            if (typeof value === 'object' && value !== null && '__fieldName' in value) {
+                const fieldName = value.__fieldName;
+                // First check if schema has mapper for this field
+                const column = this.schema.columns[fieldName];
+                if (column) {
+                    const config = column.build();
+                    if (config.mapper) {
+                        // Add mapper info to the metadata
+                        enhancedMetadata[key] = {
+                            ...value,
+                            getMapper: () => config.mapper,
+                        };
+                        continue;
+                    }
+                }
+                // Check original selection for mapper (for aliased fields like p.key.distinctDay)
+                if (mockOriginalSelection && fieldName in mockOriginalSelection) {
+                    const origValue = mockOriginalSelection[fieldName];
+                    if (typeof origValue === 'object' && origValue !== null && '__fieldName' in origValue) {
+                        const origFieldName = origValue.__fieldName;
+                        const origColumn = this.schema.columns[origFieldName];
+                        if (origColumn) {
+                            const config = origColumn.build();
+                            if (config.mapper) {
+                                enhancedMetadata[key] = {
+                                    ...value,
+                                    getMapper: () => config.mapper,
+                                };
+                                continue;
+                            }
+                        }
+                    }
+                }
+            }
+            // No mapper found, use original value
+            enhancedMetadata[key] = value;
+        }
+        return enhancedMetadata;
+    }
     /**
      * Execute query and return first result or null
      */
@@ -282,7 +384,9 @@ class GroupedSelectQueryBuilder {
             outerContext.paramCounter = context.paramCounter;
             return sql;
         };
-        return new subquery_1.Subquery(sqlBuilder, mode);
+        // Get selection metadata with mappers for table subqueries
+        const selectionMetadata = mode === 'table' ? this.getSelectionMetadata() : undefined;
+        return new subquery_1.Subquery(sqlBuilder, mode, selectionMetadata);
     }
     /**
      * Build SQL for use in CTEs - public interface for CTE builder
@@ -453,12 +557,34 @@ class GroupedSelectQueryBuilder {
         const mockRow = this.createMockRow();
         const mockOriginalSelection = this.originalSelector(mockRow);
         const mockGroupingKey = this.groupingKeySelector(mockOriginalSelection);
-        const mockGroup = this.createMockGroupedItem();
+        // Create mock grouped item using the SAME grouping key (not a fresh one)
+        // This ensures SqlFragment instances are shared between GROUP BY and SELECT
+        const mockGroup = {
+            key: mockGroupingKey,
+            count: () => createAggregateFieldRef('COUNT'),
+            sum: (selector) => createAggregateFieldRef('SUM', selector),
+            min: (selector) => createAggregateFieldRef('MIN', selector),
+            max: (selector) => createAggregateFieldRef('MAX', selector),
+            avg: (selector) => createAggregateFieldRef('AVG', selector),
+        };
         const mockResult = this.resultSelector(mockGroup);
         // Extract GROUP BY fields from the grouping key
+        // We build these first and cache the SQL for SqlFragments so they can be reused in SELECT
         const groupByFields = [];
+        const sqlFragmentCache = new Map(); // Cache built SQL for reuse in SELECT
         for (const [key, value] of Object.entries(mockGroupingKey)) {
-            if (typeof value === 'object' && value !== null && '__dbColumnName' in value) {
+            if (value instanceof conditions_1.SqlFragment) {
+                // SqlFragment in GROUP BY - build the SQL expression and cache it
+                const sqlBuildContext = {
+                    paramCounter: context.paramCounter,
+                    params: context.allParams,
+                };
+                const fragmentSql = value.buildSql(sqlBuildContext);
+                context.paramCounter = sqlBuildContext.paramCounter;
+                groupByFields.push(fragmentSql);
+                sqlFragmentCache.set(value, fragmentSql);
+            }
+            else if (typeof value === 'object' && value !== null && '__dbColumnName' in value) {
                 const field = value;
                 const tableAlias = field.__tableAlias || this.schema.name;
                 groupByFields.push(`"${tableAlias}"."${field.__dbColumnName}"`);
@@ -477,8 +603,9 @@ class GroupedSelectQueryBuilder {
                 }
                 else if (aggField.__aggregateSelector) {
                     // SUM, MIN, MAX, AVG with selector
-                    const mockOriginalRow = this.createMockRow();
-                    const field = aggField.__aggregateSelector(mockOriginalRow);
+                    // Note: The selector references fields from the ORIGINAL SELECTION (after first .select()),
+                    // not the raw table row. So we need to use mockOriginalSelection, not a fresh mock row.
+                    const field = aggField.__aggregateSelector(mockOriginalSelection);
                     if (typeof field === 'object' && field !== null && '__dbColumnName' in field) {
                         const fieldRef = field;
                         const tableAlias = fieldRef.__tableAlias || this.schema.name;
@@ -505,8 +632,8 @@ class GroupedSelectQueryBuilder {
                     selectParts.push(`CAST(COUNT(*) AS INTEGER) as "${alias}"`);
                 }
                 else if (agg.__selector) {
-                    const mockOriginalRow = this.createMockRow();
-                    const field = agg.__selector(mockOriginalRow);
+                    // Use mockOriginalSelection - the selector references fields from the first .select()
+                    const field = agg.__selector(mockOriginalSelection);
                     if (typeof field === 'object' && field !== null && '__dbColumnName' in field) {
                         const fieldRef = field;
                         const tableAlias = fieldRef.__tableAlias || this.schema.name;
@@ -526,14 +653,22 @@ class GroupedSelectQueryBuilder {
                 selectParts.push(`"${tableAlias}"."${field.__dbColumnName}" as "${alias}"`);
             }
             else if (value instanceof conditions_1.SqlFragment) {
-                // SQL fragment
-                const sqlBuildContext = {
-                    paramCounter: context.paramCounter,
-                    params: context.allParams,
-                };
-                const fragmentSql = value.buildSql(sqlBuildContext);
-                context.paramCounter = sqlBuildContext.paramCounter;
-                selectParts.push(`${fragmentSql} as "${alias}"`);
+                // SQL fragment - check if we already built this for GROUP BY
+                const cachedSql = sqlFragmentCache.get(value);
+                if (cachedSql) {
+                    // Reuse the cached SQL to ensure same parameter numbers
+                    selectParts.push(`${cachedSql} as "${alias}"`);
+                }
+                else {
+                    // Build new SQL for this fragment
+                    const sqlBuildContext = {
+                        paramCounter: context.paramCounter,
+                        params: context.allParams,
+                    };
+                    const fragmentSql = value.buildSql(sqlBuildContext);
+                    context.paramCounter = sqlBuildContext.paramCounter;
+                    selectParts.push(`${fragmentSql} as "${alias}"`);
+                }
             }
         }
         // Detect navigation property references in WHERE and add JOINs
@@ -621,9 +756,9 @@ class GroupedSelectQueryBuilder {
      */
     createMockRow() {
         const mock = {};
-        // Add columns as FieldRef objects
-        for (const [colName, colBuilder] of Object.entries(this.schema.columns)) {
-            const dbColumnName = colBuilder.build().name;
+        // Add columns as FieldRef objects - use pre-computed column name map if available
+        const columnNameMap = (0, query_builder_1.getColumnNameMapForSchema)(this.schema);
+        for (const [colName, dbColumnName] of columnNameMap) {
             Object.defineProperty(mock, colName, {
                 get: () => ({
                     __fieldName: colName,
@@ -635,15 +770,11 @@ class GroupedSelectQueryBuilder {
             });
         }
         // Add navigation properties (collections and single references)
-        const relationSchemas = new Map();
-        for (const [relName, relConfig] of Object.entries(this.schema.relations)) {
-            if (relConfig.targetTableBuilder) {
-                relationSchemas.set(relName, relConfig.targetTableBuilder.build());
-            }
-        }
-        for (const [relName, relConfig] of Object.entries(this.schema.relations)) {
+        // Performance: Use pre-computed relation entries and cached schemas
+        const relationEntries = (0, query_builder_1.getRelationEntriesForSchema)(this.schema);
+        for (const [relName, relConfig] of relationEntries) {
+            const targetSchema = (0, query_builder_1.getTargetSchemaForRelation)(this.schema, relName, relConfig);
             if (relConfig.type === 'many') {
-                const targetSchema = relationSchemas.get(relName);
                 Object.defineProperty(mock, relName, {
                     get: () => {
                         return new query_builder_1.CollectionQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKey || relConfig.foreignKeys?.[0] || '', this.schema.name, targetSchema);
@@ -653,7 +784,6 @@ class GroupedSelectQueryBuilder {
                 });
             }
             else {
-                const targetSchema = relationSchemas.get(relName);
                 Object.defineProperty(mock, relName, {
                     get: () => {
                         const refBuilder = new query_builder_1.ReferenceQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKeys || [relConfig.foreignKey || ''], relConfig.matches || [], relConfig.isMandatory ?? false, targetSchema);
@@ -669,8 +799,8 @@ class GroupedSelectQueryBuilder {
             if (join.isSubquery || !join.schema) {
                 continue;
             }
-            for (const [colName, colBuilder] of Object.entries(join.schema.columns)) {
-                const dbColumnName = colBuilder.build().name;
+            const joinColumnNameMap = (0, query_builder_1.getColumnNameMapForSchema)(join.schema);
+            for (const [colName, dbColumnName] of joinColumnNameMap) {
                 if (!mock[join.alias]) {
                     mock[join.alias] = {};
                 }
@@ -760,27 +890,13 @@ class GroupedSelectQueryBuilder {
         for (const [, value] of Object.entries(selection)) {
             if (value && typeof value === 'object' && '__tableAlias' in value && '__dbColumnName' in value) {
                 // This is a FieldRef with a table alias - check if it's from a related table
-                const tableAlias = value.__tableAlias;
-                if (tableAlias !== this.schema.name && !joins.some(j => j.alias === tableAlias)) {
-                    // This references a related table - find the relation and add a JOIN
-                    const relation = this.schema.relations[tableAlias];
-                    if (relation && relation.type === 'one') {
-                        // Get target schema from targetTableBuilder if available
-                        let targetSchema;
-                        if (relation.targetTableBuilder) {
-                            const targetTableSchema = relation.targetTableBuilder.build();
-                            targetSchema = targetTableSchema.schema;
-                        }
-                        // Add a JOIN for this reference
-                        joins.push({
-                            alias: tableAlias,
-                            targetTable: relation.targetTable,
-                            targetSchema,
-                            foreignKeys: relation.foreignKeys || [relation.foreignKey || ''],
-                            matches: relation.matches || [],
-                            isMandatory: relation.isMandatory ?? false,
-                        });
-                    }
+                this.addJoinForFieldRef(value, joins);
+            }
+            else if (value instanceof conditions_1.SqlFragment) {
+                // SqlFragment may contain navigation property references - extract them
+                const fieldRefs = value.getFieldRefs();
+                for (const fieldRef of fieldRefs) {
+                    this.addJoinForFieldRef(fieldRef, joins);
                 }
             }
             else if (value && typeof value === 'object' && !Array.isArray(value)) {
@@ -789,6 +905,36 @@ class GroupedSelectQueryBuilder {
             }
         }
     }
+    /**
+     * Add a JOIN for a FieldRef if it references a related table
+     */
+    addJoinForFieldRef(fieldRef, joins) {
+        if (!fieldRef || typeof fieldRef !== 'object' || !('__tableAlias' in fieldRef) || !('__dbColumnName' in fieldRef)) {
+            return;
+        }
+        const tableAlias = fieldRef.__tableAlias;
+        if (tableAlias && tableAlias !== this.schema.name && !joins.some(j => j.alias === tableAlias)) {
+            // This references a related table - find the relation and add a JOIN
+            const relation = this.schema.relations[tableAlias];
+            if (relation && relation.type === 'one') {
+                // Get target schema from targetTableBuilder if available
+                let targetSchema;
+                if (relation.targetTableBuilder) {
+                    const targetTableSchema = relation.targetTableBuilder.build();
+                    targetSchema = targetTableSchema.schema;
+                }
+                // Add a JOIN for this reference
+                joins.push({
+                    alias: tableAlias,
+                    targetTable: relation.targetTable,
+                    targetSchema,
+                    foreignKeys: relation.foreignKeys || [relation.foreignKey || ''],
+                    matches: relation.matches || [],
+                    isMandatory: relation.isMandatory ?? false,
+                });
+            }
+        }
+    }
     /**
      * Build HAVING condition SQL - handles aggregate field refs specially
      */
@@ -974,20 +1120,63 @@ class GroupedJoinedQueryBuilder {
         const selectionMetadata = this.resultSelector(mockLeft, mockRight);
         return new subquery_1.Subquery(sqlBuilder, mode, selectionMetadata);
     }
+    /**
+     * Get CTEs used by this query builder
+     * @internal
+     */
+    getReferencedCtes() {
+        return this.cte ? [this.cte] : [];
+    }
+    /**
+     * Get selection metadata for mapper preservation in CTEs
+     * Enhances the selection result with mapper info from the left subquery
+     * @internal
+     */
+    getSelectionMetadata() {
+        const mockLeft = this.createLeftMock();
+        const mockRight = this.createRightMock();
+        const mockResult = this.resultSelector(mockLeft, mockRight);
+        // Get mapper metadata from the left subquery
+        const leftMetadata = this.leftSubquery.getSelectionMetadata();
+        // Build enhanced metadata with mappers
+        const enhancedMetadata = {};
+        for (const [key, value] of Object.entries(mockResult)) {
+            // Check if it's a FieldRef from the left side
+            if (typeof value === 'object' && value !== null && '__fieldName' in value) {
+                const fieldName = value.__fieldName;
+                // Check if left metadata has mapper for this field
+                if (leftMetadata && fieldName in leftMetadata) {
+                    const leftValue = leftMetadata[fieldName];
+                    if (typeof leftValue === 'object' && leftValue !== null && typeof leftValue.getMapper === 'function') {
+                        enhancedMetadata[key] = {
+                            ...value,
+                            getMapper: leftValue.getMapper,
+                        };
+                        continue;
+                    }
+                }
+            }
+            // No mapper found, use original value
+            enhancedMetadata[key] = value;
+        }
+        return enhancedMetadata;
+    }
     /**
      * Build SQL for use in CTEs - public interface for CTE builder
+     * This returns SQL WITHOUT the WITH clause - CTEs should be extracted separately via getReferencedCtes()
      * @internal
      */
     buildCteQuery(queryContext) {
-        return this.buildQuery(queryContext);
+        return this.buildQuery(queryContext, true);
     }
     /**
      * Build the SQL query
+     * @param skipCteClause If true, don't include WITH clause (for embedding in outer CTEs)
      */
-    buildQuery(context) {
-        // Build CTE clause if needed
+    buildQuery(context, skipCteClause = false) {
+        // Build CTE clause if needed (unless we're being embedded in another CTE)
         let cteClause = '';
-        if (this.cte) {
+        if (this.cte && !skipCteClause) {
             cteClause = `WITH "${this.cte.name}" AS (${this.cte.query})\n`;
             context.allParams.push(...this.cte.params);
             context.paramCounter += this.cte.params.length;