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

package/AbstractSqlConnection.d.ts

@@ -40,7 +40,7 @@ export declare abstract class AbstractSqlConnection extends Connection {
     }): Promise<Knex.Transaction>;
     commit(ctx: Knex.Transaction, eventBroadcaster?: TransactionEventBroadcaster): Promise<void>;
     rollback(ctx: Knex.Transaction, eventBroadcaster?: TransactionEventBroadcaster): Promise<void>;
-    execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(queryOrKnex: string | Knex.QueryBuilder | Knex.Raw, params?: unknown[], method?: 'all' | 'get' | 'run', ctx?: Transaction, logging?: LoggingOptions): Promise<T>;
+    execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(queryOrKnex: string | Knex.QueryBuilder | Knex.Raw, params?: unknown[], method?: 'all' | 'get' | 'run', ctx?: Transaction, loggerContext?: LoggingOptions): Promise<T>;
     /**
      * Execute raw SQL queries from file
      */

package/AbstractSqlConnection.js

@@ -106,7 +106,7 @@ class AbstractSqlConnection extends core_1.Connection {
             await eventBroadcaster?.dispatchEvent(core_1.EventType.afterTransactionRollback, ctx);
         }
     }
-    async execute(queryOrKnex, params = [], method = 'all', ctx, logging) {
+    async execute(queryOrKnex, params = [], method = 'all', ctx, loggerContext) {
         await this.ensureConnection();
         if (core_1.Utils.isObject(queryOrKnex)) {
             ctx ??= (queryOrKnex.client.transacting ? queryOrKnex : null);
@@ -115,7 +115,7 @@ class AbstractSqlConnection extends core_1.Connection {
             params = q.bindings;
         }
         const formatted = this.platform.formatQuery(queryOrKnex, params);
-        const sql = this.getSql(queryOrKnex, formatted, logging);
+        const sql = this.getSql(queryOrKnex, formatted, loggerContext);
         return this.executeQuery(sql, async () => {
             const query = this.getKnex().raw(formatted);
             if (ctx) {
@@ -123,7 +123,7 @@ class AbstractSqlConnection extends core_1.Connection {
             }
             const res = await query;
             return this.transformRawResult(res, method);
-        }, { query: queryOrKnex, params, ...logging });
+        }, { query: queryOrKnex, params, ...loggerContext });
     }
     /**
      * Execute raw SQL queries from file

package/AbstractSqlDriver.d.ts

@@ -13,10 +13,10 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     protected constructor(config: Configuration, platform: Platform, connection: Constructor<Connection>, connector: string[]);
     getPlatform(): Platform;
     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>;
+    find<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: string, where: FilterQuery<T>, options?: FindOptions<T, P, F, E>): Promise<EntityData<T>[]>;
+    findOne<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: string, where: FilterQuery<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: FilterQuery<T>, options: FindOptions<T, any, any>): Promise<EntityData<T>[]>;
+    findVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: FindOptions<T, any, 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>;
     protected wrapVirtualExpressionInSubquery<T extends object>(meta: EntityMetadata<T>, expression: string, where: FilterQuery<T>, options: FindOptions<T, any>, type: QueryType): Promise<T[] | number>;
@@ -29,13 +29,13 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     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>>;
     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>, pivotJoin?: boolean): Promise<Dictionary<T[]>>;
+    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[]>>;
     private getPivotOrderBy;
     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<T>, populate: PopulateOptions<T>[], fields?: readonly EntityField<T, P>[]): PopulateOptions<T>[];
+    protected autoJoinOneToOneOwner<T extends object, P extends string = never>(meta: EntityMetadata<T>, populate: PopulateOptions<T>[], fields?: readonly EntityField<T, any>[]): PopulateOptions<T>[];
     /**
      * @internal
      */
@@ -46,7 +46,7 @@ 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 getFieldsForJoinedLoad<T extends object>(qb: QueryBuilder<T>, meta: EntityMetadata<T>, explicitFields?: Field<T>[], populate?: PopulateOptions<T>[], options?: {
+    protected getFieldsForJoinedLoad<T extends object>(qb: QueryBuilder<T>, meta: EntityMetadata<T>, explicitFields?: Field<T>[], exclude?: Field<T>[], populate?: PopulateOptions<T>[], options?: {
         strategy?: Options['loadStrategy'];
         populateWhere?: FindOptions<any>['populateWhere'];
     }, parentTableAlias?: string, parentJoinPath?: string): Field<T>[];
@@ -55,7 +55,7 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
      */
     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, logging?: LoggingOptions): QueryBuilder<T>;
+    createQueryBuilder<T extends object>(entityName: EntityName<T> | QueryBuilder<T>, ctx?: Transaction<Knex.Transaction>, preferredConnectionType?: ConnectionType, convertCustomTypes?: boolean, loggerContext?: LoggingOptions): QueryBuilder<T>;
     protected resolveConnectionType(args: {
         ctx?: Transaction<Knex.Transaction>;
         connectionType?: ConnectionType;
@@ -68,7 +68,5 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     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>[], options?: {
-        strategy?: Options['loadStrategy'];
-    }): Field<T>[];
+    protected buildFields<T extends object>(meta: EntityMetadata<T>, populate: PopulateOptions<T>[], joinedProps: PopulateOptions<T>[], qb: QueryBuilder<T>, alias: string, options: Pick<FindOptions<T, any, any, any>, 'strategy' | 'fields' | 'exclude'>): Field<T>[];
 }

package/AbstractSqlDriver.js

@@ -31,7 +31,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         const populate = this.autoJoinOneToOneOwner(meta, options.populate, options.fields);
         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, options);
+        const fields = this.buildFields(meta, populate, joinedProps, qb, qb.alias, 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)) {
@@ -111,7 +111,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         if (typeof meta.expression === 'string') {
             return this.wrapVirtualExpressionInSubquery(meta, meta.expression, where, options, type);
         }
-        const em = this.createEntityManager(false);
+        const em = this.createEntityManager();
         em.setTransactionContext(options.ctx);
         const res = meta.expression(em, where, options);
         if (typeof res === 'string') {
@@ -217,9 +217,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 }
                 return;
             }
-            const relationPojo = {};
+            let relationPojo = {};
             meta2.props
-                .filter(prop => prop.persist === false && prop.fieldNames)
+                .filter(prop => !ref && prop.persist === false && prop.fieldNames)
                 .filter(prop => !prop.lazy || populate.some(p => p.field === prop.name || p.all))
                 .forEach(prop => {
                 /* istanbul ignore if */
@@ -231,25 +231,42 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                     relationPojo[prop.name] = root[alias];
                 }
             });
-            meta2.props
-                .filter(prop => this.platform.shouldHaveColumn(prop, hint.children || []))
-                .forEach(prop => {
+            const targetProps = ref
+                ? meta2.getPrimaryProps()
+                : meta2.props.filter(prop => this.platform.shouldHaveColumn(prop, hint.children || []));
+            for (const prop of targetProps) {
                 if (prop.fieldNames.length > 1) { // composite keys
                     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]}`;
                     relationPojo[prop.name] = (typeof root[alias] === 'string' ? new Date(root[alias]) : root[alias]);
-                    delete root[alias];
                 }
                 else {
                     const alias = `${relationAlias}__${prop.fieldNames[0]}`;
                     relationPojo[prop.name] = root[alias];
-                    delete root[alias];
+                    if (prop.kind === core_1.ReferenceKind.EMBEDDED && (prop.object || meta.embeddable)) {
+                        const item = (0, core_1.parseJsonSafe)(relationPojo[prop.name]);
+                        if (Array.isArray(item)) {
+                            relationPojo[prop.name] = item.map(row => row == null ? row : this.comparator.mapResult(prop.type, row));
+                        }
+                        else {
+                            relationPojo[prop.name] = item == null ? item : this.comparator.mapResult(prop.type, item);
+                        }
+                    }
                 }
-            });
+            }
+            // properties can be mapped to multiple places, e.g. when sharing a column in multiple FKs,
+            // so we need to delete them after everything is mapped from given level
+            for (const prop of targetProps) {
+                prop.fieldNames.map(name => delete root[`${relationAlias}__${name}`]);
+            }
+            if (ref) {
+                const tmp = Object.values(relationPojo);
+                /* istanbul ignore next */
+                relationPojo = (meta2.compositePK ? tmp : tmp[0]);
+            }
             if ([core_1.ReferenceKind.MANY_TO_MANY, core_1.ReferenceKind.ONE_TO_MANY].includes(prop.kind)) {
                 result[prop.name] ??= [];
                 result[prop.name].push(relationPojo);
@@ -465,6 +482,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
         const collections = options.processCollections ? data.map(d => this.extractManyToMany(entityName, d)) : [];
         const keys = new Set();
+        const fields = new Set();
         const returning = new Set();
         data.forEach(row => {
             core_1.Utils.keys(row).forEach(k => {
@@ -498,6 +516,10 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         keys.forEach(key => {
             const prop = meta.properties[key];
             prop.fieldNames.forEach((fieldName, fieldNameIdx) => {
+                if (fields.has(fieldName)) {
+                    return;
+                }
+                fields.add(fieldName);
                 sql += `${this.platform.quoteIdentifier(fieldName)} = case`;
                 where.forEach((cond, idx) => {
                     if (key in data[idx]) {
@@ -668,7 +690,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, options);
+            const targetFields = this.buildFields(prop.targetMeta, (options.populate ?? []), [], qb, targetAlias, options);
             for (const field of targetFields) {
                 const f = field.toString();
                 fields.unshift(f.includes('.') ? field : `${targetAlias}.${f}`);
@@ -754,11 +776,13 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         return populate.filter(hint => {
             const [propName, ref] = hint.field.split(':', 2);
             const prop = meta.properties[propName] || {};
+            if ((options?.strategy || hint.strategy || prop.strategy || this.config.get('loadStrategy')) !== core_1.LoadStrategy.JOINED) {
+                return false;
+            }
             if (ref) {
-                // keep only pivot ref joins here, as that only triggers actual join
-                return prop.kind === core_1.ReferenceKind.MANY_TO_MANY;
+                return [core_1.ReferenceKind.MANY_TO_MANY, core_1.ReferenceKind.ONE_TO_MANY].includes(prop.kind);
             }
-            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);
+            return ![core_1.ReferenceKind.SCALAR, core_1.ReferenceKind.EMBEDDED].includes(prop.kind);
         });
     }
     /**
@@ -799,14 +823,14 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
         return res;
     }
-    getFieldsForJoinedLoad(qb, meta, explicitFields, populate = [], options, parentTableAlias, parentJoinPath) {
+    getFieldsForJoinedLoad(qb, meta, explicitFields, exclude, populate = [], options, parentTableAlias, parentJoinPath) {
         const fields = [];
         const joinedProps = this.joinedProps(meta, populate, options);
         if (explicitFields?.includes('*')) {
             fields.push('*');
         }
         const shouldHaveColumn = (prop, populate, fields) => {
-            if (!this.platform.shouldHaveColumn(prop, populate)) {
+            if (!this.platform.shouldHaveColumn(prop, populate, exclude)) {
                 return false;
             }
             if (!fields || prop.primary) {
@@ -838,14 +862,18 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             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}`)));
             }
+            if (prop.kind === core_1.ReferenceKind.ONE_TO_MANY && ref) {
+                fields.push(...this.getFieldsForJoinedLoad(qb, meta2, prop.referencedColumnNames, undefined, hint.children, options, tableAlias, path));
+            }
             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));
                 }
             });
+            const childExclude = exclude ? core_1.Utils.extractChildElements(exclude, prop.name) : exclude;
             if (!ref) {
-                fields.push(...this.getFieldsForJoinedLoad(qb, meta2, childExplicitFields.length === 0 ? undefined : childExplicitFields, hint.children, options, tableAlias, path));
+                fields.push(...this.getFieldsForJoinedLoad(qb, meta2, childExplicitFields.length === 0 ? undefined : childExplicitFields, childExclude, hint.children, options, tableAlias, path));
             }
         });
         return fields;
@@ -856,9 +884,9 @@ 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 (tableAlias && prop.customTypes?.some(type => type.convertToJSValueSQL)) {
+        if (tableAlias && prop.customTypes?.some(type => type?.convertToJSValueSQL)) {
             return prop.fieldNames.map((col, idx) => {
-                if (!prop.customTypes[idx].convertToJSValueSQL) {
+                if (!prop.customTypes[idx]?.convertToJSValueSQL) {
                     return col;
                 }
                 const prefixed = knex.ref(col).withSchema(tableAlias).toString();
@@ -880,9 +908,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         return prop.fieldNames;
     }
     /** @internal */
-    createQueryBuilder(entityName, ctx, preferredConnectionType, convertCustomTypes, logging) {
+    createQueryBuilder(entityName, ctx, preferredConnectionType, convertCustomTypes, loggerContext) {
         const connectionType = this.resolveConnectionType({ ctx, connectionType: preferredConnectionType });
-        const qb = new query_1.QueryBuilder(entityName, this.metadata, this, ctx, undefined, connectionType, undefined, logging);
+        const qb = new query_1.QueryBuilder(entityName, this.metadata, this, ctx, undefined, connectionType, undefined, loggerContext);
         if (!convertCustomTypes) {
             qb.unsetFlag(core_1.QueryFlag.CONVERT_CUSTOM_TYPES);
         }
@@ -1047,16 +1075,16 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
         ret.push(prop.name);
     }
-    buildFields(meta, populate, joinedProps, qb, alias, fields, options) {
+    buildFields(meta, populate, joinedProps, qb, alias, 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 hasExplicitFields = !!options.fields;
         const ret = [];
         let addFormulas = false;
         // 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 (options.fields) {
+            for (const field of this.normalizeFields(options.fields)) {
                 if (field === '*') {
                     ret.push('*');
                     continue;
@@ -1072,12 +1100,12 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 });
                 this.processField(meta, prop, parts.join('.'), ret, populate, joinedProps, qb);
             }
-            if (!fields.includes('*') && !fields.includes(`${qb.alias}.*`)) {
-                ret.unshift(...meta.primaryKeys.filter(pk => !fields.includes(pk)));
+            if (!options.fields.includes('*') && !options.fields.includes(`${qb.alias}.*`)) {
+                ret.unshift(...meta.primaryKeys.filter(pk => !options.fields.includes(pk)));
             }
         }
-        else if (lazyProps.filter(p => !p.formula).length > 0) {
-            const props = meta.props.filter(prop => this.platform.shouldHaveColumn(prop, populate, false));
+        else if (!core_1.Utils.isEmpty(options.exclude) || lazyProps.some(p => !p.formula)) {
+            const props = meta.props.filter(prop => this.platform.shouldHaveColumn(prop, populate, options.exclude, false));
             ret.push(...core_1.Utils.flatten(props.filter(p => !lazyProps.includes(p)).map(p => p.fieldNames)));
             addFormulas = true;
         }
@@ -1102,7 +1130,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
         // add joined relations after the root entity fields
         if (joinedProps.length > 0) {
-            ret.push(...this.getFieldsForJoinedLoad(qb, meta, fields, populate, options, alias));
+            ret.push(...this.getFieldsForJoinedLoad(qb, meta, options.fields, options.exclude, populate, options, alias));
         }
         return core_1.Utils.unique(ret);
     }

package/AbstractSqlPlatform.d.ts

@@ -13,10 +13,14 @@ export declare abstract class AbstractSqlPlatform extends Platform {
     quoteValue(value: any): string;
     formatQuery(sql: string, params: readonly any[]): string;
     getSearchJsonPropertySQL(path: string, type: string, aliased: boolean): string;
-    getSearchJsonPropertyKey(path: string[], type: string, aliased: boolean): string;
+    getSearchJsonPropertyKey(path: string[], type: string, aliased: boolean, value?: unknown): string;
     getJsonIndexDefinition(index: IndexDef): string[];
     isRaw(value: any): boolean;
     supportsSchemas(): boolean;
     /** @inheritDoc */
     generateCustomOrder(escapedColumn: string, values: unknown[]): string;
+    /**
+     * @internal
+     */
+    getOrderByExpression(column: string, direction: string): string[];
 }

package/AbstractSqlPlatform.js

@@ -83,7 +83,7 @@ class AbstractSqlPlatform extends core_1.Platform {
     getSearchJsonPropertySQL(path, type, aliased) {
         return this.getSearchJsonPropertyKey(path.split('->'), type, aliased);
     }
-    getSearchJsonPropertyKey(path, type, aliased) {
+    getSearchJsonPropertyKey(path, type, aliased, value) {
         const [a, ...b] = path;
         const quoteKey = (key) => key.match(/^[a-z]\w*$/i) ? key : `"${key}"`;
         if (aliased) {
@@ -112,5 +112,11 @@ class AbstractSqlPlatform extends core_1.Platform {
         });
         return ret + 'else null end)';
     }
+    /**
+     * @internal
+     */
+    getOrderByExpression(column, direction) {
+        return [`${column} ${direction.toLowerCase()}`];
+    }
 }
 exports.AbstractSqlPlatform = AbstractSqlPlatform;

package/SqlEntityManager.d.ts

@@ -1,5 +1,5 @@
 import type { Knex } from 'knex';
-import { EntityManager, type AnyEntity, type ConnectionType, type EntityData, type EntityName, type EntityRepository, type GetRepository, type QueryResult, type FilterQuery } from '@mikro-orm/core';
+import { EntityManager, type AnyEntity, type ConnectionType, type EntityData, type EntityName, type EntityRepository, type GetRepository, type QueryResult, type FilterQuery, type LoggingOptions } from '@mikro-orm/core';
 import type { AbstractSqlDriver } from './AbstractSqlDriver';
 import { QueryBuilder } from './query';
 import type { SqlEntityRepository } from './SqlEntityRepository';
@@ -10,11 +10,11 @@ export declare class SqlEntityManager<D extends AbstractSqlDriver = AbstractSqlD
     /**
      * Creates a QueryBuilder instance
      */
-    createQueryBuilder<T extends object>(entityName: EntityName<T> | QueryBuilder<T>, alias?: string, type?: ConnectionType): QueryBuilder<T>;
+    createQueryBuilder<T extends object>(entityName: EntityName<T> | QueryBuilder<T>, alias?: string, type?: ConnectionType, loggerContext?: LoggingOptions): QueryBuilder<T>;
     /**
      * Shortcut for `createQueryBuilder()`
      */
-    qb<T extends object>(entityName: EntityName<T>, alias?: string, type?: ConnectionType): QueryBuilder<T>;
+    qb<T extends object>(entityName: EntityName<T>, alias?: string, type?: ConnectionType, loggerContext?: LoggingOptions): QueryBuilder<T>;
     /**
      * Returns configured knex instance.
      */

package/SqlEntityManager.js

@@ -10,15 +10,15 @@ class SqlEntityManager extends core_1.EntityManager {
     /**
      * Creates a QueryBuilder instance
      */
-    createQueryBuilder(entityName, alias, type) {
+    createQueryBuilder(entityName, alias, type, loggerContext) {
         const context = this.getContext();
-        return new query_1.QueryBuilder(entityName, this.getMetadata(), this.getDriver(), context.getTransactionContext(), alias, type, context);
+        return new query_1.QueryBuilder(entityName, this.getMetadata(), this.getDriver(), context.getTransactionContext(), alias, type, context, loggerContext ?? context.loggerContext);
     }
     /**
      * Shortcut for `createQueryBuilder()`
      */
-    qb(entityName, alias, type) {
-        return this.createQueryBuilder(entityName, alias, type);
+    qb(entityName, alias, type, loggerContext) {
+        return this.createQueryBuilder(entityName, alias, type, loggerContext);
     }
     /**
      * Returns configured knex instance.

package/index.mjs

@@ -47,7 +47,7 @@ export const DatabaseObjectExistsException = mod.DatabaseObjectExistsException;
 export const DatabaseObjectNotFoundException = mod.DatabaseObjectNotFoundException;
 export const DatabaseSchema = mod.DatabaseSchema;
 export const DatabaseTable = mod.DatabaseTable;
-export const Dataloader = mod.Dataloader;
+export const DataloaderType = mod.DataloaderType;
 export const DataloaderUtils = mod.DataloaderUtils;
 export const DateTimeType = mod.DateTimeType;
 export const DateType = mod.DateType;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.0.0-rc.2",
+  "version": "6.0.0-rc.3",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "main": "index.js",
   "module": "index.mjs",
@@ -58,14 +58,14 @@
     "access": "public"
   },
   "dependencies": {
-    "fs-extra": "11.1.1",
-    "knex": "3.0.1",
+    "fs-extra": "11.2.0",
+    "knex": "3.1.0",
     "sqlstring": "2.3.3"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^5.9.2"
+    "@mikro-orm/core": "^5.0.0"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.0.0-rc.2"
+    "@mikro-orm/core": "6.0.0-rc.3"
   }
 }

package/query/CriteriaNode.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { inspect } from 'util';
-import { type EntityProperty, type MetadataStorage, type EntityKey } from '@mikro-orm/core';
+import { type EntityKey, type EntityProperty, type MetadataStorage } from '@mikro-orm/core';
 import type { ICriteriaNode, ICriteriaNodeProcessOptions, IQueryBuilder } from '../typings';
 /**
  * Helper for working with deeply nested where/orderBy/having criteria. Uses composite pattern to build tree from the payload.
@@ -28,5 +28,4 @@ export declare class CriteriaNode<T extends object> implements ICriteriaNode<T>
     aliased(field: string, alias?: string): string;
     /** @ignore */
     [inspect.custom](): string;
-    static isCustomExpression(field: string): boolean;
 }

package/query/CriteriaNode.js

@@ -31,7 +31,7 @@ class CriteriaNode {
                 this.prop = meta.props.find(prop => prop.name === k || (prop.fieldNames?.length === 1 && prop.fieldNames[0] === k));
                 const isProp = this.prop || meta.props.find(prop => (prop.fieldNames || []).includes(k));
                 // do not validate if the key is prefixed or type casted (e.g. `k::text`)
-                if (validate && !isProp && !k.includes('.') && !k.includes('::') && !core_1.Utils.isOperator(k) && !CriteriaNode.isCustomExpression(k)) {
+                if (validate && !isProp && !k.includes('.') && !k.includes('::') && !core_1.Utils.isOperator(k) && !core_1.RawQueryFragment.isKnownFragment(k)) {
                     throw new Error(`Trying to query by not existing property ${entityName}.${k}`);
                 }
             });
@@ -52,7 +52,7 @@ class CriteriaNode {
     shouldRename(payload) {
         const type = this.prop ? this.prop.kind : null;
         const composite = this.prop?.joinColumns ? this.prop.joinColumns.length > 1 : false;
-        const customExpression = CriteriaNode.isCustomExpression(this.key);
+        const customExpression = core_1.RawQueryFragment.isKnownFragment(this.key);
         const scalar = payload === null || core_1.Utils.isPrimaryKey(payload) || payload instanceof RegExp || payload instanceof Date || customExpression;
         const plainObject = core_1.Utils.isPlainObject(payload);
         const keys = plainObject ? Object.keys(payload) : [];
@@ -98,7 +98,7 @@ class CriteriaNode {
         if (!this.key || !this.prop) {
             return false;
         }
-        const customExpression = CriteriaNode.isCustomExpression(this.key);
+        const customExpression = core_1.RawQueryFragment.isKnownFragment(this.key);
         const scalar = this.payload === null || core_1.Utils.isPrimaryKey(this.payload) || this.payload instanceof RegExp || this.payload instanceof Date || customExpression;
         const operator = core_1.Utils.isObject(this.payload) && Object.keys(this.payload).every(k => core_1.Utils.isOperator(k, false));
         return this.prop.kind === core_1.ReferenceKind.MANY_TO_MANY && (scalar || operator);
@@ -117,8 +117,5 @@ class CriteriaNode {
             .forEach(k => o[k] = this[k]);
         return `${this.constructor.name} ${(0, util_1.inspect)(o)}`;
     }
-    static isCustomExpression(field) {
-        return !!field.match(/[ ?<>=()]|^\d/);
-    }
 }
 exports.CriteriaNode = CriteriaNode;

package/query/CriteriaNodeFactory.d.ts

@@ -1,4 +1,4 @@
-import { type Dictionary, type EntityMetadata, type MetadataStorage, type EntityKey } from '@mikro-orm/core';
+import { type Dictionary, type EntityKey, type EntityMetadata, type MetadataStorage } from '@mikro-orm/core';
 import type { ICriteriaNode } from '../typings';
 /**
  * @internal

package/query/CriteriaNodeFactory.js

@@ -5,13 +5,12 @@ const core_1 = require("@mikro-orm/core");
 const ObjectCriteriaNode_1 = require("./ObjectCriteriaNode");
 const ArrayCriteriaNode_1 = require("./ArrayCriteriaNode");
 const ScalarCriteriaNode_1 = require("./ScalarCriteriaNode");
-const CriteriaNode_1 = require("./CriteriaNode");
 /**
  * @internal
  */
 class CriteriaNodeFactory {
     static createNode(metadata, entityName, payload, parent, key) {
-        const customExpression = CriteriaNode_1.CriteriaNode.isCustomExpression(key || '');
+        const customExpression = core_1.RawQueryFragment.isKnownFragment(key || '');
         const scalar = core_1.Utils.isPrimaryKey(payload) || core_1.Utils.isRawSql(payload) || payload instanceof RegExp || payload instanceof Date || customExpression;
         if (Array.isArray(payload) && !scalar) {
             return this.createArrayNode(metadata, entityName, payload, parent, key);

package/query/ObjectCriteriaNode.d.ts

@@ -1,5 +1,5 @@
 import { CriteriaNode } from './CriteriaNode';
-import type { IQueryBuilder, ICriteriaNodeProcessOptions } from '../typings';
+import type { ICriteriaNodeProcessOptions, IQueryBuilder } from '../typings';
 /**
  * @internal
  */

package/query/ObjectCriteriaNode.js

@@ -16,7 +16,7 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
         if (nestedAlias) {
             alias = nestedAlias;
         }
-        if (this.shouldAutoJoin(nestedAlias)) {
+        if (this.shouldAutoJoin(qb, nestedAlias)) {
             if (keys.some(k => ['$some', '$none', '$every'].includes(k))) {
                 const $and = [];
                 const primaryKeys = this.metadata.find(this.entityName).primaryKeys.map(pk => {
@@ -86,7 +86,7 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
         if (nestedAlias) {
             alias = nestedAlias;
         }
-        if (this.shouldAutoJoin(nestedAlias)) {
+        if (this.shouldAutoJoin(qb, nestedAlias)) {
             return !keys.some(k => ['$some', '$none', '$every'].includes(k));
         }
         return keys.some(field => {
@@ -95,7 +95,7 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
         });
     }
     shouldInline(payload) {
-        const customExpression = ObjectCriteriaNode.isCustomExpression(this.key);
+        const customExpression = core_1.RawQueryFragment.isKnownFragment(this.key);
         const scalar = core_1.Utils.isPrimaryKey(payload) || payload instanceof RegExp || payload instanceof Date || customExpression;
         const operator = core_1.Utils.isObject(payload) && Object.keys(payload).every(k => core_1.Utils.isOperator(k, false));
         return !!this.prop && this.prop.kind !== core_1.ReferenceKind.SCALAR && !scalar && !operator;
@@ -128,7 +128,7 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
                     o[key] = payload[k];
                 }
             }
-            else if (ObjectCriteriaNode.isCustomExpression(k)) {
+            else if (core_1.RawQueryFragment.isKnownFragment(k)) {
                 o[k] = payload[k];
             }
             else {
@@ -137,15 +137,19 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
             }
         }
     }
-    shouldAutoJoin(nestedAlias) {
+    shouldAutoJoin(qb, nestedAlias) {
         if (!this.prop || !this.parent) {
             return false;
         }
+        const keys = Object.keys(this.payload);
+        if (keys.every(k => k.includes('.') && k.startsWith(`${qb.alias}.`))) {
+            return false;
+        }
+        const meta = this.metadata.find(this.entityName);
         const embeddable = this.prop.kind === core_1.ReferenceKind.EMBEDDED;
         const knownKey = [core_1.ReferenceKind.SCALAR, core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.EMBEDDED].includes(this.prop.kind) || (this.prop.kind === core_1.ReferenceKind.ONE_TO_ONE && this.prop.owner);
-        const operatorKeys = knownKey && Object.keys(this.payload).every(key => core_1.Utils.isOperator(key, false));
-        const primaryKeys = knownKey && Object.keys(this.payload).every(key => {
-            const meta = this.metadata.find(this.entityName);
+        const operatorKeys = knownKey && keys.every(key => core_1.Utils.isOperator(key, false));
+        const primaryKeys = knownKey && keys.every(key => {
             if (!meta.primaryKeys.includes(key)) {
                 return false;
             }
@@ -158,7 +162,7 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
     }
     autoJoin(qb, alias) {
         const nestedAlias = qb.getNextAlias(this.prop?.pivotTable ?? this.entityName);
-        const customExpression = ObjectCriteriaNode.isCustomExpression(this.key);
+        const customExpression = core_1.RawQueryFragment.isKnownFragment(this.key);
         const scalar = core_1.Utils.isPrimaryKey(this.payload) || this.payload instanceof RegExp || this.payload instanceof Date || customExpression;
         const operator = core_1.Utils.isPlainObject(this.payload) && Object.keys(this.payload).every(k => core_1.Utils.isOperator(k, false));
         const field = `${alias}.${this.prop.name}`;

package/query/QueryBuilder.d.ts

@@ -38,7 +38,7 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
     private readonly context?;
     private connectionType?;
     private readonly em?;
-    private readonly logging?;
+    private readonly loggerContext?;
     get mainAlias(): Alias<T>;
     get alias(): string;
     get helper(): QueryBuilderHelper;
@@ -87,7 +87,7 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
     /**
      * @internal
      */
-    constructor(entityName: EntityName<T> | QueryBuilder<T>, metadata: MetadataStorage, driver: AbstractSqlDriver, context?: Knex.Transaction<any, any[]> | undefined, alias?: string, connectionType?: ConnectionType | undefined, em?: SqlEntityManager<AbstractSqlDriver<import("..").AbstractSqlConnection, AbstractSqlPlatform>> | undefined, logging?: LoggingOptions | undefined);
+    constructor(entityName: EntityName<T> | QueryBuilder<T>, metadata: MetadataStorage, driver: AbstractSqlDriver, context?: Knex.Transaction<any, any[]> | undefined, alias?: string, connectionType?: ConnectionType | undefined, em?: SqlEntityManager<AbstractSqlDriver<import("..").AbstractSqlConnection, AbstractSqlPlatform>> | undefined, loggerContext?: LoggingOptions | undefined);
     select(fields: Field<T> | Field<T>[], distinct?: boolean): SelectQueryBuilder<T>;
     addSelect(fields: Field<T> | Field<T>[]): SelectQueryBuilder<T>;
     distinct(): SelectQueryBuilder<T>;

package/query/QueryBuilder.js

@@ -31,7 +31,7 @@ class QueryBuilder {
     context;
     connectionType;
     em;
-    logging;
+    loggerContext;
     get mainAlias() {
         this.ensureFromClause();
         return this._mainAlias;
@@ -88,13 +88,13 @@ class QueryBuilder {
     /**
      * @internal
      */
-    constructor(entityName, metadata, driver, context, alias, connectionType, em, logging) {
+    constructor(entityName, metadata, driver, context, alias, connectionType, em, loggerContext) {
         this.metadata = metadata;
         this.driver = driver;
         this.context = context;
         this.connectionType = connectionType;
         this.em = em;
-        this.logging = logging;
+        this.loggerContext = loggerContext;
         this.platform = this.driver.getPlatform();
         this.knex = this.driver.getConnection(this.connectionType).getKnex();
         if (alias) {
@@ -587,7 +587,7 @@ class QueryBuilder {
         }
         const write = method === 'run' || !this.platform.getConfig().get('preferReadReplicas');
         const type = this.connectionType || (write ? 'write' : 'read');
-        const res = await this.driver.getConnection(type).execute(query.sql, query.bindings, method, this.context, this.logging);
+        const res = await this.driver.getConnection(type).execute(query.sql, query.bindings, method, this.context, this.loggerContext);
         const meta = this.mainAlias.metadata;
         if (!options.mapResults || !meta) {
             await this.em?.storeCache(this._cache, cached, res);

package/query/QueryBuilderHelper.js

@@ -496,7 +496,7 @@ class QueryBuilderHelper {
                     order.forEach(part => ret.push(...this.getQueryOrderFromObject(type, part, populate)));
                 }
                 else {
-                    ret.push(`${colPart} ${order.toLowerCase()}`);
+                    ret.push(...this.platform.getOrderByExpression(colPart, order));
                 }
             }
         }

package/query/ScalarCriteriaNode.js

@@ -21,6 +21,12 @@ class ScalarCriteriaNode extends CriteriaNode_1.CriteriaNode {
                 qb.addSelect(field);
             }
         }
+        if (this.payload && typeof this.payload === 'object') {
+            const keys = Object.keys(this.payload).filter(key => core_1.Utils.isArrayOperator(key) && Array.isArray(this.payload[key]));
+            for (const key of keys) {
+                this.payload[key] = JSON.stringify(this.payload[key]);
+            }
+        }
         return this.payload;
     }
     willAutoJoin(qb, alias) {

package/schema/DatabaseTable.d.ts

@@ -1,4 +1,4 @@
-import { type Configuration, type Dictionary, type EntityMetadata, type EntityProperty, type MikroORMOptions, type NamingStrategy } from '@mikro-orm/core';
+import { type Configuration, type Dictionary, type EntityMetadata, type EntityProperty, type NamingStrategy } from '@mikro-orm/core';
 import type { SchemaHelper } from './SchemaHelper';
 import type { CheckDef, Column, ForeignKey, IndexDef } from '../typings';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
@@ -25,7 +25,7 @@ export declare class DatabaseTable {
     addColumn(column: Column): void;
     addColumnFromProperty(prop: EntityProperty, meta: EntityMetadata, config: Configuration): void;
     private getIndexName;
-    getEntityDeclaration(namingStrategy: NamingStrategy, schemaHelper: SchemaHelper, scalarPropertiesForRelations: NonNullable<MikroORMOptions['entityGenerator']['scalarPropertiesForRelations']>): EntityMetadata;
+    getEntityDeclaration(namingStrategy: NamingStrategy, schemaHelper: SchemaHelper, scalarPropertiesForRelations: 'always' | 'never' | 'smart'): EntityMetadata;
     private foreignKeysToProps;
     private findFkIndex;
     private getIndexProperties;

package/schema/SchemaComparator.d.ts

@@ -1,3 +1,4 @@
+import { type Dictionary } from '@mikro-orm/core';
 import type { Column, ForeignKey, IndexDef, SchemaDifference, TableDifference } from '../typings';
 import type { DatabaseSchema } from './DatabaseSchema';
 import type { DatabaseTable } from './DatabaseTable';
@@ -51,6 +52,7 @@ export declare class SchemaComparator {
      */
     isIndexFulfilledBy(index1: IndexDef, index2: IndexDef): boolean;
     diffExpression(expr1: string, expr2: string): boolean;
+    parseJsonDefault(defaultValue?: string | null): Dictionary | string | null;
     hasSameDefaultValue(from: Column, to: Column): boolean;
     private mapColumnToProperty;
     private log;

package/schema/SchemaComparator.js

@@ -449,6 +449,15 @@ class SchemaComparator {
         const simplify = (str) => str?.replace(/_\w+\\'(.*?)\\'/g, '$1').replace(/['"`()]|::\w+| +/g, '').toLowerCase();
         return simplify(expr1) !== simplify(expr2);
     }
+    parseJsonDefault(defaultValue) {
+        if (!defaultValue) {
+            return null;
+        }
+        const val = defaultValue
+            .replace(/^(_\w+\\)?'(.*?)\\?'$/, '$2')
+            .replace(/^\(?'(.*?)'\)?$/, '$1');
+        return (0, core_1.parseJsonSafe)(val);
+    }
     hasSameDefaultValue(from, to) {
         if (from.default == null || from.default.toString().toLowerCase() === 'null' || from.default.toString().startsWith('nextval(')) {
             return to.default == null || to.default.toLowerCase() === 'null';
@@ -459,8 +468,8 @@ class SchemaComparator {
             return defaultValueFrom === defaultValueTo;
         }
         if (to.mappedType instanceof core_1.JsonType) {
-            const defaultValueFrom = (0, core_1.parseJsonSafe)(from.default.replace(/^(_\w+\\)?'(.*?)\\?'$/, '$2'));
-            const defaultValueTo = (0, core_1.parseJsonSafe)(to.default?.replace(/^\(?'(.*?)'\)?$/, '$1'));
+            const defaultValueFrom = this.parseJsonDefault(from.default);
+            const defaultValueTo = this.parseJsonDefault(to.default);
             return core_1.Utils.equals(defaultValueFrom, defaultValueTo);
         }
         if (to.mappedType instanceof core_1.DateTimeType && from.default && to.default) {