@mikro-orm/knex 6.2.10-dev.1 → 6.2.10-dev.100

package/query/QueryBuilder.d.ts

@@ -1,7 +1,6 @@
-/// <reference types="node" />
 import { inspect } from 'util';
 import type { Knex } from 'knex';
-import { type AnyEntity, type ConnectionType, type Dictionary, type EntityData, type EntityMetadata, type EntityName, type EntityProperty, type FlushMode, type GroupOperator, LockMode, type LoggingOptions, type MetadataStorage, type ObjectQuery, PopulateHint, type PopulateOptions, type QBFilterQuery, type QBQueryOrderMap, QueryFlag, type QueryOrderMap, type QueryResult, type RequiredEntityData } from '@mikro-orm/core';
+import { type AnyEntity, type ConnectionType, type Dictionary, type EntityData, type EntityKey, type EntityMetadata, type EntityName, type EntityProperty, type FlushMode, type GroupOperator, type Loaded, LockMode, type LoggingOptions, type MetadataStorage, type ObjectQuery, PopulateHint, type PopulateOptions, type QBFilterQuery, type QBQueryOrderMap, QueryFlag, type QueryOrderMap, type QueryResult, RawQueryFragment, type RequiredEntityData, type ExpandProperty } from '@mikro-orm/core';
 import { JoinType, QueryType } from './enums';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver';
 import { type Alias, QueryBuilderHelper } from './QueryBuilderHelper';
@@ -12,6 +11,26 @@ export interface ExecuteOptions {
     mapResults?: boolean;
     mergeResults?: boolean;
 }
+type AnyString = string & {};
+type Compute<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type IsNever<T, True = true, False = false> = [T] extends [never] ? True : False;
+type GetAlias<T extends string> = T extends `${infer A}.${string}` ? A : never;
+type GetPropName<T extends string> = T extends `${string}.${infer P}` ? P : T;
+type AppendToHint<Parent extends string, Child extends string> = `${Parent}.${Child}`;
+type AddToContext<Type extends object, Context, Field extends string, Alias extends string, Select extends boolean> = {
+    [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] ? 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> = Compute<IsNever<Context> extends true ? AddToContext<GetType<Entity, object, Field>, object, Field, Alias, Select> : Context & AddToContext<GetType<Entity, Context, Field>, Context, Field, Alias, Select>>;
+type EntityRelations<T> = EntityKey<T, true>;
+type AddAliasesFromContext<Context> = Context[keyof Context] extends infer Join ? Join extends any ? Join extends [string, infer Alias, infer Type, any] ? `${Alias & string}.${EntityRelations<Type & {}>}` : never : never : never;
+export type QBField<Entity, RootAlias extends string, Context> = (EntityRelations<Entity> | `${RootAlias}.${EntityRelations<Entity>}` | AddAliasesFromContext<Context>) & {} | AnyString;
+export type QBField2<Entity, RootAlias extends string, Context> = (EntityKey<Entity> | `${RootAlias}.${EntityKey<Entity>}` | AddAliasesFromContext<Context>) & {} | AnyString;
 /**
  * SQL query builder with fluent interface.
  *
@@ -31,26 +50,26 @@ export interface ExecuteOptions {
  * const publisher = await qb.getSingleResult();
  * ```
  */
-export declare class QueryBuilder<T extends object = AnyEntity> {
+export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias extends string = never, Hint extends string = never, Context extends object = never> {
     protected readonly metadata: MetadataStorage;
     protected readonly driver: AbstractSqlDriver;
-    protected readonly context?: Knex.Transaction<any, any[]> | undefined;
+    protected readonly context?: Knex.Transaction | undefined;
     protected connectionType?: ConnectionType | undefined;
-    protected em?: SqlEntityManager<AbstractSqlDriver<import("..").AbstractSqlConnection, AbstractSqlPlatform>> | undefined;
+    protected em?: SqlEntityManager | undefined;
     protected loggerContext?: (LoggingOptions & Dictionary) | undefined;
-    get mainAlias(): Alias<T>;
+    get mainAlias(): Alias<Entity>;
     get alias(): string;
     get helper(): QueryBuilderHelper;
     /** @internal */
     type?: QueryType;
     /** @internal */
-    _fields?: Field<T>[];
+    _fields?: Field<Entity>[];
     /** @internal */
-    _populate: PopulateOptions<T>[];
+    _populate: PopulateOptions<Entity>[];
     /** @internal */
-    _populateWhere?: ObjectQuery<T> | PopulateHint | `${PopulateHint}`;
+    _populateWhere?: ObjectQuery<Entity> | PopulateHint | `${PopulateHint}`;
     /** @internal */
-    __populateWhere?: ObjectQuery<T> | PopulateHint | `${PopulateHint}`;
+    __populateWhere?: ObjectQuery<Entity> | PopulateHint | `${PopulateHint}`;
     /** @internal */
     _populateMap: Dictionary<string>;
     /** @internal */
@@ -63,15 +82,15 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
     protected _schema?: string;
     protected _cond: Dictionary;
     protected _data: Dictionary;
-    protected _orderBy: QueryOrderMap<T>[];
-    protected _groupBy: Field<T>[];
+    protected _orderBy: QueryOrderMap<Entity>[];
+    protected _groupBy: Field<Entity>[];
     protected _having: Dictionary;
-    protected _returning?: Field<T>[];
+    protected _returning?: Field<Entity>[];
     protected _onConflict?: {
-        fields: string[];
+        fields: string[] | RawQueryFragment;
         ignore?: boolean;
-        merge?: EntityData<T> | Field<T>[];
-        where?: QBFilterQuery<T>;
+        merge?: EntityData<Entity> | Field<Entity>[];
+        where?: QBFilterQuery<Entity>;
     }[];
     protected _limit?: number;
     protected _offset?: number;
@@ -85,62 +104,62 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
     protected lockMode?: LockMode;
     protected lockTables?: string[];
     protected subQueries: Dictionary<string>;
-    protected _mainAlias?: Alias<T>;
+    protected _mainAlias?: Alias<Entity>;
     protected _aliases: Dictionary<Alias<any>>;
     protected _helper?: QueryBuilderHelper;
     protected _query?: {
         sql?: string;
         _sql?: Knex.Sql;
         params?: readonly unknown[];
-        qb: Knex.QueryBuilder<T>;
+        qb: Knex.QueryBuilder<Entity>;
     };
     protected readonly platform: AbstractSqlPlatform;
     protected readonly knex: Knex;
     /**
      * @internal
      */
-    constructor(entityName: EntityName<T> | QueryBuilder<T>, metadata: MetadataStorage, driver: AbstractSqlDriver, context?: Knex.Transaction<any, any[]> | undefined, alias?: string, connectionType?: ConnectionType | undefined, em?: SqlEntityManager<AbstractSqlDriver<import("..").AbstractSqlConnection, AbstractSqlPlatform>> | undefined, loggerContext?: (LoggingOptions & Dictionary) | undefined);
-    select(fields: Field<T> | Field<T>[], distinct?: boolean): SelectQueryBuilder<T>;
-    addSelect(fields: Field<T> | Field<T>[]): SelectQueryBuilder<T>;
-    distinct(): SelectQueryBuilder<T>;
+    constructor(entityName: EntityName<Entity> | QueryBuilder<Entity, any, any>, metadata: MetadataStorage, driver: AbstractSqlDriver, context?: Knex.Transaction | undefined, alias?: string, connectionType?: ConnectionType | undefined, em?: SqlEntityManager | undefined, loggerContext?: (LoggingOptions & Dictionary) | undefined);
+    select(fields: Field<Entity> | Field<Entity>[], distinct?: boolean): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
+    addSelect(fields: Field<Entity> | Field<Entity>[]): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
+    distinct(): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
     /** postgres only */
-    distinctOn(fields: string | string[]): SelectQueryBuilder<T>;
-    insert(data: RequiredEntityData<T> | RequiredEntityData<T>[]): InsertQueryBuilder<T>;
-    update(data: EntityData<T>): UpdateQueryBuilder<T>;
-    delete(cond?: QBFilterQuery): DeleteQueryBuilder<T>;
-    truncate(): TruncateQueryBuilder<T>;
-    count(field?: string | string[], distinct?: boolean): CountQueryBuilder<T>;
-    join(field: string | Knex.QueryBuilder | QueryBuilder<any>, alias: string, cond?: QBFilterQuery, type?: JoinType, path?: string, schema?: string): this;
-    innerJoin(field: string | Knex.QueryBuilder | QueryBuilder<any>, alias: string, cond?: QBFilterQuery, schema?: string): this;
-    innerJoinLateral(field: string | Knex.QueryBuilder | QueryBuilder<any>, alias: string, cond?: QBFilterQuery, schema?: string): this;
-    leftJoin(field: string | Knex.QueryBuilder | QueryBuilder<any>, alias: string, cond?: QBFilterQuery, schema?: string): this;
-    leftJoinLateral(field: string | Knex.QueryBuilder | QueryBuilder<any>, alias: string, cond?: QBFilterQuery, schema?: string): this;
-    joinAndSelect(field: string | [field: string, qb: Knex.QueryBuilder | QueryBuilder<any>], alias: string, cond?: QBFilterQuery, type?: JoinType, path?: string, fields?: string[], schema?: string): SelectQueryBuilder<T>;
-    leftJoinAndSelect(field: string | [field: string, qb: Knex.QueryBuilder | QueryBuilder<any>], alias: string, cond?: QBFilterQuery, fields?: string[], schema?: string): SelectQueryBuilder<T>;
-    leftJoinLateralAndSelect(field: string | [field: string, qb: Knex.QueryBuilder | QueryBuilder<any>], alias: string, cond?: QBFilterQuery, fields?: string[], schema?: string): SelectQueryBuilder<T>;
-    innerJoinAndSelect(field: string | [field: string, qb: Knex.QueryBuilder | QueryBuilder<any>], alias: string, cond?: QBFilterQuery, fields?: string[], schema?: string): SelectQueryBuilder<T>;
-    innerJoinLateralAndSelect(field: string | [field: string, qb: Knex.QueryBuilder | QueryBuilder<any>], alias: string, cond?: QBFilterQuery, fields?: string[], schema?: string): SelectQueryBuilder<T>;
-    protected getFieldsForJoinedLoad(prop: EntityProperty<T>, alias: string, explicitFields?: string[]): Field<T>[];
+    distinctOn(fields: string | string[]): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
+    insert(data: RequiredEntityData<Entity> | RequiredEntityData<Entity>[]): InsertQueryBuilder<Entity>;
+    update(data: EntityData<Entity>): UpdateQueryBuilder<Entity>;
+    delete(cond?: QBFilterQuery): DeleteQueryBuilder<Entity>;
+    truncate(): TruncateQueryBuilder<Entity>;
+    count(field?: string | string[], distinct?: boolean): CountQueryBuilder<Entity>;
+    join<Field extends QBField<Entity, RootAlias, Context>, Alias extends string>(field: Field | Knex.QueryBuilder | QueryBuilder<any>, alias: Alias, cond?: QBFilterQuery, type?: JoinType, path?: string, schema?: string): SelectQueryBuilder<Entity, RootAlias, ModifyHint<RootAlias, Context, Hint, Field> & {}, ModifyContext<Entity, Context, Field, Alias>>;
+    innerJoin<Field extends QBField<Entity, RootAlias, Context>, Alias extends string>(field: Field | Knex.QueryBuilder | QueryBuilder<any>, alias: Alias, cond?: QBFilterQuery, schema?: string): SelectQueryBuilder<Entity, RootAlias, ModifyHint<RootAlias, Context, Hint, Field> & {}, ModifyContext<Entity, Context, Field, Alias>>;
+    innerJoinLateral(field: Knex.QueryBuilder | QueryBuilder<any>, alias: string, cond?: QBFilterQuery, schema?: string): this;
+    leftJoin<Field extends QBField<Entity, RootAlias, Context>, Alias extends string>(field: Field | Knex.QueryBuilder | QueryBuilder<any>, alias: Alias, cond?: QBFilterQuery, schema?: string): SelectQueryBuilder<Entity, RootAlias, ModifyHint<RootAlias, Context, Hint, Field> & {}, ModifyContext<Entity, Context, Field, Alias>>;
+    leftJoinLateral(field: Knex.QueryBuilder | QueryBuilder<any>, alias: string, cond?: QBFilterQuery, schema?: string): this;
+    joinAndSelect<Field extends QBField<Entity, RootAlias, Context>, Alias extends string>(field: Field | [field: Field, qb: Knex.QueryBuilder | QueryBuilder<any>], alias: Alias, cond?: QBFilterQuery, type?: JoinType, path?: string, fields?: string[], schema?: string): SelectQueryBuilder<Entity, RootAlias, ModifyHint<RootAlias, Context, Hint, Field, true> & {}, ModifyContext<Entity, Context, Field, Alias, true>>;
+    leftJoinAndSelect<Field extends QBField<Entity, RootAlias, Context>, Alias extends string>(field: Field | [field: Field, qb: Knex.QueryBuilder | QueryBuilder<any>], alias: Alias, cond?: QBFilterQuery, fields?: string[], schema?: string): SelectQueryBuilder<Entity, RootAlias, ModifyHint<RootAlias, Context, Hint, Field, true> & {}, ModifyContext<Entity, Context, Field, Alias, true>>;
+    leftJoinLateralAndSelect<Field extends QBField<Entity, RootAlias, Context>, Alias extends string>(field: [field: Field, qb: Knex.QueryBuilder | QueryBuilder<any>], alias: Alias, cond?: QBFilterQuery, fields?: string[], schema?: string): SelectQueryBuilder<Entity, RootAlias, ModifyHint<RootAlias, Context, Hint, Field, true> & {}, ModifyContext<Entity, Context, Field, Alias, true>>;
+    innerJoinAndSelect<Field extends QBField<Entity, RootAlias, Context>, Alias extends string>(field: Field | [field: Field, qb: Knex.QueryBuilder | QueryBuilder<any>], alias: Alias, cond?: QBFilterQuery, fields?: string[], schema?: string): SelectQueryBuilder<Entity, RootAlias, ModifyHint<RootAlias, Context, Hint, Field, true> & {}, ModifyContext<Entity, Context, Field, Alias, true>>;
+    innerJoinLateralAndSelect<Field extends QBField<Entity, RootAlias, Context>, Alias extends string>(field: [field: Field, qb: Knex.QueryBuilder | QueryBuilder<any>], alias: Alias, cond?: QBFilterQuery, fields?: string[], schema?: string): SelectQueryBuilder<Entity, RootAlias, ModifyHint<RootAlias, Context, Hint, Field, true> & {}, ModifyContext<Entity, Context, Field, Alias, true>>;
+    protected getFieldsForJoinedLoad(prop: EntityProperty<Entity>, alias: string, explicitFields?: string[]): Field<Entity>[];
     withSubQuery(subQuery: Knex.QueryBuilder, alias: string): this;
-    where(cond: QBFilterQuery<T>, operator?: keyof typeof GroupOperator): this;
+    where(cond: QBFilterQuery<Entity>, operator?: keyof typeof GroupOperator): this;
     where(cond: string, params?: any[], operator?: keyof typeof GroupOperator): this;
-    andWhere(cond: QBFilterQuery<T>): this;
+    andWhere(cond: QBFilterQuery<Entity>): this;
     andWhere(cond: string, params?: any[]): this;
-    orWhere(cond: QBFilterQuery<T>): this;
+    orWhere(cond: QBFilterQuery<Entity>): this;
     orWhere(cond: string, params?: any[]): this;
-    orderBy(orderBy: QBQueryOrderMap<T> | QBQueryOrderMap<T>[]): SelectQueryBuilder<T>;
-    groupBy(fields: (string | keyof T) | readonly (string | keyof T)[]): SelectQueryBuilder<T>;
-    having(cond?: QBFilterQuery | string, params?: any[]): SelectQueryBuilder<T>;
-    onConflict(fields?: Field<T> | Field<T>[]): InsertQueryBuilder<T>;
+    orderBy(orderBy: QBQueryOrderMap<Entity> | QBQueryOrderMap<Entity>[]): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
+    groupBy(fields: (string | keyof Entity) | readonly (string | keyof Entity)[]): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
+    having(cond?: QBFilterQuery | string, params?: any[]): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
+    onConflict(fields?: Field<Entity> | Field<Entity>[]): InsertQueryBuilder<Entity>;
     ignore(): this;
-    merge(data?: EntityData<T> | Field<T>[]): this;
-    returning(fields?: Field<T> | Field<T>[]): this;
+    merge(data?: EntityData<Entity> | Field<Entity>[]): this;
+    returning(fields?: Field<Entity> | Field<Entity>[]): this;
     /**
      * @internal
      */
-    populate(populate: PopulateOptions<T>[], populateWhere?: ObjectQuery<T> | PopulateHint | `${PopulateHint}`): this;
-    limit(limit?: number, offset?: number): SelectQueryBuilder<T>;
-    offset(offset?: number): SelectQueryBuilder<T>;
+    populate(populate: PopulateOptions<Entity>[], populateWhere?: ObjectQuery<Entity> | PopulateHint | `${PopulateHint}`): this;
+    limit(limit?: number, offset?: number): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
+    offset(offset?: number): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
     withSchema(schema?: string): this;
     setLockMode(mode?: LockMode, tables?: string[]): this;
     setFlushMode(flushMode?: FlushMode): this;
@@ -166,8 +185,8 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
      * Specifies FROM which entity's table select/update/delete will be executed, removing all previously set FROM-s.
      * Allows setting a main string alias of the selection data.
      */
-    from<T extends AnyEntity<T> = AnyEntity>(target: QueryBuilder<T>, aliasName?: string): SelectQueryBuilder<T>;
-    from<T extends AnyEntity<T> = AnyEntity>(target: EntityName<T>): SelectQueryBuilder<T>;
+    from<Entity extends AnyEntity<Entity> = AnyEntity>(target: QueryBuilder<Entity>, aliasName?: string): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
+    from<Entity extends AnyEntity<Entity> = AnyEntity>(target: EntityName<Entity>): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
     getKnexQuery(processVirtualEntity?: boolean): Knex.QueryBuilder;
     /**
      * @internal
@@ -214,15 +233,15 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
     /**
      * Alias for `qb.getResultList()`
      */
-    getResult(): Promise<T[]>;
+    getResult(): Promise<Loaded<Entity, Hint>[]>;
     /**
      * Executes the query, returning array of results
      */
-    getResultList(limit?: number): Promise<T[]>;
+    getResultList(limit?: number): Promise<Loaded<Entity, Hint>[]>;
     /**
      * Executes the query, returning the first result or null
      */
-    getSingleResult(): Promise<T | null>;
+    getSingleResult(): Promise<Entity | null>;
     /**
      * Executes count query (without offset and limit), returning total count of results
      */
@@ -230,17 +249,17 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
     /**
      * Executes the query, returning both array of results and total count query (without offset and limit).
      */
-    getResultAndCount(): Promise<[T[], number]>;
+    getResultAndCount(): Promise<[Entity[], number]>;
     /**
      * Provides promise-like interface so we can await the QB instance.
      */
-    then<TResult1 = any, TResult2 = never>(onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<T[] | number | QueryResult<T>>;
+    then<TResult1 = any, TResult2 = never>(onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<Loaded<Entity, Hint>[] | number | QueryResult<Entity>>;
     /**
      * Returns knex instance with sub-query aliased with given alias.
      * You can provide `EntityName.propName` as alias, then the field name will be used based on the metadata
      */
     as(alias: string): Knex.QueryBuilder;
-    clone(reset?: boolean | string[]): QueryBuilder<T>;
+    clone(reset?: boolean | string[]): QueryBuilder<Entity>;
     getKnex(processVirtualEntity?: boolean): Knex.QueryBuilder;
     /**
      * Sets logger context for this query builder.
@@ -272,31 +291,31 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
     /** @ignore */
     [inspect.custom](depth?: number): string;
 }
-export interface RunQueryBuilder<T extends object> extends Omit<QueryBuilder<T>, 'getResult' | 'getSingleResult' | 'getResultList' | 'where'> {
-    where(cond: QBFilterQuery<T> | string, params?: keyof typeof GroupOperator | any[], operator?: keyof typeof GroupOperator): this;
-    execute<U = QueryResult<T>>(method?: 'all' | 'get' | 'run', mapResults?: boolean): Promise<U>;
-    then<TResult1 = QueryResult<T>, TResult2 = never>(onfulfilled?: ((value: QueryResult<T>) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<QueryResult<T>>;
+export interface RunQueryBuilder<Entity extends object> extends Omit<QueryBuilder<Entity, any, any>, 'getResult' | 'getSingleResult' | 'getResultList' | 'where'> {
+    where(cond: QBFilterQuery<Entity> | string, params?: keyof typeof GroupOperator | any[], operator?: keyof typeof GroupOperator): this;
+    execute<Result = QueryResult<Entity>>(method?: 'all' | 'get' | 'run', mapResults?: boolean): Promise<Result>;
+    then<TResult1 = QueryResult<Entity>, TResult2 = never>(onfulfilled?: ((value: QueryResult<Entity>) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<QueryResult<Entity>>;
 }
-export interface SelectQueryBuilder<T extends object> extends QueryBuilder<T> {
-    execute<U = T[]>(method?: 'all' | 'get' | 'run', mapResults?: boolean): Promise<U>;
-    execute<U = T[]>(method: 'all', mapResults?: boolean): Promise<U>;
-    execute<U = T>(method: 'get', mapResults?: boolean): Promise<U>;
-    execute<U = QueryResult<T>>(method: 'run', mapResults?: boolean): Promise<U>;
-    then<TResult1 = T[], TResult2 = never>(onfulfilled?: ((value: T[]) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<T[]>;
+export interface SelectQueryBuilder<Entity extends object = AnyEntity, RootAlias extends string = never, Hint extends string = never, Context extends object = never> extends QueryBuilder<Entity, RootAlias, Hint, Context> {
+    execute<Result = Entity[]>(method?: 'all' | 'get' | 'run', mapResults?: boolean): Promise<Result>;
+    execute<Result = Entity[]>(method: 'all', mapResults?: boolean): Promise<Result>;
+    execute<Result = Entity>(method: 'get', mapResults?: boolean): Promise<Result>;
+    execute<Result = QueryResult<Entity>>(method: 'run', mapResults?: boolean): Promise<Result>;
+    then<TResult1 = Entity[], TResult2 = never>(onfulfilled?: ((value: Loaded<Entity, Hint>[]) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<Loaded<Entity, Hint>[]>;
 }
-export interface CountQueryBuilder<T extends object> extends QueryBuilder<T> {
-    execute<U = {
+export interface CountQueryBuilder<Entity extends object> extends QueryBuilder<Entity, any, any> {
+    execute<Result = {
         count: number;
-    }[]>(method?: 'all' | 'get' | 'run', mapResults?: boolean): Promise<U>;
-    execute<U = {
+    }[]>(method?: 'all' | 'get' | 'run', mapResults?: boolean): Promise<Result>;
+    execute<Result = {
         count: number;
-    }[]>(method: 'all', mapResults?: boolean): Promise<U>;
-    execute<U = {
+    }[]>(method: 'all', mapResults?: boolean): Promise<Result>;
+    execute<Result = {
         count: number;
-    }>(method: 'get', mapResults?: boolean): Promise<U>;
-    execute<U = QueryResult<{
+    }>(method: 'get', mapResults?: boolean): Promise<Result>;
+    execute<Result = QueryResult<{
         count: number;
-    }>>(method: 'run', mapResults?: boolean): Promise<U>;
+    }>>(method: 'run', mapResults?: boolean): Promise<Result>;
     then<TResult1 = number, TResult2 = never>(onfulfilled?: ((value: number) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<number>;
 }
 export interface InsertQueryBuilder<T extends object> extends RunQueryBuilder<T> {
@@ -307,3 +326,4 @@ export interface DeleteQueryBuilder<T extends object> extends RunQueryBuilder<T>
 }
 export interface TruncateQueryBuilder<T extends object> extends RunQueryBuilder<T> {
 }
+export {};

package/query/QueryBuilder.js

@@ -348,11 +348,13 @@ class QueryBuilder {
         this.ensureNotFinalized();
         this._onConflict ??= [];
         this._onConflict.push({
-            fields: core_1.Utils.asArray(fields).flatMap(f => {
-                const key = f.toString();
-                /* istanbul ignore next */
-                return meta.properties[key]?.fieldNames ?? [key];
-            }),
+            fields: core_1.Utils.isRawSql(fields)
+                ? fields
+                : core_1.Utils.asArray(fields).flatMap(f => {
+                    const key = f.toString();
+                    /* istanbul ignore next */
+                    return meta.properties[key]?.fieldNames ?? [key];
+                }),
         });
         return this;
     }
@@ -1222,7 +1224,7 @@ class QueryBuilder {
                     const prop = this.helper.getProperty(f, a);
                     const type = this.platform.castColumn(prop);
                     const fieldName = this.helper.mapper(field, this.type, undefined, null);
-                    if (!prop?.persist && !prop?.formula && !pks.includes(fieldName)) {
+                    if (!prop?.persist && !prop?.formula && !prop?.hasConvertToJSValueSQL && !pks.includes(fieldName)) {
                         addToSelect.push(fieldName);
                     }
                     const key = (0, core_1.raw)(`min(${this.knex.ref(fieldName)}${type})`);
@@ -1245,8 +1247,10 @@ class QueryBuilder {
                     }
                     return false;
                 });
+                /* istanbul ignore next */
                 if (field instanceof core_1.RawQueryFragment) {
-                    knexQuery.select(this.platform.formatQuery(field.sql, field.params));
+                    const sql = this.platform.formatQuery(field.sql, field.params);
+                    knexQuery.select(this.knex.raw(sql));
                 }
                 else if (field) {
                     knexQuery.select(field);

package/query/QueryBuilderHelper.d.ts

@@ -1,5 +1,5 @@
 import type { Knex } from 'knex';
-import { type Dictionary, type EntityData, type EntityKey, type EntityMetadata, type EntityProperty, type FlatQueryOrderMap, LockMode, type QBFilterQuery } from '@mikro-orm/core';
+import { type Dictionary, type EntityData, type EntityKey, type EntityMetadata, type EntityProperty, type FlatQueryOrderMap, LockMode, type QBFilterQuery, RawQueryFragment } from '@mikro-orm/core';
 import { JoinType, QueryType } from './enums';
 import type { Field, JoinOptions } from '../typings';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver';
@@ -34,7 +34,7 @@ export declare class QueryBuilderHelper {
     isSimpleRegExp(re: any): re is RegExp;
     getRegExpParam(re: RegExp): string;
     appendOnConflictClause<T>(type: QueryType, onConflict: {
-        fields: string[];
+        fields: string[] | RawQueryFragment;
         ignore?: boolean;
         merge?: EntityData<T> | Field<T>[];
         where?: QBFilterQuery<T>;

package/query/QueryBuilderHelper.js

@@ -67,7 +67,8 @@ class QueryBuilderHelper {
         }
         const rawField = core_1.RawQueryFragment.getKnownFragment(field);
         if (rawField) {
-            return this.knex.raw(rawField.sql, rawField.params);
+            // sometimes knex is confusing the binding positions, we need to interpolate early
+            return this.knex.raw(this.platform.formatQuery(rawField.sql, rawField.params));
         }
         const [a, f] = this.splitField(field);
         const prop = this.getProperty(f, a);
@@ -194,7 +195,8 @@ class QueryBuilderHelper {
                 join.primaryKeys.forEach((primaryKey, idx) => {
                     const right = `${join.alias}.${join.joinColumns[idx]}`;
                     if (join.prop.formula) {
-                        const left = join.prop.formula(join.ownerAlias);
+                        const alias = this.platform.quoteIdentifier(join.ownerAlias);
+                        const left = join.prop.formula(alias);
                         conditions.push(`${left} = ${this.knex.ref(right)}`);
                         return;
                     }
@@ -352,7 +354,16 @@ class QueryBuilderHelper {
     }
     appendOnConflictClause(type, onConflict, qb) {
         onConflict.forEach(item => {
-            const sub = item.fields.length > 0 ? qb.onConflict(item.fields) : qb.onConflict();
+            let sub;
+            if (core_1.Utils.isRawSql(item.fields)) {
+                sub = qb.onConflict(this.knex.raw(item.fields.sql, item.fields.params));
+            }
+            else if (item.fields.length > 0) {
+                sub = qb.onConflict(item.fields);
+            }
+            else {
+                sub = qb.onConflict();
+            }
             core_1.Utils.runIfNotEmpty(() => sub.ignore(), item.ignore);
             core_1.Utils.runIfNotEmpty(() => {
                 let mergeParam = item.merge;
@@ -442,6 +453,9 @@ class QueryBuilderHelper {
             const tmp = value[op].length === 1 && core_1.Utils.isPlainObject(value[op][0]) ? fields.map(f => value[op][0][f]) : value[op];
             value[op] = this.knex.raw(`(${fields.map(() => '?').join(', ')})`, tmp);
         }
+        if (value[op] instanceof core_1.RawQueryFragment) {
+            value[op] = this.knex.raw(value[op].sql, value[op].params);
+        }
         if (this.subQueries[key]) {
             return void qb[m](this.knex.raw(`(${this.subQueries[key]})`), replacement, value[op]);
         }

package/schema/DatabaseTable.d.ts

@@ -1,4 +1,4 @@
-import { type Configuration, type Dictionary, type EntityMetadata, type EntityProperty, type NamingStrategy } from '@mikro-orm/core';
+import { type Configuration, type DeferMode, type Dictionary, type EntityMetadata, type EntityProperty, type NamingStrategy } from '@mikro-orm/core';
 import type { SchemaHelper } from './SchemaHelper';
 import type { CheckDef, Column, ForeignKey, IndexDef } from '../typings';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
@@ -25,7 +25,7 @@ export declare class DatabaseTable {
     removeColumn(name: string): void;
     getIndexes(): IndexDef[];
     getChecks(): CheckDef[];
-    init(cols: Column[], indexes: IndexDef[] | undefined, checks: CheckDef<unknown>[] | undefined, pks: string[], fks?: Dictionary<ForeignKey>, enums?: Dictionary<string[]>): void;
+    init(cols: Column[], indexes: IndexDef[] | undefined, checks: CheckDef[] | undefined, pks: string[], fks?: Dictionary<ForeignKey>, enums?: Dictionary<string[]>): void;
     addColumn(column: Column): void;
     addColumnFromProperty(prop: EntityProperty, meta: EntityMetadata, config: Configuration): void;
     private getIndexName;
@@ -58,6 +58,7 @@ export declare class DatabaseTable {
         name?: string;
         type?: string;
         expression?: string;
+        deferMode?: DeferMode;
         options?: Dictionary;
     }, type: 'index' | 'unique' | 'primary'): void;
     addCheck(check: CheckDef): void;

package/schema/DatabaseTable.js

@@ -70,17 +70,11 @@ class DatabaseTable {
                     prop.length = undefined;
                 }
             }
-            if (mappedType instanceof core_1.DateTimeType || mappedType instanceof core_1.IntervalType) {
-                const match = prop.columnTypes[idx].match(/\w+\((\d+)\)/);
-                if (match) {
-                    prop.length ??= +match[1];
-                }
-                else {
-                    prop.length ??= this.platform.getDefaultDateTimeLength();
-                }
-            }
             if (prop.length == null && prop.columnTypes[idx]) {
                 prop.length = this.platform.getSchemaHelper().inferLengthFromColumnType(prop.columnTypes[idx]);
+                if (typeof mappedType.getDefaultLength !== 'undefined') {
+                    prop.length ??= mappedType.getDefaultLength(this.platform);
+                }
             }
             const primary = !meta.compositePK && !!prop.primary && prop.kind === core_1.ReferenceKind.SCALAR && this.platform.isNumericColumn(mappedType);
             this.columns[field] = {
@@ -171,7 +165,7 @@ class DatabaseTable {
     getEntityDeclaration(namingStrategy, schemaHelper, scalarPropertiesForRelations) {
         const { fksOnColumnProps, fksOnStandaloneProps, columnFks, fkIndexes, nullableForeignKeys, skippedColumnNames, } = this.foreignKeysToProps(namingStrategy, scalarPropertiesForRelations);
         const name = namingStrategy.getEntityName(this.name, this.schema);
-        const schema = new core_1.EntitySchema({ name, collection: this.name, schema: this.schema });
+        const schema = new core_1.EntitySchema({ name, collection: this.name, schema: this.schema, comment: this.comment });
         const compositeFkIndexes = {};
         const compositeFkUniques = {};
         const potentiallyUnmappedIndexes = this.indexes.filter(index => !index.primary // Skip primary index. Whether it's in use by scalar column or FK, it's already mapped.
@@ -505,6 +499,7 @@ class DatabaseTable {
             columnOptions.length = column.length;
             columnOptions.precision = column.precision;
             columnOptions.scale = column.scale;
+            columnOptions.comment = column.comment;
             columnOptions.enum = !!column.enumItems?.length;
             columnOptions.items = column.enumItems;
         }
@@ -542,7 +537,10 @@ class DatabaseTable {
         }
         return {
             name: prop,
-            type: fk ? runtimeType : (core_1.Utils.entries(core_1.t).find(([k, v]) => Object.getPrototypeOf(column.mappedType) === v.prototype)?.[0] ?? runtimeType),
+            type: fk ? runtimeType : (core_1.Utils.keys(core_1.t).find(k => {
+                const typeInCoreMap = this.platform.getMappedType(k);
+                return (typeInCoreMap !== core_1.Type.getType(core_1.UnknownType) || k === 'unknown') && typeInCoreMap === column.mappedType;
+            }) ?? runtimeType),
             runtimeType,
             kind,
             generated: column.generated,
@@ -558,6 +556,7 @@ class DatabaseTable {
             length: column.length,
             precision: column.precision,
             scale: column.scale,
+            comment: column.comment,
             index: index ? index.keyName : undefined,
             unique: unique ? unique.keyName : undefined,
             enum: !!column.enumItems?.length,
@@ -601,8 +600,7 @@ class DatabaseTable {
         // If this column is using an enum.
         if (column.enumItems?.length) {
             // We will create a new enum name for this type and set it as the property type as well.
-            // The enum name will be a concatenation of the table name and the column name.
-            return namingStrategy.getClassName(this.name + '_' + column.name, '_');
+            return namingStrategy.getEnumClassName(column.name, this.name, this.schema);
         }
         return column.mappedType?.runtimeType ?? 'unknown';
     }
@@ -659,6 +657,7 @@ class DatabaseTable {
             type: index.type,
             expression: index.expression,
             options: index.options,
+            deferMode: index.deferMode,
         });
     }
     addCheck(check) {

package/schema/SchemaComparator.js

@@ -369,7 +369,10 @@ class SchemaComparator {
         }
         const defaultRule = ['restrict', 'no action'];
         const rule = (key, method) => {
-            return (key[method] ?? defaultRule[0]).toLowerCase().replace(defaultRule[1], defaultRule[0]);
+            return (key[method] ?? defaultRule[0])
+                .toLowerCase()
+                .replace(defaultRule[1], defaultRule[0])
+                .replace(/"/g, '');
         };
         const compare = (method) => rule(key1, method) === rule(key2, method);
         return !compare('updateRule') || !compare('deleteRule');
@@ -415,7 +418,8 @@ class SchemaComparator {
             log(`'unsigned' changed for column ${tableName}.${fromColumn.name}`, { fromColumn, toColumn });
             changedProperties.add('unsigned');
         }
-        if (!this.hasSameDefaultValue(fromColumn, toColumn)) {
+        if (!(fromColumn.ignoreSchemaChanges?.includes('default') ||
+            toColumn.ignoreSchemaChanges?.includes('default')) && !this.hasSameDefaultValue(fromColumn, toColumn)) {
             log(`'default' changed for column ${tableName}.${fromColumn.name}`, { fromColumn, toColumn });
             changedProperties.add('default');
         }

package/schema/SchemaHelper.d.ts

@@ -2,7 +2,7 @@ import { type Connection, type Dictionary } from '@mikro-orm/core';
 import type { Knex } from 'knex';
 import type { AbstractSqlConnection } from '../AbstractSqlConnection';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
-import type { CheckDef, Column, IndexDef, Table, TableDifference } from '../typings';
+import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference } from '../typings';
 import type { DatabaseSchema } from './DatabaseSchema';
 import type { DatabaseTable } from './DatabaseTable';
 export declare abstract class SchemaHelper {
@@ -21,7 +21,7 @@ export declare abstract class SchemaHelper {
     getEnumDefinitions(connection: AbstractSqlConnection, checks: CheckDef[], tableName: string, schemaName?: string): Promise<Dictionary<string[]>>;
     getCreateNativeEnumSQL(name: string, values: unknown[], schema?: string): string;
     getDropNativeEnumSQL(name: string, schema?: string): string;
-    getAlterNativeEnumSQL(name: string, schema?: string, value?: string): string;
+    getAlterNativeEnumSQL(name: string, schema?: string, value?: string, items?: string[], oldItems?: string[]): string;
     loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[]): Promise<void>;
     getListTablesSQL(schemaName?: string): string;
     getRenameColumnSQL(tableName: string, oldColumnName: string, to: Column, schemaName?: string): string;
@@ -58,4 +58,20 @@ export declare abstract class SchemaHelper {
      * Uses `raw` method injected in `AbstractSqlConnection` to allow adding custom queries inside alter statements.
      */
     pushTableQuery(table: Knex.TableBuilder, expression: string, grouping?: string): void;
+    dump(builder: Knex.SchemaBuilder | string, append: string): Promise<string>;
+    createTable(tableDef: DatabaseTable, alter?: boolean): Knex.SchemaBuilder;
+    createForeignKey(table: Knex.CreateTableBuilder, foreignKey: ForeignKey, schema?: string): void;
+    splitTableName(name: string): [string | undefined, string];
+    getReferencedTableName(referencedTableName: string, schema?: string): string;
+    createIndex(table: Knex.CreateTableBuilder, index: IndexDef, tableDef: DatabaseTable, createPrimary?: boolean): void;
+    createCheck(table: Knex.CreateTableBuilder, check: CheckDef): void;
+    createSchemaBuilder(schema?: string): Knex.SchemaBuilder;
+    getAlterTable?(changedTable: TableDifference, wrap?: boolean): Promise<string>;
+    get knex(): Knex;
+    get options(): {
+        disableForeignKeys?: boolean;
+        createForeignKeyConstraints?: boolean;
+        ignoreSchema?: string[];
+        managementDbName?: string;
+    };
 }