@mikro-orm/core 6.5.10-dev.1 → 6.5.10-dev.11

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/EntityFactory.js

@@ -160,6 +160,7 @@ class EntityFactory {
                 this.create(prop.type, data[prop.name], options); // we can ignore the value, we just care about the `mergeData` call
             }
         });
+        this.unitOfWork.normalizeEntityData(meta, originalEntityData);
         (0, wrap_1.helper)(entity).__touched = false;
     }
     createReference(entityName, id, options = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "6.5.10-dev.1",
+  "version": "6.5.10-dev.11",
   "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.1",
+    "mikro-orm": "6.5.10-dev.11",
     "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> = {

package/unit-of-work/UnitOfWork.d.ts

@@ -27,6 +27,12 @@ export declare class UnitOfWork {
     private working;
     constructor(em: EntityManager);
     merge<T extends object>(entity: T, visited?: Set<AnyEntity>): void;
+    /**
+     * Entity data can wary in its shape, e.g. we might get a deep relation graph with joined strategy, but for diffing,
+     * we need to normalize the shape, so relation values are only raw FKs. This method handles that.
+     * @internal
+     */
+    normalizeEntityData<T extends object>(meta: EntityMetadata<T>, data: EntityData<T>): void;
     /**
      * @internal
      */

package/unit-of-work/UnitOfWork.js

@@ -64,6 +64,40 @@ class UnitOfWork {
         }
         this.cascade(entity, enums_1.Cascade.MERGE, visited ?? new Set());
     }
+    /**
+     * Entity data can wary in its shape, e.g. we might get a deep relation graph with joined strategy, but for diffing,
+     * we need to normalize the shape, so relation values are only raw FKs. This method handles that.
+     * @internal
+     */
+    normalizeEntityData(meta, data) {
+        const forceUndefined = this.em.config.get('forceUndefined');
+        for (const key of Utils_1.Utils.keys(data)) {
+            const prop = meta.properties[key];
+            if (!prop) {
+                continue;
+            }
+            if ([enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils_1.Utils.isPlainObject(data[prop.name])) {
+                data[prop.name] = Utils_1.Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
+            }
+            else if (prop.kind === enums_1.ReferenceKind.EMBEDDED && !prop.object && Utils_1.Utils.isPlainObject(data[prop.name])) {
+                for (const p of prop.targetMeta.props) {
+                    /* istanbul ignore next */
+                    const prefix = prop.prefix === false ? '' : prop.prefix === true ? prop.name + '_' : prop.prefix;
+                    data[prefix + p.name] = data[prop.name][p.name];
+                }
+                data[prop.name] = Utils_1.Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
+            }
+            if (prop.hydrate === false && prop.customType?.ensureComparable(meta, prop)) {
+                const converted = prop.customType.convertToJSValue(data[key], this.platform, { key, mode: 'hydration', force: true });
+                data[key] = prop.customType.convertToDatabaseValue(converted, this.platform, { key, mode: 'hydration' });
+            }
+            if (forceUndefined) {
+                if (data[key] === null) {
+                    data[key] = undefined;
+                }
+            }
+        }
+    }
     /**
      * @internal
      */
@@ -81,31 +115,11 @@ class UnitOfWork {
         wrapped.__em ??= this.em;
         wrapped.__managed = true;
         if (data && (options?.refresh || !wrapped.__originalEntityData)) {
+            this.normalizeEntityData(wrapped.__meta, data);
             for (const key of Utils_1.Utils.keys(data)) {
                 const prop = wrapped.__meta.properties[key];
-                if (!prop) {
-                    continue;
-                }
-                wrapped.__loadedProperties.add(key);
-                if ([enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils_1.Utils.isPlainObject(data[prop.name])) {
-                    data[prop.name] = Utils_1.Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
-                }
-                else if (prop.kind === enums_1.ReferenceKind.EMBEDDED && !prop.object && Utils_1.Utils.isPlainObject(data[prop.name])) {
-                    for (const p of prop.targetMeta.props) {
-                        /* istanbul ignore next */
-                        const prefix = prop.prefix === false ? '' : prop.prefix === true ? prop.name + '_' : prop.prefix;
-                        data[prefix + p.name] = data[prop.name][p.name];
-                    }
-                    data[prop.name] = Utils_1.Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
-                }
-                if (prop.hydrate === false && prop.customType?.ensureComparable(wrapped.__meta, prop)) {
-                    const converted = prop.customType.convertToJSValue(data[key], this.platform, { key, mode: 'hydration', force: true });
-                    data[key] = prop.customType.convertToDatabaseValue(converted, this.platform, { key, mode: 'hydration' });
-                }
-                if (forceUndefined) {
-                    if (data[key] === null) {
-                        data[key] = undefined;
-                    }
+                if (prop) {
+                    wrapped.__loadedProperties.add(key);
                 }
             }
             wrapped.__originalEntityData = data;