linkgress-orm 0.2.11 → 0.2.14

package/dist/query/query-builder.js

@@ -13,6 +13,8 @@ const subquery_1 = require("./subquery");
 const grouped_query_1 = require("./grouped-query");
 const cte_builder_1 = require("./cte-builder");
 const collection_strategy_factory_1 = require("./collection-strategy.factory");
+const union_builder_1 = require("./union-builder");
+const future_query_1 = require("./future-query");
 /**
  * Field type categories for optimized result transformation
  * const enum is inlined at compile time for zero runtime overhead
@@ -1068,6 +1070,177 @@ class SelectQueryBuilder {
             : await this.client.query(sql, params);
         return result.rows[0]?.exists === true;
     }
+    /**
+     * Combine this query with another using UNION (removes duplicates)
+     *
+     * @param query Another SelectQueryBuilder with compatible selection type
+     * @returns A UnionQueryBuilder for further chaining
+     *
+     * @example
+     * ```typescript
+     * const result = await db.users
+     *   .select(u => ({ id: u.id, name: u.name }))
+     *   .union(db.customers.select(c => ({ id: c.id, name: c.name })))
+     *   .orderBy(r => r.name)
+     *   .toList();
+     * ```
+     */
+    union(query) {
+        const unionBuilder = new union_builder_1.UnionQueryBuilder(this, this.client, this.executor);
+        return unionBuilder.union(query);
+    }
+    /**
+     * Combine this query with another using UNION ALL (keeps all rows including duplicates)
+     *
+     * @param query Another SelectQueryBuilder with compatible selection type
+     * @returns A UnionQueryBuilder for further chaining
+     *
+     * @example
+     * ```typescript
+     * // UNION ALL is faster than UNION as it doesn't need to remove duplicates
+     * const allLogs = await db.errorLogs
+     *   .select(l => ({ timestamp: l.createdAt, message: l.message }))
+     *   .unionAll(db.infoLogs.select(l => ({ timestamp: l.createdAt, message: l.message })))
+     *   .orderBy(r => r.timestamp)
+     *   .toList();
+     * ```
+     */
+    unionAll(query) {
+        const unionBuilder = new union_builder_1.UnionQueryBuilder(this, this.client, this.executor);
+        return unionBuilder.unionAll(query);
+    }
+    /**
+     * Build SQL for use in UNION queries (without ORDER BY, LIMIT, OFFSET)
+     * @internal Used by UnionQueryBuilder
+     */
+    buildUnionSql(context) {
+        const queryContext = {
+            ctes: new Map(),
+            cteCounter: 0,
+            paramCounter: context.paramCounter,
+            allParams: context.params,
+            collectionStrategy: this.collectionStrategy,
+            executor: this.executor,
+        };
+        const mockRow = this._createMockRow();
+        const selectionResult = this.selector(mockRow);
+        // Build query without ORDER BY, LIMIT, OFFSET for union component
+        const { sql } = this.buildQueryCore(selectionResult, queryContext, false);
+        // Update context's param counter
+        context.paramCounter = queryContext.paramCounter;
+        return sql;
+    }
+    /**
+     * Create a future query that will be executed later.
+     * Use with FutureQueryRunner.runAsync() for batch execution.
+     *
+     * @returns A FutureQuery that can be executed individually or in a batch
+     *
+     * @example
+     * ```typescript
+     * const q1 = db.users.select(u => ({ id: u.id, name: u.username })).future();
+     * const q2 = db.posts.select(p => ({ title: p.title })).future();
+     *
+     * // Execute in a single roundtrip
+     * const [users, posts] = await FutureQueryRunner.runAsync([q1, q2]);
+     * ```
+     */
+    future() {
+        const context = {
+            ctes: new Map(),
+            cteCounter: 0,
+            paramCounter: 1,
+            allParams: [],
+            collectionStrategy: this.collectionStrategy,
+            executor: this.executor,
+        };
+        const mockRow = this._createMockRow();
+        const selectionResult = this.selector(mockRow);
+        const { sql, params, nestedPaths } = this.buildQuery(selectionResult, context);
+        // Create transform function that captures current state
+        const transformFn = (rows) => {
+            if (rows.length === 0)
+                return [];
+            // Reconstruct nested objects if needed
+            let processedRows = rows;
+            if (nestedPaths.size > 0) {
+                processedRows = rows.map(row => this.reconstructNestedObjects(row, nestedPaths));
+            }
+            return this.transformResults(processedRows, selectionResult);
+        };
+        return new future_query_1.FutureQuery(sql, params, transformFn, this.client, this.executor);
+    }
+    /**
+     * Create a future query that returns a single result or null.
+     * Use with FutureQueryRunner.runAsync() for batch execution.
+     *
+     * @returns A FutureSingleQuery that resolves to a single result or null
+     *
+     * @example
+     * ```typescript
+     * const q1 = db.users.where(u => eq(u.id, 1)).select(u => u).futureFirstOrDefault();
+     * const q2 = db.posts.where(p => eq(p.id, 5)).select(p => p).futureFirstOrDefault();
+     *
+     * const [user, post] = await FutureQueryRunner.runAsync([q1, q2]);
+     * // user: User | null
+     * // post: Post | null
+     * ```
+     */
+    futureFirstOrDefault() {
+        // Apply LIMIT 1 for efficiency
+        const originalLimit = this.limitValue;
+        this.limitValue = 1;
+        const context = {
+            ctes: new Map(),
+            cteCounter: 0,
+            paramCounter: 1,
+            allParams: [],
+            collectionStrategy: this.collectionStrategy,
+            executor: this.executor,
+        };
+        const mockRow = this._createMockRow();
+        const selectionResult = this.selector(mockRow);
+        const { sql, params, nestedPaths } = this.buildQuery(selectionResult, context);
+        // Restore original limit
+        this.limitValue = originalLimit;
+        // Create transform function
+        const transformFn = (rows) => {
+            if (rows.length === 0)
+                return [];
+            let processedRows = rows;
+            if (nestedPaths.size > 0) {
+                processedRows = rows.map(row => this.reconstructNestedObjects(row, nestedPaths));
+            }
+            return this.transformResults(processedRows, selectionResult);
+        };
+        return new future_query_1.FutureSingleQuery(sql, params, transformFn, this.client, this.executor);
+    }
+    /**
+     * Create a future query that returns a count.
+     * Use with FutureQueryRunner.runAsync() for batch execution.
+     *
+     * @returns A FutureCountQuery that resolves to a number
+     *
+     * @example
+     * ```typescript
+     * const q1 = db.users.futureCount();
+     * const q2 = db.posts.futureCount();
+     * const q3 = db.comments.where(c => eq(c.isPublished, true)).futureCount();
+     *
+     * const [userCount, postCount, commentCount] = await FutureQueryRunner.runAsync([q1, q2, q3]);
+     * ```
+     */
+    futureCount() {
+        const context = {
+            ctes: new Map(),
+            cteCounter: 0,
+            paramCounter: 1,
+            allParams: [],
+            executor: this.executor,
+        };
+        const { sql, params } = this.buildAggregateQuery(context, 'count');
+        return new future_query_1.FutureCountQuery(sql, params, this.client, this.executor);
+    }
     /**
      * Execute query and return results as array
      * Collection results are automatically resolved to arrays
@@ -3412,6 +3585,237 @@ ${joinClauses.join('\n')}`;
             nestedPaths,
         };
     }
+    /**
+     * Build the core SQL query, optionally excluding ORDER BY, LIMIT, and OFFSET
+     * Used by buildUnionSql to build component queries for UNION
+     * @internal
+     */
+    buildQueryCore(selection, context, includeOrderLimitOffset = true) {
+        // Handle user-defined CTEs first - their params need to come before main query params
+        for (const cte of this.ctes) {
+            context.allParams.push(...cte.params);
+            context.paramCounter += cte.params.length;
+        }
+        const selectParts = [];
+        const collectionFields = [];
+        const joins = [];
+        const nestedPaths = new Set();
+        // Scan selection for navigation property references and add JOINs
+        this.detectAndAddJoinsFromSelection(selection, joins);
+        // Scan WHERE condition for navigation property references and add JOINs
+        this.detectAndAddJoinsFromCondition(this.whereCond, joins);
+        // Handle case where selection is a single value (not an object with properties)
+        if (selection instanceof conditions_1.SqlFragment) {
+            const sqlBuildContext = {
+                paramCounter: context.paramCounter,
+                params: context.allParams,
+            };
+            const fragmentSql = selection.buildSql(sqlBuildContext);
+            context.paramCounter = sqlBuildContext.paramCounter;
+            selectParts.push(fragmentSql);
+        }
+        else if (typeof selection === 'object' && selection !== null && '__dbColumnName' in selection) {
+            const tableAlias = ('__tableAlias' in selection && selection.__tableAlias) ? selection.__tableAlias : this.schema.name;
+            selectParts.push(`"${tableAlias}"."${selection.__dbColumnName}"`);
+        }
+        else if (selection instanceof CollectionQueryBuilder) {
+            throw new Error('Cannot use CollectionQueryBuilder directly as selection');
+        }
+        else {
+            // Process selection object properties
+            for (const [key, value] of Object.entries(selection)) {
+                if (value instanceof CollectionQueryBuilder || (value && typeof value === 'object' && '__collectionResult' in value)) {
+                    // Collection fields are not supported in UNION queries for simplicity
+                    // Skip them - they would need complex handling
+                    continue;
+                }
+                else if (value instanceof subquery_1.Subquery || (value && typeof value === 'object' && 'buildSql' in value && typeof value.buildSql === 'function' && '__mode' in value)) {
+                    const sqlBuildContext = {
+                        paramCounter: context.paramCounter,
+                        params: context.allParams,
+                    };
+                    const subquerySql = value.buildSql(sqlBuildContext);
+                    context.paramCounter = sqlBuildContext.paramCounter;
+                    selectParts.push(`(${subquerySql}) as "${key}"`);
+                }
+                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 "${key}"`);
+                }
+                else if (typeof value === 'object' && value !== null && '__dbColumnName' in value) {
+                    if ('__tableAlias' in value && value.__tableAlias && typeof value.__tableAlias === 'string') {
+                        const tableAlias = value.__tableAlias;
+                        const columnName = value.__dbColumnName;
+                        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,
+                            });
+                        }
+                        const cteJoin = this.manualJoins.find(j => j.cte && j.cte.name === tableAlias);
+                        if (cteJoin && cteJoin.cte && cteJoin.cte.isAggregationColumn(columnName)) {
+                            selectParts.push(`COALESCE("${tableAlias}"."${columnName}", '[]'::json) as "${key}"`);
+                        }
+                        else {
+                            selectParts.push(`"${tableAlias}"."${columnName}" as "${key}"`);
+                        }
+                    }
+                    else {
+                        selectParts.push(`"${this.schema.name}"."${value.__dbColumnName}" as "${key}"`);
+                    }
+                }
+                else if (typeof value === 'string') {
+                    selectParts.push(`"${this.schema.name}"."${value}" as "${key}"`);
+                }
+                else if (typeof value === 'object' && value !== null) {
+                    if (!('__dbColumnName' in value)) {
+                        if (Array.isArray(value)) {
+                            continue;
+                        }
+                        if (value instanceof CollectionQueryBuilder) {
+                            continue;
+                        }
+                        else if (value instanceof ReferenceQueryBuilder) {
+                            continue; // Skip ReferenceQueryBuilder in union queries
+                        }
+                    }
+                    selectParts.push(`$${context.paramCounter++} as "${key}"`);
+                    context.allParams.push(value);
+                }
+                else if (value === undefined) {
+                    continue;
+                }
+                else {
+                    selectParts.push(`$${context.paramCounter++} as "${key}"`);
+                    context.allParams.push(value);
+                }
+            }
+        }
+        // Build WHERE clause
+        let whereClause = '';
+        if (this.whereCond) {
+            const condBuilder = new conditions_1.ConditionBuilder();
+            const { sql, params, placeholders, paramCounter: newParamCounter } = condBuilder.build(this.whereCond, context.paramCounter, context.placeholders);
+            whereClause = `WHERE ${sql}`;
+            context.paramCounter = newParamCounter;
+            context.allParams.push(...params);
+            if (placeholders) {
+                context.placeholders = placeholders;
+            }
+        }
+        // Build ORDER BY clause (only if includeOrderLimitOffset is true)
+        let orderByClause = '';
+        if (includeOrderLimitOffset && this.orderByFields.length > 0) {
+            const colNameMap = getColumnNameMapForSchema(this.schema);
+            const orderParts = this.orderByFields.map(({ field, direction }) => {
+                if (selection && typeof selection === 'object' && !Array.isArray(selection) && field in selection) {
+                    return `"${field}" ${direction}`;
+                }
+                else {
+                    const dbColumnName = colNameMap.get(field) ?? field;
+                    return `"${this.schema.name}"."${dbColumnName}" ${direction}`;
+                }
+            });
+            orderByClause = `ORDER BY ${orderParts.join(', ')}`;
+        }
+        // Build LIMIT/OFFSET (only if includeOrderLimitOffset is true)
+        let limitClause = '';
+        if (includeOrderLimitOffset) {
+            if (this.limitValue !== undefined) {
+                limitClause = `LIMIT ${this.limitValue}`;
+            }
+            if (this.offsetValue !== undefined) {
+                limitClause += ` OFFSET ${this.offsetValue}`;
+            }
+        }
+        // Build final query with CTEs
+        let finalQuery = '';
+        const allCtes = [];
+        for (const cte of this.ctes) {
+            allCtes.push(`"${cte.name}" AS (${cte.query})`);
+        }
+        if (context.ctes.size > 0) {
+            for (const [cteName, { sql }] of context.ctes.entries()) {
+                allCtes.push(`"${cteName}" AS (${sql})`);
+            }
+        }
+        if (allCtes.length > 0) {
+            finalQuery = `WITH ${allCtes.join(', ')}\n`;
+        }
+        // Build main query
+        const qualifiedTableName = this.getQualifiedTableName(this.schema.name, this.schema.schema);
+        let fromClause = `FROM ${qualifiedTableName}`;
+        // Add manual JOINs
+        for (const manualJoin of this.manualJoins) {
+            const joinTypeStr = manualJoin.type === 'INNER' ? 'INNER JOIN' : 'LEFT JOIN';
+            const condBuilder = new conditions_1.ConditionBuilder();
+            const { sql: condSql, params: condParams, placeholders: joinPlaceholders, paramCounter: newParamCounter } = condBuilder.build(manualJoin.condition, context.paramCounter, context.placeholders);
+            context.paramCounter = newParamCounter;
+            context.allParams.push(...condParams);
+            if (joinPlaceholders) {
+                context.placeholders = joinPlaceholders;
+            }
+            if (manualJoin.cte) {
+                fromClause += `\n${joinTypeStr} "${manualJoin.cte.name}" ON ${condSql}`;
+            }
+            else if (manualJoin.isSubquery && manualJoin.subquery) {
+                const subqueryBuildContext = {
+                    paramCounter: context.paramCounter,
+                    params: context.allParams,
+                };
+                const subquerySql = manualJoin.subquery.buildSql(subqueryBuildContext);
+                context.paramCounter = subqueryBuildContext.paramCounter;
+                fromClause += `\n${joinTypeStr} (${subquerySql}) AS "${manualJoin.alias}" ON ${condSql}`;
+            }
+            else {
+                fromClause += `\n${joinTypeStr} "${manualJoin.table}" AS "${manualJoin.alias}" ON ${condSql}`;
+            }
+        }
+        // Add JOINs for single navigation
+        for (const join of joins) {
+            const joinType = join.isMandatory ? 'INNER JOIN' : 'LEFT JOIN';
+            const sourceTable = join.sourceAlias || this.schema.name;
+            const onConditions = [];
+            for (let i = 0; i < join.foreignKeys.length; i++) {
+                const fk = join.foreignKeys[i];
+                const match = join.matches[i];
+                onConditions.push(`"${sourceTable}"."${fk}" = "${join.alias}"."${match}"`);
+            }
+            const joinTableName = this.getQualifiedTableName(join.targetTable, join.targetSchema);
+            fromClause += `\n${joinType} ${joinTableName} AS "${join.alias}" ON ${onConditions.join(' AND ')}`;
+        }
+        // Add DISTINCT if needed
+        const distinctClause = this.isDistinct ? 'DISTINCT ' : '';
+        // Build final SQL
+        const queryParts = [`SELECT ${distinctClause}${selectParts.join(', ')}`, fromClause];
+        if (whereClause)
+            queryParts.push(whereClause);
+        if (orderByClause)
+            queryParts.push(orderByClause);
+        if (limitClause)
+            queryParts.push(limitClause);
+        finalQuery += queryParts.join('\n').trim();
+        return {
+            sql: finalQuery,
+            params: context.allParams,
+            nestedPaths,
+        };
+    }
     /**
      * Transform database results
      */
@@ -4907,21 +5311,19 @@ class CollectionQueryBuilder {
                 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) {
+                // However, correlated subqueries (used for toNumberList, etc.) don't need joins -
+                // they are embedded directly in the SELECT expression
+                if (nestedResult.tableName && (nestedResult.isCTE || nestedResult.joinClause)) {
                     let nestedJoinClause;
                     if (nestedResult.isCTE) {
                         // CTE strategy: join by parent_id
                         // The join should be: this.targetTable.id = nestedCte.parent_id
                         nestedJoinClause = `LEFT JOIN "${nestedResult.tableName}" ON "${this.targetTable}"."id" = "${nestedResult.tableName}".parent_id`;
                     }
-                    else if (nestedResult.joinClause) {
+                    else {
                         // LATERAL strategy: use the provided join clause (contains full LATERAL subquery)
                         nestedJoinClause = nestedResult.joinClause;
                     }
-                    else {
-                        // Fallback for other strategies
-                        nestedJoinClause = `LEFT JOIN "${nestedResult.tableName}" ON "${this.targetTable}"."id" = "${nestedResult.tableName}".parent_id`;
-                    }
                     return {
                         alias,
                         expression: nestedResult.selectExpression || nestedResult.sql,
@@ -4938,6 +5340,17 @@ class CollectionQueryBuilder {
                     };
                 }
                 // The nested collection becomes a correlated subquery in SELECT
+                // For scalar aggregations (count, min, max, sum), don't include nestedCollectionInfo
+                // because the result is a scalar value, not a structured object that needs transformation
+                const aggregationType = field.getAggregationType();
+                const isScalarAggregation = aggregationType && ['COUNT', 'MIN', 'MAX', 'SUM'].includes(aggregationType);
+                if (isScalarAggregation) {
+                    // Scalar aggregation - just return the expression, no nested transformation needed
+                    return {
+                        alias,
+                        expression: nestedResult.selectExpression || nestedResult.sql,
+                    };
+                }
                 return {
                     alias,
                     expression: nestedResult.selectExpression || nestedResult.sql,