@mikro-orm/knex 6.0.0-dev.4 → 6.0.0-dev.6

package/{dist/AbstractSqlConnection.js → AbstractSqlConnection.js}

@@ -102,6 +102,11 @@ class AbstractSqlConnection extends core_1.Connection {
         await this.client.raw(buf.toString());
     }
     createKnexClient(type) {
+        const driverOptions = this.config.get('driverOptions');
+        if (driverOptions.context?.client instanceof knex_1.knex.Client) {
+            this.logger.log('info', 'Reusing knex client provided via `driverOptions`');
+            return driverOptions;
+        }
         return (0, knex_1.knex)(this.getKnexOptions(type))
             .on('query', data => {
             if (!data.__knexQueryUid) {

package/AbstractSqlDriver.d.ts

@@ -0,0 +1,66 @@
+import type { Knex } from 'knex';
+import type { AnyEntity, Collection, ConnectionType, Configuration, Constructor, CountOptions, DeleteOptions, Dictionary, DriverMethodOptions, EntityData, EntityDictionary, EntityField, EntityMetadata, EntityName, EntityProperty, FilterQuery, FindOneOptions, FindOptions, IDatabaseDriver, LockOptions, NativeInsertUpdateManyOptions, NativeInsertUpdateOptions, PopulateOptions, Primary, QueryOrderMap, QueryResult, Transaction } from '@mikro-orm/core';
+import { DatabaseDriver, EntityManagerType } from '@mikro-orm/core';
+import type { AbstractSqlConnection } from './AbstractSqlConnection';
+import type { AbstractSqlPlatform } from './AbstractSqlPlatform';
+import { QueryBuilder, QueryType } from './query';
+import { SqlEntityManager } from './SqlEntityManager';
+import type { Field } from './typings';
+export declare abstract class AbstractSqlDriver<C extends AbstractSqlConnection = AbstractSqlConnection> extends DatabaseDriver<C> {
+    [EntityManagerType]: SqlEntityManager<this>;
+    protected readonly connection: C;
+    protected readonly replicas: C[];
+    protected readonly platform: AbstractSqlPlatform;
+    protected constructor(config: Configuration, platform: AbstractSqlPlatform, connection: Constructor<C>, connector: string[]);
+    getPlatform(): AbstractSqlPlatform;
+    createEntityManager<D extends IDatabaseDriver = IDatabaseDriver>(useContext?: boolean): D[typeof EntityManagerType];
+    find<T extends object, P extends string = never>(entityName: string, where: FilterQuery<T>, options?: FindOptions<T, P>): Promise<EntityData<T>[]>;
+    findOne<T extends object, P extends string = never>(entityName: string, where: FilterQuery<T>, options?: FindOneOptions<T, P>): Promise<EntityData<T> | null>;
+    findVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: FindOptions<T, any>): Promise<EntityData<T>[]>;
+    countVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: CountOptions<T>): Promise<number>;
+    protected wrapVirtualExpressionInSubquery<T extends object>(meta: EntityMetadata<T>, expression: string, where: FilterQuery<T>, options: FindOptions<T, any>, type: QueryType.COUNT): Promise<number>;
+    protected wrapVirtualExpressionInSubquery<T extends object>(meta: EntityMetadata<T>, expression: string, where: FilterQuery<T>, options: FindOptions<T, any>, type: QueryType.SELECT): Promise<T[]>;
+    protected wrapVirtualExpressionInSubquery<T extends object>(meta: EntityMetadata<T>, expression: string, where: FilterQuery<T>, options: FindOptions<T, any>): Promise<T[]>;
+    mapResult<T extends object>(result: EntityData<T>, meta: EntityMetadata<T>, populate?: PopulateOptions<T>[], qb?: QueryBuilder<T>, map?: Dictionary): EntityData<T> | null;
+    private mapJoinedProps;
+    private appendToCollection;
+    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>): Promise<QueryResult<T>>;
+    nativeUpdate<T extends object>(entityName: string, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
+    nativeUpdateMany<T extends object>(entityName: string, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
+    nativeDelete<T extends object>(entityName: string, where: FilterQuery<T> | string | any, options?: DeleteOptions<T>): Promise<QueryResult<T>>;
+    syncCollection<T extends object, O extends object>(coll: Collection<T, O>, options?: DriverMethodOptions): Promise<void>;
+    loadFromPivotTable<T extends object, O extends object>(prop: EntityProperty, owners: Primary<O>[][], where?: FilterQuery<any>, orderBy?: QueryOrderMap<T>[], ctx?: Transaction, options?: FindOptions<T, any>): Promise<Dictionary<T[]>>;
+    execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(queryOrKnex: string | Knex.QueryBuilder | Knex.Raw, params?: any[], method?: 'all' | 'get' | 'run', ctx?: Transaction): Promise<T>;
+    /**
+     * 1:1 owner side needs to be marked for population so QB auto-joins the owner id
+     */
+    protected autoJoinOneToOneOwner<T extends object, P extends string = never>(meta: EntityMetadata, populate: PopulateOptions<T>[], fields?: readonly EntityField<T, P>[]): PopulateOptions<T>[];
+    protected joinedProps<T>(meta: EntityMetadata, populate: PopulateOptions<T>[]): PopulateOptions<T>[];
+    /**
+     * @internal
+     */
+    mergeJoinedResult<T extends object>(rawResults: EntityData<T>[], meta: EntityMetadata<T>): EntityData<T>[];
+    protected getFieldsForJoinedLoad<T extends object>(qb: QueryBuilder<T>, meta: EntityMetadata<T>, explicitFields?: Field<T>[], populate?: PopulateOptions<T>[], parentTableAlias?: string, parentJoinPath?: string): Field<T>[];
+    /**
+     * @internal
+     */
+    mapPropToFieldNames<T extends object>(qb: QueryBuilder<T>, prop: EntityProperty<T>, tableAlias?: string): Field<T>[];
+    /** @internal */
+    createQueryBuilder<T extends object>(entityName: EntityName<T> | QueryBuilder<T>, ctx?: Transaction<Knex.Transaction>, preferredConnectionType?: ConnectionType, convertCustomTypes?: boolean): QueryBuilder<T>;
+    protected resolveConnectionType(args: {
+        ctx?: Transaction<Knex.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 updateCollectionDiff<T extends object, O extends object>(meta: EntityMetadata<O>, prop: EntityProperty<T>, pks: Primary<O>[], deleteDiff: Primary<T>[][] | boolean, insertDiff: Primary<T>[][], options?: DriverMethodOptions & {
+        ownerSchema?: string;
+    }): Promise<void>;
+    lockPessimistic<T>(entity: T, options: LockOptions): Promise<void>;
+    protected buildJoinedPropsOrderBy<T extends object>(entityName: string, qb: QueryBuilder<T>, meta: EntityMetadata<T>, populate: PopulateOptions<T>[], 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>[], populate: PopulateOptions<T>[], joinedProps: PopulateOptions<T>[], qb: QueryBuilder<T>): void;
+    protected buildFields<T extends object>(meta: EntityMetadata<T>, populate: PopulateOptions<T>[], joinedProps: PopulateOptions<T>[], qb: QueryBuilder<T>, fields?: Field<T>[]): Field<T>[];
+}

package/{dist/AbstractSqlDriver.js → AbstractSqlDriver.js}

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractSqlDriver = void 0;
 const core_1 = require("@mikro-orm/core");
-const QueryBuilder_1 = require("./query/QueryBuilder");
+const query_1 = require("./query");
 const SqlEntityManager_1 = require("./SqlEntityManager");
 class AbstractSqlDriver extends core_1.DatabaseDriver {
     constructor(config, platform, connection, connector) {
@@ -21,16 +21,19 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
     async find(entityName, where, options = {}) {
         options = { populate: [], orderBy: [], ...options };
         const meta = this.metadata.find(entityName);
+        if (meta?.virtual) {
+            return this.findVirtual(entityName, where, options);
+        }
         const populate = this.autoJoinOneToOneOwner(meta, options.populate, options.fields);
         const joinedProps = this.joinedProps(meta, populate);
-        const qb = this.createQueryBuilder(entityName, options.ctx, !!options.ctx, false);
+        const qb = this.createQueryBuilder(entityName, options.ctx, options.connectionType, false);
         const fields = this.buildFields(meta, populate, joinedProps, qb, options.fields);
         const joinedPropsOrderBy = this.buildJoinedPropsOrderBy(entityName, qb, meta, joinedProps);
         if (core_1.Utils.isPrimaryKey(where, meta.compositePK)) {
             where = { [core_1.Utils.getPrimaryKeyHash(meta.primaryKeys)]: where };
         }
         qb.select(fields)
-            .populate(populate)
+            .populate(populate, joinedProps.length > 0 ? options.populateWhere : undefined)
             .where(where)
             .orderBy([...core_1.Utils.asArray(options.orderBy), ...joinedPropsOrderBy])
             .groupBy(options.groupBy)
@@ -57,9 +60,70 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         if (joinedProps.length === 0) {
             opts.limit = 1;
         }
+        if (opts.limit > 0 && !opts.flags?.includes(core_1.QueryFlag.DISABLE_PAGINATE)) {
+            opts.flags ?? (opts.flags = []);
+            opts.flags.push(core_1.QueryFlag.DISABLE_PAGINATE);
+        }
         const res = await this.find(entityName, where, opts);
         return res[0] || null;
     }
+    async findVirtual(entityName, where, options) {
+        const meta = this.metadata.get(entityName);
+        /* istanbul ignore next */
+        if (!meta.expression) {
+            return [];
+        }
+        if (typeof meta.expression === 'string') {
+            return this.wrapVirtualExpressionInSubquery(meta, meta.expression, where, options);
+        }
+        const em = this.createEntityManager(false);
+        em.setTransactionContext(options.ctx);
+        const res = meta.expression(em, where, options);
+        if (res instanceof (query_1.QueryBuilder)) {
+            return this.wrapVirtualExpressionInSubquery(meta, res.getFormattedQuery(), where, options);
+        }
+        /* istanbul ignore next */
+        return res;
+    }
+    async countVirtual(entityName, where, options) {
+        const meta = this.metadata.get(entityName);
+        /* istanbul ignore next */
+        if (!meta.expression) {
+            return 0;
+        }
+        if (typeof meta.expression === 'string') {
+            return this.wrapVirtualExpressionInSubquery(meta, meta.expression, where, options, query_1.QueryType.COUNT);
+        }
+        const em = this.createEntityManager(false);
+        em.setTransactionContext(options.ctx);
+        const res = meta.expression(em, where, options);
+        if (res instanceof (query_1.QueryBuilder)) {
+            return this.wrapVirtualExpressionInSubquery(meta, res.getFormattedQuery(), where, options, query_1.QueryType.COUNT);
+        }
+        /* istanbul ignore next */
+        return res;
+    }
+    async wrapVirtualExpressionInSubquery(meta, expression, where, options, type = query_1.QueryType.SELECT) {
+        const qb = this.createQueryBuilder(meta.className, options?.ctx, options.connectionType, options.convertCustomTypes)
+            .limit(options?.limit, options?.offset);
+        if (options.orderBy) {
+            qb.orderBy(options.orderBy);
+        }
+        qb.where(where);
+        const kqb = qb.getKnexQuery().clear('select');
+        if (type === query_1.QueryType.COUNT) {
+            kqb.select(qb.raw('count(*) as count'));
+        }
+        else { // select
+            kqb.select('*');
+        }
+        kqb.fromRaw(`(${expression}) as ${this.platform.quoteIdentifier(qb.alias)}`);
+        const res = await this.execute(kqb);
+        if (type === query_1.QueryType.COUNT) {
+            return res[0].count;
+        }
+        return res.map(row => this.mapResult(row, meta));
+    }
     mapResult(result, meta, populate = [], qb, map = {}) {
         const ret = super.mapResult(result, meta);
         /* istanbul ignore if */
@@ -137,23 +201,25 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             collection.push(relationPojo);
         }
     }
-    async count(entityName, where, options = {}, ctx) {
+    async count(entityName, where, options = {}) {
         const meta = this.metadata.find(entityName);
-        const pks = meta.primaryKeys;
-        const qb = this.createQueryBuilder(entityName, ctx, !!ctx, false)
+        if (meta?.virtual) {
+            return this.countVirtual(entityName, where, options);
+        }
+        const qb = this.createQueryBuilder(entityName, options.ctx, options.connectionType, false)
             .groupBy(options.groupBy)
             .having(options.having)
             .populate(options.populate ?? [])
             .withSchema(this.getSchemaName(meta, options))
             .where(where);
-        return this.rethrow(qb.getCount(pks, true));
+        return this.rethrow(qb.getCount());
     }
     async nativeInsert(entityName, data, options = {}) {
         options.convertCustomTypes ?? (options.convertCustomTypes = true);
         const meta = this.metadata.find(entityName);
         const collections = this.extractManyToMany(entityName, data);
-        const pks = this.getPrimaryKeyFields(entityName);
-        const qb = this.createQueryBuilder(entityName, options.ctx, true, options.convertCustomTypes).withSchema(this.getSchemaName(meta, options));
+        const pks = meta?.primaryKeys ?? [this.config.getNamingStrategy().referenceColumnName()];
+        const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes).withSchema(this.getSchemaName(meta, options));
         const res = await this.rethrow(qb.insert(data).execute('run', false));
         res.row = res.row || {};
         let pk;
@@ -161,7 +227,8 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             pk = core_1.Utils.getPrimaryKeyCond(data, pks);
         }
         else {
-            res.insertId = data[pks[0]] || res.insertId || res.row[pks[0]];
+            /* istanbul ignore next */
+            res.insertId = data[pks[0]] ?? res.insertId ?? res.row[pks[0]];
             pk = [res.insertId];
         }
         await this.processManyToMany(meta, pk, collections, false, options);
@@ -170,29 +237,30 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
     async nativeInsertMany(entityName, data, options = {}) {
         options.processCollections ?? (options.processCollections = true);
         options.convertCustomTypes ?? (options.convertCustomTypes = true);
-        const meta = this.metadata.get(entityName);
+        const meta = this.metadata.find(entityName);
         const collections = options.processCollections ? data.map(d => this.extractManyToMany(entityName, d)) : [];
         const pks = this.getPrimaryKeyFields(entityName);
         const set = new Set();
         data.forEach(row => Object.keys(row).forEach(k => set.add(k)));
-        const props = [...set].map(name => meta.properties[name] ?? { name, fieldNames: [name] });
+        const props = [...set].map(name => meta?.properties[name] ?? { name, fieldNames: [name] });
         const fields = core_1.Utils.flatten(props.map(prop => prop.fieldNames));
-        let res;
-        if (fields.length === 0) {
-            const qb = this.createQueryBuilder(entityName, options.ctx, true, options.convertCustomTypes).withSchema(this.getSchemaName(meta, options));
-            res = await this.rethrow(qb.insert(data).execute('run', false));
+        const params = [];
+        /* istanbul ignore next */
+        const tableName = meta ? this.getTableName(meta, options) : this.platform.quoteIdentifier(entityName);
+        let sql = `insert into ${tableName} `;
+        sql += fields.length > 0 ? '(' + fields.map(k => this.platform.quoteIdentifier(k)).join(', ') + ')' : `(${this.platform.quoteIdentifier(pks[0])})`;
+        if (fields.length > 0 || this.platform.usesDefaultKeyword()) {
+            sql += ' values ';
         }
         else {
-            let sql = `insert into ${this.getTableName(meta, options)} `;
-            /* istanbul ignore next */
-            sql += fields.length > 0 ? '(' + fields.map(k => this.platform.quoteIdentifier(k)).join(', ') + ')' : 'default';
-            sql += ` values `;
-            const params = [];
+            sql += ' ' + data.map(() => `select null as ${this.platform.quoteIdentifier(pks[0])}`).join(' union all ');
+        }
+        if (fields.length > 0 || this.platform.usesDefaultKeyword()) {
             sql += data.map(row => {
                 const keys = [];
                 props.forEach(prop => {
                     if (prop.fieldNames.length > 1) {
-                        params.push(...row[prop.name]);
+                        params.push(...(row[prop.name] ?? prop.fieldNames.map(() => null)));
                         keys.push(...prop.fieldNames.map(_ => '?'));
                     }
                     else if (prop.customType && 'convertToDatabaseValueSQL' in prop.customType && !this.platform.isRaw(row[prop.name])) {
@@ -204,17 +272,17 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                         keys.push('?');
                     }
                 });
-                return '(' + keys.join(', ') + ')';
+                return '(' + (keys.join(', ') || 'default') + ')';
             }).join(', ');
-            if (this.platform.usesReturningStatement()) {
-                /* istanbul ignore next */
-                const returningProps = meta.props.filter(prop => prop.primary || prop.defaultRaw);
-                const returningFields = core_1.Utils.flatten(returningProps.map(prop => prop.fieldNames));
-                /* istanbul ignore next */
-                sql += returningFields.length > 0 ? ` returning ${returningFields.map(field => this.platform.quoteIdentifier(field)).join(', ')}` : '';
-            }
-            res = await this.execute(sql, params, 'run', options.ctx);
         }
+        if (this.platform.usesReturningStatement()) {
+            /* istanbul ignore next */
+            const returningProps = meta.hydrateProps.filter(prop => prop.persist !== false && (prop.primary || prop.defaultRaw));
+            const returningFields = core_1.Utils.flatten(returningProps.map(prop => prop.fieldNames));
+            /* istanbul ignore next */
+            sql += returningFields.length > 0 ? ` returning ${returningFields.map(field => this.platform.quoteIdentifier(field)).join(', ')}` : '';
+        }
+        const res = await this.execute(sql, params, 'run', options.ctx);
         let pk;
         /* istanbul ignore next */
         if (pks.length > 1) { // owner has composite pk
@@ -238,13 +306,23 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         const collections = this.extractManyToMany(entityName, data);
         let res = { affectedRows: 0, insertId: 0, row: {} };
         if (core_1.Utils.isPrimaryKey(where) && pks.length === 1) {
-            where = { [pks[0]]: where };
+            /* istanbul ignore next */
+            where = { [meta?.primaryKeys[0] ?? pks[0]]: where };
         }
         if (core_1.Utils.hasObjectKeys(data)) {
-            const qb = this.createQueryBuilder(entityName, options.ctx, true, options.convertCustomTypes)
-                .update(data)
-                .withSchema(this.getSchemaName(meta, options))
-                .where(where);
+            const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes)
+                .withSchema(this.getSchemaName(meta, options));
+            if (options.upsert) {
+                /* istanbul ignore next */
+                const uniqueFields = core_1.Utils.isPlainObject(where) ? Object.keys(where) : meta.primaryKeys;
+                /* istanbul ignore next */
+                qb.insert(data)
+                    .onConflict(uniqueFields.map(p => meta?.properties[p]?.fieldNames[0] ?? p))
+                    .merge(Object.keys(data).filter(f => !uniqueFields.includes(f)));
+            }
+            else {
+                qb.update(data).where(where);
+            }
             res = await this.rethrow(qb.execute('run', false));
         }
         /* istanbul ignore next */
@@ -276,7 +354,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                         else {
                             sql += '?';
                         }
-                        params.push(...pks, prop.fieldNames.length > 1 ? data[idx][key][fieldNameIdx] : data[idx][key]);
+                        params.push(...pks, prop.fieldNames.length > 1 ? data[idx][key]?.[fieldNameIdx] : data[idx][key]);
                     }
                 });
                 sql += ` else ${this.platform.quoteIdentifier(fieldName)} end, `;
@@ -300,15 +378,24 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         const pks = core_1.Utils.flatten(pkProps.map(pk => meta.properties[pk].fieldNames));
         sql += pks.length > 1 ? `(${pks.map(pk => `${this.platform.quoteIdentifier(pk)}`).join(', ')})` : this.platform.quoteIdentifier(pks[0]);
         const conds = where.map(cond => {
+            if (core_1.Utils.isPlainObject(cond) && core_1.Utils.getObjectKeysSize(cond) === 1) {
+                cond = Object.values(cond)[0];
+            }
             if (pks.length > 1) {
-                pkProps.forEach(pk => params.push(cond[pk]));
+                pkProps.forEach(pk => {
+                    if (Array.isArray(cond[pk])) {
+                        params.push(...core_1.Utils.flatten(cond[pk]));
+                    }
+                    else {
+                        params.push(cond[pk]);
+                    }
+                });
                 return `(${new Array(pks.length).fill('?').join(', ')})`;
             }
             params.push(cond);
             return '?';
         });
-        const values = pks.length > 1 && this.platform.requiresValuesKeyword() ? 'values ' : '';
-        sql += ` in (${values}${conds.join(', ')})`;
+        sql += ` in (${conds.join(', ')})`;
         const res = await this.rethrow(this.execute(sql, params, 'run', options.ctx));
         for (let i = 0; i < collections.length; i++) {
             await this.processManyToMany(meta, where[i], collections[i], false, options);
@@ -321,17 +408,17 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         if (core_1.Utils.isPrimaryKey(where) && pks.length === 1) {
             where = { [pks[0]]: where };
         }
-        const qb = this.createQueryBuilder(entityName, options.ctx, true, false).delete(where).withSchema(this.getSchemaName(meta, options));
+        const qb = this.createQueryBuilder(entityName, options.ctx, 'write', false).delete(where).withSchema(this.getSchemaName(meta, options));
         return this.rethrow(qb.execute('run', false));
     }
     async syncCollection(coll, options) {
-        const wrapped = coll.owner.__helper;
+        const wrapped = (0, core_1.helper)(coll.owner);
         const meta = wrapped.__meta;
         const pks = wrapped.getPrimaryKeys(true);
         const snap = coll.getSnapshot();
         const includes = (arr, item) => !!arr.find(i => core_1.Utils.equals(i, item));
-        const snapshot = snap ? snap.map(item => item.__helper.getPrimaryKeys(true)) : [];
-        const current = coll.getItems(false).map(item => item.__helper.getPrimaryKeys(true));
+        const snapshot = snap ? snap.map(item => (0, core_1.helper)(item).getPrimaryKeys(true)) : [];
+        const current = coll.getItems(false).map(item => (0, core_1.helper)(item).getPrimaryKeys(true));
         const deleteDiff = snap ? snapshot.filter(item => !includes(current, item)) : true;
         const insertDiff = current.filter(item => !includes(snapshot, item));
         const target = snapshot.filter(item => includes(current, item)).concat(...insertDiff);
@@ -345,7 +432,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
         if (coll.property.reference === core_1.ReferenceType.ONE_TO_MANY) {
             const cols = coll.property.referencedColumnNames;
-            const qb = this.createQueryBuilder(coll.property.type, ctx, true)
+            const qb = this.createQueryBuilder(coll.property.type, ctx, 'write')
                 .withSchema(this.getSchemaName(meta, options))
                 .update({ [coll.property.mappedBy]: pks })
                 .getKnexQuery()
@@ -354,7 +441,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
         /* istanbul ignore next */
         const ownerSchema = wrapped.getSchema() === '*' ? this.config.get('schema') : wrapped.getSchema();
-        const pivotMeta = this.metadata.find(coll.property.pivotTable);
+        const pivotMeta = this.metadata.find(coll.property.pivotEntity);
         if (pivotMeta.schema === '*') {
             /* istanbul ignore next */
             options ?? (options = {});
@@ -365,7 +452,8 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
     async loadFromPivotTable(prop, owners, where = {}, orderBy, ctx, options) {
         const pivotProp2 = this.getPivotInverseProperty(prop);
         const ownerMeta = this.metadata.find(pivotProp2.type);
-        const cond = { [`${prop.pivotTable}.${pivotProp2.name}`]: { $in: ownerMeta.compositePK ? owners : owners.map(o => o[0]) } };
+        const pivotMeta = this.metadata.find(prop.pivotEntity);
+        const cond = { [`${prop.pivotEntity}.${pivotProp2.name}`]: { $in: ownerMeta.compositePK ? owners : owners.map(o => o[0]) } };
         /* istanbul ignore if */
         if (!core_1.Utils.isEmpty(where) && Object.keys(where).every(k => core_1.Utils.isOperator(k, false))) {
             where = cond;
@@ -374,15 +462,23 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             where = { ...where, ...cond };
         }
         orderBy = this.getPivotOrderBy(prop, orderBy);
-        const qb = this.createQueryBuilder(prop.type, ctx, !!ctx)
+        const qb = this.createQueryBuilder(prop.type, ctx, options?.connectionType)
             .unsetFlag(core_1.QueryFlag.CONVERT_CUSTOM_TYPES)
             .withSchema(this.getSchemaName(prop.targetMeta, options));
-        const populate = this.autoJoinOneToOneOwner(prop.targetMeta, [{ field: prop.pivotTable }]);
+        const populate = this.autoJoinOneToOneOwner(prop.targetMeta, [{ field: prop.pivotEntity }]);
         const fields = this.buildFields(prop.targetMeta, (options?.populate ?? []), [], qb, options?.fields);
         qb.select(fields).populate(populate).where(where).orderBy(orderBy).setLockMode(options?.lockMode, options?.lockTableAliases);
         if (owners.length === 1 && (options?.offset != null || options?.limit != null)) {
             qb.limit(options.limit, options.offset);
         }
+        if (prop.targetMeta.schema !== '*' && pivotMeta.schema === '*' && options?.schema) {
+            // eslint-disable-next-line dot-notation
+            qb['finalize']();
+            // eslint-disable-next-line dot-notation
+            Object.values(qb['_joins']).forEach(join => {
+                join.schema = options.schema;
+            });
+        }
         const items = owners.length ? await this.rethrow(qb.execute('all')) : [];
         const map = {};
         const pkProps = ownerMeta.getPrimaryProps();
@@ -407,26 +503,17 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
     async execute(queryOrKnex, params = [], method = 'all', ctx) {
         return this.rethrow(this.connection.execute(queryOrKnex, params, method, ctx));
     }
-    getTableName(meta, options) {
-        let tableName = this.platform.quoteIdentifier(meta.collection);
-        if (options.schema === '*') {
-            return this.platform.quoteIdentifier(this.config.get('schema')) + '.' + tableName;
-        }
-        if (meta.schema || options.schema) {
-            tableName = this.platform.quoteIdentifier(options.schema ?? meta.schema) + '.' + tableName;
-        }
-        return tableName;
-    }
     /**
      * 1:1 owner side needs to be marked for population so QB auto-joins the owner id
      */
     autoJoinOneToOneOwner(meta, populate, fields = []) {
-        if (!this.config.get('autoJoinOneToOneOwner') || fields.length > 0) {
+        if (!this.config.get('autoJoinOneToOneOwner')) {
             return populate;
         }
         const relationsToPopulate = populate.map(({ field }) => field);
         const toPopulate = meta.relations
             .filter(prop => prop.reference === core_1.ReferenceType.ONE_TO_ONE && !prop.owner && !relationsToPopulate.includes(prop.name))
+            .filter(prop => fields.length === 0 || fields.some(f => prop.name === f || prop.name.startsWith(`${String(f)}.`)))
             .map(prop => ({ field: prop.name, strategy: prop.strategy }));
         return [...populate, ...toPopulate];
     }
@@ -506,13 +593,27 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
         return prop.fieldNames;
     }
-    createQueryBuilder(entityName, ctx, write, convertCustomTypes) {
-        const qb = new QueryBuilder_1.QueryBuilder(entityName, this.metadata, this, ctx, undefined, write ? 'write' : 'read');
+    /** @internal */
+    createQueryBuilder(entityName, ctx, preferredConnectionType, convertCustomTypes) {
+        const connectionType = this.resolveConnectionType({ ctx, connectionType: preferredConnectionType });
+        const qb = new query_1.QueryBuilder(entityName, this.metadata, this, ctx, undefined, connectionType);
         if (!convertCustomTypes) {
             qb.unsetFlag(core_1.QueryFlag.CONVERT_CUSTOM_TYPES);
         }
         return qb;
     }
+    resolveConnectionType(args) {
+        if (args.ctx) {
+            return 'write';
+        }
+        else if (args.connectionType) {
+            return args.connectionType;
+        }
+        else if (this.config.get('preferReadReplicas') === true) {
+            return 'read';
+        }
+        return 'write';
+    }
     extractManyToMany(entityName, data) {
         if (!this.metadata.has(entityName)) {
             return {};
@@ -541,7 +642,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             deleteDiff = [];
         }
         if (deleteDiff === true || deleteDiff.length > 0) {
-            const qb1 = this.createQueryBuilder(prop.pivotTable, options?.ctx, true)
+            const qb1 = this.createQueryBuilder(prop.pivotEntity, options?.ctx, 'write')
                 .withSchema(this.getSchemaName(meta, options))
                 .unsetFlag(core_1.QueryFlag.CONVERT_CUSTOM_TYPES);
             const knex = qb1.getKnex();
@@ -562,11 +663,11 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         });
         /* istanbul ignore else */
         if (this.platform.allowsMultiInsert()) {
-            await this.nativeInsertMany(prop.pivotTable, items, { ...options, convertCustomTypes: false, processCollections: false });
+            await this.nativeInsertMany(prop.pivotEntity, items, { ...options, convertCustomTypes: false, processCollections: false });
         }
         else {
             await core_1.Utils.runSerial(items, item => {
-                return this.createQueryBuilder(prop.pivotTable, options?.ctx, true)
+                return this.createQueryBuilder(prop.pivotEntity, options?.ctx, 'write')
                     .unsetFlag(core_1.QueryFlag.CONVERT_CUSTOM_TYPES)
                     .withSchema(this.getSchemaName(meta, options))
                     .insert(item)
@@ -575,7 +676,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
     }
     async lockPessimistic(entity, options) {
-        const meta = entity.__helper.__meta;
+        const meta = (0, core_1.helper)(entity).__meta;
         const qb = this.createQueryBuilder(entity.constructor.name, options.ctx).unsetFlag(core_1.QueryFlag.CONVERT_CUSTOM_TYPES).withSchema(options.schema ?? meta.schema);
         const cond = core_1.Utils.getPrimaryKeyCond(entity, meta.primaryKeys);
         qb.select('1').where(cond).setLockMode(options.lockMode, options.lockTableAliases);
@@ -601,6 +702,43 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         });
         return orderBy;
     }
+    normalizeFields(fields, prefix = '') {
+        const ret = [];
+        for (const field of fields) {
+            if (typeof field === 'string') {
+                ret.push(prefix + field);
+                continue;
+            }
+            if (core_1.Utils.isPlainObject(field)) {
+                for (const key of Object.keys(field)) {
+                    ret.push(...this.normalizeFields(field[key], key + '.'));
+                }
+            }
+        }
+        return ret;
+    }
+    processField(meta, prop, field, ret, populate, joinedProps, qb) {
+        if (!prop || (prop.reference === core_1.ReferenceType.ONE_TO_ONE && !prop.owner)) {
+            return;
+        }
+        if (prop.reference === core_1.ReferenceType.EMBEDDED) {
+            if (prop.object) {
+                ret.push(prop.fieldNames[0]);
+                return;
+            }
+            const parts = field.split('.');
+            const top = parts.shift();
+            for (const key of Object.keys(prop.embeddedProps)) {
+                if (!top || key === top) {
+                    this.processField(meta, prop.embeddedProps[key], parts.join('.'), ret, populate, joinedProps, qb);
+                }
+            }
+            return;
+        }
+        if (prop.fieldNames) {
+            ret.push(prop.fieldNames[0]);
+        }
+    }
     buildFields(meta, populate, joinedProps, qb, fields) {
         const lazyProps = meta.props.filter(prop => prop.lazy && !populate.some(p => p.field === prop.name || p.all));
         const hasLazyFormulas = meta.props.some(p => p.lazy && p.formula);
@@ -611,11 +749,21 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             ret.push(...this.getFieldsForJoinedLoad(qb, meta, fields, populate));
         }
         else if (fields) {
-            for (const field of [...fields]) {
-                if (core_1.Utils.isPlainObject(field) || field.toString().includes('.')) {
+            for (const field of this.normalizeFields(fields)) {
+                if (field === '*') {
+                    ret.push('*');
                     continue;
                 }
-                ret.push(field);
+                const parts = field.split('.');
+                const rootPropName = parts.shift(); // first one is the `prop`
+                const prop = core_1.QueryHelper.findProperty(rootPropName, {
+                    metadata: this.metadata,
+                    platform: this.platform,
+                    entityName: meta.className,
+                    where: {},
+                    aliasMap: qb.getAliasMap(),
+                });
+                this.processField(meta, prop, parts.join('.'), ret, populate, joinedProps, qb);
             }
             ret.unshift(...meta.primaryKeys.filter(pk => !fields.includes(pk)));
         }
@@ -638,7 +786,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 .filter(prop => prop.customType?.convertToDatabaseValueSQL || prop.customType?.convertToJSValueSQL)
                 .forEach(prop => ret.push(prop.name));
         }
-        return ret.length > 0 ? ret : ['*'];
+        return ret.length > 0 ? core_1.Utils.unique(ret) : ['*'];
     }
 }
 exports.AbstractSqlDriver = AbstractSqlDriver;

package/{dist/AbstractSqlPlatform.d.ts → AbstractSqlPlatform.d.ts}

@@ -1,4 +1,4 @@
-import type { Constructor, EntityManager, EntityRepository, IDatabaseDriver } from '@mikro-orm/core';
+import type { Constructor, EntityManager, EntityRepository, IDatabaseDriver, MikroORM } from '@mikro-orm/core';
 import { Platform } from '@mikro-orm/core';
 import type { SchemaHelper } from './schema';
 import { SchemaGenerator } from './schema';
@@ -6,14 +6,14 @@ export declare abstract class AbstractSqlPlatform extends Platform {
     protected readonly schemaHelper?: SchemaHelper;
     usesPivotTable(): boolean;
     indexForeignKeys(): boolean;
-    getRepositoryClass<T>(): Constructor<EntityRepository<T>>;
+    getRepositoryClass<T extends object>(): Constructor<EntityRepository<T>>;
     getSchemaHelper(): SchemaHelper | undefined;
-    getSchemaGenerator(driver: IDatabaseDriver): SchemaGenerator;
-    getEntityGenerator(em: EntityManager): any;
-    getMigrator(em: EntityManager): any;
+    /** @inheritDoc */
+    lookupExtensions(orm: MikroORM): void;
+    getSchemaGenerator(driver: IDatabaseDriver, em?: EntityManager): SchemaGenerator;
     quoteValue(value: any): string;
     formatQuery(sql: string, params: readonly any[]): string;
-    getSearchJsonPropertySQL(path: string, type: string): string;
+    getSearchJsonPropertySQL(path: string, type: string, aliased: boolean): string;
     isRaw(value: any): boolean;
     supportsSchemas(): boolean;
     /** @inheritDoc */