@mikro-orm/knex 6.0.0-rc.0 → 6.0.0-rc.2

package/AbstractSqlConnection.d.ts

@@ -10,8 +10,22 @@ export declare abstract class AbstractSqlConnection extends Connection {
     /** @inheritDoc */
     connect(): void | Promise<void>;
     getKnex(): Knex;
+    /**
+     * @inheritDoc
+     */
     close(force?: boolean): Promise<void>;
+    /**
+     * @inheritDoc
+     */
     isConnected(): Promise<boolean>;
+    /**
+     * @inheritDoc
+     */
+    checkConnection(): Promise<{
+        ok: boolean;
+        reason?: string;
+        error?: Error;
+    }>;
     transactional<T>(cb: (trx: Transaction<Knex.Transaction>) => Promise<T>, options?: {
         isolationLevel?: IsolationLevel;
         readOnly?: boolean;

package/AbstractSqlConnection.js

@@ -26,10 +26,16 @@ class AbstractSqlConnection extends core_1.Connection {
         }
         return this.client;
     }
+    /**
+     * @inheritDoc
+     */
     async close(force) {
         await super.close(force);
         await this.getKnex().destroy();
     }
+    /**
+     * @inheritDoc
+     */
     async isConnected() {
         try {
             await this.getKnex().raw('select 1');
@@ -39,6 +45,18 @@ class AbstractSqlConnection extends core_1.Connection {
             return false;
         }
     }
+    /**
+     * @inheritDoc
+     */
+    async checkConnection() {
+        try {
+            await this.getKnex().raw('select 1');
+            return { ok: true };
+        }
+        catch (error) {
+            return { ok: false, reason: error.message, error };
+        }
+    }
     async transactional(cb, options = {}) {
         const trx = await this.begin(options);
         try {

package/AbstractSqlDriver.d.ts

@@ -1,5 +1,5 @@
 import type { Knex } from 'knex';
-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 IDatabaseDriver, type LockOptions, type LoggingOptions, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type OrderDefinition, type PopulateOptions, type Primary, type QueryOrderMap, type QueryResult, 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 IDatabaseDriver, type LockOptions, type LoggingOptions, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type Options, type OrderDefinition, type PopulateOptions, type Primary, type QueryOrderMap, type QueryResult, type Transaction, type UpsertManyOptions, type UpsertOptions } from '@mikro-orm/core';
 import type { AbstractSqlConnection } from './AbstractSqlConnection';
 import type { AbstractSqlPlatform } from './AbstractSqlPlatform';
 import { QueryBuilder, QueryType } from './query';
@@ -15,6 +15,7 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     createEntityManager<D extends IDatabaseDriver = IDatabaseDriver>(useContext?: boolean): D[typeof EntityManagerType];
     find<T extends object, P extends string = never, F extends string = '*'>(entityName: string, where: FilterQuery<T>, options?: FindOptions<T, P, F>): Promise<EntityData<T>[]>;
     findOne<T extends object, P extends string = never, F extends string = '*'>(entityName: string, where: FilterQuery<T>, options?: FindOneOptions<T, P, F>): Promise<EntityData<T> | null>;
+    protected hasToManyJoins<T extends object>(hint: PopulateOptions<T>, meta: EntityMetadata<T>): boolean;
     findVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: FindOptions<T, any, any>): Promise<EntityData<T>[]>;
     countVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: CountOptions<T, any>): Promise<number>;
     protected findFromVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: FindOptions<T, any> | CountOptions<T, any>, type: QueryType): Promise<EntityData<T>[] | number>;
@@ -38,12 +39,17 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     /**
      * @internal
      */
-    joinedProps<T>(meta: EntityMetadata, populate: PopulateOptions<T>[]): PopulateOptions<T>[];
+    joinedProps<T>(meta: EntityMetadata, populate: PopulateOptions<T>[], options?: {
+        strategy?: Options['loadStrategy'];
+    }): PopulateOptions<T>[];
     /**
      * @internal
      */
     mergeJoinedResult<T extends object>(rawResults: EntityData<T>[], meta: EntityMetadata<T>, joinedProps: PopulateOptions<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>[];
+    protected getFieldsForJoinedLoad<T extends object>(qb: QueryBuilder<T>, meta: EntityMetadata<T>, explicitFields?: Field<T>[], populate?: PopulateOptions<T>[], options?: {
+        strategy?: Options['loadStrategy'];
+        populateWhere?: FindOptions<any>['populateWhere'];
+    }, parentTableAlias?: string, parentJoinPath?: string): Field<T>[];
     /**
      * @internal
      */
@@ -57,8 +63,12 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     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>;
     lockPessimistic<T extends object>(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 buildOrderBy<T extends object>(qb: QueryBuilder<T>, meta: EntityMetadata<T>, populate: PopulateOptions<T>[], options: Pick<FindOptions<any>, 'strategy' | 'orderBy' | 'populateOrderBy'>): QueryOrderMap<T>[];
+    protected buildPopulateOrderBy<T extends object>(qb: QueryBuilder<T>, meta: EntityMetadata<T>, populateOrderBy: QueryOrderMap<T>[], parentPath: string, parentAlias?: string): QueryOrderMap<T>[];
+    protected buildJoinedPropsOrderBy<T extends object>(qb: QueryBuilder<T>, 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>[], 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>, alias: string, fields?: Field<T>[]): Field<T>[];
+    protected buildFields<T extends object>(meta: EntityMetadata<T>, populate: PopulateOptions<T>[], joinedProps: PopulateOptions<T>[], qb: QueryBuilder<T>, alias: string, fields?: Field<T>[], options?: {
+        strategy?: Options['loadStrategy'];
+    }): Field<T>[];
 }

package/AbstractSqlDriver.js

@@ -29,17 +29,19 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             return this.findVirtual(entityName, where, options);
         }
         const populate = this.autoJoinOneToOneOwner(meta, options.populate, options.fields);
-        const joinedProps = this.joinedProps(meta, populate);
+        const joinedProps = this.joinedProps(meta, populate, options);
         const qb = this.createQueryBuilder(entityName, options.ctx, options.connectionType, false, options.logging);
-        const fields = this.buildFields(meta, populate, joinedProps, qb, qb.alias, options.fields);
-        const joinedPropsOrderBy = this.buildJoinedPropsOrderBy(entityName, qb, meta, joinedProps);
-        const orderBy = [...core_1.Utils.asArray(options.orderBy), ...joinedPropsOrderBy];
+        const fields = this.buildFields(meta, populate, joinedProps, qb, qb.alias, options.fields, options);
+        const orderBy = this.buildOrderBy(qb, meta, populate, options);
+        core_1.Utils.asArray(options.flags).forEach(flag => qb.setFlag(flag));
         if (core_1.Utils.isPrimaryKey(where, meta.compositePK)) {
             where = { [core_1.Utils.getPrimaryKeyHash(meta.primaryKeys)]: where };
         }
         const { first, last, before, after } = options;
         const isCursorPagination = [first, last, before, after].some(v => v != null);
+        qb.__populateWhere = options._populateWhere;
         qb.select(fields)
+            // only add populateWhere if we are populate-joining, as this will be used to add `on` conditions
             .populate(populate, joinedProps.length > 0 ? options.populateWhere : undefined)
             .where(where)
             .groupBy(options.groupBy)
@@ -55,13 +57,12 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         else {
             qb.orderBy(orderBy);
         }
-        if (options.limit !== undefined) {
+        if (options.limit != null || options.offset != null) {
             qb.limit(options.limit, options.offset);
         }
         if (options.lockMode) {
             qb.setLockMode(options.lockMode, options.lockTableAliases);
         }
-        core_1.Utils.asArray(options.flags).forEach(flag => qb.setFlag(flag));
         const result = await this.rethrow(qb.execute('all'));
         if (isCursorPagination && !first && !!last) {
             result.reverse();
@@ -72,8 +73,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         const opts = { populate: [], ...(options || {}) };
         const meta = this.metadata.find(entityName);
         const populate = this.autoJoinOneToOneOwner(meta, opts.populate, opts.fields);
-        const joinedProps = this.joinedProps(meta, populate);
-        if (joinedProps.length === 0) {
+        const joinedProps = this.joinedProps(meta, populate, options);
+        const hasToManyJoins = joinedProps.some(hint => this.hasToManyJoins(hint, meta));
+        if (joinedProps.length === 0 || !hasToManyJoins) {
             opts.limit = 1;
         }
         if (opts.limit > 0 && !opts.flags?.includes(core_1.QueryFlag.DISABLE_PAGINATE)) {
@@ -83,6 +85,17 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         const res = await this.find(entityName, where, opts);
         return res[0] || null;
     }
+    hasToManyJoins(hint, meta) {
+        const [propName] = hint.field.split(':', 2);
+        const prop = meta.properties[propName];
+        if (prop && [core_1.ReferenceKind.ONE_TO_MANY, core_1.ReferenceKind.MANY_TO_MANY].includes(prop.kind)) {
+            return true;
+        }
+        if (hint.children && prop.targetMeta) {
+            return hint.children.some(hint => this.hasToManyJoins(hint, prop.targetMeta));
+        }
+        return false;
+    }
     async findVirtual(entityName, where, options) {
         return this.findFromVirtual(entityName, where, options, query_1.QueryType.SELECT);
     }
@@ -155,34 +168,61 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
     }
     mapJoinedProps(result, meta, populate, qb, root, map, parentJoinPath) {
         const joinedProps = this.joinedProps(meta, populate);
-        joinedProps.forEach(p => {
-            const relation = meta.properties[p.field];
+        joinedProps.forEach(hint => {
+            const [propName, ref] = hint.field.split(':', 2);
+            const prop = meta.properties[propName];
             /* istanbul ignore next */
-            if (!relation) {
+            if (!prop) {
+                return;
+            }
+            const pivotRefJoin = prop.kind === core_1.ReferenceKind.MANY_TO_MANY && ref;
+            const meta2 = this.metadata.find(prop.type);
+            let path = parentJoinPath ? `${parentJoinPath}.${prop.name}` : `${meta.name}.${prop.name}`;
+            if (!parentJoinPath) {
+                path = '[populate]' + path;
+            }
+            if (pivotRefJoin) {
+                path += '[pivot]';
+            }
+            const relationAlias = qb.getAliasForJoinPath(path, { matchPopulateJoins: true });
+            // pivot ref joins via joined strategy need to be handled separately here, as they dont join the target entity
+            if (pivotRefJoin) {
+                let item;
+                if (prop.inverseJoinColumns.length > 1) { // composite keys
+                    item = prop.inverseJoinColumns.map(name => root[`${relationAlias}__${name}`]);
+                }
+                else {
+                    const alias = `${relationAlias}__${prop.inverseJoinColumns[0]}`;
+                    item = root[alias];
+                }
+                prop.joinColumns.forEach(name => delete root[`${relationAlias}__${name}`]);
+                prop.inverseJoinColumns.forEach(name => delete root[`${relationAlias}__${name}`]);
+                result[prop.name] ??= [];
+                if (item) {
+                    result[prop.name].push(item);
+                }
                 return;
             }
-            const meta2 = this.metadata.find(relation.type);
-            const path = parentJoinPath ? `${parentJoinPath}.${relation.name}` : `${meta.name}.${relation.name}`;
-            const relationAlias = qb.getAliasForJoinPath(path);
-            const relationPojo = {};
             // If the primary key value for the relation is null, we know we haven't joined to anything
             // and therefore we don't return any record (since all values would be null)
             const hasPK = meta2.primaryKeys.every(pk => meta2.properties[pk].fieldNames.every(name => {
                 return root[`${relationAlias}__${name}`] != null;
             }));
             if (!hasPK) {
-                if ([core_1.ReferenceKind.MANY_TO_MANY, core_1.ReferenceKind.ONE_TO_MANY].includes(relation.kind)) {
-                    result[relation.name] ??= [];
+                if ([core_1.ReferenceKind.MANY_TO_MANY, core_1.ReferenceKind.ONE_TO_MANY].includes(prop.kind)) {
+                    result[prop.name] ??= [];
                 }
-                if ([core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(relation.kind)) {
-                    result[relation.name] = null;
+                if ([core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
+                    result[prop.name] ??= null;
                 }
                 return;
             }
-            const tz = this.platform.getTimezone();
+            const relationPojo = {};
             meta2.props
                 .filter(prop => prop.persist === false && prop.fieldNames)
+                .filter(prop => !prop.lazy || populate.some(p => p.field === prop.name || p.all))
                 .forEach(prop => {
+                /* istanbul ignore if */
                 if (prop.fieldNames.length > 1) { // composite keys
                     relationPojo[prop.name] = prop.fieldNames.map(name => root[`${relationAlias}__${name}`]);
                 }
@@ -192,11 +232,12 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 }
             });
             meta2.props
-                .filter(prop => this.platform.shouldHaveColumn(prop, p.children || []))
+                .filter(prop => this.platform.shouldHaveColumn(prop, hint.children || []))
                 .forEach(prop => {
                 if (prop.fieldNames.length > 1) { // composite keys
-                    relationPojo[prop.name] = prop.fieldNames.map(name => root[`${relationAlias}__${name}`]);
+                    const fk = prop.fieldNames.map(name => root[`${relationAlias}__${name}`]);
                     prop.fieldNames.map(name => delete root[`${relationAlias}__${name}`]);
+                    relationPojo[prop.name] = core_1.Utils.mapFlatCompositePrimaryKey(fk, prop);
                 }
                 else if (prop.runtimeType === 'Date') {
                     const alias = `${relationAlias}__${prop.fieldNames[0]}`;
@@ -209,14 +250,14 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                     delete root[alias];
                 }
             });
-            if ([core_1.ReferenceKind.MANY_TO_MANY, core_1.ReferenceKind.ONE_TO_MANY].includes(relation.kind)) {
-                result[relation.name] ??= [];
-                result[relation.name].push(relationPojo);
+            if ([core_1.ReferenceKind.MANY_TO_MANY, core_1.ReferenceKind.ONE_TO_MANY].includes(prop.kind)) {
+                result[prop.name] ??= [];
+                result[prop.name].push(relationPojo);
             }
             else {
-                result[relation.name] = relationPojo;
+                result[prop.name] = relationPojo;
             }
-            const populateChildren = p.children || [];
+            const populateChildren = hint.children || [];
             this.mapJoinedProps(relationPojo, meta2, populateChildren, qb, root, map, path);
         });
     }
@@ -388,10 +429,10 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             }
             else {
                 qb.update(data).where(where);
-                // reload generated columns
+                // reload generated columns and version fields
                 const returning = [];
                 meta?.props
-                    .filter(prop => prop.generated && !prop.primary)
+                    .filter(prop => (prop.generated && !prop.primary) || prop.version)
                     .forEach(prop => returning.push(prop.name));
                 qb.returning(returning);
             }
@@ -407,7 +448,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         options.convertCustomTypes ??= true;
         const meta = this.metadata.get(entityName);
         if (options.upsert) {
-            const uniqueFields = options.onConflictFields ?? (core_1.Utils.isPlainObject(where[0]) ? Object.keys(where[0]) : meta.primaryKeys);
+            const uniqueFields = options.onConflictFields ?? (core_1.Utils.isPlainObject(where[0]) ? Object.keys(where[0]).flatMap(key => core_1.Utils.splitPrimaryKeys(key)) : meta.primaryKeys);
             const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes).withSchema(this.getSchemaName(meta, options));
             const returning = (0, core_1.getOnConflictReturningFields)(meta, data[0], uniqueFields, options);
             qb.insert(data)
@@ -420,7 +461,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             if (options.onConflictAction === 'ignore') {
                 qb.ignore();
             }
-            return qb.execute('run', false);
+            return this.rethrow(qb.execute('run', false));
         }
         const collections = options.processCollections ? data.map(d => this.extractManyToMany(entityName, d)) : [];
         const keys = new Set();
@@ -433,9 +474,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 }
             });
         });
-        // reload generated columns
+        // reload generated columns and version fields
         meta?.props
-            .filter(prop => prop.generated && !prop.primary)
+            .filter(prop => (prop.generated && !prop.primary) || prop.version)
             .forEach(prop => returning.add(prop.name));
         const pkCond = core_1.Utils.flatten(meta.primaryKeys.map(pk => meta.properties[pk].fieldNames)).map(pk => `${this.platform.quoteIdentifier(pk)} = ?`).join(' and ');
         const params = [];
@@ -627,7 +668,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             const targetAlias = qb.getNextAlias(prop.targetMeta.tableName);
             const targetSchema = this.getSchemaName(prop.targetMeta, options) ?? this.platform.getDefaultSchemaName();
             qb.innerJoin(pivotProp1.name, targetAlias, {}, targetSchema);
-            const targetFields = this.buildFields(prop.targetMeta, (options.populate ?? []), [], qb, targetAlias, options.fields);
+            const targetFields = this.buildFields(prop.targetMeta, (options.populate ?? []), [], qb, targetAlias, options.fields, options);
             for (const field of targetFields) {
                 const f = field.toString();
                 fields.unshift(f.includes('.') ? field : `${targetAlias}.${f}`);
@@ -638,7 +679,8 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 qb.leftJoin(`${targetAlias}.${hint.field}`, alias);
                 // eslint-disable-next-line dot-notation
                 Object.values(qb['_joins']).forEach(join => {
-                    if (join.alias === alias && join.prop.name === hint.field) {
+                    const [propName] = hint.field.split(':', 2);
+                    if (join.alias === alias && join.prop.name === propName) {
                         fields.push(...qb.helper.mapJoinColumns(qb.type, join));
                     }
                 });
@@ -702,16 +744,21 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         const toPopulate = meta.relations
             .filter(prop => prop.kind === core_1.ReferenceKind.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 }));
+            .map(prop => ({ field: `${prop.name}:ref`, strategy: prop.strategy }));
         return [...populate, ...toPopulate];
     }
     /**
      * @internal
      */
-    joinedProps(meta, populate) {
-        return populate.filter(p => {
-            const prop = meta.properties[p.field] || {};
-            return (p.strategy || prop.strategy || this.config.get('loadStrategy')) === core_1.LoadStrategy.JOINED && ![core_1.ReferenceKind.SCALAR, core_1.ReferenceKind.EMBEDDED].includes(prop.kind);
+    joinedProps(meta, populate, options) {
+        return populate.filter(hint => {
+            const [propName, ref] = hint.field.split(':', 2);
+            const prop = meta.properties[propName] || {};
+            if (ref) {
+                // keep only pivot ref joins here, as that only triggers actual join
+                return prop.kind === core_1.ReferenceKind.MANY_TO_MANY;
+            }
+            return (prop.strategy || options?.strategy || hint.strategy || this.config.get('loadStrategy')) === core_1.LoadStrategy.JOINED && ![core_1.ReferenceKind.SCALAR, core_1.ReferenceKind.EMBEDDED].includes(prop.kind);
         });
     }
     /**
@@ -724,18 +771,23 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             const pk = core_1.Utils.getCompositeKeyHash(item, meta);
             if (map[pk]) {
                 for (const hint of joinedProps) {
-                    const prop = meta.properties[hint.field];
-                    if (!item[hint.field]) {
+                    const [propName, ref] = hint.field.split(':', 2);
+                    const prop = meta.properties[propName];
+                    if (!item[propName]) {
+                        continue;
+                    }
+                    if (prop.kind === core_1.ReferenceKind.MANY_TO_MANY && ref) {
+                        map[pk][propName] = [...map[pk][propName], ...item[propName]];
                         continue;
                     }
                     switch (prop.kind) {
                         case core_1.ReferenceKind.ONE_TO_MANY:
                         case core_1.ReferenceKind.MANY_TO_MANY:
-                            map[pk][hint.field] = this.mergeJoinedResult([...map[pk][hint.field], ...item[hint.field]], prop.targetMeta, hint.children ?? []);
+                            map[pk][propName] = this.mergeJoinedResult([...map[pk][propName], ...item[propName]], prop.targetMeta, hint.children ?? []);
                             break;
                         case core_1.ReferenceKind.MANY_TO_ONE:
                         case core_1.ReferenceKind.ONE_TO_ONE:
-                            map[pk][hint.field] = this.mergeJoinedResult([map[pk][hint.field], item[hint.field]], prop.targetMeta, hint.children ?? [])[0];
+                            map[pk][propName] = this.mergeJoinedResult([map[pk][propName], item[propName]], prop.targetMeta, hint.children ?? [])[0];
                             break;
                     }
                 }
@@ -747,9 +799,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
         return res;
     }
-    getFieldsForJoinedLoad(qb, meta, explicitFields, populate = [], parentTableAlias, parentJoinPath) {
+    getFieldsForJoinedLoad(qb, meta, explicitFields, populate = [], options, parentTableAlias, parentJoinPath) {
         const fields = [];
-        const joinedProps = this.joinedProps(meta, populate);
+        const joinedProps = this.joinedProps(meta, populate, options);
         if (explicitFields?.includes('*')) {
             fields.push('*');
         }
@@ -762,25 +814,39 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             }
             return fields.some(f => f === prop.name || f.toString().startsWith(prop.name + '.'));
         };
-        // alias all fields in the primary table
-        meta.props
-            .filter(prop => shouldHaveColumn(prop, populate, explicitFields))
-            .forEach(prop => fields.push(...this.mapPropToFieldNames(qb, prop, parentTableAlias)));
-        joinedProps.forEach(relation => {
-            const [propName] = relation.field.split(':', 2);
+        const populateWhereAll = options?._populateWhere === 'all' || core_1.Utils.isEmpty(options?._populateWhere);
+        // root entity is already handled, skip that
+        if (parentJoinPath) {
+            // alias all fields in the primary table
+            meta.props
+                .filter(prop => shouldHaveColumn(prop, populate, explicitFields))
+                .forEach(prop => fields.push(...this.mapPropToFieldNames(qb, prop, parentTableAlias)));
+        }
+        joinedProps.forEach(hint => {
+            const [propName, ref] = hint.field.split(':', 2);
             const prop = meta.properties[propName];
             const meta2 = this.metadata.find(prop.type);
+            const pivotRefJoin = prop.kind === core_1.ReferenceKind.MANY_TO_MANY && ref;
             const tableAlias = qb.getNextAlias(prop.name);
             const field = parentTableAlias ? `${parentTableAlias}.${prop.name}` : prop.name;
-            const path = parentJoinPath ? `${parentJoinPath}.${prop.name}` : `${meta.name}.${prop.name}`;
-            qb.join(field, tableAlias, {}, query_1.JoinType.leftJoin, path);
+            let path = parentJoinPath ? `${parentJoinPath}.${prop.name}` : `${meta.name}.${prop.name}`;
+            if (!parentJoinPath && populateWhereAll && !path.startsWith('[populate]')) {
+                path = '[populate]' + path;
+            }
+            const joinType = pivotRefJoin ? query_1.JoinType.pivotJoin : query_1.JoinType.leftJoin;
+            qb.join(field, tableAlias, {}, joinType, path);
+            if (pivotRefJoin) {
+                fields.push(...prop.joinColumns.map(col => qb.helper.mapper(`${tableAlias}.${col}`, qb.type, undefined, `${tableAlias}__${col}`)), ...prop.inverseJoinColumns.map(col => qb.helper.mapper(`${tableAlias}.${col}`, qb.type, undefined, `${tableAlias}__${col}`)));
+            }
             const childExplicitFields = explicitFields?.filter(f => core_1.Utils.isPlainObject(f)).map(o => o[prop.name])[0] || [];
             explicitFields?.forEach(f => {
                 if (typeof f === 'string' && f.startsWith(`${prop.name}.`)) {
                     childExplicitFields.push(f.substring(prop.name.length + 1));
                 }
             });
-            fields.push(...this.getFieldsForJoinedLoad(qb, meta2, childExplicitFields.length === 0 ? undefined : childExplicitFields, relation.children, tableAlias, path));
+            if (!ref) {
+                fields.push(...this.getFieldsForJoinedLoad(qb, meta2, childExplicitFields.length === 0 ? undefined : childExplicitFields, hint.children, options, tableAlias, path));
+            }
         });
         return fields;
     }
@@ -790,7 +856,17 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
     mapPropToFieldNames(qb, prop, tableAlias) {
         const knex = this.connection.getKnex();
         const aliased = knex.ref(tableAlias ? `${tableAlias}__${prop.fieldNames[0]}` : prop.fieldNames[0]).toString();
-        if (prop.customType?.convertToJSValueSQL && tableAlias) {
+        if (tableAlias && prop.customTypes?.some(type => type.convertToJSValueSQL)) {
+            return prop.fieldNames.map((col, idx) => {
+                if (!prop.customTypes[idx].convertToJSValueSQL) {
+                    return col;
+                }
+                const prefixed = knex.ref(col).withSchema(tableAlias).toString();
+                const aliased = knex.ref(`${tableAlias}__${col}`).toString();
+                return (0, core_1.raw)(`${prop.customTypes[idx].convertToJSValueSQL(prefixed, this.platform)} as ${aliased}`);
+            });
+        }
+        if (tableAlias && prop.customType?.convertToJSValueSQL) {
             const prefixed = knex.ref(prop.fieldNames[0]).withSchema(tableAlias).toString();
             return [(0, core_1.raw)(`${prop.customType.convertToJSValueSQL(prefixed, this.platform)} as ${aliased}`)];
         }
@@ -857,25 +933,83 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         qb.select((0, core_1.raw)('1')).where(cond).setLockMode(options.lockMode, options.lockTableAliases);
         await this.rethrow(qb.execute());
     }
-    buildJoinedPropsOrderBy(entityName, qb, meta, populate, parentPath) {
+    buildOrderBy(qb, meta, populate, options) {
+        const joinedProps = this.joinedProps(meta, populate, options);
+        // `options._populateWhere` is a copy of the value provided by user with a fallback to the global config option
+        // as `options.populateWhere` will be always recomputed to respect filters
+        const populateWhereAll = options._populateWhere !== 'infer' && !core_1.Utils.isEmpty(options._populateWhere);
+        const path = (populateWhereAll ? '[populate]' : '') + meta.className;
+        const populateOrderBy = this.buildPopulateOrderBy(qb, meta, core_1.Utils.asArray(options.populateOrderBy ?? options.orderBy), path);
+        const joinedPropsOrderBy = this.buildJoinedPropsOrderBy(qb, meta, joinedProps, options, path);
+        return [...core_1.Utils.asArray(options.orderBy), ...populateOrderBy, ...joinedPropsOrderBy];
+    }
+    buildPopulateOrderBy(qb, meta, populateOrderBy, parentPath, parentAlias = qb.alias) {
         const orderBy = [];
-        const joinedProps = this.joinedProps(meta, populate);
-        joinedProps.forEach(relation => {
-            const [propName] = relation.field.split(':', 2);
+        for (let i = 0; i < populateOrderBy.length; i++) {
+            const orderHint = populateOrderBy[i];
+            for (const propName of core_1.Utils.keys(orderHint)) {
+                const prop = meta.properties[propName];
+                const meta2 = this.metadata.find(prop.type);
+                const childOrder = orderHint[prop.name];
+                let path = `${parentPath}.${propName}`;
+                if (prop.kind === core_1.ReferenceKind.MANY_TO_MANY && typeof childOrder !== 'object') {
+                    path += '[pivot]';
+                }
+                const join = qb.getJoinForPath(path, { matchPopulateJoins: true });
+                const propAlias = qb.getAliasForJoinPath(join ?? path, { matchPopulateJoins: true }) ?? parentAlias;
+                if (!join && parentAlias === qb.alias) {
+                    continue;
+                }
+                if (![core_1.ReferenceKind.SCALAR, core_1.ReferenceKind.EMBEDDED].includes(prop.kind) && typeof childOrder === 'object') {
+                    const children = this.buildPopulateOrderBy(qb, meta2, core_1.Utils.asArray(childOrder), path, propAlias);
+                    orderBy.push(...children);
+                    continue;
+                }
+                if (prop.kind === core_1.ReferenceKind.MANY_TO_MANY && join) {
+                    if (prop.fixedOrderColumn) {
+                        orderBy.push({ [`${join.alias}.${prop.fixedOrderColumn}`]: childOrder });
+                    }
+                    else {
+                        for (const col of prop.inverseJoinColumns) {
+                            orderBy.push({ [`${join.ownerAlias}.${col}`]: childOrder });
+                        }
+                    }
+                    continue;
+                }
+                const order = typeof childOrder === 'object' ? childOrder[propName] : childOrder;
+                orderBy.push({ [`${propAlias}.${propName}`]: order });
+            }
+        }
+        return orderBy;
+    }
+    buildJoinedPropsOrderBy(qb, meta, populate, options, parentPath) {
+        const orderBy = [];
+        const joinedProps = this.joinedProps(meta, populate, options);
+        for (const hint of joinedProps) {
+            const [propName, ref] = hint.field.split(':', 2);
             const prop = meta.properties[propName];
             const propOrderBy = prop.orderBy;
-            const path = `${parentPath ? parentPath : entityName}.${relation.field}`;
-            const propAlias = qb.getAliasForJoinPath(path);
+            let path = `${parentPath}.${propName}`;
+            if (prop.kind === core_1.ReferenceKind.MANY_TO_MANY && ref) {
+                path += '[pivot]';
+            }
+            const join = qb.getJoinForPath(path, { matchPopulateJoins: true });
+            const propAlias = qb.getAliasForJoinPath(join ?? path, { matchPopulateJoins: true });
+            const meta2 = this.metadata.find(prop.type);
+            if (prop.kind === core_1.ReferenceKind.MANY_TO_MANY && prop.fixedOrder && join) {
+                const alias = ref ? propAlias : join.ownerAlias;
+                orderBy.push({ [`${alias}.${prop.fixedOrderColumn}`]: core_1.QueryOrder.ASC });
+            }
             if (propOrderBy) {
                 core_1.Utils.keys(propOrderBy).forEach(field => {
                     orderBy.push({ [`${propAlias}.${field}`]: propOrderBy[field] });
                 });
             }
-            if (relation.children) {
-                const meta2 = this.metadata.find(prop.type);
-                orderBy.push(...this.buildJoinedPropsOrderBy(prop.name, qb, meta2, relation.children, path));
+            if (hint.children) {
+                const buildJoinedPropsOrderBy = this.buildJoinedPropsOrderBy(qb, meta2, hint.children, options, path);
+                orderBy.push(...buildJoinedPropsOrderBy);
             }
-        });
+        }
         return orderBy;
     }
     normalizeFields(fields, prefix = '') {
@@ -913,17 +1047,15 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
         ret.push(prop.name);
     }
-    buildFields(meta, populate, joinedProps, qb, alias, fields) {
+    buildFields(meta, populate, joinedProps, qb, alias, fields, options) {
         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);
         const requiresSQLConversion = meta.props.some(p => p.customType?.convertToJSValueSQL && p.persist !== false);
         const hasExplicitFields = !!fields;
         const ret = [];
         let addFormulas = false;
-        if (joinedProps.length > 0) {
-            ret.push(...this.getFieldsForJoinedLoad(qb, meta, fields, populate));
-        }
-        else if (fields) {
+        // handle root entity properties first, this is used for both strategies in the same way
+        if (fields) {
             for (const field of this.normalizeFields(fields)) {
                 if (field === '*') {
                     ret.push('*');
@@ -940,7 +1072,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 });
                 this.processField(meta, prop, parts.join('.'), ret, populate, joinedProps, qb);
             }
-            ret.unshift(...meta.primaryKeys.filter(pk => !fields.includes(pk)));
+            if (!fields.includes('*') && !fields.includes(`${qb.alias}.*`)) {
+                ret.unshift(...meta.primaryKeys.filter(pk => !fields.includes(pk)));
+            }
         }
         else if (lazyProps.filter(p => !p.formula).length > 0) {
             const props = meta.props.filter(prop => this.platform.shouldHaveColumn(prop, populate, false));
@@ -951,6 +1085,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             ret.push('*');
             addFormulas = true;
         }
+        else {
+            ret.push('*');
+        }
         if (ret.length > 0 && !hasExplicitFields && addFormulas) {
             meta.props
                 .filter(prop => prop.formula && !lazyProps.includes(prop))
@@ -963,7 +1100,11 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 .filter(prop => prop.hasConvertToDatabaseValueSQL || prop.hasConvertToJSValueSQL)
                 .forEach(prop => ret.push(prop.name));
         }
-        return ret.length > 0 ? core_1.Utils.unique(ret) : ['*'];
+        // add joined relations after the root entity fields
+        if (joinedProps.length > 0) {
+            ret.push(...this.getFieldsForJoinedLoad(qb, meta, fields, populate, options, alias));
+        }
+        return core_1.Utils.unique(ret);
     }
 }
 exports.AbstractSqlDriver = AbstractSqlDriver;

package/SqlEntityRepository.js

@@ -24,7 +24,7 @@ class SqlEntityRepository extends core_1.EntityRepository {
      * Returns configured knex instance.
      */
     getKnex(type) {
-        return this.getEntityManager().getKnex();
+        return this.getEntityManager().getKnex(type);
     }
     /**
      * @inheritDoc