@mikro-orm/core 6.5.10-dev.23 → 6.5.10-dev.25

package/EntityManager.d.ts

@@ -3,7 +3,7 @@ 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 { 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';
@@ -130,7 +130,7 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
     /**
      * @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

@@ -290,12 +290,14 @@ class EntityManager {
             if (!joined && !hint.filter) {
                 continue;
             }
-            const where = await this.applyFilters(prop.type, {}, options.filters ?? {}, 'read', {
+            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,
             });
@@ -328,7 +330,8 @@ class EntityManager {
                 || (parent?.className === prop.targetMeta.root.className && parent.propName === prop.inversedBy)) {
                 continue;
             }
-            const cond = await this.applyFilters(prop.type, {}, options.filters ?? {}, 'read', options);
+            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;
@@ -383,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}'`);
                 }

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> {
     /**
@@ -242,6 +243,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/EntityHelper.js

@@ -175,6 +175,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;
@@ -310,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';
@@ -134,6 +135,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.
      *
@@ -511,10 +516,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';

package/entity/defineEntity.js

@@ -126,6 +126,12 @@ class UniversalPropertyOptionsBuilder {
     defaultRaw(defaultRaw) {
         return this.assignOptions({ defaultRaw });
     }
+    /**
+     * Allow controlling `filters` option. This will be overridden with `em.fork` or `FindOptions` if provided.
+     */
+    filters(filters) {
+        return this.assignOptions({ filters });
+    }
     /**
      * Set to map some SQL snippet for the entity.
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "6.5.10-dev.23",
+  "version": "6.5.10-dev.25",
   "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.23",
+    "mikro-orm": "6.5.10-dev.25",
     "reflect-metadata": "0.2.2"
   }
 }

package/typings.d.ts

@@ -10,7 +10,7 @@ import type { Configuration, RawQueryFragment } from './utils';
 import type { EntityManager } from './EntityManager';
 import type { EmbeddedPrefixMode } from './decorators/Embedded';
 import type { EventSubscriber } from './events';
-import type { FindOneOptions, FindOptions, LoadHint } from './drivers';
+import type { FilterOptions, FindOneOptions, FindOptions, LoadHint } from './drivers';
 export type Constructor<T = unknown> = new (...args: any[]) => T;
 export type Dictionary<T = any> = {
     [k: string]: T;
@@ -351,6 +351,7 @@ export interface EntityProperty<Owner = any, Target = any> {
     default?: string | number | boolean | null;
     defaultRaw?: string;
     formula?: (alias: string) => string;
+    filters?: FilterOptions;
     prefix?: string | boolean;
     prefixMode?: EmbeddedPrefixMode;
     embedded?: [EntityKey<Owner>, EntityKey<Owner>];

package/utils/QueryHelper.d.ts

@@ -1,6 +1,7 @@
 import type { Dictionary, EntityMetadata, EntityProperty, FilterDef, FilterQuery } from '../typings';
 import type { Platform } from '../platforms';
 import type { MetadataStorage } from '../metadata/MetadataStorage';
+import type { FilterOptions } from '../drivers/IDatabaseDriver';
 /** @internal */
 export declare class QueryHelper {
     static readonly SUPPORTED_OPERATORS: string[];
@@ -13,7 +14,8 @@ export declare class QueryHelper {
     static liftGroupOperators<T extends object>(where: Dictionary, meta: EntityMetadata<T>, metadata: MetadataStorage, key?: string): string | undefined;
     static inlinePrimaryKeyObjects<T extends object>(where: Dictionary, meta: EntityMetadata<T>, metadata: MetadataStorage, key?: string): boolean;
     static processWhere<T extends object>(options: ProcessWhereOptions<T>): FilterQuery<T>;
-    static getActiveFilters(entityName: string, options: Dictionary<boolean | Dictionary> | string[] | boolean, filters: Dictionary<FilterDef>): FilterDef[];
+    static getActiveFilters(entityName: string, options: FilterOptions | undefined, filters: Dictionary<FilterDef>): FilterDef[];
+    static mergePropertyFilters(propFilters: FilterOptions | undefined, options: FilterOptions | undefined): FilterOptions | undefined;
     static isFilterActive(entityName: string, filterName: string, filter: FilterDef, options: Dictionary<boolean | Dictionary>): boolean;
     static processCustomType<T extends object>(prop: EntityProperty<T>, cond: FilterQuery<T>, platform: Platform, key?: string, fromQuery?: boolean): FilterQuery<T>;
     private static isSupportedOperator;

package/utils/QueryHelper.js

@@ -205,6 +205,24 @@ class QueryHelper {
             return filters[f];
         });
     }
+    static mergePropertyFilters(propFilters, options) {
+        if (!options || !propFilters || options === true || propFilters === true) {
+            return options ?? propFilters;
+        }
+        if (Array.isArray(propFilters)) {
+            propFilters = propFilters.reduce((o, item) => {
+                o[item] = true;
+                return o;
+            }, {});
+        }
+        if (Array.isArray(options)) {
+            options = options.reduce((o, item) => {
+                o[item] = true;
+                return o;
+            }, {});
+        }
+        return Utils_1.Utils.mergeConfig({}, propFilters, options);
+    }
     static isFilterActive(entityName, filterName, filter, options) {
         if (filter.entity && !filter.entity.includes(entityName)) {
             return false;