@mikro-orm/core 6.5.10-dev.10 → 6.5.10-dev.12

package/EntityManager.d.ts

@@ -4,7 +4,7 @@ import { type Configuration, Cursor } from './utils';
 import { type AssignOptions, EntityFactory, EntityLoader, type EntityLoaderOptions, type EntityRepository, EntityValidator, Reference } from './entity';
 import { UnitOfWork } from './unit-of-work';
 import type { CountOptions, DeleteOptions, FindAllOptions, FindByCursorOptions, FindOneOptions, FindOneOrFailOptions, FindOptions, GetReferenceOptions, IDatabaseDriver, LockOptions, NativeInsertUpdateOptions, UpdateOptions, UpsertManyOptions, UpsertOptions } from './drivers';
-import type { AnyEntity, AnyString, ArrayElement, AutoPath, ConnectionType, Dictionary, EntityData, EntityDictionary, EntityDTO, EntityMetadata, EntityName, FilterQuery, FromEntityType, GetRepository, IHydrator, IsSubset, Loaded, MaybePromise, MergeLoaded, MergeSelected, NoInfer, ObjectQuery, Primary, Ref, RequiredEntityData, UnboxArray } from './typings';
+import type { AnyEntity, AnyString, ArrayElement, AutoPath, ConnectionType, Dictionary, EntityData, EntityDictionary, EntityDTO, EntityMetadata, EntityName, FilterDef, FilterQuery, FromEntityType, GetRepository, IHydrator, IsSubset, Loaded, MaybePromise, MergeLoaded, MergeSelected, NoInfer, ObjectQuery, Primary, Ref, RequiredEntityData, UnboxArray } from './typings';
 import { FlushMode, LockMode, PopulatePath, type TransactionOptions } from './enums';
 import type { MetadataStorage } from './metadata';
 import type { Transaction } from './connections';
@@ -83,19 +83,19 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
     /**
      * Registers global filter to this entity manager. Global filters are enabled by default (unless disabled via last parameter).
      */
-    addFilter<T1>(name: string, cond: FilterQuery<T1> | ((args: Dictionary) => MaybePromise<FilterQuery<T1>>), entityName?: EntityName<T1> | [EntityName<T1>], enabled?: boolean): void;
+    addFilter<T1>(name: string, cond: FilterQuery<T1> | ((args: Dictionary) => MaybePromise<FilterQuery<T1>>), entityName?: EntityName<T1> | [EntityName<T1>], options?: boolean | Partial<FilterDef>): void;
     /**
      * Registers global filter to this entity manager. Global filters are enabled by default (unless disabled via last parameter).
      */
-    addFilter<T1, T2>(name: string, cond: FilterQuery<T1 | T2> | ((args: Dictionary) => MaybePromise<FilterQuery<T1 | T2>>), entityName?: [EntityName<T1>, EntityName<T2>], enabled?: boolean): void;
+    addFilter<T1, T2>(name: string, cond: FilterQuery<T1 | T2> | ((args: Dictionary) => MaybePromise<FilterQuery<T1 | T2>>), entityName?: [EntityName<T1>, EntityName<T2>], options?: boolean | Partial<FilterDef>): void;
     /**
      * Registers global filter to this entity manager. Global filters are enabled by default (unless disabled via last parameter).
      */
-    addFilter<T1, T2, T3>(name: string, cond: FilterQuery<T1 | T2 | T3> | ((args: Dictionary) => MaybePromise<FilterQuery<T1 | T2 | T3>>), entityName?: [EntityName<T1>, EntityName<T2>, EntityName<T3>], enabled?: boolean): void;
+    addFilter<T1, T2, T3>(name: string, cond: FilterQuery<T1 | T2 | T3> | ((args: Dictionary) => MaybePromise<FilterQuery<T1 | T2 | T3>>), entityName?: [EntityName<T1>, EntityName<T2>, EntityName<T3>], options?: boolean | Partial<FilterDef>): void;
     /**
      * Registers global filter to this entity manager. Global filters are enabled by default (unless disabled via last parameter).
      */
-    addFilter(name: string, cond: Dictionary | ((args: Dictionary) => MaybePromise<FilterQuery<AnyEntity>>), entityName?: EntityName<AnyEntity> | EntityName<AnyEntity>[], enabled?: boolean): void;
+    addFilter(name: string, cond: Dictionary | ((args: Dictionary) => MaybePromise<FilterQuery<AnyEntity>>), entityName?: EntityName<AnyEntity> | EntityName<AnyEntity>[], options?: boolean | Partial<FilterDef>): void;
     /**
      * Sets filter parameter values globally inside context defined by this entity manager.
      * If you want to set shared value for all contexts, be sure to use the root entity manager.
@@ -123,7 +123,10 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
     /**
      * When filters are active on M:1 or 1:1 relations, we need to ref join them eagerly as they might affect the FK value.
      */
-    protected autoJoinRefsForFilters<T extends object>(meta: EntityMetadata<T>, options: FindOptions<T, any, any, any> | FindOneOptions<T, any, any, any>): Promise<void>;
+    protected autoJoinRefsForFilters<T extends object>(meta: EntityMetadata<T>, options: FindOptions<T, any, any, any> | FindOneOptions<T, any, any, any>, parent?: {
+        className: string;
+        propName: string;
+    }): Promise<void>;
     /**
      * @internal
      */

package/EntityManager.js

@@ -197,8 +197,8 @@ class EntityManager {
     /**
      * Registers global filter to this entity manager. Global filters are enabled by default (unless disabled via last parameter).
      */
-    addFilter(name, cond, entityName, enabled = true) {
-        const options = { name, cond, default: enabled };
+    addFilter(name, cond, entityName, options = true) {
+        options = typeof options === 'object' ? { name, cond, default: true, ...options } : { name, cond, default: options };
         if (entityName) {
             options.entity = utils_1.Utils.asArray(entityName).map(n => utils_1.Utils.className(n));
         }
@@ -308,29 +308,29 @@ class EntityManager {
     /**
      * When filters are active on M:1 or 1:1 relations, we need to ref join them eagerly as they might affect the FK value.
      */
-    async autoJoinRefsForFilters(meta, options) {
-        if (!meta || !this.config.get('autoJoinRefsForFilters')) {
+    async autoJoinRefsForFilters(meta, options, parent) {
+        if (!meta || !this.config.get('autoJoinRefsForFilters') || options.filters === false) {
             return;
         }
-        const props = meta.relations.filter(prop => {
-            return !prop.object && [enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind)
-                && ((options.fields?.length ?? 0) === 0 || options.fields?.some(f => prop.name === f || prop.name.startsWith(`${String(f)}.`)));
-        });
         const ret = options.populate;
-        for (const prop of props) {
+        for (const prop of meta.relations) {
+            if (prop.object
+                || ![enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind)
+                || !((options.fields?.length ?? 0) === 0 || options.fields?.some(f => prop.name === f || prop.name.startsWith(`${String(f)}.`)))
+                || (parent?.className === prop.targetMeta.root.className && parent.propName === prop.inversedBy)) {
+                continue;
+            }
             const cond = await this.applyFilters(prop.type, {}, options.filters ?? {}, 'read', options);
             if (!utils_1.Utils.isEmpty(cond)) {
                 const populated = options.populate.filter(({ field }) => field.split(':')[0] === prop.name);
                 let found = false;
-                if (populated.length > 0) {
-                    for (const hint of populated) {
-                        if (!hint.all) {
-                            hint.filter = true;
-                            found = true;
-                        }
-                        else if (hint.field === `${prop.name}:ref`) {
-                            found = true;
-                        }
+                for (const hint of populated) {
+                    if (!hint.all) {
+                        hint.filter = true;
+                    }
+                    const strategy = (0, utils_2.getLoadingStrategy)(prop.strategy || hint.strategy || options.strategy || this.config.get('loadStrategy'), prop.kind);
+                    if (hint.field === `${prop.name}:ref` || (hint.filter && strategy === enums_1.LoadStrategy.JOINED)) {
+                        found = true;
                     }
                 }
                 if (!found) {
@@ -338,6 +338,14 @@ class EntityManager {
                 }
             }
         }
+        for (const hint of ret) {
+            const [field, ref] = hint.field.split(':');
+            const prop = meta?.properties[field];
+            if (prop && !ref) {
+                hint.children ??= [];
+                await this.autoJoinRefsForFilters(prop.targetMeta, { ...options, populate: hint.children }, { className: meta.root.className, propName: prop.name });
+            }
+        }
     }
     /**
      * @internal
@@ -376,13 +384,17 @@ class EntityManager {
             else {
                 cond = filter.cond;
             }
-            ret.push(utils_1.QueryHelper.processWhere({
+            cond = utils_1.QueryHelper.processWhere({
                 where: cond,
                 entityName,
                 metadata: this.metadata,
                 platform: this.driver.getPlatform(),
                 aliased: type === 'read',
-            }));
+            });
+            if (filter.strict) {
+                Object.defineProperty(cond, '__strict', { value: filter.strict, enumerable: false });
+            }
+            ret.push(cond);
         }
         const conds = [...ret, where].filter(c => utils_1.Utils.hasObjectKeys(c));
         return conds.length > 1 ? { $and: conds } : conds[0];
@@ -1387,7 +1399,7 @@ class EntityManager {
         const em = this.getContext();
         em.prepareOptions(options);
         const entityName = arr[0].constructor.name;
-        const preparedPopulate = await em.preparePopulate(entityName, { populate: populate }, options.validate);
+        const preparedPopulate = await em.preparePopulate(entityName, { populate: populate, filters: options.filters }, options.validate);
         await em.entityLoader.populate(entityName, arr, preparedPopulate, options);
         return entities;
     }

package/entity/EntityLoader.js

@@ -213,7 +213,7 @@ class EntityLoader {
         }
     }
     async findChildren(entities, prop, populate, options, ref) {
-        const children = this.getChildReferences(entities, prop, options, ref);
+        const children = Utils_1.Utils.unique(this.getChildReferences(entities, prop, options, ref));
         const meta = prop.targetMeta;
         let fk = Utils_1.Utils.getPrimaryKeyHash(meta.primaryKeys);
         let schema = options.schema;
@@ -269,6 +269,24 @@ class EntityLoader {
             // @ts-ignore not a public option, will be propagated to the populate call
             visited: options.visited,
         });
+        if ([enums_1.ReferenceKind.ONE_TO_ONE, enums_1.ReferenceKind.MANY_TO_ONE].includes(prop.kind) && items.length !== children.length) {
+            const nullVal = this.em.config.get('forceUndefined') ? undefined : null;
+            const itemsMap = {};
+            const childrenMap = {};
+            for (const item of items) {
+                itemsMap[(0, wrap_1.helper)(item).getSerializedPrimaryKey()] ??= true;
+            }
+            for (const child of children) {
+                childrenMap[(0, wrap_1.helper)(child).getSerializedPrimaryKey()] ??= true;
+            }
+            for (const entity of entities) {
+                const key = (0, wrap_1.helper)(entity[prop.name] ?? {})?.getSerializedPrimaryKey();
+                if (childrenMap[key] != null && itemsMap[key] == null) {
+                    entity[prop.name] = nullVal;
+                    (0, wrap_1.helper)(entity).__originalEntityData[prop.name] = null;
+                }
+            }
+        }
         for (const item of items) {
             if (ref && !(0, wrap_1.helper)(item).__onLoadFired) {
                 (0, wrap_1.helper)(item).__initialized = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "6.5.10-dev.10",
+  "version": "6.5.10-dev.12",
   "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",
@@ -64,7 +64,7 @@
     "esprima": "4.0.1",
     "fs-extra": "11.3.2",
     "globby": "11.1.0",
-    "mikro-orm": "6.5.10-dev.10",
+    "mikro-orm": "6.5.10-dev.12",
     "reflect-metadata": "0.2.2"
   }
 }

package/typings.d.ts

@@ -710,6 +710,7 @@ export type FilterDef = {
     default?: boolean;
     entity?: string[];
     args?: boolean;
+    strict?: boolean;
 };
 export type Populate<T, P extends string = never> = readonly AutoPath<T, P, `${PopulatePath}`>[] | false;
 export type PopulateOptions<T> = {