@mikro-orm/core 6.5.10-dev.8 → 6.6.0

package/EntityManager.d.ts

@@ -3,8 +3,8 @@ import DataLoader from 'dataloader';
 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 { CountOptions, DeleteOptions, FilterOptions, 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, 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.
@@ -119,15 +119,18 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
     protected processWhere<Entity extends object, Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(entityName: string, where: FilterQuery<Entity>, options: FindOptions<Entity, Hint, Fields, Excludes> | FindOneOptions<Entity, Hint, Fields, Excludes>, type: 'read' | 'update' | 'delete'): Promise<FilterQuery<Entity>>;
     protected applyDiscriminatorCondition<Entity extends object>(entityName: string, where: FilterQuery<Entity>): FilterQuery<Entity>;
     protected createPopulateWhere<Entity extends object>(cond: ObjectQuery<Entity>, options: FindOptions<Entity, any, any, any> | FindOneOptions<Entity, any, any, any> | CountOptions<Entity, any>): ObjectQuery<Entity>;
-    protected getJoinedFilters<Entity extends object>(meta: EntityMetadata<Entity>, cond: ObjectQuery<Entity>, options: FindOptions<Entity, any, any, any> | FindOneOptions<Entity, any, any, any>): Promise<ObjectQuery<Entity>>;
+    protected getJoinedFilters<Entity extends object>(meta: EntityMetadata<Entity>, options: FindOptions<Entity, any, any, any> | FindOneOptions<Entity, any, any, any>): Promise<ObjectQuery<Entity> | undefined>;
     /**
      * 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
      */
-    applyFilters<Entity extends object>(entityName: string, where: FilterQuery<Entity> | undefined, options: Dictionary<boolean | Dictionary> | string[] | boolean, type: 'read' | 'update' | 'delete', findOptions?: FindOptions<any, any, any, any> | FindOneOptions<any, any, any, any>): Promise<FilterQuery<Entity> | undefined>;
+    applyFilters<Entity extends object>(entityName: string, where: FilterQuery<Entity> | undefined, options: FilterOptions | undefined, type: 'read' | 'update' | 'delete', findOptions?: FindOptions<any, any, any, any> | FindOneOptions<any, any, any, any>): Promise<FilterQuery<Entity> | undefined>;
     /**
      * Calls `em.find()` and `em.count()` with the same arguments (where applicable) and returns the results as tuple
      * where the first element is the array of entities, and the second is the count.

package/EntityManager.js

@@ -143,7 +143,7 @@ class EntityManager {
         // save the original hint value so we know it was infer/all
         options._populateWhere = options.populateWhere ?? this.config.get('populateWhere');
         options.populateWhere = this.createPopulateWhere({ ...where }, options);
-        options.populateFilter = await this.getJoinedFilters(meta, { ...where }, options);
+        options.populateFilter = await this.getJoinedFilters(meta, options);
         const results = await em.driver.find(entityName, where, { ctx: em.transactionContext, em, ...options });
         if (results.length === 0) {
             await em.storeCache(options.cache, cached, []);
@@ -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));
         }
@@ -277,29 +277,39 @@ class EntityManager {
         }
         return ret;
     }
-    async getJoinedFilters(meta, cond, options) {
+    async getJoinedFilters(meta, options) {
+        if (!this.config.get('filtersOnRelations') || !options.populate) {
+            return undefined;
+        }
         const ret = {};
-        if (options.populate) {
-            for (const hint of options.populate) {
-                const field = hint.field.split(':')[0];
-                const prop = meta.properties[field];
-                const strategy = (0, utils_2.getLoadingStrategy)(prop.strategy || hint.strategy || options.strategy || this.config.get('loadStrategy'), prop.kind);
-                const joined = strategy === enums_1.LoadStrategy.JOINED && prop.kind !== enums_1.ReferenceKind.SCALAR;
-                if (!joined && !hint.filter) {
-                    continue;
-                }
-                const where = await this.applyFilters(prop.type, {}, options.filters ?? {}, 'read', { ...options, populate: hint.children });
-                const where2 = await this.getJoinedFilters(prop.targetMeta, {}, { ...options, populate: hint.children, populateWhere: enums_1.PopulateHint.ALL });
-                if (utils_1.Utils.hasObjectKeys(where)) {
-                    ret[field] = ret[field] ? { $and: [where, ret[field]] } : where;
+        for (const hint of options.populate) {
+            const field = hint.field.split(':')[0];
+            const prop = meta.properties[field];
+            const strategy = (0, utils_2.getLoadingStrategy)(prop.strategy || hint.strategy || options.strategy || this.config.get('loadStrategy'), prop.kind);
+            const joined = strategy === enums_1.LoadStrategy.JOINED && prop.kind !== enums_1.ReferenceKind.SCALAR;
+            if (!joined && !hint.filter) {
+                continue;
+            }
+            const filters = utils_1.QueryHelper.mergePropertyFilters(prop.filters, options.filters);
+            const where = await this.applyFilters(prop.type, {}, filters, 'read', {
+                ...options,
+                populate: hint.children,
+            });
+            const where2 = await this.getJoinedFilters(prop.targetMeta, {
+                ...options,
+                filters,
+                populate: hint.children,
+                populateWhere: enums_1.PopulateHint.ALL,
+            });
+            if (utils_1.Utils.hasObjectKeys(where)) {
+                ret[field] = ret[field] ? { $and: [where, ret[field]] } : where;
+            }
+            if (where2 && utils_1.Utils.hasObjectKeys(where2)) {
+                if (ret[field]) {
+                    utils_1.Utils.merge(ret[field], where2);
                 }
-                if (utils_1.Utils.hasObjectKeys(where2)) {
-                    if (ret[field]) {
-                        utils_1.Utils.merge(ret[field], where2);
-                    }
-                    else {
-                        ret[field] = where2;
-                    }
+                else {
+                    ret[field] = where2;
                 }
             }
         }
@@ -308,29 +318,30 @@ 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) {
-            const cond = await this.applyFilters(prop.type, {}, options.filters ?? {}, 'read', options);
+        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;
+            }
+            options = { ...options, filters: utils_1.QueryHelper.mergePropertyFilters(prop.filters, options.filters) };
+            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 +349,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
@@ -367,7 +386,7 @@ class EntityManager {
             let cond;
             if (filter.cond instanceof Function) {
                 // @ts-ignore
-                const args = utils_1.Utils.isPlainObject(options[filter.name]) ? options[filter.name] : this.getContext().filterParams[filter.name];
+                const args = utils_1.Utils.isPlainObject(options?.[filter.name]) ? options[filter.name] : this.getContext().filterParams[filter.name];
                 if (!args && filter.cond.length > 0 && filter.args !== false) {
                     throw new Error(`No arguments provided for filter '${filter.name}'`);
                 }
@@ -376,13 +395,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];
@@ -568,7 +591,7 @@ class EntityManager {
         // save the original hint value so we know it was infer/all
         options._populateWhere = options.populateWhere ?? this.config.get('populateWhere');
         options.populateWhere = this.createPopulateWhere({ ...where }, options);
-        options.populateFilter = await this.getJoinedFilters(meta, { ...where }, options);
+        options.populateFilter = await this.getJoinedFilters(meta, options);
         const data = await em.driver.findOne(entityName, where, {
             ctx: em.transactionContext,
             em,
@@ -1204,6 +1227,7 @@ class EntityManager {
             ...options,
             newEntity: !options.managed,
             merge: options.managed,
+            normalizeAccessors: true,
         });
         options.persist ??= em.config.get('persistOnCreate');
         if (options.persist && !this.getMetadata(entityName).embeddable) {
@@ -1253,7 +1277,7 @@ class EntityManager {
         const meta = em.metadata.find(entityName);
         options._populateWhere = options.populateWhere ?? this.config.get('populateWhere');
         options.populateWhere = this.createPopulateWhere({ ...where }, options);
-        options.populateFilter = await this.getJoinedFilters(meta, { ...where }, options);
+        options.populateFilter = await this.getJoinedFilters(meta, options);
         em.validator.validateParams(where);
         delete options.orderBy;
         const cacheKey = em.cacheKey(entityName, options, 'em.count', where);
@@ -1387,7 +1411,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/decorators/Property.d.ts

@@ -3,6 +3,7 @@ import type { EntityName, Constructor, CheckCallback, GeneratedColumnCallback, A
 import type { Type, types } from '../types';
 import type { EntityManager } from '../EntityManager';
 import type { SerializeOptions } from '../serialization/EntitySerializer';
+import type { FilterOptions } from '../drivers/IDatabaseDriver';
 export declare function Property<T extends object>(options?: PropertyOptions<T>): (target: any, propertyName: string) => any;
 export interface PropertyOptions<Owner> {
     /**
@@ -161,7 +162,7 @@ export interface PropertyOptions<Owner> {
      * Set true to define the properties as setter. (virtual)
      *
      * @example
-     * ```
+     * ```ts
      * @Property({ setter: true })
      * set address(value: string) {
      *     this._address = value.toLocaleLowerCase();
@@ -173,7 +174,7 @@ export interface PropertyOptions<Owner> {
      * Set true to define the properties as getter. (virtual)
      *
      * @example
-     * ```
+     * ```ts
      * @Property({ getter: true })
      * get fullName() {
      *   return this.firstName + this.lastName;
@@ -186,7 +187,7 @@ export interface PropertyOptions<Owner> {
      * to the method name.
      *
      * @example
-     * ```
+     * ```ts
      * @Property({ getter: true })
      * getFullName() {
      *   return this.firstName + this.lastName;
@@ -194,6 +195,53 @@ export interface PropertyOptions<Owner> {
      * ```
      */
     getterName?: keyof Owner;
+    /**
+     * When using a private property backed by a public get/set pair, use the `accessor` option to point to the other side.
+     *
+     * > The `fieldName` will be inferred based on the accessor name unless specified explicitly.
+     *
+     * If the `accessor` option points to something, the ORM will use the backing property directly.
+     *
+     * @example
+     * ```ts
+     * @Entity()
+     * export class User {
+     *   // the ORM will use the backing field directly
+     *   @Property({ accessor: 'email' })
+     *   private _email: string;
+     *
+     *   get email() {
+     *     return this._email;
+     *   }
+     *
+     *   set email() {
+     *     return this._email;
+     *   }
+     * }
+     *```
+     *
+     * If you want to the ORM to use your accessor internally too, use `accessor: true` on the get/set property instead.
+     * This is handy if you want to use a native private property for the backing field.
+     *
+     * @example
+     * ```ts
+     * @Entity({ forceConstructor: true })
+     * export class User {
+     *   #email: string;
+     *
+     *   // the ORM will use the accessor internally
+     *   @Property({ accessor: true })
+     *   get email() {
+     *     return this.#email;
+     *   }
+     *
+     *   set email() {
+     *     return this.#email;
+     *   }
+     * }
+     * ```
+     */
+    accessor?: keyof Owner | boolean;
     /**
      * Set to define serialized primary key for MongoDB. (virtual)
      * Alias for `@SerializedPrimaryKey()` decorator.
@@ -242,6 +290,8 @@ export interface ReferenceOptions<Owner, Target> extends PropertyOptions<Owner>
     eager?: boolean;
     /** Override the default loading strategy for this property. This option has precedence over the global `loadStrategy`, but can be overridden by `FindOptions.strategy`. */
     strategy?: LoadStrategy | `${LoadStrategy}`;
+    /** Control filter parameters for the relation. This will serve as a default value when processing filters on this relation. It's value can be overridden via `em.fork()` or `FindOptions`. */
+    filters?: FilterOptions;
 }
 /**
  * Inspired by https://github.com/typeorm/typeorm/blob/941b584ba135617e55d6685caef671172ec1dc03/src/driver/types/ColumnTypes.ts

package/entity/Collection.js

@@ -35,6 +35,7 @@ class Collection extends ArrayCollection_1.ArrayCollection {
     async load(options = {}) {
         if (this.isInitialized(true) && !options.refresh) {
             const em = this.getEntityManager(this.items, false);
+            options = { ...options, filters: utils_1.QueryHelper.mergePropertyFilters(this.property.filters, options.filters) };
             await em?.populate(this.items, options.populate, options);
             this.setSerializationContext(options);
         }
@@ -220,6 +221,7 @@ class Collection extends ArrayCollection_1.ArrayCollection {
             return this;
         }
         const em = this.getEntityManager();
+        options = { ...options, filters: utils_1.QueryHelper.mergePropertyFilters(this.property.filters, options.filters) };
         if (options.dataloader ?? [enums_1.DataloaderType.ALL, enums_1.DataloaderType.COLLECTION].includes(utils_1.DataloaderUtils.getDataloaderType(em.config.get('dataloader')))) {
             const order = [...this.items]; // copy order of references
             const orderBy = this.createOrderBy(options.orderBy);

package/entity/EntityFactory.d.ts

@@ -15,6 +15,7 @@ export interface FactoryOptions {
     recomputeSnapshot?: boolean;
     schema?: string;
     parentSchema?: string;
+    normalizeAccessors?: boolean;
 }
 export declare class EntityFactory {
     private readonly em;

package/entity/EntityFactory.js

@@ -7,6 +7,7 @@ const enums_1 = require("../enums");
 const Reference_1 = require("./Reference");
 const wrap_1 = require("./wrap");
 const EntityHelper_1 = require("./EntityHelper");
+const JsonType_1 = require("../types/JsonType");
 class EntityFactory {
     em;
     driver;
@@ -76,7 +77,9 @@ class EntityFactory {
                         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);
                         }
-                        data[prop.name] = prop.customType.convertToDatabaseValue(data[prop.name], this.platform, { key: prop.name, mode: 'hydration' });
+                        if (prop.customType instanceof JsonType_1.JsonType && this.platform.convertsJsonAutomatically()) {
+                            data[prop.name] = prop.customType.convertToDatabaseValue(data[prop.name], this.platform, { key: prop.name, mode: 'hydration' });
+                        }
                     }
                 }
             }
@@ -248,10 +251,10 @@ class EntityFactory {
     }
     hydrate(entity, meta, data, options) {
         if (options.initialized) {
-            this.hydrator.hydrate(entity, meta, data, this, 'full', options.newEntity, options.convertCustomTypes, options.schema, this.driver.getSchemaName(meta, options));
+            this.hydrator.hydrate(entity, meta, data, this, 'full', options.newEntity, options.convertCustomTypes, options.schema, this.driver.getSchemaName(meta, options), options.normalizeAccessors);
         }
         else {
-            this.hydrator.hydrateReference(entity, meta, data, this, options.convertCustomTypes, options.schema, this.driver.getSchemaName(meta, options));
+            this.hydrator.hydrateReference(entity, meta, data, this, options.convertCustomTypes, options.schema, this.driver.getSchemaName(meta, options), options.normalizeAccessors);
         }
         Utils_1.Utils.keys(data).forEach(key => {
             (0, wrap_1.helper)(entity)?.__loadedProperties.add(key);

package/entity/EntityHelper.js

@@ -90,7 +90,7 @@ class EntityHelper {
                 });
                 return;
             }
-            if (prop.inherited || prop.primary || prop.persist === false || prop.trackChanges === false || prop.embedded || isCollection) {
+            if (prop.inherited || prop.primary || prop.accessor || prop.persist === false || prop.trackChanges === false || prop.embedded || isCollection) {
                 return;
             }
             Object.defineProperty(meta.prototype, prop.name, {
@@ -116,7 +116,18 @@ class EntityHelper {
     static defineCustomInspect(meta) {
         // @ts-ignore
         meta.prototype[node_util_1.inspect.custom] ??= function (depth = 2) {
-            const object = { ...this };
+            const object = {};
+            const keys = new Set(Utils_1.Utils.keys(this)); // .sort((a, b) => (meta.propertyOrder.get(a) ?? 0) - (meta.propertyOrder.get(b) ?? 0));
+            for (const prop of meta.props) {
+                if (keys.has(prop.name) || (prop.getter && prop.accessor === prop.name)) {
+                    object[prop.name] = this[prop.name];
+                }
+            }
+            for (const key of keys) {
+                if (!meta.properties[key]) {
+                    object[key] = this[key];
+                }
+            }
             // ensure we dont have internal symbols in the POJO
             [typings_1.OptionalProps, typings_1.EntityRepositoryType, typings_1.PrimaryKeyProp, typings_1.EagerProps, typings_1.HiddenProps].forEach(sym => delete object[sym]);
             meta.props
@@ -175,6 +186,10 @@ class EntityHelper {
                 continue;
             }
             const inverse = value?.[prop2.name];
+            if (prop.ref && owner[prop.name]) {
+                // eslint-disable-next-line dot-notation
+                owner[prop.name]['property'] = prop;
+            }
             if (Utils_1.Utils.isCollection(inverse) && inverse.isPartial()) {
                 continue;
             }

package/entity/EntityLoader.d.ts

@@ -1,7 +1,7 @@
-import type { AnyEntity, ConnectionType, Dictionary, EntityProperty, FilterQuery, PopulateOptions } from '../typings';
+import type { AnyEntity, ConnectionType, EntityProperty, FilterQuery, PopulateOptions } from '../typings';
 import type { EntityManager } from '../EntityManager';
 import { LoadStrategy, type LockMode, type PopulateHint, PopulatePath, type QueryOrderMap } from '../enums';
-import type { EntityField } from '../drivers/IDatabaseDriver';
+import type { EntityField, FilterOptions } from '../drivers/IDatabaseDriver';
 import type { LoggingOptions } from '../logging/Logger';
 export type EntityLoaderOptions<Entity, Fields extends string = PopulatePath.ALL, Excludes extends string = never> = {
     where?: FilterQuery<Entity>;
@@ -14,7 +14,7 @@ export type EntityLoaderOptions<Entity, Fields extends string = PopulatePath.ALL
     lookup?: boolean;
     convertCustomTypes?: boolean;
     ignoreLazyScalarProperties?: boolean;
-    filters?: Dictionary<boolean | Dictionary> | string[] | boolean;
+    filters?: FilterOptions;
     strategy?: LoadStrategy;
     lockMode?: Exclude<LockMode, LockMode.OPTIMISTIC>;
     schema?: string;

package/entity/EntityLoader.js

@@ -35,7 +35,6 @@ class EntityLoader {
         const visited = options.visited ??= new Set();
         options.where ??= {};
         options.orderBy ??= {};
-        options.filters ??= {};
         options.lookup ??= true;
         options.validate ??= true;
         options.refresh ??= false;
@@ -213,7 +212,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 +268,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 = new Set();
+            const childrenMap = new Set();
+            for (const item of items) {
+                itemsMap.add((0, wrap_1.helper)(item).getSerializedPrimaryKey());
+            }
+            for (const child of children) {
+                childrenMap.add((0, wrap_1.helper)(child).getSerializedPrimaryKey());
+            }
+            for (const entity of entities) {
+                const key = (0, wrap_1.helper)(entity[prop.name] ?? {})?.getSerializedPrimaryKey();
+                if (childrenMap.has(key) && !itemsMap.has(key)) {
+                    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;
@@ -292,6 +309,7 @@ class EntityLoader {
         if (prop.kind === enums_1.ReferenceKind.SCALAR && !prop.lazy) {
             return;
         }
+        options = { ...options, filters: QueryHelper_1.QueryHelper.mergePropertyFilters(prop.filters, options.filters) };
         const populated = await this.populateMany(entityName, entities, populate, options);
         if (!populate.children && !populate.all) {
             return;

package/entity/Reference.d.ts

@@ -3,6 +3,7 @@ import type { AddEager, AddOptional, Dictionary, EntityClass, EntityKey, EntityP
 import type { FindOneOptions, FindOneOrFailOptions } from '../drivers/IDatabaseDriver';
 export declare class Reference<T extends object> {
     private entity;
+    private property?;
     constructor(entity: T);
     static create<T extends object>(entity: T | Ref<T>): Ref<T>;
     static createFromPK<T extends object>(entityType: EntityClass<T>, pk: Primary<T>, options?: {

package/entity/Reference.js

@@ -10,6 +10,7 @@ const utils_1 = require("../utils");
 const errors_1 = require("../errors");
 class Reference {
     entity;
+    property;
     constructor(entity) {
         this.entity = entity;
         this.set(entity);
@@ -69,7 +70,9 @@ class Reference {
      */
     static wrapReference(entity, prop) {
         if (entity && prop.ref && !Reference.isReference(entity)) {
-            return Reference.create(entity);
+            const ref = Reference.create(entity);
+            ref.property = prop;
+            return ref;
         }
         return entity;
     }
@@ -89,6 +92,7 @@ class Reference {
         if (!wrapped.__em) {
             return this.entity;
         }
+        options = { ...options, filters: utils_1.QueryHelper.mergePropertyFilters(this.property?.filters, options.filters) };
         if (this.isInitialized() && !options.refresh && options.populate) {
             await wrapped.__em.populate(this.entity, options.populate, options);
         }
@@ -149,7 +153,7 @@ class Reference {
     /** @ignore */
     [node_util_1.inspect.custom](depth = 2) {
         const object = { ...this };
-        const hidden = ['meta'];
+        const hidden = ['meta', 'property'];
         hidden.forEach(k => delete object[k]);
         const ret = (0, node_util_1.inspect)(object, { depth });
         const wrapped = (0, wrap_1.helper)(this.entity);

package/entity/defineEntity.d.ts

@@ -6,8 +6,8 @@ import type { ManyToOneOptions } from '../decorators/ManyToOne';
 import type { OneToManyOptions } from '../decorators/OneToMany';
 import type { OneToOneOptions } from '../decorators/OneToOne';
 import type { ManyToManyOptions } from '../decorators/ManyToMany';
-import type { AnyString, GeneratedColumnCallback, Constructor, CheckCallback, FilterQuery, EntityName, Dictionary, EntityMetadata, PrimaryKeyProp, Hidden, Opt, Primary, EntityClass } from '../typings';
-import type { Reference, ScalarReference } from './Reference';
+import type { AnyString, GeneratedColumnCallback, Constructor, CheckCallback, FilterQuery, EntityName, Dictionary, EntityMetadata, PrimaryKeyProp, Hidden, Opt, Primary, EntityClass, Ref } from '../typings';
+import type { ScalarReference } from './Reference';
 import type { SerializeOptions } from '../serialization/EntitySerializer';
 import type { Cascade, DeferMode, EventType, LoadStrategy, QueryOrderMap } from '../enums';
 import type { IType, Type } from '../types/Type';
@@ -15,6 +15,7 @@ import { types } from '../types';
 import { EntitySchema } from '../metadata/EntitySchema';
 import type { Collection } from './Collection';
 import type { EventSubscriber } from '../events';
+import type { FilterOptions } from '../drivers/IDatabaseDriver';
 export type UniversalPropertyKeys = keyof PropertyOptions<any> | keyof EnumOptions<any> | keyof EmbeddedOptions<any, any> | keyof ReferenceOptions<any, any> | keyof ManyToOneOptions<any, any> | keyof OneToManyOptions<any, any> | keyof OneToOneOptions<any, any> | keyof ManyToManyOptions<any, any>;
 type BuilderExtraKeys = '~options' | '~type' | '$type';
 type ExcludeKeys = 'entity' | 'items';
@@ -110,14 +111,12 @@ export declare class UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys
     returning(returning?: boolean): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     /**
      * Automatically set the property value when entity gets created, executed during flush operation.
-     * @param entity
      */
     onCreate(onCreate: (entity: any, em: EntityManager) => Value): Pick<UniversalPropertyOptionsBuilder<Value, Options & {
         onCreate: (...args: any[]) => any;
     }, IncludeKeys>, IncludeKeys>;
     /**
      * Automatically update the property value every time entity gets updated, executed during flush operation.
-     * @param entity
      */
     onUpdate(onUpdate: (entity: any, em: EntityManager) => Value): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     /**
@@ -134,6 +133,10 @@ export declare class UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys
     defaultRaw(defaultRaw: string): Pick<UniversalPropertyOptionsBuilder<Value, Options & {
         defaultRaw: string;
     }, IncludeKeys>, IncludeKeys>;
+    /**
+     * Allow controlling `filters` option. This will be overridden with `em.fork` or `FindOptions` if provided.
+     */
+    filters(filters: FilterOptions): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     /**
      * Set to map some SQL snippet for the entity.
      *
@@ -361,6 +364,7 @@ export declare class UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys
     foreignKeyName(foreignKeyName: string): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     /** Remove the entity when it gets disconnected from the relationship (see {@doclink cascading | Cascading}). */
     orphanRemoval(orphanRemoval?: boolean): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
+    accessor(accessor?: string | boolean): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
 }
 export interface EmptyOptions extends Partial<Record<UniversalPropertyKeys, unknown>> {
 }
@@ -511,10 +515,10 @@ type MaybeRelationRef<Value, Options> = Options extends {
 } ? Value : Options extends {
     ref: true;
     kind: '1:1';
-} ? Value extends object ? Reference<Value> : never : Options extends {
+} ? Value extends object ? Ref<Value> : never : Options extends {
     ref: true;
     kind: 'm:1';
-} ? Value extends object ? Reference<Value> : never : Options extends {
+} ? Value extends object ? Ref<Value> : never : Options extends {
     kind: '1:m';
 } ? Value extends object ? Collection<Value> : never : Options extends {
     kind: 'm:n';