@mikro-orm/core 7.0.0-dev.291 → 7.0.0-dev.293

package/EntityManager.d.ts

@@ -121,6 +121,7 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
     }): T;
     setFlushMode(flushMode?: FlushMode | `${FlushMode}`): void;
     protected processWhere<Entity extends object, Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(entityName: EntityName<Entity>, where: FilterQuery<Entity>, options: FindOptions<Entity, Hint, Fields, Excludes> | FindOneOptions<Entity, Hint, Fields, Excludes>, type: 'read' | 'update' | 'delete'): Promise<FilterQuery<Entity>>;
+    protected processUnionWhere<Entity extends object, Hint extends string = never>(entityName: EntityName<Entity>, options: FindOptions<Entity, Hint, any, any> | CountOptions<Entity, Hint> | UpdateOptions<Entity> | DeleteOptions<Entity>, type: 'read' | 'update' | 'delete'): Promise<void>;
     protected applyDiscriminatorCondition<Entity extends object>(entityName: EntityName<Entity>, 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>, options: FindOptions<Entity, any, any, any> | FindOneOptions<Entity, any, any, any>): Promise<ObjectQuery<Entity> | undefined>;

package/EntityManager.js

@@ -141,6 +141,7 @@ export class EntityManager {
         options._populateWhere = options.populateWhere ?? this.config.get('populateWhere');
         options.populateWhere = this.createPopulateWhere({ ...where }, options);
         options.populateFilter = await this.getJoinedFilters(meta, options);
+        await em.processUnionWhere(entityName, options, 'read');
         const results = await em.driver.find(entityName, where, { ctx: em.transactionContext, em, ...options });
         if (results.length === 0) {
             await em.storeCache(options.cache, cached, []);
@@ -298,6 +299,14 @@ export class EntityManager {
         where = this.applyDiscriminatorCondition(entityName, where);
         return where;
     }
+    async processUnionWhere(entityName, options, type) {
+        if (options.unionWhere?.length) {
+            if (!this.driver.getPlatform().supportsUnionWhere()) {
+                throw new Error(`unionWhere is only supported on SQL drivers`);
+            }
+            options.unionWhere = await Promise.all(options.unionWhere.map(branch => this.processWhere(entityName, branch, options, type)));
+        }
+    }
     // this method only handles the problem for mongo driver, SQL drivers have their implementation inside QueryBuilder
     applyDiscriminatorCondition(entityName, where) {
         const meta = this.metadata.find(entityName);
@@ -642,6 +651,7 @@ export class EntityManager {
         options._populateWhere = options.populateWhere ?? this.config.get('populateWhere');
         options.populateWhere = this.createPopulateWhere({ ...where }, options);
         options.populateFilter = await this.getJoinedFilters(meta, options);
+        await em.processUnionWhere(entityName, options, 'read');
         const data = await em.driver.findOne(entityName, where, {
             ctx: em.transactionContext,
             em,
@@ -1188,11 +1198,12 @@ export class EntityManager {
     async nativeUpdate(entityName, where, data, options = {}) {
         const em = this.getContext(false);
         em.prepareOptions(options);
+        await em.processUnionWhere(entityName, options, 'update');
         data = QueryHelper.processObjectParams(data);
         where = await em.processWhere(entityName, where, { ...options, convertCustomTypes: false }, 'update');
         validateParams(data, 'update data');
         validateParams(where, 'update condition');
-        const res = await em.driver.nativeUpdate(entityName, where, data, { ctx: em.transactionContext, ...options });
+        const res = await em.driver.nativeUpdate(entityName, where, data, { ctx: em.transactionContext, em, ...options });
         return res.affectedRows;
     }
     /**
@@ -1201,9 +1212,10 @@ export class EntityManager {
     async nativeDelete(entityName, where, options = {}) {
         const em = this.getContext(false);
         em.prepareOptions(options);
+        await em.processUnionWhere(entityName, options, 'delete');
         where = await em.processWhere(entityName, where, options, 'delete');
         validateParams(where, 'delete condition');
-        const res = await em.driver.nativeDelete(entityName, where, { ctx: em.transactionContext, ...options });
+        const res = await em.driver.nativeDelete(entityName, where, { ctx: em.transactionContext, em, ...options });
         return res.affectedRows;
     }
     /**
@@ -1322,6 +1334,7 @@ export class EntityManager {
         options.populateFilter = await this.getJoinedFilters(meta, options);
         validateParams(where);
         delete options.orderBy;
+        await em.processUnionWhere(entityName, options, 'read');
         const cacheKey = em.cacheKey(entityName, options, 'em.count', where);
         const cached = await em.tryCache(entityName, options.cache, cacheKey);
         if (cached?.data !== undefined) {

package/drivers/IDatabaseDriver.d.ts

@@ -110,6 +110,22 @@ export interface FindOptions<Entity, Hint extends string = never, Fields extends
      * when nesting the condition. This is used for implementation of joined filters.
      */
     populateFilter?: ObjectQuery<Entity>;
+    /**
+     * Index-friendly alternative to `$or` for conditions that span joined relations.
+     * Each array element becomes an independent branch combined via `UNION ALL` subquery:
+     * `WHERE pk IN (branch_1 UNION ALL branch_2 ... branch_N)`.
+     * The database plans each branch independently, enabling per-table index usage
+     * (e.g. GIN trigram indexes for fuzzy search across related entities).
+     * sql only
+     */
+    unionWhere?: ObjectQuery<Entity>[];
+    /**
+     * Strategy for combining `unionWhere` branches.
+     * - `'union-all'` (default) — skips deduplication, faster for most use cases.
+     * - `'union'` — deduplicates rows between branches; useful when branch overlap is very high.
+     * sql only
+     */
+    unionWhereStrategy?: 'union-all' | 'union';
     /** Used for ordering of the populate queries. If not specified, the value of `options.orderBy` is used. */
     populateOrderBy?: OrderDefinition<Entity>;
     /** Per-relation overrides for populate loading behavior. Keys are populate paths (same as used in `populate`). */
@@ -199,6 +215,13 @@ export interface NativeInsertUpdateOptions<T> {
     /** `nativeUpdate()` only option */
     upsert?: boolean;
     loggerContext?: LogContext;
+    /** sql only */
+    unionWhere?: ObjectQuery<T>[];
+    /** sql only */
+    unionWhereStrategy?: 'union-all' | 'union';
+    filters?: FilterOptions;
+    /** @internal */
+    em?: EntityManager;
 }
 export interface NativeInsertUpdateManyOptions<T> extends NativeInsertUpdateOptions<T> {
     processCollections?: boolean;
@@ -223,6 +246,10 @@ export interface CountOptions<T extends object, P extends string = never> {
     populate?: Populate<T, P>;
     populateWhere?: ObjectQuery<T> | PopulateHint | `${PopulateHint}`;
     populateFilter?: ObjectQuery<T>;
+    /** @see FindOptions.unionWhere */
+    unionWhere?: ObjectQuery<T>[];
+    /** @see FindOptions.unionWhereStrategy */
+    unionWhereStrategy?: 'union-all' | 'union';
     ctx?: Transaction;
     connectionType?: ConnectionType;
     flushMode?: FlushMode | `${FlushMode}`;
@@ -245,12 +272,28 @@ export interface UpdateOptions<T> {
     filters?: FilterOptions;
     schema?: string;
     ctx?: Transaction;
+    /** sql only */
+    unionWhere?: ObjectQuery<T>[];
+    /** sql only */
+    unionWhereStrategy?: 'union-all' | 'union';
 }
 export interface DeleteOptions<T> extends DriverMethodOptions {
     filters?: FilterOptions;
+    /** sql only */
+    unionWhere?: ObjectQuery<T>[];
+    /** sql only */
+    unionWhereStrategy?: 'union-all' | 'union';
+    /** @internal */
+    em?: EntityManager;
 }
 export interface NativeDeleteOptions<T> extends DriverMethodOptions {
     filters?: FilterOptions;
+    /** sql only */
+    unionWhere?: ObjectQuery<T>[];
+    /** sql only */
+    unionWhereStrategy?: 'union-all' | 'union';
+    /** @internal */
+    em?: EntityManager;
 }
 export interface LockOptions extends DriverMethodOptions {
     lockMode?: LockMode;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.291",
+  "version": "7.0.0-dev.293",
   "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.",
   "exports": {
     "./package.json": "./package.json",

package/platforms/Platform.d.ts

@@ -140,6 +140,7 @@ export declare abstract class Platform {
     getDefaultMappedType(type: string): Type<unknown>;
     supportsMultipleCascadePaths(): boolean;
     supportsMultipleStatements(): boolean;
+    supportsUnionWhere(): boolean;
     getArrayDeclarationSQL(): string;
     marshallArray(values: string[]): string;
     unmarshallArray(value: string): string[];

package/platforms/Platform.js

@@ -235,6 +235,9 @@ export class Platform {
     supportsMultipleStatements() {
         return this.config.get('multipleStatements');
     }
+    supportsUnionWhere() {
+        return false;
+    }
     getArrayDeclarationSQL() {
         return 'text';
     }

package/utils/Utils.js

@@ -123,7 +123,7 @@ export function parseJsonSafe(value) {
 }
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.0.0-dev.291';
+    static #ORM_VERSION = '7.0.0-dev.293';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */