@mikro-orm/sql 7.0.0-dev.98 → 7.0.0-rc.0

package/AbstractSqlConnection.d.ts

@@ -1,14 +1,15 @@
 import { type ControlledTransaction, type Dialect, Kysely } from 'kysely';
-import { type AnyEntity, Connection, type Dictionary, type EntityData, type IsolationLevel, type LogContext, type LoggingOptions, type MaybePromise, type QueryResult, RawQueryFragment, type Transaction, type TransactionEventBroadcaster } from '@mikro-orm/core';
+import { type AnyEntity, Connection, type Dictionary, type EntityData, type IsolationLevel, type LogContext, type LoggingOptions, type QueryResult, RawQueryFragment, type Transaction, type TransactionEventBroadcaster } from '@mikro-orm/core';
 import type { AbstractSqlPlatform } from './AbstractSqlPlatform.js';
 import { NativeQueryBuilder } from './query/NativeQueryBuilder.js';
 export declare abstract class AbstractSqlConnection extends Connection {
+    #private;
     protected platform: AbstractSqlPlatform;
-    protected client: Kysely<any>;
-    abstract createKyselyDialect(overrides: Dictionary): MaybePromise<Dialect>;
+    abstract createKyselyDialect(overrides: Dictionary): Dialect;
     connect(options?: {
         skipOnConnect?: boolean;
     }): Promise<void>;
+    createKysely(): void;
     /**
      * @inheritDoc
      */
@@ -47,10 +48,8 @@ export declare abstract class AbstractSqlConnection extends Connection {
     private prepareQuery;
     execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(query: string | NativeQueryBuilder | RawQueryFragment, params?: readonly unknown[], method?: 'all' | 'get' | 'run', ctx?: Transaction, loggerContext?: LoggingOptions): Promise<T>;
     stream<T extends EntityData<AnyEntity>>(query: string | NativeQueryBuilder | RawQueryFragment, params?: readonly unknown[], ctx?: Transaction<Kysely<any>>, loggerContext?: LoggingOptions): AsyncIterableIterator<T>;
-    /**
-     * Execute raw SQL queries from file
-     */
-    loadFile(path: string): Promise<void>;
+    /** @inheritDoc */
+    executeDump(dump: string): Promise<void>;
     private getSql;
     protected transformRawResult<T>(res: any, method?: 'all' | 'get' | 'run'): T;
 }

package/AbstractSqlConnection.js

@@ -2,37 +2,41 @@ import { CompiledQuery, Kysely } from 'kysely';
 import { Connection, EventType, RawQueryFragment, Utils, } from '@mikro-orm/core';
 import { NativeQueryBuilder } from './query/NativeQueryBuilder.js';
 export class AbstractSqlConnection extends Connection {
-    client;
+    #client;
     async connect(options) {
+        this.getClient();
+        this.connected = true;
+        if (options?.skipOnConnect !== true) {
+            await this.onConnect();
+        }
+    }
+    createKysely() {
         let driverOptions = this.options.driverOptions ?? this.config.get('driverOptions');
         if (typeof driverOptions === 'function') {
-            driverOptions = await driverOptions();
+            driverOptions = driverOptions();
         }
         if (driverOptions instanceof Kysely) {
             this.logger.log('info', 'Reusing Kysely client provided via `driverOptions`');
-            this.client = driverOptions;
+            this.#client = driverOptions;
         }
         else if ('createDriver' in driverOptions) {
             this.logger.log('info', 'Reusing Kysely dialect provided via `driverOptions`');
-            this.client = new Kysely({ dialect: driverOptions });
+            this.#client = new Kysely({ dialect: driverOptions });
         }
         else {
-            this.client = new Kysely({
-                dialect: await this.createKyselyDialect(driverOptions),
+            this.#client = new Kysely({
+                dialect: this.createKyselyDialect(driverOptions),
             });
         }
-        this.connected = true;
-        if (options?.skipOnConnect !== true) {
-            await this.onConnect();
-        }
     }
     /**
      * @inheritDoc
      */
     async close(force) {
         await super.close(force);
-        await this.client?.destroy();
+        await this.#client?.destroy();
         this.connected = false;
+        this.#client = undefined;
     }
     /**
      * @inheritDoc
@@ -49,7 +53,7 @@ export class AbstractSqlConnection extends Connection {
             return { ok: false, reason: 'Connection not established' };
         }
         try {
-            await this.client.executeQuery(CompiledQuery.raw('select 1'));
+            await this.getClient().executeQuery(CompiledQuery.raw('select 1'));
             return { ok: true };
         }
         catch (error) {
@@ -57,7 +61,10 @@ export class AbstractSqlConnection extends Connection {
         }
     }
     getClient() {
-        return this.client;
+        if (!this.#client) {
+            this.createKysely();
+        }
+        return this.#client;
     }
     async transactional(cb, options = {}) {
         const trx = await this.begin(options);
@@ -86,7 +93,7 @@ export class AbstractSqlConnection extends Connection {
         }
         await this.ensureConnection();
         await options.eventBroadcaster?.dispatchEvent(EventType.beforeTransactionStart);
-        let trxBuilder = this.client.startTransaction();
+        let trxBuilder = this.getClient().startTransaction();
         if (options.isolationLevel) {
             trxBuilder = trxBuilder.setIsolationLevel(options.isolationLevel);
         }
@@ -155,7 +162,7 @@ export class AbstractSqlConnection extends Connection {
         const sql = this.getSql(q.query, q.formatted, loggerContext);
         return this.executeQuery(sql, async () => {
             const compiled = CompiledQuery.raw(q.formatted);
-            const res = await (ctx ?? this.client).executeQuery(compiled);
+            const res = await (ctx ?? this.#client).executeQuery(compiled);
             return this.transformRawResult(res, method);
         }, { ...q, ...loggerContext });
     }
@@ -172,7 +179,7 @@ export class AbstractSqlConnection extends Connection {
             parameters: [],
         };
         try {
-            const res = (ctx ?? this.client).getExecutor().stream(compiled, 1);
+            const res = (ctx ?? this.getClient()).getExecutor().stream(compiled, 1);
             this.logQuery(sql, {
                 sql, params,
                 ...loggerContext,
@@ -189,16 +196,12 @@ export class AbstractSqlConnection extends Connection {
             throw e;
         }
     }
-    /**
-     * Execute raw SQL queries from file
-     */
-    async loadFile(path) {
+    /** @inheritDoc */
+    async executeDump(dump) {
         await this.ensureConnection();
-        const { readFile } = globalThis.process.getBuiltinModule('node:fs/promises');
-        const buf = await readFile(path);
         try {
-            const raw = CompiledQuery.raw(buf.toString());
-            await this.client.executeQuery(raw);
+            const raw = CompiledQuery.raw(dump);
+            await this.getClient().executeQuery(raw);
         }
         catch (e) {
             /* v8 ignore next */

package/AbstractSqlDriver.d.ts

@@ -1,11 +1,11 @@
-import { type AnyEntity, type Collection, type Configuration, type ConnectionType, type Constructor, type CountOptions, DatabaseDriver, type DeleteOptions, type Dictionary, type DriverMethodOptions, type EntityData, type EntityDictionary, type EntityField, EntityManagerType, type EntityMetadata, type EntityName, type EntityProperty, type FilterQuery, type FindOneOptions, type FindOptions, type LockOptions, type LoggingOptions, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type ObjectQuery, type Options, type OrderDefinition, type PopulateOptions, type PopulatePath, type Primary, type QueryOrderMap, type QueryResult, RawQueryFragment, type StreamOptions, type Transaction, type UpsertManyOptions, type UpsertOptions } from '@mikro-orm/core';
+import { type AnyEntity, type Collection, type Configuration, type ConnectionType, type Constructor, type CountOptions, DatabaseDriver, type DeleteOptions, type Dictionary, type DriverMethodOptions, type EntityData, type EntityDictionary, type EntityField, EntityManagerType, type EntityMetadata, type EntityName, type EntityProperty, type FilterQuery, type FindOneOptions, type FindOptions, type FormulaTable, type LockOptions, type LoggingOptions, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type ObjectQuery, type Options, type OrderDefinition, type PopulateOptions, type PopulatePath, type Primary, type QueryOrderMap, type QueryResult, type Raw, RawQueryFragment, type StreamOptions, type Transaction, type UpsertManyOptions, type UpsertOptions } from '@mikro-orm/core';
 import type { AbstractSqlConnection } from './AbstractSqlConnection.js';
 import type { AbstractSqlPlatform } from './AbstractSqlPlatform.js';
 import { QueryBuilder } from './query/QueryBuilder.js';
 import { type NativeQueryBuilder } from './query/NativeQueryBuilder.js';
 import { QueryType } from './query/enums.js';
 import { SqlEntityManager } from './SqlEntityManager.js';
-import type { Field } from './typings.js';
+import type { InternalField } from './typings.js';
 export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlConnection = AbstractSqlConnection, Platform extends AbstractSqlPlatform = AbstractSqlPlatform> extends DatabaseDriver<Connection> {
     [EntityManagerType]: SqlEntityManager<this>;
     protected readonly connection: Connection;
@@ -13,25 +13,42 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     protected readonly platform: Platform;
     protected constructor(config: Configuration, platform: Platform, connection: Constructor<Connection>, connector: string[]);
     getPlatform(): Platform;
+    /** Evaluates a formula callback, handling both string and Raw return values. */
+    evaluateFormula(formula: (...args: any[]) => string | Raw, columns: any, table: FormulaTable): string;
+    /** For TPT entities, returns ownProps (columns in this table); otherwise returns all props. */
+    private getTableProps;
+    /** Creates a FormulaTable object for use in formula callbacks. */
+    private createFormulaTable;
     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: string, where: ObjectQuery<T>, options?: FindOptions<T, P, F, E>): Promise<EntityData<T>[]>;
-    findOne<T extends object, P extends string = never, F extends string = PopulatePath.ALL, E extends string = never>(entityName: string, where: ObjectQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
+    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>[]>;
+    findOne<T extends object, P extends string = never, F extends string = PopulatePath.ALL, E extends string = never>(entityName: EntityName<T>, where: ObjectQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
     protected hasToManyJoins<T extends object>(hint: PopulateOptions<T>, meta: EntityMetadata<T>): boolean;
-    findVirtual<T extends object>(entityName: string, where: ObjectQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
-    countVirtual<T extends object>(entityName: string, where: ObjectQuery<T>, options: CountOptions<T, any>): Promise<number>;
-    protected findFromVirtual<T extends object>(entityName: string, where: ObjectQuery<T>, options: FindOptions<T, any> | CountOptions<T, any>, type: QueryType): Promise<EntityData<T>[] | number>;
+    findVirtual<T extends object>(entityName: EntityName<T>, where: ObjectQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
+    countVirtual<T extends object>(entityName: EntityName<T>, where: ObjectQuery<T>, options: CountOptions<T, any>): Promise<number>;
+    protected findFromVirtual<T extends object>(entityName: EntityName<T>, where: ObjectQuery<T>, options: FindOptions<T, any> | CountOptions<T, any>, type: QueryType): Promise<EntityData<T>[] | number>;
     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>;
     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.
+     * TPT parent columns are selected with aliases like `parent_alias__column_name`,
+     * and need to be renamed back to `column_name` for the result mapper to work.
+     */
+    private mapTPTColumns;
     private mapJoinedProps;
-    count<T extends object>(entityName: string, where: any, options?: CountOptions<T>): Promise<number>;
-    nativeInsert<T extends object>(entityName: string, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
-    nativeInsertMany<T extends object>(entityName: string, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>, transform?: (sql: string) => string): Promise<QueryResult<T>>;
-    nativeUpdate<T extends object>(entityName: string, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T> & UpsertOptions<T>): Promise<QueryResult<T>>;
-    nativeUpdateMany<T extends object>(entityName: string, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T> & UpsertManyOptions<T>): Promise<QueryResult<T>>;
-    nativeDelete<T extends object>(entityName: string, where: FilterQuery<T> | string | any, options?: DeleteOptions<T>): Promise<QueryResult<T>>;
+    /**
+     * Maps a single property from a joined result row into the relation pojo.
+     * Handles polymorphic FKs, composite keys, Date parsing, and embedded objects.
+     */
+    private mapJoinedProp;
+    count<T extends object>(entityName: EntityName<T>, where: any, options?: CountOptions<T>): Promise<number>;
+    nativeInsert<T extends object>(entityName: EntityName<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
+    nativeInsertMany<T extends object>(entityName: EntityName<T>, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>, transform?: (sql: string) => string): Promise<QueryResult<T>>;
+    nativeUpdate<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T> & UpsertOptions<T>): Promise<QueryResult<T>>;
+    nativeUpdateMany<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T> & UpsertManyOptions<T>): Promise<QueryResult<T>>;
+    nativeDelete<T extends object>(entityName: EntityName<T>, where: FilterQuery<T> | string | any, options?: DeleteOptions<T>): Promise<QueryResult<T>>;
     /**
      * Fast comparison for collection snapshots that are represented by PK arrays.
      * Compares scalars via `===` and fallbacks to Utils.equals()` for more complex types like Buffer.
@@ -40,6 +57,24 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     private comparePrimaryKeyArrays;
     syncCollections<T extends object, O extends object>(collections: Iterable<Collection<T, O>>, options?: DriverMethodOptions): Promise<void>;
     loadFromPivotTable<T extends object, O extends object>(prop: EntityProperty, owners: Primary<O>[][], where?: FilterQuery<any>, orderBy?: OrderDefinition<T>, ctx?: Transaction, options?: FindOptions<T, any, any, any>, pivotJoin?: boolean): Promise<Dictionary<T[]>>;
+    /**
+     * Load from a polymorphic M:N pivot table.
+     */
+    protected loadFromPolymorphicPivotTable<T extends object, O extends object>(prop: EntityProperty, owners: Primary<O>[][], where?: FilterQuery<any>, orderBy?: OrderDefinition<T>, ctx?: Transaction, options?: FindOptions<T, any, any, any>, pivotJoin?: boolean): Promise<Dictionary<T[]>>;
+    /**
+     * Load from owner side of polymorphic M:N (e.g., Post -> Tags)
+     */
+    protected loadPolymorphicPivotOwnerSide<T extends object, O extends object>(prop: EntityProperty, owners: Primary<O>[][], where: FilterQuery<any>, orderBy?: OrderDefinition<T>, ctx?: Transaction, options?: FindOptions<T, any, any, any>, pivotJoin?: boolean, inverseProp?: EntityProperty): Promise<Dictionary<T[]>>;
+    /**
+     * Load from inverse side of polymorphic M:N (e.g., Tag -> Posts)
+     * Uses single query with join via virtual relation on pivot.
+     */
+    protected loadPolymorphicPivotInverseSide<T extends object, O extends object>(prop: EntityProperty, owners: Primary<O>[][], where: FilterQuery<any>, orderBy?: OrderDefinition<T>, ctx?: Transaction, options?: FindOptions<T, any, any, any>): Promise<Dictionary<T[]>>;
+    /**
+     * Build a map from owner PKs to their related entities from pivot table results.
+     */
+    private buildPivotResultMap;
+    private wrapPopulateFilter;
     private getPivotOrderBy;
     execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(query: string | NativeQueryBuilder | RawQueryFragment, params?: any[], method?: 'all' | 'get' | 'run', ctx?: Transaction, loggerContext?: LoggingOptions): Promise<T>;
     stream<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: StreamOptions<T, any, any, any>): AsyncIterableIterator<T>;
@@ -57,32 +92,55 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
      * @internal
      */
     mergeJoinedResult<T extends object>(rawResults: EntityData<T>[], meta: EntityMetadata<T>, joinedProps: PopulateOptions<T>[]): EntityData<T>[];
-    protected shouldHaveColumn<T, U>(meta: EntityMetadata<T>, prop: EntityProperty<U>, populate: readonly PopulateOptions<U>[], fields?: readonly Field<U>[], exclude?: readonly Field<U>[]): boolean;
-    protected getFieldsForJoinedLoad<T extends object>(qb: QueryBuilder<T, any, any, any>, meta: EntityMetadata<T>, options: FieldsForJoinedLoadOptions<T>): Field<T>[];
+    protected shouldHaveColumn<T, U>(meta: EntityMetadata<T>, prop: EntityProperty<U>, populate: readonly PopulateOptions<U>[], fields?: readonly InternalField<U>[], exclude?: readonly InternalField<U>[]): boolean;
+    protected getFieldsForJoinedLoad<T extends object>(qb: QueryBuilder<T, any, any, any>, meta: EntityMetadata<T>, options: FieldsForJoinedLoadOptions<T>): InternalField<T>[];
+    /**
+     * Adds LEFT JOINs and fields for TPT polymorphic loading when populating a relation to a TPT base class.
+     * @internal
+     */
+    protected addTPTPolymorphicJoinsForRelation<T extends object>(qb: QueryBuilder<T, any, any, any>, meta: EntityMetadata<T>, baseAlias: string, fields: InternalField<T>[]): void;
+    /**
+     * Find the alias for a TPT child table in the query builder.
+     * @internal
+     */
+    protected findTPTChildAlias<T extends object>(qb: QueryBuilder<T, any, any, any>, childMeta: EntityMetadata): string | undefined;
+    /**
+     * Builds a CASE WHEN expression for TPT discriminator.
+     * Determines concrete entity type based on which child table has a non-null PK.
+     * @internal
+     */
+    buildTPTDiscriminatorExpression(meta: EntityMetadata, descendants: EntityMetadata[], aliasMap: Dictionary<string>, baseAlias: string): Raw;
+    /**
+     * Maps TPT child-specific fields during hydration.
+     * When a relation points to a TPT base class, the actual entity might be a child class.
+     * This method reads the discriminator to determine the concrete type and maps child-specific fields.
+     * @internal
+     */
+    protected mapTPTChildFields<T extends object>(relationPojo: EntityData<T>, meta: EntityMetadata<T>, relationAlias: string, qb: QueryBuilder<T, any, any, any>, root: EntityData<T>): void;
     /**
      * @internal
      */
-    mapPropToFieldNames<T extends object>(qb: QueryBuilder<T, any, any, any>, prop: EntityProperty<T>, tableAlias: string, explicitFields?: readonly Field<T>[]): Field<T>[];
+    mapPropToFieldNames<T extends object>(qb: QueryBuilder<T, any, any, any, any, any>, prop: EntityProperty<T>, tableAlias: string, meta: EntityMetadata<T>, schema?: string, explicitFields?: readonly InternalField<T>[]): InternalField<T>[];
     /** @internal */
     createQueryBuilder<T extends object>(entityName: EntityName<T> | QueryBuilder<T, any, any, any>, ctx?: Transaction, preferredConnectionType?: ConnectionType, convertCustomTypes?: boolean, loggerContext?: LoggingOptions, alias?: string, em?: SqlEntityManager): QueryBuilder<T, any, any, any>;
     protected resolveConnectionType(args: {
         ctx?: Transaction;
         connectionType?: ConnectionType;
     }): ConnectionType;
-    protected extractManyToMany<T>(entityName: string, data: EntityDictionary<T>): EntityData<T>;
-    protected processManyToMany<T extends object>(meta: EntityMetadata<T> | undefined, pks: Primary<T>[], collections: EntityData<T>, clear: boolean, options?: DriverMethodOptions): Promise<void>;
+    protected extractManyToMany<T>(meta: EntityMetadata<T>, data: EntityDictionary<T>): EntityData<T>;
+    protected processManyToMany<T extends object>(meta: EntityMetadata<T>, pks: Primary<T>[], collections: EntityData<T>, clear: boolean, options?: DriverMethodOptions): Promise<void>;
     lockPessimistic<T extends object>(entity: T, options: LockOptions): Promise<void>;
     protected buildPopulateWhere<T extends object>(meta: EntityMetadata<T>, joinedProps: PopulateOptions<T>[], options: Pick<FindOptions<any>, 'populateWhere'>): ObjectQuery<T>;
     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>[];
-    protected normalizeFields<T extends object>(fields: Field<T>[], prefix?: string): string[];
-    protected processField<T extends object>(meta: EntityMetadata<T>, prop: EntityProperty<T> | undefined, field: string, ret: Field<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'>): Field<T>[];
+    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>[];
 }
 interface FieldsForJoinedLoadOptions<T extends object> {
-    explicitFields?: readonly Field<T>[];
-    exclude?: readonly Field<T>[];
+    explicitFields?: readonly InternalField<T>[];
+    exclude?: readonly InternalField<T>[];
     populate?: readonly PopulateOptions<T>[];
     strategy?: Options['loadStrategy'];
     populateWhere?: FindOptions<any>['populateWhere'];
@@ -90,5 +148,6 @@ interface FieldsForJoinedLoadOptions<T extends object> {
     parentTableAlias: string;
     parentJoinPath?: string;
     count?: boolean;
+    schema?: string;
 }
 export {};