@mikro-orm/sql 7.0.0-rc.0 → 7.0.0-rc.1

package/AbstractSqlDriver.d.ts

@@ -19,6 +19,7 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     private getTableProps;
     /** Creates a FormulaTable object for use in formula callbacks. */
     private createFormulaTable;
+    private validateSqlOptions;
     createEntityManager(useContext?: boolean): this[typeof EntityManagerType];
     private createQueryBuilderFromOptions;
     find<T extends object, P extends string = never, F extends string = PopulatePath.ALL, E extends string = never>(entityName: EntityName<T>, where: ObjectQuery<T>, options?: FindOptions<T, P, F, E>): Promise<EntityData<T>[]>;
@@ -30,6 +31,11 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     protected streamFromVirtual<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: StreamOptions<T, any>): AsyncIterableIterator<EntityData<T>>;
     protected wrapVirtualExpressionInSubquery<T extends object>(meta: EntityMetadata<T>, expression: string, where: FilterQuery<T>, options: FindOptions<T, any>, type: QueryType): Promise<T[] | number>;
     protected wrapVirtualExpressionInSubqueryStream<T extends object>(meta: EntityMetadata<T>, expression: string, where: FilterQuery<T>, options: FindOptions<T, any, any, any>, type: QueryType.SELECT): AsyncIterableIterator<T>;
+    /**
+     * Virtual entities have no PKs, so to-many populate joins can't be deduplicated.
+     * Force balanced strategy to load to-many relations via separate queries.
+     */
+    private forceBalancedStrategy;
     mapResult<T extends object>(result: EntityData<T>, meta: EntityMetadata<T>, populate?: PopulateOptions<T>[], qb?: QueryBuilder<T, any, any, any>, map?: Dictionary): EntityData<T> | null;
     /**
      * Maps aliased columns from TPT parent tables back to their original field names.
@@ -134,6 +140,7 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     protected buildOrderBy<T extends object>(qb: QueryBuilder<T, any, any, any>, meta: EntityMetadata<T>, populate: PopulateOptions<T>[], options: Pick<FindOptions<any>, 'strategy' | 'orderBy' | 'populateOrderBy'>): QueryOrderMap<T>[];
     protected buildPopulateOrderBy<T extends object>(qb: QueryBuilder<T, any, any, any>, meta: EntityMetadata<T>, populateOrderBy: QueryOrderMap<T>[], parentPath: string, explicit: boolean, parentAlias?: string): QueryOrderMap<T>[];
     protected buildJoinedPropsOrderBy<T extends object>(qb: QueryBuilder<T, any, any, any>, meta: EntityMetadata<T>, populate: PopulateOptions<T>[], options?: Pick<FindOptions<any>, 'strategy' | 'orderBy' | 'populateOrderBy'>, parentPath?: string): QueryOrderMap<T>[];
+    private buildToManyOrderBy;
     protected normalizeFields<T extends object>(fields: InternalField<T>[], prefix?: string): string[];
     protected processField<T extends object>(meta: EntityMetadata<T>, prop: EntityProperty<T> | undefined, field: string, ret: InternalField<T>[]): void;
     protected buildFields<T extends object>(meta: EntityMetadata<T>, populate: PopulateOptions<T>[], joinedProps: PopulateOptions<T>[], qb: QueryBuilder<T, any, any, any>, alias: string, options: Pick<FindOptions<T, any, any, any>, 'strategy' | 'fields' | 'exclude'>, schema?: string): InternalField<T>[];

package/AbstractSqlDriver.js

@@ -32,6 +32,14 @@ export class AbstractSqlDriver extends DatabaseDriver {
         const qualifiedName = effectiveSchema ? `${effectiveSchema}.${meta.tableName}` : meta.tableName;
         return { alias, name: meta.tableName, schema: effectiveSchema, qualifiedName, toString: () => alias };
     }
+    validateSqlOptions(options) {
+        if (options.collation != null && typeof options.collation !== 'string') {
+            throw new Error('Collation option for SQL drivers must be a string (collation name). Use a CollationOptions object only with MongoDB.');
+        }
+        if (options.indexHint != null && typeof options.indexHint !== 'string') {
+            throw new Error('indexHint for SQL drivers must be a string (e.g. \'force index(my_index)\'). Use an object only with MongoDB.');
+        }
+    }
     createEntityManager(useContext) {
         const EntityManagerClass = this.config.get('entityManager', SqlEntityManager);
         return new EntityManagerClass(this.config, this, this.metadata, useContext);
@@ -49,6 +57,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         if (Utils.isPrimaryKey(where, meta.compositePK)) {
             where = { [Utils.getPrimaryKeyHash(meta.primaryKeys)]: where };
         }
+        this.validateSqlOptions(options);
         const { first, last, before, after } = options;
         const isCursorPagination = [first, last, before, after].some(v => v != null);
         qb.__populateWhere = options._populateWhere;
@@ -59,6 +68,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
             .groupBy(options.groupBy)
             .having(options.having)
             .indexHint(options.indexHint)
+            .collation(options.collation)
             .comment(options.comments)
             .hintComment(options.hintComments);
         if (isCursorPagination) {
@@ -180,7 +190,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         yield* res;
     }
     async wrapVirtualExpressionInSubquery(meta, expression, where, options, type) {
-        const qb = await this.createQueryBuilderFromOptions(meta, where, options);
+        const qb = await this.createQueryBuilderFromOptions(meta, where, this.forceBalancedStrategy(options));
         qb.setFlag(QueryFlag.DISABLE_PAGINATE);
         const isCursorPagination = [options.first, options.last, options.before, options.after].some(v => v != null);
         const native = qb.getNativeQuery(false);
@@ -199,7 +209,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         return res.map(row => this.mapResult(row, meta));
     }
     async *wrapVirtualExpressionInSubqueryStream(meta, expression, where, options, type) {
-        const qb = await this.createQueryBuilderFromOptions(meta, where, options);
+        const qb = await this.createQueryBuilderFromOptions(meta, where, this.forceBalancedStrategy(options));
         qb.unsetFlag(QueryFlag.DISABLE_PAGINATE);
         const native = qb.getNativeQuery(false);
         native.from(raw(`(${expression}) as ${this.platform.quoteIdentifier(qb.alias)}`));
@@ -210,6 +220,24 @@ export class AbstractSqlDriver extends DatabaseDriver {
             yield this.mapResult(row, meta);
         }
     }
+    /**
+     * Virtual entities have no PKs, so to-many populate joins can't be deduplicated.
+     * Force balanced strategy to load to-many relations via separate queries.
+     */
+    forceBalancedStrategy(options) {
+        const clearStrategy = (hints) => {
+            return hints.map(hint => ({
+                ...hint,
+                strategy: undefined,
+                children: hint.children ? clearStrategy(hint.children) : undefined,
+            }));
+        };
+        const opts = { ...options, strategy: 'balanced' };
+        if (Array.isArray(opts.populate)) {
+            opts.populate = clearStrategy(opts.populate);
+        }
+        return opts;
+    }
     mapResult(result, meta, populate = [], qb, map = {}) {
         // For TPT inheritance, map aliased parent table columns back to their field names
         if (qb && meta.inheritanceType === 'tpt' && meta.tptParent) {
@@ -474,8 +502,10 @@ export class AbstractSqlDriver extends DatabaseDriver {
         if (meta && !Utils.isEmpty(populate)) {
             this.buildFields(meta, populate, joinedProps, qb, qb.alias, options, schema);
         }
+        this.validateSqlOptions(options);
         qb.__populateWhere = options._populateWhere;
         qb.indexHint(options.indexHint)
+            .collation(options.collation)
             .comment(options.comments)
             .hintComment(options.hintComments)
             .groupBy(options.groupBy)
@@ -1486,7 +1516,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
             return [raw(`${this.evaluateFormula(prop.formula, columns, table)} as ${aliased}`)];
         }
         return prop.fieldNames.map(fieldName => {
-            return `${tableAlias}.${fieldName} as ${tableAlias}__${fieldName}`;
+            return raw('?? as ??', [`${tableAlias}.${fieldName}`, `${tableAlias}__${fieldName}`]);
         });
     }
     /** @internal */
@@ -1639,38 +1669,41 @@ export class AbstractSqlDriver extends DatabaseDriver {
         for (const hint of joinedProps) {
             const [propName, ref] = hint.field.split(':', 2);
             const prop = meta.properties[propName];
-            const propOrderBy = prop.orderBy;
             let path = `${parentPath}.${propName}`;
             if (prop.kind === ReferenceKind.MANY_TO_MANY && ref) {
                 path += '[pivot]';
             }
-            const join = qb.getJoinForPath(path, { matchPopulateJoins: true });
-            const propAlias = qb.getAliasForJoinPath(join ?? path, { matchPopulateJoins: true });
-            if (prop.kind === ReferenceKind.MANY_TO_MANY && prop.fixedOrder && join) {
-                const alias = ref ? propAlias : join.ownerAlias;
-                orderBy.push({ [`${alias}.${prop.fixedOrderColumn}`]: QueryOrder.ASC });
-            }
-            const effectiveOrderBy = QueryHelper.mergeOrderBy(propOrderBy, prop.targetMeta?.orderBy);
-            for (const item of effectiveOrderBy) {
-                for (const field of Utils.getObjectQueryKeys(item)) {
-                    const order = item[field];
-                    if (RawQueryFragment.isKnownFragmentSymbol(field)) {
-                        const { sql, params } = RawQueryFragment.getKnownFragment(field);
-                        const sql2 = propAlias ? sql.replace(new RegExp(ALIAS_REPLACEMENT_RE, 'g'), propAlias) : sql;
-                        const key = raw(sql2, params);
-                        orderBy.push({ [key]: order });
-                        continue;
-                    }
-                    orderBy.push({ [`${propAlias}.${field}`]: order });
-                }
+            if ([ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(prop.kind)) {
+                this.buildToManyOrderBy(qb, prop, path, ref, orderBy);
             }
             if (hint.children) {
-                const buildJoinedPropsOrderBy = this.buildJoinedPropsOrderBy(qb, prop.targetMeta, hint.children, options, path);
-                orderBy.push(...buildJoinedPropsOrderBy);
+                orderBy.push(...this.buildJoinedPropsOrderBy(qb, prop.targetMeta, hint.children, options, path));
             }
         }
         return orderBy;
     }
+    buildToManyOrderBy(qb, prop, path, ref, orderBy) {
+        const join = qb.getJoinForPath(path, { matchPopulateJoins: true });
+        const propAlias = qb.getAliasForJoinPath(join ?? path, { matchPopulateJoins: true });
+        if (prop.kind === ReferenceKind.MANY_TO_MANY && prop.fixedOrder && join) {
+            const alias = ref ? propAlias : join.ownerAlias;
+            orderBy.push({ [`${alias}.${prop.fixedOrderColumn}`]: QueryOrder.ASC });
+        }
+        const effectiveOrderBy = QueryHelper.mergeOrderBy(prop.orderBy, prop.targetMeta?.orderBy);
+        for (const item of effectiveOrderBy) {
+            for (const field of Utils.getObjectQueryKeys(item)) {
+                const order = item[field];
+                if (RawQueryFragment.isKnownFragmentSymbol(field)) {
+                    const { sql, params } = RawQueryFragment.getKnownFragment(field);
+                    const sql2 = propAlias ? sql.replace(new RegExp(ALIAS_REPLACEMENT_RE, 'g'), propAlias) : sql;
+                    const key = raw(sql2, params);
+                    orderBy.push({ [key]: order });
+                    continue;
+                }
+                orderBy.push({ [`${propAlias}.${field}`]: order });
+            }
+        }
+    }
     normalizeFields(fields, prefix = '') {
         const ret = [];
         for (const field of fields) {

package/AbstractSqlPlatform.d.ts

@@ -33,5 +33,12 @@ export declare abstract class AbstractSqlPlatform extends Platform {
     /**
      * @internal
      */
-    getOrderByExpression(column: string, direction: string): string[];
+    getOrderByExpression(column: string, direction: string, collation?: string): string[];
+    /**
+     * Quotes a collation name for use in COLLATE clauses.
+     * @internal
+     */
+    quoteCollation(collation: string): string;
+    /** @internal */
+    protected validateCollationName(collation: string): void;
 }

package/AbstractSqlPlatform.js

@@ -94,7 +94,24 @@ export class AbstractSqlPlatform extends Platform {
     /**
      * @internal
      */
-    getOrderByExpression(column, direction) {
+    getOrderByExpression(column, direction, collation) {
+        if (collation) {
+            return [`${column} collate ${this.quoteCollation(collation)} ${direction.toLowerCase()}`];
+        }
         return [`${column} ${direction.toLowerCase()}`];
     }
+    /**
+     * Quotes a collation name for use in COLLATE clauses.
+     * @internal
+     */
+    quoteCollation(collation) {
+        this.validateCollationName(collation);
+        return this.quoteIdentifier(collation);
+    }
+    /** @internal */
+    validateCollationName(collation) {
+        if (!/^[\w]+$/.test(collation)) {
+            throw new Error(`Invalid collation name: '${collation}'. Collation names must contain only word characters.`);
+        }
+    }
 }

package/dialects/mysql/BaseMySqlPlatform.d.ts

@@ -41,6 +41,6 @@ export declare class BaseMySqlPlatform extends AbstractSqlPlatform {
     supportsCreatingFullTextIndex(): boolean;
     getFullTextWhereClause(): string;
     getFullTextIndexExpression(indexName: string, schemaName: string | undefined, tableName: string, columns: SimpleColumnMeta[]): string;
-    getOrderByExpression(column: string, direction: string): string[];
+    getOrderByExpression(column: string, direction: string, collation?: string): string[];
     getDefaultClientUrl(): string;
 }

package/dialects/mysql/BaseMySqlPlatform.js

@@ -105,13 +105,14 @@ export class BaseMySqlPlatform extends AbstractSqlPlatform {
         const quotedIndexName = this.quoteIdentifier(indexName);
         return `alter table ${quotedTableName} add fulltext index ${quotedIndexName}(${quotedColumnNames.join(',')})`;
     }
-    getOrderByExpression(column, direction) {
+    getOrderByExpression(column, direction, collation) {
         const ret = [];
         const dir = direction.toLowerCase();
+        const col = collation ? `${column} collate ${this.quoteCollation(collation)}` : column;
         if (dir in this.ORDER_BY_NULLS_TRANSLATE) {
-            ret.push(`${column} ${this.ORDER_BY_NULLS_TRANSLATE[dir]}`);
+            ret.push(`${col} ${this.ORDER_BY_NULLS_TRANSLATE[dir]}`);
         }
-        ret.push(`${column} ${dir.replace(/(\s|nulls|first|last)*/gi, '')}`);
+        ret.push(`${col} ${dir.replace(/(\s|nulls|first|last)*/gi, '')}`);
         return ret;
     }
     getDefaultClientUrl() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.0.0-rc.0",
+  "version": "7.0.0-rc.1",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "type": "module",
   "exports": {
@@ -56,6 +56,6 @@
     "@mikro-orm/core": "^6.6.4"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-rc.0"
+    "@mikro-orm/core": "7.0.0-rc.1"
   }
 }

package/query/ObjectCriteriaNode.js

@@ -90,7 +90,7 @@ export class ObjectCriteriaNode extends CriteriaNode {
             const operator = Utils.isOperator(field);
             const isRawField = RawQueryFragment.isKnownFragmentSymbol(field);
             // we need to keep the prefixing for formulas otherwise we would lose aliasing context when nesting inside group operators
-            const virtual = childNode.prop?.persist === false && !childNode.prop?.formula;
+            const virtual = childNode.prop?.persist === false && !childNode.prop?.formula && !!options?.type;
             // if key is missing, we are inside group operator and we need to prefix with alias
             const primaryKey = this.key && this.metadata.find(this.entityName)?.primaryKeys.includes(field);
             const isToOne = childNode.prop && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(childNode.prop.kind);

package/query/QueryBuilder.d.ts

@@ -52,14 +52,16 @@ type AddToContext<Type extends object, Context, Field extends string, Alias exte
     [K in Alias]: [GetPath<Context, Field>, K, ExpandProperty<Type[GetPropName<Field> & keyof Type]>, Select];
 };
 type GetPath<Context, Field extends string> = GetAlias<Field> extends infer Alias ? IsNever<Alias> extends true ? GetPropName<Field> : Alias extends keyof Context ? Context[Alias] extends [infer Path, ...any[]] ? AppendToHint<Path & string, GetPropName<Field>> : GetPropName<Field> : GetPropName<Field> : GetPropName<Field>;
-type GetType<Type extends object, Context, Field extends string> = GetAlias<Field> extends infer Alias ? IsNever<Alias> extends true ? Type : Alias extends keyof Context ? Context[Alias] extends [string, string, infer PropType, any] ? PropType & object : Type : Type : Type;
+type GetType<Type extends object, Context, Field extends string> = GetAlias<Field> extends infer Alias ? IsNever<Alias> extends true ? Type : [Context] extends [never] ? Type : Alias extends keyof Context ? Context[Alias] extends [string, string, infer PropType, any] ? PropType & object : Type : Type : Type;
 type AddToHint<RootAlias, Context, Field extends string, Select extends boolean = false> = Select extends true ? GetAlias<Field> extends infer Alias ? IsNever<Alias> extends true ? GetPropName<Field> : Alias extends RootAlias ? GetPropName<Field> : Alias extends keyof Context ? Context[Alias] extends [infer Path, ...any[]] ? AppendToHint<Path & string, GetPropName<Field>> : GetPropName<Field> : GetPropName<Field> : GetPropName<Field> : never;
 export type ModifyHint<RootAlias, Context, Hint extends string, Field extends string, Select extends boolean = false> = Hint | AddToHint<RootAlias, Context, Field, Select>;
 export type ModifyContext<Entity extends object, Context, Field extends string, Alias extends string, Select extends boolean = false> = IsNever<Context> extends true ? AddToContext<GetType<Entity, object, Field>, object, Field, Alias, Select> : Context & AddToContext<GetType<Entity, Context, Field>, Context, Field, Alias, Select>;
 type StripRootAlias<F extends string, RootAlias extends string, Context = never> = F extends `${RootAlias}.${infer Field}` ? Field : F extends `${infer Alias}.${string}` ? Alias extends AliasNames<Context> ? never : F : F;
-type ExtractRootFields<Fields, RootAlias extends string, Context = never> = [Fields] extends ['*'] ? '*' : Fields extends `${RootAlias}.*` ? '*' : Fields extends string ? StripRootAlias<Fields, RootAlias, Context> : never;
+type StripFieldAlias<F extends string> = F extends `${infer Path} as ${string}` ? Path : F;
+type ExtractRootFields<Fields, RootAlias extends string, Context = never> = [Fields] extends ['*'] ? '*' : Fields extends `${RootAlias}.*` ? '*' : Fields extends string ? StripRootAlias<StripFieldAlias<Fields>, RootAlias, Context> : never;
 type PrefixWithPath<Path extends string, Field extends string> = `${Path}.${Field}`;
 type StripJoinAlias<F extends string, Alias extends string> = F extends `${Alias}.${infer Field}` ? Field : F;
+export type JoinSelectField<JoinedEntity, Alias extends string> = (keyof JoinedEntity & string) | `${Alias}.${keyof JoinedEntity & string}`;
 type AddJoinFields<RootAlias, Context, Field extends string, Alias extends string, JoinFields extends readonly string[]> = JoinFields extends readonly (infer F)[] ? F extends string ? PrefixWithPath<AddToHint<RootAlias, Context, Field, true> & string, StripJoinAlias<F, Alias>> : never : never;
 export type ModifyFields<CurrentFields extends string, RootAlias, Context, Field extends string, Alias extends string, JoinFields extends readonly string[] | undefined> = JoinFields extends readonly string[] ? CurrentFields | AddJoinFields<RootAlias, Context, Field, Alias, JoinFields> : CurrentFields;
 type EntityRelations<T> = EntityKey<T, true>;
@@ -68,25 +70,33 @@ type AliasNames<Context> = Context[keyof Context] extends infer Join ? Join exte
 type ContextRelationKeys<Context> = Context[keyof Context] extends infer Join ? Join extends any ? Join extends [string, infer Alias, infer Type, any] ? `${Alias & string}.${EntityRelations<Type & object>}` : never : never : never;
 export type QBField<Entity, RootAlias extends string, Context> = EntityRelations<Entity> | `${RootAlias}.${EntityRelations<Entity>}` | ([Context] extends [never] ? never : ContextRelationKeys<Context>);
 type ContextFieldKeys<Context> = Context[keyof Context] extends infer Join ? Join extends any ? Join extends [string, infer Alias, infer Type, any] ? `${Alias & string}.${keyof Type & string}` : never : never : never;
-export type Field<Entity, RootAlias extends string = never, Context = never> = EntityKey<Entity> | (IsNever<RootAlias> extends true ? never : `${RootAlias}.${EntityKey<Entity>}` | `${RootAlias}.*`) | ([Context] extends [never] ? never : ContextFieldKeys<Context> | `${AliasNames<Context>}.*`) | '*' | QueryBuilder<any> | NativeQueryBuilder | RawQueryFragment<any> | (RawQueryFragment & symbol);
+type WithAlias<T extends string> = T | `${T} as ${string}`;
+export type Field<Entity, RootAlias extends string = never, Context = never> = WithAlias<EntityKey<Entity>> | (IsNever<RootAlias> extends true ? never : WithAlias<`${RootAlias}.${EntityKey<Entity>}`> | `${RootAlias}.*`) | ([Context] extends [never] ? never : WithAlias<ContextFieldKeys<Context>> | `${AliasNames<Context>}.*`) | '*' | QueryBuilder<any> | NativeQueryBuilder | RawQueryFragment<any> | (RawQueryFragment & symbol);
 type RootAliasOrderKeys<RootAlias extends string, Entity> = {
     [K in `${RootAlias}.${EntityKey<Entity>}`]?: QueryOrderKeysFlat;
 };
 type ContextOrderKeys<Context> = {
     [K in ContextFieldKeys<Context>]?: QueryOrderKeysFlat;
 };
-export type ContextOrderByMap<Entity, RootAlias extends string = never, Context = never> = QueryOrderMap<Entity> | ((IsNever<RootAlias> extends true ? {} : RootAliasOrderKeys<RootAlias, Entity>) & ([Context] extends [never] ? {} : ContextOrderKeys<Context>));
+type RawOrderKeys<RawAliases extends string> = {
+    [K in RawAliases]?: QueryOrderKeysFlat;
+};
+export type ContextOrderByMap<Entity, RootAlias extends string = never, Context = never, RawAliases extends string = never> = QueryOrderMap<Entity> | ((IsNever<RootAlias> extends true ? {} : RootAliasOrderKeys<RootAlias, Entity>) & ([Context] extends [never] ? {} : ContextOrderKeys<Context>) & (IsNever<RawAliases> extends true ? {} : string extends RawAliases ? {} : RawOrderKeys<RawAliases>));
 type AliasedPath<Alias extends string, Type, P extends string> = P extends `${Alias}.*` ? P : P extends `${Alias}.${infer Rest}` ? `${Alias}.${AutoPath<Type & object, Rest, `${PopulatePath.ALL}`>}` : never;
 type ContextAliasedPath<Context, P extends string> = Context[keyof Context] extends infer Join ? Join extends any ? Join extends [string, infer Alias, infer Type, any] ? AliasedPath<Alias & string, Type, P> : never : never : never;
-type NestedAutoPath<Entity, RootAlias extends string, Context, P extends string> = P extends `${string}:ref` ? never : AliasedPath<RootAlias, Entity, P> | ContextAliasedPath<Context, P> | AutoPath<Entity, P, `${PopulatePath.ALL}`>;
+type NestedAutoPath<Entity, RootAlias extends string, Context, P extends string> = P extends `${string}:ref` ? never : P extends `${infer Path} as ${string}` ? (AliasedPath<RootAlias, Entity, Path> | ContextAliasedPath<Context, Path> | AutoPath<Entity, Path, `${PopulatePath.ALL}`>) extends never ? never : P : AliasedPath<RootAlias, Entity, P> | ContextAliasedPath<Context, P> | AutoPath<Entity, P, `${PopulatePath.ALL}`>;
 type AliasedObjectQuery<Entity extends object, Alias extends string> = {
     [K in EntityKey<Entity> as `${Alias}.${K}`]?: ObjectQuery<Entity>[K];
 };
-type JoinCondition<JoinedEntity extends object, Alias extends string> = ObjectQuery<JoinedEntity> | AliasedObjectQuery<JoinedEntity, Alias>;
+type JoinCondition<JoinedEntity extends object, Alias extends string> = (ObjectQuery<JoinedEntity> | AliasedObjectQuery<JoinedEntity, Alias>) & {
+    $not?: JoinCondition<JoinedEntity, Alias>;
+    $or?: JoinCondition<JoinedEntity, Alias>[];
+    $and?: JoinCondition<JoinedEntity, Alias>[];
+};
 type RawJoinCondition = {
     [key: string]: FilterValue<Scalar> | RawQueryFragment;
 };
-type ExtractRawAliasFromField<F> = F extends RawQueryFragment<infer A> ? (A extends string ? A : never) : never;
+type ExtractRawAliasFromField<F> = F extends RawQueryFragment<infer A> ? (A extends string ? A : never) : F extends `${string} as ${infer A}` ? A : never;
 type ExtractRawAliasesFromTuple<T extends readonly unknown[]> = T extends readonly [infer Head, ...infer Tail] ? ExtractRawAliasFromField<Head> | ExtractRawAliasesFromTuple<Tail> : never;
 type ExtractRawAliases<Fields> = Fields extends readonly unknown[] ? ExtractRawAliasesFromTuple<Fields> : ExtractRawAliasFromField<Fields>;
 type FlatOperatorMap = {
@@ -194,6 +204,7 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     protected _joinedProps: Map<string, PopulateOptions<any>>;
     protected _cache?: boolean | number | [string, number];
     protected _indexHint?: string;
+    protected _collation?: string;
     protected _comments: string[];
     protected _hintComments: string[];
     protected flushMode?: FlushMode;
@@ -228,6 +239,10 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      * // Select with raw expressions
      * qb.select([raw('count(*) as total')]);
      *
+     * // Select with aliases (works for regular and formula properties)
+     * qb.select(['id', 'fullName as displayName']);
+     * qb.select(['id', sql.ref('fullName').as('displayName')]);
+     *
      * // Select with distinct
      * qb.select('*', true);
      * ```
@@ -396,11 +411,11 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      *   .where({ 'a.name': 'John' });
      * ```
      */
-    joinAndSelect<Field extends QBField<Entity, RootAlias, Context>, Alias extends string, const JoinFields extends readonly string[] | undefined = undefined>(field: Field | [Field, RawQueryFragment | QueryBuilder<any>], alias: Alias, cond?: JoinCondition<JoinedEntityType<Entity, Context, Field & string>, Alias>, type?: JoinType, path?: string, fields?: JoinFields, schema?: string): SelectQueryBuilder<Entity, RootAlias, ModifyHint<RootAlias, Context, Hint, Field, true> & {}, ModifyContext<Entity, Context, Field, Alias, true>, RawAliases, ModifyFields<Fields, RootAlias, Context, Field, Alias, JoinFields>>;
-    leftJoinAndSelect<Field extends QBField<Entity, RootAlias, Context>, Alias extends string, const JoinFields extends readonly string[] | undefined = undefined>(field: Field | [Field, RawQueryFragment | QueryBuilder<any>], alias: Alias, cond?: JoinCondition<JoinedEntityType<Entity, Context, Field & string>, Alias>, fields?: JoinFields, schema?: string): SelectQueryBuilder<Entity, RootAlias, ModifyHint<RootAlias, Context, Hint, Field, true> & {}, ModifyContext<Entity, Context, Field, Alias, true>, RawAliases, ModifyFields<Fields, RootAlias, Context, Field, Alias, JoinFields>>;
-    leftJoinLateralAndSelect<Field extends QBField<Entity, RootAlias, Context>, Alias extends string, const JoinFields extends readonly string[] | undefined = undefined>(field: [Field, RawQueryFragment | QueryBuilder<any>], alias: Alias, cond?: JoinCondition<JoinedEntityType<Entity, Context, Field & string>, Alias>, fields?: JoinFields, schema?: string): SelectQueryBuilder<Entity, RootAlias, ModifyHint<RootAlias, Context, Hint, Field, true> & {}, ModifyContext<Entity, Context, Field, Alias, true>, RawAliases, ModifyFields<Fields, RootAlias, Context, Field, Alias, JoinFields>>;
-    innerJoinAndSelect<Field extends QBField<Entity, RootAlias, Context>, Alias extends string, const JoinFields extends readonly string[] | undefined = undefined>(field: Field | [Field, RawQueryFragment | QueryBuilder<any>], alias: Alias, cond?: JoinCondition<JoinedEntityType<Entity, Context, Field & string>, Alias>, fields?: JoinFields, schema?: string): SelectQueryBuilder<Entity, RootAlias, ModifyHint<RootAlias, Context, Hint, Field, true> & {}, ModifyContext<Entity, Context, Field, Alias, true>, RawAliases, ModifyFields<Fields, RootAlias, Context, Field, Alias, JoinFields>>;
-    innerJoinLateralAndSelect<Field extends QBField<Entity, RootAlias, Context>, Alias extends string, const JoinFields extends readonly string[] | undefined = undefined>(field: [Field, RawQueryFragment | QueryBuilder<any>], alias: Alias, cond?: JoinCondition<JoinedEntityType<Entity, Context, Field & string>, Alias>, fields?: JoinFields, schema?: string): SelectQueryBuilder<Entity, RootAlias, ModifyHint<RootAlias, Context, Hint, Field, true> & {}, ModifyContext<Entity, Context, Field, Alias, true>, RawAliases, ModifyFields<Fields, RootAlias, Context, Field, Alias, JoinFields>>;
+    joinAndSelect<Field extends QBField<Entity, RootAlias, Context>, Alias extends string, const JoinFields extends readonly [JoinSelectField<JoinedEntityType<Entity, Context, Field & string>, Alias>, ...JoinSelectField<JoinedEntityType<Entity, Context, Field & string>, Alias>[]] | undefined = undefined>(field: Field | [Field, RawQueryFragment | QueryBuilder<any>], alias: Alias, cond?: JoinCondition<JoinedEntityType<Entity, Context, Field & string>, Alias>, type?: JoinType, path?: string, fields?: JoinFields, schema?: string): SelectQueryBuilder<Entity, RootAlias, ModifyHint<RootAlias, Context, Hint, Field, true> & {}, ModifyContext<Entity, Context, Field, Alias, true>, RawAliases, ModifyFields<Fields, RootAlias, Context, Field, Alias, JoinFields>>;
+    leftJoinAndSelect<Field extends QBField<Entity, RootAlias, Context>, Alias extends string, const JoinFields extends readonly [JoinSelectField<JoinedEntityType<Entity, Context, Field & string>, Alias>, ...JoinSelectField<JoinedEntityType<Entity, Context, Field & string>, Alias>[]] | undefined = undefined>(field: Field | [Field, RawQueryFragment | QueryBuilder<any>], alias: Alias, cond?: JoinCondition<JoinedEntityType<Entity, Context, Field & string>, Alias>, fields?: JoinFields, schema?: string): SelectQueryBuilder<Entity, RootAlias, ModifyHint<RootAlias, Context, Hint, Field, true> & {}, ModifyContext<Entity, Context, Field, Alias, true>, RawAliases, ModifyFields<Fields, RootAlias, Context, Field, Alias, JoinFields>>;
+    leftJoinLateralAndSelect<Field extends QBField<Entity, RootAlias, Context>, Alias extends string, const JoinFields extends readonly [JoinSelectField<JoinedEntityType<Entity, Context, Field & string>, Alias>, ...JoinSelectField<JoinedEntityType<Entity, Context, Field & string>, Alias>[]] | undefined = undefined>(field: [Field, RawQueryFragment | QueryBuilder<any>], alias: Alias, cond?: JoinCondition<JoinedEntityType<Entity, Context, Field & string>, Alias>, fields?: JoinFields, schema?: string): SelectQueryBuilder<Entity, RootAlias, ModifyHint<RootAlias, Context, Hint, Field, true> & {}, ModifyContext<Entity, Context, Field, Alias, true>, RawAliases, ModifyFields<Fields, RootAlias, Context, Field, Alias, JoinFields>>;
+    innerJoinAndSelect<Field extends QBField<Entity, RootAlias, Context>, Alias extends string, const JoinFields extends readonly [JoinSelectField<JoinedEntityType<Entity, Context, Field & string>, Alias>, ...JoinSelectField<JoinedEntityType<Entity, Context, Field & string>, Alias>[]] | undefined = undefined>(field: Field | [Field, RawQueryFragment | QueryBuilder<any>], alias: Alias, cond?: JoinCondition<JoinedEntityType<Entity, Context, Field & string>, Alias>, fields?: JoinFields, schema?: string): SelectQueryBuilder<Entity, RootAlias, ModifyHint<RootAlias, Context, Hint, Field, true> & {}, ModifyContext<Entity, Context, Field, Alias, true>, RawAliases, ModifyFields<Fields, RootAlias, Context, Field, Alias, JoinFields>>;
+    innerJoinLateralAndSelect<Field extends QBField<Entity, RootAlias, Context>, Alias extends string, const JoinFields extends readonly [JoinSelectField<JoinedEntityType<Entity, Context, Field & string>, Alias>, ...JoinSelectField<JoinedEntityType<Entity, Context, Field & string>, Alias>[]] | undefined = undefined>(field: [Field, RawQueryFragment | QueryBuilder<any>], alias: Alias, cond?: JoinCondition<JoinedEntityType<Entity, Context, Field & string>, Alias>, fields?: JoinFields, schema?: string): SelectQueryBuilder<Entity, RootAlias, ModifyHint<RootAlias, Context, Hint, Field, true> & {}, ModifyContext<Entity, Context, Field, Alias, true>, RawAliases, ModifyFields<Fields, RootAlias, Context, Field, Alias, JoinFields>>;
     protected getFieldsForJoinedLoad(prop: EntityProperty<Entity>, alias: string, explicitFields?: readonly string[]): InternalField<Entity>[];
     /**
      * Apply filters to the QB where condition.
@@ -503,7 +518,7 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      * qb.orderBy({ 'profile.bio': 'asc' }); // nested via dot notation
      * ```
      */
-    orderBy(orderBy: ContextOrderByMap<Entity, RootAlias, Context> | ContextOrderByMap<Entity, RootAlias, Context>[]): SelectQueryBuilder<Entity, RootAlias, Hint, Context, RawAliases, Fields>;
+    orderBy(orderBy: ContextOrderByMap<Entity, RootAlias, Context, RawAliases> | ContextOrderByMap<Entity, RootAlias, Context, RawAliases>[]): SelectQueryBuilder<Entity, RootAlias, Hint, Context, RawAliases, Fields>;
     /**
      * Adds an ORDER BY clause to the query, replacing any existing order.
      *
@@ -516,19 +531,21 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      * ```
      */
     orderBy<const T extends Record<string, QueryOrderKeysFlat>>(orderBy: T & {
-        [K in keyof T]: K extends NestedAutoPath<Entity, RootAlias, Context, K & string> ? T[K] : never;
+        [K in keyof T]: K extends NestedAutoPath<Entity, RootAlias, Context, K & string> ? T[K] : (K extends RawAliases ? T[K] : never);
     }): SelectQueryBuilder<Entity, RootAlias, Hint, Context, RawAliases, Fields>;
     /**
      * Adds additional ORDER BY clause without replacing existing order.
      */
-    andOrderBy(orderBy: ContextOrderByMap<Entity, RootAlias, Context> | ContextOrderByMap<Entity, RootAlias, Context>[]): SelectQueryBuilder<Entity, RootAlias, Hint, Context, RawAliases, Fields>;
+    andOrderBy(orderBy: ContextOrderByMap<Entity, RootAlias, Context, RawAliases> | ContextOrderByMap<Entity, RootAlias, Context, RawAliases>[]): SelectQueryBuilder<Entity, RootAlias, Hint, Context, RawAliases, Fields>;
     /**
      * Adds additional ORDER BY clause without replacing existing order.
      */
     andOrderBy<const T extends Record<string, QueryOrderKeysFlat>>(orderBy: T & {
-        [K in keyof T]: K extends NestedAutoPath<Entity, RootAlias, Context, K & string> ? T[K] : never;
+        [K in keyof T]: K extends NestedAutoPath<Entity, RootAlias, Context, K & string> ? T[K] : (K extends RawAliases ? T[K] : never);
     }): SelectQueryBuilder<Entity, RootAlias, Hint, Context, RawAliases, Fields>;
     private processOrderBy;
+    /** Collect custom aliases from select fields (stored as 'resolved as alias' strings by select()). */
+    private getSelectAliases;
     /**
      * Adds a GROUP BY clause to the query.
      *
@@ -611,6 +628,10 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      * Adds index hint to the FROM clause.
      */
     indexHint(sql: string | undefined): this;
+    /**
+     * Adds COLLATE clause to ORDER BY expressions.
+     */
+    collation(collation: string | undefined): this;
     /**
      * Prepend comment to the sql query using the syntax `/* ... *&#8205;/`. Some characters are forbidden such as `/*, *&#8205;/` and `?`.
      */