@mikro-orm/core 7.2.8-dev.8 → 7.2.8

package/EntityManager.js

@@ -1841,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);

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/entity/EntityLoader.d.ts

@@ -73,6 +73,7 @@ export declare class EntityLoader {
     private initializeCollections;
     private initializeOneToMany;
     private initializeManyToMany;
+    private initializePartitions;
     private findChildren;
     private mergePrimaryCondition;
     private populateField;

package/entity/EntityLoader.js

@@ -186,7 +186,7 @@ export class EntityLoader {
         if (prop.polymorphic && prop.polymorphTargets) {
             return this.populatePolymorphic(entities, prop, options, !!ref);
         }
-        const { items, partial } = await this.findChildren(options.filtered ?? entities, prop, populate, {
+        const { items, partial, partitions } = await this.findChildren(options.filtered ?? entities, prop, populate, {
             ...options,
             where,
             orderBy: mergedOrderBy,
@@ -194,6 +194,10 @@ export class EntityLoader {
         const hasLimit = populate.limit != null;
         const isPartial = partial || hasLimit;
         const customOrder = mergedOrderBy.length > 0 || !!prop.orderBy || !!prop.targetMeta?.orderBy;
+        if (partitions) {
+            this.initializePartitions(filtered, items, field, partitions);
+            return items;
+        }
         this.initializeCollections(filtered, prop, field, items, customOrder, isPartial, hasLimit);
         return items;
     }
@@ -336,6 +340,18 @@ export class EntityLoader {
             }
         }
     }
+    initializePartitions(filtered, children, field, partitions) {
+        // a child belongs only to the owners whose slice returned it, not to every owner in its array
+        const key = (entity) => helper(entity).getSerializedPrimaryKey();
+        const owners = new Map(filtered.map(entity => [key(entity), []]));
+        const items = new Map(children.map(child => [key(child), child]));
+        for (const [owner, child] of partitions) {
+            owners.get('' + owner)?.push(items.get('' + child));
+        }
+        for (const entity of filtered) {
+            entity[field].hydrate(owners.get(key(entity)), true, true, true);
+        }
+    }
     async findChildren(entities, prop, populate, options, ref) {
         const children = Utils.unique(this.getChildReferences(entities, prop, options, ref, populate));
         const meta = prop.targetMeta;
@@ -434,11 +450,13 @@ export class EntityLoader {
             visited: options.visited,
         };
         if (populate.limit != null) {
-            findOptions._partitionLimit = {
-                partitionBy: fk,
-                limit: populate.limit,
-                offset: populate.offset,
-            };
+            // the owners of an M:N without a pivot table are stored as an array, the driver slices per owner
+            const owners = prop.kind === ReferenceKind.MANY_TO_MANY && ownerProp ? ids : undefined;
+            findOptions._partitionLimit = { partitionBy: fk, limit: populate.limit, offset: populate.offset, owners };
+            // a cached result would not carry the per-owner partitions the driver writes back
+            if (owners) {
+                findOptions.cache = false;
+            }
         }
         const items = await this.#em.find(meta.class, where, findOptions);
         // For targetKey relations, wire up loaded entities to parent references
@@ -501,7 +519,7 @@ export class EntityLoader {
                 this.#em.getUnitOfWork().unmarkAsLoaded(item);
             }
         }
-        return { items, partial };
+        return { items, partial, partitions: findOptions._partitionLimit?.partitions };
     }
     mergePrimaryCondition(ids, pk, options, meta, metadata, platform) {
         const cond1 = QueryHelper.processWhere({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.2.8-dev.8",
+  "version": "7.2.8",
   "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/serialization/EntitySerializer.js

@@ -76,12 +76,12 @@ export class EntitySerializer {
         const meta = wrapped.__meta;
         let contextCreated = false;
         options = prepareOptions(options);
-        if (!wrapped.__serializationContext.root) {
-            const root = new SerializationContext();
-            SerializationContext.propagate(root, entity, (meta, prop) => meta.properties[prop]?.kind !== ReferenceKind.SCALAR);
+        let root = wrapped.__serializationContext.root;
+        if (!root) {
+            root = new SerializationContext();
             contextCreated = true;
         }
-        const root = wrapped.__serializationContext.root;
+        SerializationContext.propagate(root, entity, (meta, prop) => meta.properties[prop]?.kind !== ReferenceKind.SCALAR);
         const ret = {};
         const props = new Set();
         if (meta.serializedPrimaryKey && !meta.compositePK) {

package/serialization/EntityTransformer.js

@@ -21,12 +21,12 @@ export class EntityTransformer {
         if (!wrapped) {
             return entity;
         }
-        if (!wrapped.__serializationContext.root) {
-            const root = new SerializationContext(wrapped.__serializationContext.populate, wrapped.__serializationContext.fields, wrapped.__serializationContext.exclude);
-            SerializationContext.propagate(root, entity, isVisible);
+        let root = wrapped.__serializationContext.root;
+        if (!root) {
+            root = new SerializationContext(wrapped.__serializationContext.populate, wrapped.__serializationContext.fields, wrapped.__serializationContext.exclude);
             contextCreated = true;
         }
-        const root = wrapped.__serializationContext.root;
+        SerializationContext.propagate(root, entity, isVisible);
         const meta = wrapped.__meta;
         const ret = {};
         const props = new Set();

package/serialization/SerializationContext.d.ts

@@ -18,7 +18,8 @@ export declare class SerializationContext<T extends object> {
     /** Cleans up the serialization context by removing root references from all tracked entities. */
     close(): void;
     /**
-     * When initializing new context, we need to propagate it to the whole entity graph recursively.
+     * Propagates the context to the entity and its direct relations, so nested serialization calls pick it up.
+     * Runs for every serialized entity, so the context spreads along the serialized path instead of the whole graph.
      */
     static propagate(root: SerializationContext<any>, entity: AnyEntity, isVisible: (meta: EntityMetadata, prop: string) => boolean): void;
     /** Checks whether a property is explicitly listed in the populate hints for the current path. */

package/serialization/SerializationContext.js

@@ -47,7 +47,8 @@ export class SerializationContext {
         }
     }
     /**
-     * When initializing new context, we need to propagate it to the whole entity graph recursively.
+     * Propagates the context to the entity and its direct relations, so nested serialization calls pick it up.
+     * Runs for every serialized entity, so the context spreads along the serialized path instead of the whole graph.
      */
     static propagate(root, entity, isVisible) {
         root.register(entity);
@@ -59,14 +60,14 @@ export class SerializationContext {
             const target = entity[key];
             if (Utils.isEntity(target, true)) {
                 if (!target.__helper.__serializationContext.root) {
-                    this.propagate(root, target, isVisible);
+                    root.register(target);
                 }
                 continue;
             }
             if (Utils.isCollection(target)) {
                 for (const item of target.getItems(false)) {
                     if (!item.__helper.__serializationContext.root) {
-                        this.propagate(root, item, isVisible);
+                        root.register(item);
                     }
                 }
             }

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