@mikro-orm/core 7.2.8-dev.1 → 7.2.8-dev.10

package/EntityManager.js

@@ -19,6 +19,7 @@ import { TransactionEventBroadcaster } from './events/TransactionEventBroadcaste
 import { MetadataError, OptimisticLockError, ValidationError } from './errors.js';
 import { applyPopulateHints, getLoadingStrategy } from './entity/utils.js';
 import { TransactionManager } from './utils/TransactionManager.js';
+import { scopeCacheKey, stringifyCacheKey } from './cache/cache-key.js';
 /**
  * The EntityManager is the central access point to ORM functionality. It is a facade to all different ORM subsystems
  * such as UnitOfWork, Query Language, and Repository API.
@@ -211,9 +212,14 @@ export class EntityManager {
         await em.tryFlush(entityName, options);
         const where = (await em.processWhere(entityName, options.where ?? {}, options, 'read'));
         validateParams(where);
-        options.orderBy = options.orderBy || {};
-        options.populate = (await em.preparePopulate(entityName, options));
         const meta = this.metadata.get(entityName);
+        if (meta.orderBy) {
+            options.orderBy = QueryHelper.mergeOrderBy(options.orderBy, meta.orderBy);
+        }
+        else {
+            options.orderBy ??= {};
+        }
+        options.populate = (await em.preparePopulate(entityName, options));
         em.validateIndexUsage(meta, options.where ?? {}, options);
         options = { ...options };
         // save the original hint value so we know it was infer/all
@@ -857,6 +863,10 @@ export class EntityManager {
             return em.lockAndPopulate(meta, entity, where, options);
         }
         validateParams(where);
+        // before the cache key so cached results share the merged orderBy
+        if (meta.orderBy) {
+            options.orderBy = QueryHelper.mergeOrderBy(options.orderBy, meta.orderBy);
+        }
         options.populate = (await em.preparePopulate(entityName, options));
         const cacheKey = em.cacheKey(entityName, options, 'em.findOne', where);
         const cached = await em.tryCache(entityName, options.cache, cacheKey, options.refresh, true, options.schema);
@@ -1831,6 +1841,7 @@ export class EntityManager {
         options.populateWhere = this.createPopulateWhere({ ...where }, options);
         options.populateFilter = await this.getJoinedFilters(meta, options);
         validateParams(where);
+        em.validateIndexUsage(meta, where, options);
         delete options.orderBy;
         await em.processUnionWhere(entityName, options, 'read');
         const cacheKey = em.cacheKey(entityName, options, 'em.count', where);
@@ -2458,11 +2469,7 @@ export class EntityManager {
         const em = this.getContext();
         // a named cache key (`config[0]`) discards the computed `key`, which already carries the session context — so
         // scope it here too, otherwise a fork's rows would be served to another session context under the same name
-        const cacheKey = Array.isArray(config)
-            ? em.#sessionContext
-                ? `${config[0]}|${JSON.stringify(em.#sessionContext)}`
-                : config[0]
-            : JSON.stringify(key);
+        const cacheKey = Array.isArray(config) ? scopeCacheKey(config[0], em.#sessionContext) : stringifyCacheKey(key);
         const cached = await em.#resultCache.get(cacheKey);
         if (!cached) {
             return { key: cacheKey, data: cached };
@@ -2515,7 +2522,7 @@ export class EntityManager {
         await em.#resultCache.remove(cacheKey);
         // named keys are scoped by the session context (see `tryCache`), so clear this context's variant too
         if (em.#sessionContext) {
-            await em.#resultCache.remove(`${cacheKey}|${JSON.stringify(em.#sessionContext)}`);
+            await em.#resultCache.remove(scopeCacheKey(cacheKey, em.#sessionContext));
         }
     }
     /**

package/cache/cache-key.d.ts

@@ -0,0 +1,5 @@
+import type { SessionContext } from '../typings.js';
+/** Serializes a result cache or dataloader batch key, telling apart all values a query can contain. */
+export declare function stringifyCacheKey(key: unknown): string;
+/** Scopes a named result cache key by the session context, so rows are not served across session contexts. */
+export declare function scopeCacheKey(name: string, sessionContext?: SessionContext): string;

package/cache/cache-key.js

@@ -0,0 +1,30 @@
+import { isRaw, isSubquery, Raw } from '../utils/RawQueryFragment.js';
+import { Utils } from '../utils/Utils.js';
+// JSON loses RegExp patterns, `raw()` params and `raw()` keys (symbols), and throws on bigints and sub-queries; `this[key]` is the value before `toJSON()`
+function replacer(key, value) {
+    const original = isSubquery(this[key]) ? this[key].toRaw() : this[key];
+    if (typeof original === 'bigint') {
+        return { bigint: original.toString() };
+    }
+    if (original instanceof RegExp) {
+        return { regexp: original.source, flags: original.flags };
+    }
+    if (isRaw(original)) {
+        return { sql: original.sql, params: original.params };
+    }
+    if (Raw.hasObjectFragments(value)) {
+        return Utils.getObjectQueryKeys(value).map(k => [
+            Raw.getKnownFragment(k) ?? k,
+            value[k],
+        ]);
+    }
+    return value;
+}
+/** Serializes a result cache or dataloader batch key, telling apart all values a query can contain. */
+export function stringifyCacheKey(key) {
+    return JSON.stringify(key, replacer);
+}
+/** Scopes a named result cache key by the session context, so rows are not served across session contexts. */
+export function scopeCacheKey(name, sessionContext) {
+    return sessionContext ? `${name}|${JSON.stringify(sessionContext)}` : name;
+}

package/drivers/IDatabaseDriver.d.ts

@@ -326,6 +326,8 @@ export interface CountOptions<T extends object, P extends string = never> extend
     flushMode?: FlushMode | `${FlushMode}`;
     /** SQL: appended to FROM clause (e.g. `'force index(my_index)'`); MongoDB: index name or spec passed as `hint`. */
     indexHint?: string | Dictionary;
+    /** @see FindOptions.using */
+    using?: IndexName<T> | IndexName<T>[];
     /** sql only */
     comments?: string | string[];
     /** sql only */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.2.8-dev.1",
+  "version": "7.2.8-dev.10",
   "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/unit-of-work/UnitOfWork.js

@@ -395,7 +395,7 @@ export class UnitOfWork {
             this.#persistStack.delete(entity);
             this.#identityMap.delete(entity);
         }
-        // remove from referencing relations that are nullable
+        // unlink loaded inverse-side items only when the FK is `set null`, other delete rules are left to the database
         const entityMeta = helper(entity).__meta;
         for (const prop of entityMeta.bidirectionalRelations) {
             const inverseProp = prop.mappedBy || prop.inversedBy;
@@ -410,7 +410,9 @@ export class UnitOfWork {
                 : inverseTarget.class !== entityMeta.class) {
                 continue;
             }
-            if (prop.kind === ReferenceKind.ONE_TO_MANY && prop2.nullable && Utils.isCollection(relation)) {
+            if (prop.kind === ReferenceKind.ONE_TO_MANY &&
+                prop2.deleteRule === 'set null' &&
+                Utils.isCollection(relation)) {
                 for (const item of relation.getItems(false)) {
                     delete item[inverseProp];
                 }

package/utils/DataloaderUtils.js

@@ -3,6 +3,9 @@ import { helper } from '../entity/wrap.js';
 import { Reference } from '../entity/Reference.js';
 import { ReferenceKind } from '../enums.js';
 import { Utils } from './Utils.js';
+import { stringifyCacheKey } from '../cache/cache-key.js';
+// the original options of each group key, JSON cannot restore values like RegExp or `raw()` from the key
+const groupOptions = new WeakMap();
 export class DataloaderUtils {
     static DataLoader;
     /**
@@ -11,6 +14,8 @@ export class DataloaderUtils {
      */
     static groupPrimaryKeysByEntityAndOpts(refsWithOpts) {
         const map = new Map();
+        const options = new Map();
+        groupOptions.set(map, options);
         for (const [ref, opts] of refsWithOpts) {
             /* The key is a combination of the uniqueName (a unique table name based identifier) and a stringified version if the load options because we want
                to map each combination of entities/options into separate find queries in order to return accurate results.
@@ -25,7 +30,8 @@ export class DataloaderUtils {
                Thus such approach should probably be configurable, if not opt-in.
                NOTE: meta + opts multi maps (https://github.com/martian17/ds-js) might be a more elegant way
                to implement this but not necessarily faster.  */
-            const key = `${helper(ref).__meta.uniqueName}|${JSON.stringify(opts ?? {})}`;
+            const key = `${helper(ref).__meta.uniqueName}|${stringifyCacheKey(opts ?? {})}`;
+            options.set(key, opts ?? {});
             let primaryKeysSet = map.get(key);
             if (primaryKeysSet == null) {
                 primaryKeysSet = new Set();
@@ -44,7 +50,7 @@ export class DataloaderUtils {
             const groupedIdsMap = DataloaderUtils.groupPrimaryKeysByEntityAndOpts(refsWithOpts);
             const promises = Array.from(groupedIdsMap).map(([key, idsSet]) => {
                 const uniqueName = key.substring(0, key.indexOf('|'));
-                const opts = JSON.parse(key.substring(key.indexOf('|') + 1));
+                const opts = groupOptions.get(groupedIdsMap).get(key);
                 const meta = em.getMetadata().getByUniqueName(uniqueName);
                 return em.find(meta.class, Array.from(idsSet), opts);
             });
@@ -64,6 +70,8 @@ export class DataloaderUtils {
      */
     static groupInversedOrMappedKeysByEntityAndOpts(collsWithOpts) {
         const entitiesMap = new Map();
+        const options = new Map();
+        groupOptions.set(entitiesMap, options);
         for (const [col, opts] of collsWithOpts) {
             /*
             We first get the entity name of the Collection and together with its options (see groupPrimaryKeysByEntityAndOpts
@@ -72,7 +80,8 @@ export class DataloaderUtils {
             The value is another Map which we can use to filter the find query to get results pertaining to the collections that have been dataloaded:
             its keys are the props we are going to filter to and its values are the corresponding PKs.
             */
-            const key = `${col.property.targetMeta.uniqueName}|${JSON.stringify(opts ?? {})}`;
+            const key = `${col.property.targetMeta.uniqueName}|${stringifyCacheKey(opts ?? {})}`;
+            options.set(key, opts ?? {});
             let filterMap = entitiesMap.get(key); // We are going to use this map to filter the entities pertaining to the collections that have been dataloaded.
             if (filterMap == null) {
                 filterMap = new Map();
@@ -100,7 +109,9 @@ export class DataloaderUtils {
     static entitiesAndOptsMapToQueries(entitiesAndOptsMap, em) {
         return Array.from(entitiesAndOptsMap, async ([key, filterMap]) => {
             const uniqueName = key.substring(0, key.indexOf('|'));
-            const opts = JSON.parse(key.substring(key.indexOf('|') + 1));
+            const opts = groupOptions
+                .get(entitiesAndOptsMap)
+                ?.get(key) ?? JSON.parse(key.substring(key.indexOf('|') + 1));
             const meta = em.getMetadata().getByUniqueName(uniqueName);
             const res = await em.find(meta.class, opts?.where != null && Object.keys(opts.where).length > 0
                 ? {
@@ -168,7 +179,7 @@ export class DataloaderUtils {
             // We need to filter the results in order to map each input collection
             // to a subset of each query matching the collection items.
             return collsWithOpts.map(([col, opts]) => {
-                const key = `${col.property.targetMeta.uniqueName}|${JSON.stringify(opts ?? {})}`;
+                const key = `${col.property.targetMeta.uniqueName}|${stringifyCacheKey(opts ?? {})}`;
                 const entities = resultsMap.get(key);
                 if (entities == null) {
                     // Should never happen
@@ -187,7 +198,7 @@ export class DataloaderUtils {
         return async (collsWithOpts) => {
             const groups = new Map();
             for (const [col, opts] of collsWithOpts) {
-                const key = `${col.property.targetMeta.uniqueName}.${col.property.name}|${JSON.stringify(opts ?? {})}`;
+                const key = `${col.property.targetMeta.uniqueName}.${col.property.name}|${stringifyCacheKey(opts ?? {})}`;
                 const value = groups.get(key) ?? [];
                 value.push([col, opts ?? {}]);
                 groups.set(key, value);
@@ -252,7 +263,7 @@ export class DataloaderUtils {
                 // sharing a relation with the same property name (e.g. `Author.books` and `Publisher.books`)
                 // don't collide into a single batch that would use one owner's FK mapping for the other.
                 const ownerUniqueName = helper(col.owner).__meta.uniqueName;
-                const key = `${ownerUniqueName}.${prop.name}|${JSON.stringify(opts ?? {})}`;
+                const key = `${ownerUniqueName}.${prop.name}|${stringifyCacheKey(opts ?? {})}`;
                 keys.push(key);
                 let group = groups.get(key);
                 if (!group) {
@@ -260,7 +271,7 @@ export class DataloaderUtils {
                     groups.set(key, group);
                 }
                 const pk = helper(col.owner).getPrimaryKey();
-                group.ownerPKs.set(JSON.stringify(pk), pk);
+                group.ownerPKs.set(stringifyCacheKey(pk), pk);
             }
             const promises = Array.from(groups.entries()).map(async ([key, group]) => {
                 const allPKs = Array.from(group.ownerPKs.values());

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.8-dev.1';
+    static #ORM_VERSION = '7.2.8-dev.10';
     /** Default session variable name backing an RLS filter argument (`current_setting('mikro.<filter>.<arg>')`). */
     static getRlsSettingName(filterName, argName) {
         return `mikro.${filterName}.${argName}`;