@mikro-orm/core 7.0.0-dev.32 → 7.0.0-dev.321

package/connections/Connection.d.ts

@@ -17,7 +17,9 @@ export declare abstract class Connection {
     /**
      * Establishes connection to database
      */
-    abstract connect(): void | Promise<void>;
+    abstract connect(options?: {
+        skipOnConnect?: boolean;
+    }): void | Promise<void>;
     /**
      * Are we connected to the database
      */
@@ -37,18 +39,24 @@ export declare abstract class Connection {
      */
     close(force?: boolean): Promise<void>;
     /**
-     * Ensure the connection exists, this is used to support lazy connect when using `MikroORM.initSync()`
+     * Ensure the connection exists, this is used to support lazy connect when using `new MikroORM()` instead of the async `init` method.
      */
     ensureConnection(): Promise<void>;
+    /**
+     * Execute raw SQL queries, handy from running schema dump loaded from a file.
+     * This method doesn't support transactions, as opposed to `orm.schema.execute()`, which is used internally.
+     */
+    executeDump(dump: string): Promise<void>;
+    protected onConnect(): Promise<void>;
     transactional<T>(cb: (trx: Transaction) => Promise<T>, options?: {
-        isolationLevel?: IsolationLevel;
+        isolationLevel?: IsolationLevel | `${IsolationLevel}`;
         readOnly?: boolean;
         ctx?: Transaction;
         eventBroadcaster?: TransactionEventBroadcaster;
         loggerContext?: LogContext;
     }): Promise<T>;
     begin(options?: {
-        isolationLevel?: IsolationLevel;
+        isolationLevel?: IsolationLevel | `${IsolationLevel}`;
         readOnly?: boolean;
         ctx?: Transaction;
         eventBroadcaster?: TransactionEventBroadcaster;
@@ -58,7 +66,6 @@ export declare abstract class Connection {
     rollback(ctx: Transaction, eventBroadcaster?: TransactionEventBroadcaster, loggerContext?: LogContext): Promise<void>;
     abstract execute<T>(query: string, params?: any[], method?: 'all' | 'get' | 'run', ctx?: Transaction): Promise<QueryResult<T> | any | any[]>;
     getConnectionOptions(): ConnectionConfig;
-    getClientUrl(): string;
     setMetadata(metadata: MetadataStorage): void;
     setPlatform(platform: Platform): void;
     getPlatform(): Platform;

package/connections/Connection.js

@@ -1,4 +1,3 @@
-import { URL } from 'node:url';
 import { Utils } from '../utils/Utils.js';
 export class Connection {
     config;
@@ -17,7 +16,18 @@ export class Connection {
             this.options = Utils.copy(options);
         }
         else {
-            const props = ['dbName', 'clientUrl', 'host', 'port', 'user', 'password', 'multipleStatements', 'pool', 'schema', 'driverOptions'];
+            const props = [
+                'dbName',
+                'clientUrl',
+                'host',
+                'port',
+                'user',
+                'password',
+                'multipleStatements',
+                'pool',
+                'schema',
+                'driverOptions',
+            ];
             this.options = props.reduce((o, i) => {
                 o[i] = this.config.get(i);
                 return o;
@@ -33,13 +43,32 @@ export class Connection {
             .forEach(k => delete this.options[k]);
     }
     /**
-     * Ensure the connection exists, this is used to support lazy connect when using `MikroORM.initSync()`
+     * Ensure the connection exists, this is used to support lazy connect when using `new MikroORM()` instead of the async `init` method.
      */
     async ensureConnection() {
         if (!this.connected) {
             await this.connect();
         }
     }
+    /**
+     * Execute raw SQL queries, handy from running schema dump loaded from a file.
+     * This method doesn't support transactions, as opposed to `orm.schema.execute()`, which is used internally.
+     */
+    async executeDump(dump) {
+        throw new Error(`Executing SQL dumps is not supported by current driver`);
+    }
+    async onConnect() {
+        const schemaGenerator = this.config.getExtension('@mikro-orm/schema-generator');
+        if (this.type === 'write' && schemaGenerator) {
+            if (this.config.get('ensureDatabase')) {
+                const options = this.config.get('ensureDatabase');
+                await schemaGenerator.ensureDatabase(typeof options === 'boolean' ? {} : { ...options, forceCheck: true });
+            }
+            if (this.config.get('ensureIndexes')) {
+                await schemaGenerator.ensureIndexes();
+            }
+        }
+    }
     async transactional(cb, options) {
         throw new Error(`Transactions are not supported by current driver`);
     }
@@ -67,24 +96,17 @@ export class Connection {
             }
         }
         else {
-            const url = new URL(this.config.getClientUrl());
+            const url = new URL(this.config.get('clientUrl'));
             this.options.host = ret.host = this.options.host ?? this.config.get('host', decodeURIComponent(url.hostname));
             this.options.port = ret.port = this.options.port ?? this.config.get('port', +url.port);
             this.options.user = ret.user = this.options.user ?? this.config.get('user', decodeURIComponent(url.username));
-            this.options.password = ret.password = this.options.password ?? this.config.get('password', decodeURIComponent(url.password));
-            this.options.dbName = ret.database = this.options.dbName ?? this.config.get('dbName', decodeURIComponent(url.pathname).replace(/^\//, ''));
+            this.options.password = ret.password =
+                this.options.password ?? this.config.get('password', decodeURIComponent(url.password));
+            this.options.dbName = ret.database =
+                this.options.dbName ?? this.config.get('dbName', decodeURIComponent(url.pathname).replace(/^\//, ''));
         }
         return ret;
     }
-    getClientUrl() {
-        const options = this.getConnectionOptions();
-        const url = new URL(this.config.getClientUrl(true));
-        const password = options.password ? ':*****' : '';
-        const schema = options.schema && options.schema !== this.platform.getDefaultSchemaName()
-            ? `?schema=${options.schema}`
-            : '';
-        return `${url.protocol}//${options.user}${password}@${options.host}:${options.port}${schema}`;
-    }
     setMetadata(metadata) {
         this.metadata = metadata;
     }

package/drivers/DatabaseDriver.d.ts

@@ -1,5 +1,5 @@
-import { type CountOptions, type DeleteOptions, type DriverMethodOptions, EntityManagerType, type FindOneOptions, type FindOptions, type IDatabaseDriver, type LockOptions, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type OrderDefinition } from './IDatabaseDriver.js';
-import type { ConnectionType, Dictionary, EntityData, EntityDictionary, EntityMetadata, EntityProperty, FilterQuery, PopulateOptions, Primary } from '../typings.js';
+import { type CountOptions, type DeleteOptions, type DriverMethodOptions, EntityManagerType, type FindOneOptions, type FindOptions, type IDatabaseDriver, type LockOptions, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type OrderDefinition, type StreamOptions } from './IDatabaseDriver.js';
+import type { ConnectionType, Constructor, Dictionary, EntityData, EntityDictionary, EntityMetadata, EntityName, EntityProperty, FilterQuery, PopulateOptions, Primary } from '../typings.js';
 import type { MetadataStorage } from '../metadata/MetadataStorage.js';
 import type { Connection, QueryResult, Transaction } from '../connections/Connection.js';
 import { type Configuration, type ConnectionOptions } from '../utils/Configuration.js';
@@ -9,7 +9,7 @@ import type { Platform } from '../platforms/Platform.js';
 import type { Collection } from '../entity/Collection.js';
 import { EntityManager } from '../EntityManager.js';
 import { DriverException } from '../exceptions.js';
-import type { Logger } from '../logging/Logger.js';
+import { MikroORM } from '../MikroORM.js';
 export declare abstract class DatabaseDriver<C extends Connection> implements IDatabaseDriver<C> {
     readonly config: Configuration;
     protected readonly dependencies: string[];
@@ -17,33 +17,37 @@ export declare abstract class DatabaseDriver<C extends Connection> implements ID
     protected readonly connection: C;
     protected readonly replicas: C[];
     protected readonly platform: Platform;
-    protected readonly logger: Logger;
     protected comparator: EntityComparator;
     protected metadata: MetadataStorage;
     protected constructor(config: Configuration, dependencies: string[]);
-    abstract 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>[]>;
-    abstract 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>;
-    abstract nativeInsert<T extends object>(entityName: string, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
-    abstract nativeInsertMany<T extends object>(entityName: string, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>, transform?: (sql: string) => string): Promise<QueryResult<T>>;
-    abstract 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>>;
-    abstract nativeDelete<T extends object>(entityName: string, where: FilterQuery<T>, options?: DeleteOptions<T>): Promise<QueryResult<T>>;
-    abstract count<T extends object, P extends string = never>(entityName: string, where: FilterQuery<T>, options?: CountOptions<T, P>): Promise<number>;
+    abstract find<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: EntityName<T>, where: FilterQuery<T>, options?: FindOptions<T, P, F, E>): Promise<EntityData<T>[]>;
+    abstract findOne<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: EntityName<T>, where: FilterQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
+    abstract nativeInsert<T extends object>(entityName: EntityName<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
+    abstract nativeInsertMany<T extends object>(entityName: EntityName<T>, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>, transform?: (sql: string) => string): Promise<QueryResult<T>>;
+    abstract nativeUpdate<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
+    nativeUpdateMany<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
+    abstract nativeDelete<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options?: DeleteOptions<T>): Promise<QueryResult<T>>;
+    abstract count<T extends object, P extends string = never>(entityName: EntityName<T>, where: FilterQuery<T>, options?: CountOptions<T, P>): Promise<number>;
     createEntityManager(useContext?: boolean): this[typeof EntityManagerType];
-    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>;
-    aggregate(entityName: string, pipeline: any[]): Promise<any[]>;
+    findVirtual<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
+    countVirtual<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: CountOptions<T, any>): Promise<number>;
+    aggregate(entityName: EntityName, pipeline: any[]): Promise<any[]>;
     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[]>>;
     syncCollections<T extends object, O extends object>(collections: Iterable<Collection<T, O>>, options?: DriverMethodOptions): Promise<void>;
     mapResult<T extends object>(result: EntityDictionary<T>, meta?: EntityMetadata<T>, populate?: PopulateOptions<T>[]): EntityData<T> | null;
-    connect(): Promise<C>;
-    reconnect(): Promise<C>;
+    connect(options?: {
+        skipOnConnect?: boolean;
+    }): Promise<C>;
+    reconnect(options?: {
+        skipOnConnect?: boolean;
+    }): Promise<C>;
     getConnection(type?: ConnectionType): C;
     close(force?: boolean): Promise<void>;
     getPlatform(): Platform;
     setMetadata(metadata: MetadataStorage): void;
     getMetadata(): MetadataStorage;
     getDependencies(): string[];
+    protected isPopulated<T extends object>(meta: EntityMetadata<T>, prop: EntityProperty<T>, hint: PopulateOptions<T>, name?: string): boolean;
     protected processCursorOptions<T extends object, P extends string>(meta: EntityMetadata<T>, options: FindOptions<T, P, any, any>, orderBy: OrderDefinition<T>): {
         orderBy: OrderDefinition<T>[];
         where: FilterQuery<T>;
@@ -52,9 +56,10 @@ export declare abstract class DatabaseDriver<C extends Connection> implements ID
     /** @internal */
     mapDataToFieldNames(data: Dictionary, stringifyJsonArrays: boolean, properties?: Record<string, EntityProperty>, convertCustomTypes?: boolean, object?: boolean): Dictionary;
     protected inlineEmbeddables<T extends object>(meta: EntityMetadata<T>, data: T, where?: boolean): void;
-    protected getPrimaryKeyFields(entityName: string): string[];
+    protected getPrimaryKeyFields<T>(meta: EntityMetadata<T>): string[];
     protected createReplicas(cb: (c: ConnectionOptions) => C): C[];
     lockPessimistic<T extends object>(entity: T, options: LockOptions): Promise<void>;
+    abstract stream<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: StreamOptions<T>): AsyncIterableIterator<T>;
     /**
      * @inheritDoc
      */
@@ -71,4 +76,6 @@ export declare abstract class DatabaseDriver<C extends Connection> implements ID
         schema?: string;
         parentSchema?: string;
     }): string | undefined;
+    /** @internal */
+    getORMClass(): Constructor<MikroORM>;
 }

package/drivers/DatabaseDriver.js

@@ -8,7 +8,9 @@ import { EntityManager } from '../EntityManager.js';
 import { CursorError, ValidationError } from '../errors.js';
 import { DriverException } from '../exceptions.js';
 import { helper } from '../entity/wrap.js';
+import { PolymorphicRef } from '../entity/PolymorphicRef.js';
 import { JsonType } from '../types/JsonType.js';
+import { MikroORM } from '../MikroORM.js';
 export class DatabaseDriver {
     config;
     dependencies;
@@ -16,13 +18,11 @@ export class DatabaseDriver {
     connection;
     replicas = [];
     platform;
-    logger;
     comparator;
     metadata;
     constructor(config, dependencies) {
         this.config = config;
         this.dependencies = dependencies;
-        this.logger = this.config.getLogger();
     }
     async nativeUpdateMany(entityName, where, data, options) {
         throw new Error(`Batch updates are not supported by ${this.constructor.name} driver`);
@@ -31,11 +31,11 @@ export class DatabaseDriver {
         const EntityManagerClass = this.config.get('entityManager', EntityManager);
         return new EntityManagerClass(this.config, this, this.metadata, useContext);
     }
-    /* v8 ignore next 3 */
+    /* v8 ignore next */
     async findVirtual(entityName, where, options) {
         throw new Error(`Virtual entities are not supported by ${this.constructor.name} driver.`);
     }
-    /* v8 ignore next 3 */
+    /* v8 ignore next */
     async countVirtual(entityName, where, options) {
         throw new Error(`Counting virtual entities is not supported by ${this.constructor.name} driver.`);
     }
@@ -47,32 +47,35 @@ export class DatabaseDriver {
     }
     async syncCollections(collections, options) {
         for (const coll of collections) {
+            /* v8 ignore else */
             if (!coll.property.owner) {
                 if (coll.getSnapshot() === undefined) {
                     throw ValidationError.cannotModifyInverseCollection(coll.owner, coll.property);
                 }
                 continue;
             }
-            /* v8 ignore next 3 */
-            const pk = coll.property.targetMeta.primaryKeys[0];
-            const data = { [coll.property.name]: coll.getIdentifiers(pk) };
-            await this.nativeUpdate(coll.owner.constructor.name, helper(coll.owner).getPrimaryKey(), data, options);
+            /* v8 ignore next */
+            {
+                const pk = coll.property.targetMeta.primaryKeys[0];
+                const data = { [coll.property.name]: coll.getIdentifiers(pk) };
+                await this.nativeUpdate(coll.owner.constructor, helper(coll.owner).getPrimaryKey(), data, options);
+            }
         }
     }
     mapResult(result, meta, populate = []) {
         if (!result || !meta) {
             return result ?? null;
         }
-        return this.comparator.mapResult(meta.className, result);
+        return this.comparator.mapResult(meta, result);
     }
-    async connect() {
-        await this.connection.connect();
+    async connect(options) {
+        await this.connection.connect(options);
         await Promise.all(this.replicas.map(replica => replica.connect()));
         return this.connection;
     }
-    async reconnect() {
+    async reconnect(options) {
         await this.close(true);
-        await this.connect();
+        await this.connect(options);
         return this.connection;
     }
     getConnection(type = 'write') {
@@ -105,6 +108,15 @@ export class DatabaseDriver {
     getDependencies() {
         return this.dependencies;
     }
+    isPopulated(meta, prop, hint, name) {
+        if (hint.field === prop.name || hint.field === name || hint.all) {
+            return true;
+        }
+        if (prop.embedded && hint.children && meta.properties[prop.embedded[0]].name === hint.field) {
+            return hint.children.some(c => this.isPopulated(meta, prop, c, prop.embedded[1]));
+        }
+        return false;
+    }
     processCursorOptions(meta, options, orderBy) {
         const { first, last, before, after, overfetch } = options;
         const limit = first ?? last;
@@ -139,15 +151,15 @@ export class DatabaseDriver {
         }
         const createOrderBy = (prop, direction) => {
             if (Utils.isPlainObject(direction)) {
-                const value = Utils.keys(direction).reduce((o, key) => {
+                const value = Utils.getObjectQueryKeys(direction).reduce((o, key) => {
                     Object.assign(o, createOrderBy(key, direction[key]));
                     return o;
                 }, {});
-                return ({ [prop]: value });
+                return { [prop]: value };
             }
             const desc = direction === QueryOrderNumeric.DESC || direction.toString().toLowerCase() === 'desc';
             const dir = Utils.xor(desc, isLast) ? 'desc' : 'asc';
-            return ({ [prop]: dir });
+            return { [prop]: dir };
         };
         return {
             orderBy: definition.map(([prop, direction]) => createOrderBy(prop, direction)),
@@ -155,22 +167,51 @@ export class DatabaseDriver {
         };
     }
     createCursorCondition(definition, offsets, inverse, meta) {
-        const createCondition = (prop, direction, offset, eq = false) => {
-            if (offset === null) {
-                throw CursorError.missingValue(meta.className, prop);
-            }
+        const createCondition = (prop, direction, offset, eq = false, path = prop) => {
             if (Utils.isPlainObject(direction)) {
+                if (offset === undefined) {
+                    throw CursorError.missingValue(meta.className, path);
+                }
                 const value = Utils.keys(direction).reduce((o, key) => {
-                    if (Utils.isEmpty(offset[key])) {
-                        throw CursorError.missingValue(meta.className, `${prop}.${key}`);
-                    }
-                    Object.assign(o, createCondition(key, direction[key], offset[key], eq));
+                    Object.assign(o, createCondition(key, direction[key], offset?.[key], eq, `${path}.${key}`));
                     return o;
                 }, {});
-                return ({ [prop]: value });
+                return { [prop]: value };
             }
-            const desc = direction === QueryOrderNumeric.DESC || direction.toString().toLowerCase() === 'desc';
-            const operator = Utils.xor(desc, inverse) ? '$lt' : '$gt';
+            const isDesc = direction === QueryOrderNumeric.DESC || direction.toString().toLowerCase() === 'desc';
+            const dirStr = direction.toString().toLowerCase();
+            let nullsFirst;
+            if (dirStr.includes('nulls first')) {
+                nullsFirst = true;
+            }
+            else if (dirStr.includes('nulls last')) {
+                nullsFirst = false;
+            }
+            else {
+                // Default: NULLS LAST for ASC, NULLS FIRST for DESC (matches most databases)
+                nullsFirst = isDesc;
+            }
+            const operator = Utils.xor(isDesc, inverse) ? '$lt' : '$gt';
+            // For leaf-level properties, undefined means missing value
+            if (offset === undefined) {
+                throw CursorError.missingValue(meta.className, path);
+            }
+            // Handle null offset (intentional null cursor value)
+            if (offset === null) {
+                if (eq) {
+                    // Equal to null
+                    return { [prop]: null };
+                }
+                // Strict comparison with null cursor value
+                // hasItemsAfterNull: forward + nullsFirst, or backward + nullsLast
+                const hasItemsAfterNull = Utils.xor(nullsFirst, inverse);
+                if (hasItemsAfterNull) {
+                    return { [prop]: { $ne: null } };
+                }
+                // No items after null in this direction, return impossible condition
+                return { [prop]: [] };
+            }
+            // Non-null offset
             return { [prop]: { [operator + (eq ? 'e' : '')]: offset } };
         };
         const [order, ...otherOrders] = definition;
@@ -213,24 +254,68 @@ export class DatabaseDriver {
                 else {
                     data[prop.fieldNames[0]] = this.mapDataToFieldNames(copy, stringifyJsonArrays, prop.embeddedProps, convertCustomTypes, true);
                 }
-                if (stringifyJsonArrays && prop.array) {
+                if (stringifyJsonArrays && prop.array && !object) {
                     data[prop.fieldNames[0]] = this.platform.convertJsonToDatabaseValue(data[prop.fieldNames[0]]);
                 }
                 return;
             }
+            // Handle polymorphic relations - convert tuple or PolymorphicRef to separate columns
+            // Tuple format: ['discriminator', id] or ['discriminator', id1, id2] for composite keys
+            // Must be checked BEFORE joinColumns array handling since polymorphic uses fieldNames (includes discriminator)
+            if (prop.polymorphic && prop.fieldNames && prop.fieldNames.length >= 2) {
+                let discriminator;
+                let ids;
+                if (Array.isArray(data[k]) && typeof data[k][0] === 'string' && prop.discriminatorMap?.[data[k][0]]) {
+                    // Tuple format: ['discriminator', ...ids]
+                    const [disc, ...rest] = data[k];
+                    discriminator = disc;
+                    ids = rest;
+                }
+                else if (data[k] instanceof PolymorphicRef) {
+                    // PolymorphicRef wrapper (internal use)
+                    discriminator = data[k].discriminator;
+                    const polyId = data[k].id;
+                    // Handle object-style composite key IDs like { tenantId: 1, orgId: 100 }
+                    if (polyId && typeof polyId === 'object' && !Array.isArray(polyId)) {
+                        const targetEntity = prop.discriminatorMap?.[discriminator];
+                        const targetMeta = this.metadata.get(targetEntity);
+                        ids = targetMeta.primaryKeys.map(pk => polyId[pk]);
+                    }
+                    else {
+                        ids = Utils.asArray(polyId);
+                    }
+                }
+                if (discriminator) {
+                    const discriminatorColumn = prop.fieldNames[0];
+                    const idColumns = prop.fieldNames.slice(1);
+                    delete data[k];
+                    data[discriminatorColumn] = discriminator;
+                    idColumns.forEach((col, idx) => {
+                        data[col] = ids[idx];
+                    });
+                    return;
+                }
+            }
             if (prop.joinColumns && Array.isArray(data[k])) {
                 const copy = Utils.flatten(data[k]);
                 delete data[k];
-                prop.joinColumns.forEach((joinColumn, idx) => data[joinColumn] = copy[idx]);
+                prop.joinColumns.forEach((joinColumn, idx) => (data[joinColumn] = copy[idx]));
                 return;
             }
             if (prop.joinColumns?.length > 1 && data[k] == null) {
                 delete data[k];
-                prop.ownColumns.forEach(joinColumn => data[joinColumn] = null);
+                prop.ownColumns.forEach(joinColumn => (data[joinColumn] = null));
                 return;
             }
-            if (prop.customType && convertCustomTypes && !(prop.customType instanceof JsonType && object) && !isRaw(data[k])) {
-                data[k] = prop.customType.convertToDatabaseValue(data[k], this.platform, { fromQuery: true, key: k, mode: 'query-data' });
+            if (prop.customType &&
+                convertCustomTypes &&
+                !(prop.customType instanceof JsonType && object) &&
+                !isRaw(data[k])) {
+                data[k] = prop.customType.convertToDatabaseValue(data[k], this.platform, {
+                    fromQuery: true,
+                    key: k,
+                    mode: 'query-data',
+                });
             }
             if (prop.hasConvertToDatabaseValueSQL && !prop.object && !isRaw(data[k])) {
                 const quoted = this.platform.quoteValue(data[k]);
@@ -244,7 +329,7 @@ export class DatabaseDriver {
         return data;
     }
     inlineEmbeddables(meta, data, where) {
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (data == null) {
             return;
         }
@@ -264,38 +349,38 @@ export class DatabaseDriver {
                     // explicitly allow `$exists`, `$eq` and `$ne` operators here as they can't be misused this way
                     const operator = Object.keys(data[prop.name]).some(f => Utils.isOperator(f) && !['$exists', '$ne', '$eq'].includes(f));
                     if (operator) {
-                        throw ValidationError.cannotUseOperatorsInsideEmbeddables(meta.className, prop.name, data);
+                        throw ValidationError.cannotUseOperatorsInsideEmbeddables(meta.class, prop.name, data);
                     }
                     if (prop.object && where) {
                         const inline = (payload, sub, path) => {
                             if (sub.kind === ReferenceKind.EMBEDDED && Utils.isObject(payload[sub.embedded[1]])) {
                                 return Object.keys(payload[sub.embedded[1]]).forEach(kkk => {
                                     if (!sub.embeddedProps[kkk]) {
-                                        throw ValidationError.invalidEmbeddableQuery(meta.className, kkk, sub.type);
+                                        throw ValidationError.invalidEmbeddableQuery(meta.class, kkk, sub.type);
                                     }
-                                    inline(payload[sub.embedded[1]], sub.embeddedProps[kkk], [...path, sub.embedded[1]]);
+                                    inline(payload[sub.embedded[1]], sub.embeddedProps[kkk], [...path, sub.fieldNames[0]]);
                                 });
                             }
-                            data[`${path.join('.')}.${sub.embedded[1]}`] = payload[sub.embedded[1]];
+                            data[`${path.join('.')}.${sub.fieldNames[0]}`] = payload[sub.embedded[1]];
                         };
                         const parentPropName = kk.substring(0, kk.indexOf('.'));
                         // we might be using some native JSON operator, e.g. with mongodb's `$geoWithin` or `$exists`
                         if (props[kk]) {
                             /* v8 ignore next */
-                            inline(data[prop.name], props[kk] || props[parentPropName], [prop.name]);
+                            inline(data[prop.name], props[kk] || props[parentPropName], [prop.fieldNames[0]]);
                         }
                         else if (props[parentPropName]) {
-                            data[`${prop.name}.${kk}`] = data[prop.name][kk];
+                            data[`${prop.fieldNames[0]}.${kk}`] = data[prop.name][kk];
                         }
                         else {
                             unknownProp = true;
                         }
                     }
                     else if (props[kk]) {
-                        data[props[kk].name] = data[prop.name][props[kk].embedded[1]];
+                        data[props[kk].fieldNames[0]] = data[prop.name][props[kk].embedded[1]];
                     }
                     else {
-                        throw ValidationError.invalidEmbeddableQuery(meta.className, kk, prop.type);
+                        throw ValidationError.invalidEmbeddableQuery(meta.class, kk, prop.type);
                     }
                 });
                 if (!unknownProp) {
@@ -304,14 +389,24 @@ export class DatabaseDriver {
             }
         });
     }
-    getPrimaryKeyFields(entityName) {
-        const meta = this.metadata.find(entityName);
-        return meta ? Utils.flatten(meta.getPrimaryProps().map(pk => pk.fieldNames)) : [this.config.getNamingStrategy().referenceColumnName()];
+    getPrimaryKeyFields(meta) {
+        return meta.getPrimaryProps().flatMap(pk => pk.fieldNames);
     }
     createReplicas(cb) {
         const replicas = this.config.get('replicas', []);
         const ret = [];
-        const props = ['dbName', 'clientUrl', 'host', 'port', 'user', 'password', 'multipleStatements', 'pool', 'name', 'driverOptions'];
+        const props = [
+            'dbName',
+            'clientUrl',
+            'host',
+            'port',
+            'user',
+            'password',
+            'multipleStatements',
+            'pool',
+            'name',
+            'driverOptions',
+        ];
         for (const conf of replicas) {
             const replicaConfig = Utils.copy(conf);
             for (const prop of props) {
@@ -372,4 +467,8 @@ export class DatabaseDriver {
         const schemaName = meta?.schema === '*' ? this.config.getSchema() : meta?.schema;
         return options?.schema ?? options?.parentSchema ?? schemaName ?? this.config.getSchema();
     }
+    /** @internal */
+    getORMClass() {
+        return MikroORM;
+    }
 }