linkgress-orm 0.0.3 → 0.1.1

package/dist/query/grouped-query.js

@@ -1,8 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GroupedSelectQueryBuilder = exports.GroupedQueryBuilder = void 0;
+exports.GroupedJoinedQueryBuilder = exports.GroupedSelectQueryBuilder = exports.GroupedQueryBuilder = void 0;
 const conditions_1 = require("./conditions");
+const query_utils_1 = require("./query-utils");
 const subquery_1 = require("./subquery");
+const query_builder_1 = require("./query-builder");
+const cte_builder_1 = require("./cte-builder");
 /**
  * Create an aggregate field reference that can be used in conditions
  */
@@ -80,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,
@@ -93,13 +96,38 @@ class GroupedQueryBuilder {
                 configurable: true,
             });
         }
+        // Add navigation properties (collections and single references)
+        // 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') {
+                Object.defineProperty(mock, relName, {
+                    get: () => {
+                        return new query_builder_1.CollectionQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKey || relConfig.foreignKeys?.[0] || '', this.schema.name, targetSchema);
+                    },
+                    enumerable: true,
+                    configurable: true,
+                });
+            }
+            else {
+                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);
+                        return refBuilder.createMockTargetRow();
+                    },
+                    enumerable: true,
+                    configurable: true,
+                });
+            }
+        }
         // Add columns from manually joined tables
         for (const join of this.manualJoins) {
             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] = {};
                 }
@@ -166,35 +194,7 @@ class GroupedSelectQueryBuilder {
         const mockGroup = this.createMockGroupedItem();
         const mockResult = this.resultSelector(mockGroup);
         const result = selector(mockResult);
-        // Handle array of [field, direction] tuples
-        if (Array.isArray(result) && result.length > 0 && Array.isArray(result[0])) {
-            for (const [fieldRef, direction] of result) {
-                if (fieldRef && typeof fieldRef === 'object' && '__fieldName' in fieldRef) {
-                    this.orderByFields.push({
-                        field: fieldRef.__dbColumnName || fieldRef.__fieldName,
-                        direction: direction || 'ASC'
-                    });
-                }
-            }
-        }
-        // Handle array of fields (all ASC)
-        else if (Array.isArray(result)) {
-            for (const fieldRef of result) {
-                if (fieldRef && typeof fieldRef === 'object' && '__fieldName' in fieldRef) {
-                    this.orderByFields.push({
-                        field: fieldRef.__dbColumnName || fieldRef.__fieldName,
-                        direction: 'ASC'
-                    });
-                }
-            }
-        }
-        // Handle single field
-        else if (result && typeof result === 'object' && '__fieldName' in result) {
-            this.orderByFields.push({
-                field: result.__dbColumnName || result.__fieldName,
-                direction: 'ASC'
-            });
-        }
+        (0, query_utils_1.parseOrderBy)(result, this.orderByFields);
         return this;
     }
     /**
@@ -279,6 +279,167 @@ class GroupedSelectQueryBuilder {
         };
         return new subquery_1.Subquery(sqlBuilder, mode);
     }
+    /**
+     * Build SQL for use in CTEs - public interface for CTE builder
+     * @internal
+     */
+    buildCteQuery(queryContext) {
+        return this.buildQuery(queryContext);
+    }
+    /**
+     * Add a LEFT JOIN to the grouped query result
+     * This wraps the grouped query as a subquery and joins to it
+     *
+     * @example
+     * const result = await db.orders
+     *   .select(o => ({ customerId: o.customerId, total: o.total }))
+     *   .groupBy(o => ({ customerId: o.customerId }))
+     *   .select(g => ({ customerId: g.key.customerId, totalSum: g.sum(o => o.total) }))
+     *   .leftJoin(
+     *     customerDetailsCte,
+     *     (grouped, details) => eq(grouped.customerId, details.customerId),
+     *     (grouped, details) => ({ ...grouped, details: details.items })
+     *   )
+     *   .toList();
+     */
+    leftJoin(rightSource, condition, selector, alias) {
+        return this.joinInternal('LEFT', rightSource, condition, selector, alias);
+    }
+    /**
+     * Add an INNER JOIN to the grouped query result
+     * This wraps the grouped query as a subquery and joins to it
+     */
+    innerJoin(rightSource, condition, selector, alias) {
+        return this.joinInternal('INNER', rightSource, condition, selector, alias);
+    }
+    /**
+     * Internal join implementation
+     */
+    joinInternal(joinType, rightSource, condition, selector, alias) {
+        // Wrap this grouped query as a subquery
+        const leftSubquery = this.asSubquery('table');
+        const leftAlias = 'grouped_0';
+        // Determine the right alias and source info
+        let rightAlias;
+        let isCteJoin = false;
+        let cte;
+        if ((0, cte_builder_1.isCte)(rightSource)) {
+            rightAlias = rightSource.name;
+            isCteJoin = true;
+            cte = rightSource;
+        }
+        else {
+            if (!alias) {
+                throw new Error('Alias is required when joining a subquery');
+            }
+            rightAlias = alias;
+        }
+        // Create mock for left (the grouped query result)
+        const mockLeft = this.createMockForSelection(leftAlias);
+        // Create mock for right - at runtime these are already FieldRef-like objects
+        const mockRight = (isCteJoin
+            ? this.createMockForCte(cte)
+            : this.createMockForSubquery(rightAlias, rightSource));
+        // Evaluate the join condition
+        const joinCondition = condition(mockLeft, mockRight);
+        // Create the result selector
+        const createLeftMock = () => this.createMockForSelection(leftAlias);
+        const createRightMock = () => (isCteJoin
+            ? this.createMockForCte(cte)
+            : this.createMockForSubquery(rightAlias, rightSource));
+        return new GroupedJoinedQueryBuilder(this.schema, this.client, leftSubquery, leftAlias, rightSource, rightAlias, joinType, joinCondition, selector, createLeftMock, createRightMock, this.executor, isCteJoin ? cte : undefined);
+    }
+    /**
+     * Create a mock object for the current selection (for join conditions)
+     * The key is the alias used in the SELECT clause, so we use it as __dbColumnName
+     */
+    createMockForSelection(alias) {
+        const mockGroup = this.createMockGroupedItem();
+        const mockResult = this.resultSelector(mockGroup);
+        // Wrap with alias - always use the key as the column name since
+        // that's what the subquery SELECT clause uses as the alias
+        const wrapped = {};
+        for (const [key, value] of Object.entries(mockResult)) {
+            // Preserve mapper if present
+            const mapper = (typeof value === 'object' && value !== null && typeof value.getMapper === 'function')
+                ? { getMapper: () => value.getMapper() }
+                : {};
+            wrapped[key] = {
+                __fieldName: key,
+                __dbColumnName: key, // Use key as column name (the subquery alias)
+                __tableAlias: alias,
+                ...mapper,
+            };
+        }
+        return wrapped;
+    }
+    /**
+     * Create a mock for a subquery result
+     */
+    createMockForSubquery(alias, subquery) {
+        const selectionMetadata = subquery.getSelectionMetadata();
+        return new Proxy({}, {
+            get(target, prop) {
+                if (typeof prop === 'symbol')
+                    return undefined;
+                if (selectionMetadata && prop in selectionMetadata) {
+                    const value = selectionMetadata[prop];
+                    if (typeof value === 'object' && value !== null && typeof value.getMapper === 'function') {
+                        return {
+                            __fieldName: prop,
+                            __dbColumnName: prop,
+                            __tableAlias: alias,
+                            getMapper: () => value.getMapper(),
+                        };
+                    }
+                }
+                return {
+                    __fieldName: prop,
+                    __dbColumnName: prop,
+                    __tableAlias: alias,
+                };
+            },
+            has() { return true; },
+            ownKeys() { return []; },
+            getOwnPropertyDescriptor() {
+                return { enumerable: true, configurable: true };
+            }
+        });
+    }
+    /**
+     * Create a mock for a CTE
+     */
+    createMockForCte(cte) {
+        const alias = cte.name;
+        const selectionMetadata = cte.selectionMetadata;
+        return new Proxy({}, {
+            get(target, prop) {
+                if (typeof prop === 'symbol')
+                    return undefined;
+                if (selectionMetadata && prop in selectionMetadata) {
+                    const value = selectionMetadata[prop];
+                    if (typeof value === 'object' && value !== null && typeof value.getMapper === 'function') {
+                        return {
+                            __fieldName: prop,
+                            __dbColumnName: prop,
+                            __tableAlias: alias,
+                            getMapper: () => value.getMapper(),
+                        };
+                    }
+                }
+                return {
+                    __fieldName: prop,
+                    __dbColumnName: prop,
+                    __tableAlias: alias,
+                };
+            },
+            has() { return true; },
+            ownKeys() { return []; },
+            getOwnPropertyDescriptor() {
+                return { enumerable: true, configurable: true };
+            }
+        });
+    }
     /**
      * Build the SQL query for grouped results
      */
@@ -287,12 +448,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}"`);
@@ -311,8 +494,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;
@@ -339,8 +523,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;
@@ -360,18 +544,45 @@ 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
+        const navigationJoins = [];
+        // Detect joins from the original selection (navigation properties used in select)
+        this.detectAndAddJoinsFromSelection(mockOriginalSelection, navigationJoins);
+        // Detect joins from WHERE condition
+        this.detectAndAddJoinsFromCondition(this.whereCond, navigationJoins);
         // Build FROM clause with JOINs
         let fromClause = `FROM "${this.schema.name}"`;
+        // Add navigation property JOINs first
+        for (const navJoin of navigationJoins) {
+            const joinType = navJoin.isMandatory ? 'INNER JOIN' : 'LEFT JOIN';
+            const targetTableName = navJoin.targetSchema
+                ? `"${navJoin.targetSchema}"."${navJoin.targetTable}"`
+                : `"${navJoin.targetTable}"`;
+            // Build join condition: source.foreignKey = target.match
+            const joinConditions = navJoin.foreignKeys.map((fk, i) => {
+                const targetCol = navJoin.matches[i] || 'id';
+                return `"${this.schema.name}"."${fk}" = "${navJoin.alias}"."${targetCol}"`;
+            });
+            fromClause += `\n${joinType} ${targetTableName} AS "${navJoin.alias}" ON ${joinConditions.join(' AND ')}`;
+        }
         // Add manual JOINs
         for (const manualJoin of this.manualJoins) {
             const joinTypeStr = manualJoin.type === 'INNER' ? 'INNER JOIN' : 'LEFT JOIN';
@@ -436,9 +647,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,
@@ -449,13 +660,38 @@ class GroupedSelectQueryBuilder {
                 configurable: true,
             });
         }
+        // Add navigation properties (collections and single references)
+        // 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') {
+                Object.defineProperty(mock, relName, {
+                    get: () => {
+                        return new query_builder_1.CollectionQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKey || relConfig.foreignKeys?.[0] || '', this.schema.name, targetSchema);
+                    },
+                    enumerable: true,
+                    configurable: true,
+                });
+            }
+            else {
+                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);
+                        return refBuilder.createMockTargetRow();
+                    },
+                    enumerable: true,
+                    configurable: true,
+                });
+            }
+        }
         // Add columns from manually joined tables
         for (const join of this.manualJoins) {
             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] = {};
                 }
@@ -498,6 +734,98 @@ class GroupedSelectQueryBuilder {
             },
         };
     }
+    /**
+     * Detect navigation property references in a WHERE condition and add necessary JOINs
+     */
+    detectAndAddJoinsFromCondition(condition, joins) {
+        if (!condition) {
+            return;
+        }
+        // Get all field references from the condition
+        const fieldRefs = condition.getFieldRefs();
+        for (const fieldRef of fieldRefs) {
+            if ('__tableAlias' in fieldRef && fieldRef.__tableAlias) {
+                const tableAlias = fieldRef.__tableAlias;
+                // Check if this references a related table that isn't already joined
+                if (tableAlias !== this.schema.name && !joins.some(j => j.alias === tableAlias)) {
+                    // Find the relation config for this navigation
+                    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,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Detect navigation properties in a selection and add JOINs for them
+     */
+    detectAndAddJoinsFromSelection(selection, joins) {
+        if (!selection || typeof selection !== 'object') {
+            return;
+        }
+        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
+                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)) {
+                // Recursively check nested objects
+                this.detectAndAddJoinsFromSelection(value, joins);
+            }
+        }
+    }
+    /**
+     * 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
      */
@@ -585,4 +913,208 @@ class GroupedSelectQueryBuilder {
     }
 }
 exports.GroupedSelectQueryBuilder = GroupedSelectQueryBuilder;
+/**
+ * Query builder for grouped queries that have been joined
+ * This handles the case where a GroupedSelectQueryBuilder is joined with a CTE or subquery
+ */
+class GroupedJoinedQueryBuilder {
+    constructor(schema, client, leftSubquery, leftAlias, rightSource, rightAlias, joinType, joinCondition, resultSelector, createLeftMock, createRightMock, executor, cte) {
+        this.orderByFields = [];
+        this.additionalJoins = [];
+        this.schema = schema;
+        this.client = client;
+        this.leftSubquery = leftSubquery;
+        this.leftAlias = leftAlias;
+        this.rightSource = rightSource;
+        this.rightAlias = rightAlias;
+        this.joinType = joinType;
+        this.joinCondition = joinCondition;
+        this.resultSelector = resultSelector;
+        this.createLeftMock = createLeftMock;
+        this.createRightMock = createRightMock;
+        this.executor = executor;
+        this.cte = cte;
+    }
+    /**
+     * Limit results
+     */
+    limit(count) {
+        this.limitValue = count;
+        return this;
+    }
+    /**
+     * Offset results
+     */
+    offset(count) {
+        this.offsetValue = count;
+        return this;
+    }
+    orderBy(selector) {
+        const mockLeft = this.createLeftMock();
+        const mockRight = this.createRightMock();
+        const mockResult = this.resultSelector(mockLeft, mockRight);
+        const result = selector(mockResult);
+        (0, query_utils_1.parseOrderBy)(result, this.orderByFields, query_utils_1.getQualifiedFieldName);
+        return this;
+    }
+    /**
+     * Execute query and return results
+     */
+    async toList() {
+        const context = {
+            ctes: new Map(),
+            cteCounter: 0,
+            paramCounter: 1,
+            allParams: [],
+        };
+        const { sql, params } = this.buildQuery(context);
+        const result = this.executor
+            ? await this.executor.query(sql, params)
+            : await this.client.query(sql, params);
+        return result.rows;
+    }
+    /**
+     * Execute query and return first result or null
+     */
+    async first() {
+        const results = await this.limit(1).toList();
+        return results.length > 0 ? results[0] : null;
+    }
+    /**
+     * Execute query and return first result or throw
+     */
+    async firstOrThrow() {
+        const result = await this.first();
+        if (!result) {
+            throw new Error('No results found');
+        }
+        return result;
+    }
+    /**
+     * Convert to subquery for use in other queries
+     */
+    asSubquery(mode = 'table') {
+        const sqlBuilder = (outerContext) => {
+            const context = {
+                ctes: new Map(),
+                cteCounter: 0,
+                paramCounter: outerContext.paramCounter,
+                allParams: outerContext.params,
+            };
+            const { sql } = this.buildQuery(context);
+            outerContext.paramCounter = context.paramCounter;
+            return sql;
+        };
+        // Preserve selection metadata for mappers
+        const mockLeft = this.createLeftMock();
+        const mockRight = this.createRightMock();
+        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] : [];
+    }
+    /**
+     * 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, true);
+    }
+    /**
+     * Build the SQL query
+     * @param skipCteClause If true, don't include WITH clause (for embedding in outer CTEs)
+     */
+    buildQuery(context, skipCteClause = false) {
+        // Build CTE clause if needed (unless we're being embedded in another CTE)
+        let cteClause = '';
+        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;
+        }
+        // Build SELECT clause from result selector
+        const mockLeft = this.createLeftMock();
+        const mockRight = this.createRightMock();
+        const mockResult = this.resultSelector(mockLeft, mockRight);
+        const selectParts = [];
+        for (const [alias, value] of Object.entries(mockResult)) {
+            if (typeof value === 'object' && value !== null && '__dbColumnName' in value) {
+                const field = value;
+                const tableAlias = field.__tableAlias;
+                if (tableAlias) {
+                    selectParts.push(`"${tableAlias}"."${field.__dbColumnName}" as "${alias}"`);
+                }
+                else {
+                    selectParts.push(`"${field.__dbColumnName}" as "${alias}"`);
+                }
+            }
+            else if (value instanceof conditions_1.SqlFragment) {
+                const sqlBuildContext = {
+                    paramCounter: context.paramCounter,
+                    params: context.allParams,
+                };
+                const fragmentSql = value.buildSql(sqlBuildContext);
+                context.paramCounter = sqlBuildContext.paramCounter;
+                selectParts.push(`${fragmentSql} as "${alias}"`);
+            }
+            else {
+                selectParts.push(`"${alias}"`);
+            }
+        }
+        // Build FROM clause with the left subquery
+        const leftSqlContext = {
+            paramCounter: context.paramCounter,
+            params: context.allParams,
+        };
+        const leftSql = this.leftSubquery.buildSql(leftSqlContext);
+        context.paramCounter = leftSqlContext.paramCounter;
+        let fromClause = `FROM (${leftSql}) AS "${this.leftAlias}"`;
+        // Build JOIN clause
+        const joinTypeStr = this.joinType === 'INNER' ? 'INNER JOIN' : 'LEFT JOIN';
+        const condBuilder = new conditions_1.ConditionBuilder();
+        const { sql: condSql, params: condParams } = condBuilder.build(this.joinCondition, context.paramCounter);
+        context.paramCounter += condParams.length;
+        context.allParams.push(...condParams);
+        if (this.cte) {
+            // Join to CTE
+            fromClause += `\n${joinTypeStr} "${this.rightAlias}" ON ${condSql}`;
+        }
+        else {
+            // Join to subquery
+            const rightSqlContext = {
+                paramCounter: context.paramCounter,
+                params: context.allParams,
+            };
+            const rightSql = this.rightSource.buildSql(rightSqlContext);
+            context.paramCounter = rightSqlContext.paramCounter;
+            fromClause += `\n${joinTypeStr} (${rightSql}) AS "${this.rightAlias}" ON ${condSql}`;
+        }
+        // Build ORDER BY clause
+        let orderByClause = '';
+        if (this.orderByFields.length > 0) {
+            const orderParts = this.orderByFields.map(({ field, direction }) => `${field} ${direction}`);
+            orderByClause = `ORDER BY ${orderParts.join(', ')}`;
+        }
+        // Build LIMIT/OFFSET
+        let limitClause = '';
+        if (this.limitValue !== undefined) {
+            limitClause = `LIMIT ${this.limitValue}`;
+        }
+        if (this.offsetValue !== undefined) {
+            limitClause += ` OFFSET ${this.offsetValue}`;
+        }
+        const finalQuery = `${cteClause}SELECT ${selectParts.join(', ')}\n${fromClause}\n${orderByClause}\n${limitClause}`.trim();
+        return {
+            sql: finalQuery,
+            params: context.allParams,
+        };
+    }
+}
+exports.GroupedJoinedQueryBuilder = GroupedJoinedQueryBuilder;
 //# sourceMappingURL=grouped-query.js.map