@mikro-orm/core 7.2.0-dev.5 → 7.2.0-dev.7

package/EntityManager.d.ts

@@ -601,7 +601,7 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
      * some additional lazy properties, if so, we reload and merge the data from database
      */
     protected shouldRefresh<T extends object, P extends string = never, F extends string = never, E extends string = never>(meta: EntityMetadata<T>, entity: T, options: FindOneOptions<T, P, F, E>): boolean;
-    protected prepareOptions(options: (FindOptions<any, any, any, any> | FindOneOptions<any, any, any, any> | CountOptions<any, any> | CountByOptions<any>) & AbortQueryOptions): void;
+    protected prepareOptions<Options extends (FindOptions<any, any, any, any> | FindOneOptions<any, any, any, any> | CountOptions<any, any> | CountByOptions<any>) & AbortQueryOptions>(options: Options): Options;
     /**
      * @internal
      */

package/EntityManager.js

@@ -116,7 +116,7 @@ export class EntityManager {
             return ret;
         }
         const em = this.getContext();
-        em.prepareOptions(options);
+        options = em.prepareOptions(options);
         const meta = this.metadata.get(entityName);
         em.validateIndexUsage(meta, where, options);
         await em.tryFlush(entityName, options);
@@ -199,7 +199,7 @@ export class EntityManager {
      */
     async *stream(entityName, options = {}) {
         const em = this.getContext();
-        em.prepareOptions(options);
+        options = em.prepareOptions(options);
         options.strategy = 'joined';
         await em.tryFlush(entityName, options);
         const where = (await em.processWhere(entityName, options.where ?? {}, options, 'read'));
@@ -258,6 +258,7 @@ export class EntityManager {
      * Registers global filter to this entity manager. Global filters are enabled by default (unless disabled via last parameter).
      */
     addFilter(options) {
+        options = { ...options };
         if (options.entity) {
             options.entity = Utils.asArray(options.entity).map(n => Utils.className(n));
         }
@@ -528,7 +529,7 @@ export class EntityManager {
     async findAndCount(entityName, where, options = {}) {
         const em = this.getContext(false);
         await em.tryFlush(entityName, options);
-        options.flushMode = 'commit'; // do not try to auto flush again
+        options = { ...options, flushMode: 'commit' }; // do not try to auto flush again
         return Promise.all([
             em.find(entityName, where, options),
             em.count(entityName, where, options),
@@ -592,6 +593,7 @@ export class EntityManager {
      */
     async findByCursor(entityName, options) {
         const em = this.getContext(false);
+        options = { ...options };
         options.overfetch ??= true;
         options.where ??= {};
         if (Utils.isEmpty(options.orderBy) && !Raw.hasObjectFragments(options.orderBy)) {
@@ -610,10 +612,10 @@ export class EntityManager {
     async refreshOrFail(entity, options = {}) {
         const ret = await this.refresh(entity, options);
         if (!ret) {
-            options.failHandler ??= this.config.get('findOneOrFailHandler');
+            const failHandler = options.failHandler ?? this.config.get('findOneOrFailHandler');
             const wrapped = helper(entity);
             const where = wrapped.getPrimaryKey();
-            throw options.failHandler(wrapped.__meta.className, where);
+            throw failHandler(wrapped.__meta.className, where);
         }
         return ret;
     }
@@ -667,7 +669,7 @@ export class EntityManager {
             return ret;
         }
         const em = this.getContext();
-        em.prepareOptions(options);
+        options = em.prepareOptions(options);
         let entity = em.#unitOfWork.tryGetById(entityName, where, options.schema);
         // query for a not managed entity which is already in the identity map as it
         // was provided with a PK this entity does not exist in the db, there can't
@@ -739,11 +741,11 @@ export class EntityManager {
         }
         if (!entity || isStrictViolation) {
             const key = options.strict ? 'findExactlyOneOrFailHandler' : 'findOneOrFailHandler';
-            options.failHandler ??= this.config.get(key);
+            const failHandler = options.failHandler ?? this.config.get(key);
             const name = Utils.className(entityName);
             /* v8 ignore next */
             where = Utils.isEntity(where) ? helper(where).getPrimaryKey() : where;
-            throw options.failHandler(name, where);
+            throw failHandler(name, where);
         }
         return entity;
     }
@@ -778,7 +780,7 @@ export class EntityManager {
             return ret;
         }
         const em = this.getContext(false);
-        em.prepareOptions(options);
+        options = em.prepareOptions(options);
         let entityName;
         let where;
         let entity = null;
@@ -916,7 +918,7 @@ export class EntityManager {
             return ret;
         }
         const em = this.getContext(false);
-        em.prepareOptions(options);
+        options = em.prepareOptions(options);
         let entityName;
         let propIndex;
         if (data === undefined) {
@@ -1202,7 +1204,7 @@ export class EntityManager {
      */
     async lock(entity, lockMode, options = {}) {
         options = Utils.isPlainObject(options) ? options : { lockVersion: options };
-        this.getContext(false).prepareOptions(options);
+        options = this.getContext(false).prepareOptions(options);
         await this.getUnitOfWork().lock(entity, { lockMode, ...options });
     }
     /**
@@ -1210,7 +1212,7 @@ export class EntityManager {
      */
     async insert(entityNameOrEntity, data, options = {}) {
         const em = this.getContext(false);
-        em.prepareOptions(options);
+        options = em.prepareOptions(options);
         let entityName;
         if (data === undefined) {
             entityName = entityNameOrEntity.constructor;
@@ -1277,7 +1279,7 @@ export class EntityManager {
             overrides = overridesOrOptions;
         }
         options ??= {};
-        em.prepareOptions(options);
+        options = em.prepareOptions(options);
         const meta = em.metadata.get(entityName);
         const res = await em.driver.nativeClone(entityName, where, overrides, {
             ctx: em.#transactionContext,
@@ -1293,7 +1295,7 @@ export class EntityManager {
      */
     async insertMany(entityNameOrEntities, data, options = {}) {
         const em = this.getContext(false);
-        em.prepareOptions(options);
+        options = em.prepareOptions(options);
         let entityName;
         if (data === undefined) {
             entityName = entityNameOrEntities[0].constructor;
@@ -1336,7 +1338,7 @@ export class EntityManager {
      */
     async nativeUpdate(entityName, where, data, options = {}) {
         const em = this.getContext(false);
-        em.prepareOptions(options);
+        options = em.prepareOptions(options);
         await em.processUnionWhere(entityName, options, 'update');
         data = QueryHelper.processObjectParams(data);
         where = await em.processWhere(entityName, where, { ...options, convertCustomTypes: false }, 'update');
@@ -1385,7 +1387,7 @@ export class EntityManager {
      */
     async nativeDelete(entityName, where, options = {}) {
         const em = this.getContext(false);
-        em.prepareOptions(options);
+        options = em.prepareOptions(options);
         await em.processUnionWhere(entityName, options, 'delete');
         where = (await em.processWhere(entityName, where, options, 'delete'));
         validateParams(where, 'delete condition');
@@ -1428,6 +1430,7 @@ export class EntityManager {
             return this.merge(entityName.constructor, entityName, data);
         }
         const em = options.disableContextResolution ? this : this.getContext();
+        options = { ...options };
         options.schema ??= em.#schema;
         options.validate ??= true;
         options.cascade ??= true;
@@ -1461,6 +1464,7 @@ export class EntityManager {
      */
     create(entityName, data, options = {}) {
         const em = this.getContext();
+        options = { ...options };
         options.schema ??= em.#schema;
         const entity = em.#entityFactory.create(entityName, data, {
             ...options,
@@ -1484,6 +1488,7 @@ export class EntityManager {
      * Gets a reference to the entity identified by the given type and identifier without actually loading it, if the entity is not yet loaded
      */
     getReference(entityName, id, options = {}) {
+        options = { ...options };
         options.schema ??= this.schema;
         options.convertCustomTypes ??= false;
         const meta = this.metadata.get(entityName);
@@ -1504,13 +1509,10 @@ export class EntityManager {
      */
     async count(entityName, where = {}, options = {}) {
         const em = this.getContext(false);
-        // Shallow copy options since the object will be modified when deleting orderBy
-        options = { ...options };
-        em.prepareOptions(options);
+        options = em.prepareOptions(options);
         await em.tryFlush(entityName, options);
         where = await em.processWhere(entityName, where, options, 'read');
         options.populate = (await em.preparePopulate(entityName, options));
-        options = { ...options };
         // save the original hint value so we know it was infer/all
         const meta = em.metadata.find(entityName);
         options._populateWhere = options.populateWhere ?? this.config.get('populateWhere');
@@ -1654,7 +1656,7 @@ export class EntityManager {
             return entities;
         }
         const em = this.getContext();
-        em.prepareOptions(options);
+        options = em.prepareOptions(options);
         const entityName = arr[0].constructor;
         const preparedPopulate = await em.preparePopulate(entityName, { populate: populate, filters: options.filters, populateHints: options.populateHints }, options.validate);
         await em.#entityLoader.populate(entityName, arr, preparedPopulate, options);
@@ -1665,6 +1667,7 @@ export class EntityManager {
      */
     fork(options = {}) {
         const em = options.disableContextResolution ? this : this.getContext(false);
+        options = { ...options };
         options.clear ??= true;
         options.useContext ??= false;
         options.freshEventManager ??= false;
@@ -2073,10 +2076,13 @@ export class EntityManager {
         if (!Utils.isEmpty(options.fields) && !Utils.isEmpty(options.exclude)) {
             throw new ValidationError(`Cannot combine 'fields' and 'exclude' option.`);
         }
-        options.schema ??= this.#schema;
-        options.signal ??= this.signal;
-        options.inflightQueryAbortStrategy ??= this.inflightQueryAbortStrategy;
-        options.logging = options.loggerContext = Utils.merge({ id: this.id }, this.loggerContext, options.loggerContext, options.logging);
+        // the options object belongs to the caller, everything below works on our own copy
+        const opts = { ...options };
+        opts.schema ??= this.#schema;
+        opts.signal ??= this.signal;
+        opts.inflightQueryAbortStrategy ??= this.inflightQueryAbortStrategy;
+        opts.logging = opts.loggerContext = Utils.merge({ id: this.id }, this.loggerContext, opts.loggerContext, opts.logging);
+        return opts;
     }
     /**
      * @internal

package/connections/Connection.d.ts

@@ -51,6 +51,13 @@ export declare abstract class Connection {
      * This method doesn't support transactions, as opposed to `orm.schema.execute()`, which is used internally.
      */
     executeDump(dump: string): Promise<void>;
+    /**
+     * Returns the underlying database client the connection drives — e.g. the `pg` pool, the
+     * `better-sqlite3` database, or the `PGlite` instance — for vendor APIs MikroORM does not wrap.
+     * Each driver narrows the return type to its own client. Its lifecycle belongs to the ORM, so
+     * leave closing it to `orm.close()` unless you supplied the client yourself via `driverOptions`.
+     */
+    getNativeClient(): Promise<unknown>;
     protected onConnect(): Promise<void>;
     /** Executes a callback inside a transaction, committing on success and rolling back on failure. */
     transactional<T>(cb: (trx: Transaction) => Promise<T>, options?: {

package/connections/Connection.js

@@ -65,6 +65,15 @@ export class Connection {
     async executeDump(dump) {
         throw new Error(`Executing SQL dumps is not supported by current driver`);
     }
+    /**
+     * Returns the underlying database client the connection drives — e.g. the `pg` pool, the
+     * `better-sqlite3` database, or the `PGlite` instance — for vendor APIs MikroORM does not wrap.
+     * Each driver narrows the return type to its own client. Its lifecycle belongs to the ORM, so
+     * leave closing it to `orm.close()` unless you supplied the client yourself via `driverOptions`.
+     */
+    async getNativeClient() {
+        throw new Error(`Accessing the native client is not supported by current driver`);
+    }
     async onConnect() {
         const schemaGenerator = this.config.getExtension('@mikro-orm/schema-generator');
         if (this.type === 'write' && schemaGenerator) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.2.0-dev.5",
+  "version": "7.2.0-dev.7",
   "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.",
   "keywords": [
     "data-mapper",

package/utils/Utils.js

@@ -153,7 +153,7 @@ export function parseJsonSafe(value) {
 /** Collection of general-purpose utility methods used throughout the ORM. */
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.2.0-dev.5';
+    static #ORM_VERSION = '7.2.0-dev.7';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */