@mikro-orm/core 6.3.9-dev.1 → 6.3.9-dev.3

package/EntityManager.d.ts

@@ -115,7 +115,8 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
     setFlushMode(flushMode?: FlushMode): void;
     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 applyJoinedFilters<Entity extends object>(meta: EntityMetadata<Entity>, cond: ObjectQuery<Entity>, options: FindOptions<Entity, any, any, any> | FindOneOptions<Entity, any, any, any>): Promise<ObjectQuery<Entity>>;
+    protected createPopulateWhere<Entity extends object>(cond: ObjectQuery<Entity>, options: FindOptions<Entity, any, any, any> | FindOneOptions<Entity, any, any, 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>>;
     /**
      * 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.
      */

package/EntityManager.js

@@ -140,7 +140,8 @@ class EntityManager {
         options = { ...options };
         // save the original hint value so we know it was infer/all
         options._populateWhere = options.populateWhere ?? this.config.get('populateWhere');
-        options.populateWhere = await this.applyJoinedFilters(meta, { ...where }, options);
+        options.populateWhere = this.createPopulateWhere({ ...where }, options);
+        options.populateFilter = await this.getJoinedFilters(meta, { ...where }, options);
         const results = await em.driver.find(entityName, where, { ctx: em.transactionContext, ...options });
         if (results.length === 0) {
             await em.storeCache(options.cache, cached, []);
@@ -264,7 +265,7 @@ class EntityManager {
         where[meta.root.discriminatorColumn] = children.length > 0 ? { $in: [meta.discriminatorValue, ...children.map(c => c.discriminatorValue)] } : meta.discriminatorValue;
         return where;
     }
-    async applyJoinedFilters(meta, cond, options) {
+    createPopulateWhere(cond, options) {
         const ret = {};
         const populateWhere = options.populateWhere ?? this.config.get('populateWhere');
         if (populateWhere === enums_1.PopulateHint.INFER) {
@@ -273,6 +274,10 @@ class EntityManager {
         else if (typeof populateWhere === 'object') {
             utils_1.Utils.merge(ret, populateWhere);
         }
+        return ret;
+    }
+    async getJoinedFilters(meta, cond, options) {
+        const ret = {};
         if (options.populate) {
             for (const hint of options.populate) {
                 const field = hint.field.split(':')[0];
@@ -282,7 +287,7 @@ class EntityManager {
                     continue;
                 }
                 const where = await this.applyFilters(prop.type, {}, options.filters ?? {}, 'read', { ...options, populate: hint.children });
-                const where2 = await this.applyJoinedFilters(prop.targetMeta, {}, { ...options, populate: hint.children, populateWhere: enums_1.PopulateHint.ALL });
+                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;
                 }
@@ -531,7 +536,8 @@ class EntityManager {
         options = { ...options };
         // save the original hint value so we know it was infer/all
         options._populateWhere = options.populateWhere ?? this.config.get('populateWhere');
-        options.populateWhere = await this.applyJoinedFilters(meta, { ...where }, options);
+        options.populateWhere = this.createPopulateWhere({ ...where }, options);
+        options.populateFilter = await this.getJoinedFilters(meta, { ...where }, options);
         const data = await em.driver.findOne(entityName, where, {
             ctx: em.transactionContext,
             ...options,

package/drivers/IDatabaseDriver.d.ts

@@ -74,11 +74,36 @@ export interface LoadHint<Entity, Hint extends string = never, Fields extends st
     exclude?: readonly AutoPath<Entity, Excludes>[];
 }
 export interface FindOptions<Entity, Hint extends string = never, Fields extends string = PopulatePath.ALL, Excludes extends string = never> extends LoadHint<Entity, Hint, Fields, Excludes> {
+    /**
+     * Where condition for populated relations. This will have no effect on the root entity.
+     * With `select-in` strategy, this is applied only to the populate queries.
+     * With `joined` strategy, those are applied as `join on` conditions.
+     * When you use a nested condition on a to-many relation, it will produce a nested inner join,
+     * discarding the collection items based on the child condition.
+     */
     populateWhere?: ObjectQuery<Entity> | PopulateHint | `${PopulateHint}`;
+    /**
+     * Filter condition for populated relations. This is similar to `populateWhere`, but will produce a `left join`
+     * when nesting the condition. This is used for implementation of joined filters.
+     */
+    populateFilter?: ObjectQuery<Entity> | PopulateHint | `${PopulateHint}`;
+    /** Used for ordering of the populate queries. If not specified, the value of `options.orderBy` is used. */
     populateOrderBy?: OrderDefinition<Entity>;
+    /** Ordering of the results.Can be an object or array of objects, keys are property names, values are ordering (asc/desc) */
     orderBy?: OrderDefinition<Entity>;
+    /** Control result caching for this query. Result cache is by default disabled, not to be confused with the identity map. */
     cache?: boolean | number | [string, number];
+    /**
+     * Limit the number of returned results. If you try to use limit/offset on a query that joins a to-many relation, pagination mechanism
+     * will be triggered, resulting in a subquery condition, to apply this limit only to the root entities
+     * instead of the cartesian product you get from a database in this case.
+     */
     limit?: number;
+    /**
+     * Sets the offset. If you try to use limit/offset on a query that joins a to-many relation, pagination mechanism
+     * will be triggered, resulting in a subquery condition, to apply this limit only to the root entities
+     * instead of the cartesian product you get from a database in this case.
+     */
     offset?: number;
     /** Fetch items `before` this cursor. */
     before?: string | {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "6.3.9-dev.1",
+  "version": "6.3.9-dev.3",
   "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.2.0",
     "globby": "11.1.0",
-    "mikro-orm": "6.3.9-dev.1",
+    "mikro-orm": "6.3.9-dev.3",
     "reflect-metadata": "0.2.2"
   }
 }

package/utils/QueryHelper.d.ts

@@ -12,6 +12,7 @@ export declare class QueryHelper {
     static processCustomType<T extends object>(prop: EntityProperty<T>, cond: FilterQuery<T>, platform: Platform, key?: string, fromQuery?: boolean): FilterQuery<T>;
     private static isSupportedOperator;
     private static processJsonCondition;
+    private static getValueType;
     static findProperty<T>(fieldName: string, options: ProcessWhereOptions<T>): EntityProperty<T> | undefined;
 }
 interface ProcessWhereOptions<T> {

package/utils/QueryHelper.js

@@ -197,7 +197,7 @@ class QueryHelper {
         return prop.customType.convertToDatabaseValue(cond, platform, { fromQuery, key, mode: 'query' });
     }
     static isSupportedOperator(key) {
-        return !!QueryHelper.SUPPORTED_OPERATORS.find(op => key.includes(op));
+        return !!QueryHelper.SUPPORTED_OPERATORS.find(op => key === op);
     }
     static processJsonCondition(o, value, path, platform, alias) {
         if (Utils_1.Utils.isPlainObject(value) && !Object.keys(value).some(k => Utils_1.Utils.isOperator(k))) {
@@ -210,12 +210,20 @@ class QueryHelper {
             o[path[0]] = value;
             return o;
         }
-        const operatorObject = Utils_1.Utils.isPlainObject(value) && Object.keys(value).every(k => Utils_1.Utils.isOperator(k));
-        const type = operatorObject ? typeof Object.values(value)[0] : typeof value;
+        const type = this.getValueType(value);
         const k = platform.getSearchJsonPropertyKey(path, type, alias, value);
         o[k] = value;
         return o;
     }
+    static getValueType(value) {
+        if (Array.isArray(value)) {
+            return typeof value[0];
+        }
+        if (Utils_1.Utils.isPlainObject(value) && Object.keys(value).every(k => Utils_1.Utils.isOperator(k))) {
+            return this.getValueType(Object.values(value)[0]);
+        }
+        return typeof value;
+    }
     static findProperty(fieldName, options) {
         const parts = fieldName.split('.');
         const propName = parts.pop();