@mikro-orm/core 7.1.16-dev.6 → 7.1.16-dev.8

package/EntityManager.js

@@ -383,6 +383,7 @@ export class EntityManager {
                 filters,
                 populate: hint.children,
                 populateWhere: PopulateHint.ALL,
+                populateFilter: undefined,
             });
             if (Utils.hasObjectKeys(where)) {
                 ret[field] = ret[field] ? { $and: [where, ret[field]] } : where;

package/drivers/DatabaseDriver.js

@@ -184,8 +184,14 @@ export class DatabaseDriver {
                 }, {});
                 return { [prop]: value };
             }
-            const desc = direction === QueryOrderNumeric.DESC || direction.toString().toLowerCase() === 'desc';
-            const dir = Utils.xor(desc, isLast) ? 'desc' : 'asc';
+            const dirStr = direction.toString().toLowerCase();
+            const desc = direction === QueryOrderNumeric.DESC || dirStr.startsWith('desc');
+            let dir = Utils.xor(desc, isLast) ? 'desc' : 'asc';
+            const nullsFirst = dirStr.includes('nulls first');
+            // backward pagination reverses the whole ordering, so the nulls placement flips with the direction
+            if (nullsFirst || dirStr.includes('nulls last')) {
+                dir += Utils.xor(nullsFirst, isLast) ? ' nulls first' : ' nulls last';
+            }
             return { [prop]: dir };
         };
         // the cursor condition is created at the driver level, after the EM already converted custom types
@@ -251,10 +257,12 @@ export class DatabaseDriver {
                     Object.assign(o, createCondition(key, direction[key], offset?.[key], eq, `${path}.${key}`, childProps ?? {}, insideJson));
                     return o;
                 }, {});
-                return { [prop]: value };
+                // an unconstrained group must stay unconstrained, an empty object condition would instead
+                // match only rows where every child value is null (e.g. object embeddables)
+                return Utils.hasObjectKeys(value) ? { [prop]: value } : {};
             }
-            const isDesc = direction === QueryOrderNumeric.DESC || direction.toString().toLowerCase() === 'desc';
             const dirStr = direction.toString().toLowerCase();
+            const isDesc = direction === QueryOrderNumeric.DESC || dirStr.startsWith('desc');
             let nullsFirst;
             if (dirStr.includes('nulls first')) {
                 nullsFirst = true;
@@ -274,13 +282,14 @@ export class DatabaseDriver {
             offset = this.mapCursorOffset(propMeta, offset, insideJson);
             // Handle null offset (intentional null cursor value)
             if (offset === null) {
+                // hasItemsAfterNull: forward + nullsFirst, or backward + nullsLast
+                const hasItemsAfterNull = Utils.xor(nullsFirst, inverse);
                 if (eq) {
-                    // Equal to null
-                    return { [prop]: null };
+                    // the `>=` half of the keyset condition: every row when the nulls come first in this
+                    // direction, only the null ones when they come last
+                    return hasItemsAfterNull ? {} : { [prop]: null };
                 }
                 // Strict comparison with null cursor value
-                // hasItemsAfterNull: forward + nullsFirst, or backward + nullsLast
-                const hasItemsAfterNull = Utils.xor(nullsFirst, inverse);
                 if (hasItemsAfterNull) {
                     return { [prop]: { $ne: null } };
                 }
@@ -422,8 +431,8 @@ export class DatabaseDriver {
                 const props = prop.embeddedProps;
                 let unknownProp = false;
                 Object.keys(data[prop.name]).forEach(kk => {
-                    // explicitly allow `$exists`, `$eq`, `$ne` and `$elemMatch` operators here as they can't be misused this way
-                    const operator = Object.keys(data[prop.name]).some(f => Utils.isOperator(f) && !['$exists', '$ne', '$eq', '$elemMatch'].includes(f));
+                    // explicitly allow `$exists`, `$eq`, `$ne`, `$elemMatch` and `$all` operators here as they can't be misused this way
+                    const operator = Object.keys(data[prop.name]).some(f => Utils.isOperator(f) && !['$exists', '$ne', '$eq', '$elemMatch', '$all'].includes(f));
                     if (operator) {
                         throw ValidationError.cannotUseOperatorsInsideEmbeddables(meta.class, prop.name, data);
                     }

package/entity/EntityLoader.d.ts

@@ -1,4 +1,4 @@
-import type { AnyEntity, AutoPath, ConnectionType, EntityName, EntityProperty, FilterQuery, PopulateHintOptions, PopulateOptions } from '../typings.js';
+import type { AnyEntity, AutoPath, ConnectionType, EntityName, EntityProperty, FilterQuery, ObjectQuery, PopulateHintOptions, PopulateOptions } from '../typings.js';
 import type { EntityManager } from '../EntityManager.js';
 import { LoadStrategy, type LockMode, type PopulateHint, PopulatePath, type QueryOrderMap } from '../enums.js';
 import type { InflightQueryAbortStrategy } from '../connections/Connection.js';
@@ -14,6 +14,8 @@ export interface EntityLoaderOptions<Entity, Fields extends string = never, Excl
     where?: FilterQuery<Entity>;
     /** Controls how `where` conditions are applied to populated relations. */
     populateWhere?: PopulateHint | `${PopulateHint}`;
+    /** @see FindOptions.populateFilter */
+    populateFilter?: ObjectQuery<Entity>;
     /** Ordering for populated relations. */
     orderBy?: QueryOrderMap<Entity> | QueryOrderMap<Entity>[];
     /** Whether to reload already loaded entities. */
@@ -77,6 +79,10 @@ export declare class EntityLoader {
     /** @internal */
     findChildrenFromPivotTable<Entity extends object>(filtered: Entity[], prop: EntityProperty<Entity>, options: Required<EntityLoaderOptions<Entity>>, orderBy?: QueryOrderMap<Entity>[], populate?: PopulateOptions<Entity>, pivotJoin?: boolean): Promise<AnyEntity[][]>;
     private extractChildCondition;
+    /** Extracts the part of `options.populateFilter` that applies to the given relation. */
+    private extractChildPopulateFilter;
+    /** Splits an extracted populate filter into the conditions on the populated entity and those on its own relations. */
+    private splitPopulateFilter;
     private buildFields;
     private getChildReferences;
     private filterCollections;

package/entity/EntityLoader.js

@@ -334,7 +334,7 @@ export class EntityLoader {
         // When targetKey is set, use it for FK lookup instead of the PK
         let fk = prop.targetKey ?? Utils.getPrimaryKeyHash(meta.primaryKeys);
         let schema = options.schema;
-        const partial = !Utils.isEmpty(prop.where) || !Utils.isEmpty(options.where);
+        const partial = !Utils.isEmpty(prop.where) || !Utils.isEmpty(options.where) || !Utils.isEmpty(options.populateFilter);
         let polymorphicOwnerProp;
         const ownerProp = prop.kind === ReferenceKind.ONE_TO_MANY || (prop.kind === ReferenceKind.MANY_TO_MANY && !prop.owner)
             ? meta.properties[prop.mappedBy]
@@ -394,12 +394,20 @@ export class EntityLoader {
         if (!Utils.isEmpty(prop.where) || Raw.hasObjectFragments(prop.where)) {
             where = { $and: [where, prop.where] };
         }
+        const childFilter = options.populateFilter ? await this.extractChildPopulateFilter(options, prop) : undefined;
+        // conditions on the populated entity itself have no sink in the child query (the joined strategy puts
+        // them on the join), only the nested relation ones can be forwarded as its own `populateFilter`
+        const [ownFilter, nestedFilter] = this.splitPopulateFilter(childFilter, meta);
+        if (ownFilter) {
+            where = { $and: [where, ownFilter] };
+        }
         const orderBy = QueryHelper.mergeOrderBy(options.orderBy, prop.orderBy);
         const findOptions = {
             filters,
             convertCustomTypes,
             lockMode,
             populateWhere,
+            populateFilter: nestedFilter,
             logging,
             orderBy,
             populate: populate.children ?? populate.all ?? [],
@@ -575,6 +583,9 @@ export class EntityLoader {
                 filters,
                 ignoreLazyScalarProperties,
                 populateWhere,
+                populateFilter: options.populateFilter
+                    ? (await this.extractChildPopulateFilter(options, prop))
+                    : undefined,
                 connectionType,
                 logging,
                 schema,
@@ -611,7 +622,7 @@ export class EntityLoader {
         const fields = this.buildFields(options.fields, prop);
         // oxfmt-ignore
         const exclude = Array.isArray(options.exclude) ? Utils.extractChildElements(options.exclude, prop.name) : options.exclude;
-        const populateFilter = options.populateFilter?.[prop.name];
+        const populateFilter = options.populateFilter ? await this.extractChildPopulateFilter(options, prop) : undefined;
         const options2 = { ...options, fields, exclude, populateFilter };
         ['limit', 'offset', 'first', 'last', 'before', 'after', 'overfetch'].forEach(prop => delete options2[prop]);
         options2.populate = populate?.children ?? [];
@@ -656,7 +667,8 @@ export class EntityLoader {
     }
     async extractChildCondition(options, prop, filters = false) {
         const where = options.where;
-        const subCond = Utils.isPlainObject(where[prop.name]) ? where[prop.name] : {};
+        // shallow copy, the operator normalization below must not mutate the caller's condition
+        const subCond = Utils.isPlainObject(where[prop.name]) ? { ...where[prop.name] } : {};
         const meta2 = prop.targetMeta;
         const pk = Utils.getPrimaryKeyHash(meta2.primaryKeys);
         ['$and', '$or'].forEach(op => {
@@ -679,8 +691,8 @@ export class EntityLoader {
         });
         const operators = Object.keys(subCond).filter(key => Utils.isOperator(key, false));
         if (operators.length > 0) {
+            subCond[pk] = Utils.isPlainObject(subCond[pk]) ? { ...subCond[pk] } : (subCond[pk] ?? {});
             operators.forEach(op => {
-                subCond[pk] ??= {};
                 subCond[pk][op] = subCond[op];
                 delete subCond[op];
             });
@@ -690,6 +702,24 @@ export class EntityLoader {
         }
         return subCond;
     }
+    /** Extracts the part of `options.populateFilter` that applies to the given relation. */
+    async extractChildPopulateFilter(options, prop) {
+        const filter = await this.extractChildCondition({ ...options, where: options.populateFilter }, prop);
+        return Utils.isEmpty(filter) ? undefined : filter;
+    }
+    /** Splits an extracted populate filter into the conditions on the populated entity and those on its own relations. */
+    splitPopulateFilter(filter, meta) {
+        if (!filter) {
+            return [undefined, undefined];
+        }
+        const own = {};
+        const nested = {};
+        for (const key of Object.keys(filter)) {
+            const target = meta.relations.some(rel => rel.name === key) ? nested : own;
+            target[key] = filter[key];
+        }
+        return [Utils.isEmpty(own) ? undefined : own, Utils.isEmpty(nested) ? undefined : nested];
+    }
     buildFields(fields = [], prop, ref) {
         if (ref) {
             fields = prop.targetMeta.primaryKeys.map(targetPkName => `${prop.name}.${targetPkName}`);

package/enums.d.ts

@@ -39,6 +39,8 @@ export declare enum QueryOperator {
     $in = "in",
     /** Not included in the given list. */
     $nin = "not in",
+    /** Contains all of the given values, supported on collection properties and on mongo arrays. */
+    $all = "all",
     /** Greater than. */
     $gt = ">",
     /** Greater than or equal to. */

package/enums.js

@@ -41,6 +41,8 @@ export var QueryOperator;
     QueryOperator["$in"] = "in";
     /** Not included in the given list. */
     QueryOperator["$nin"] = "not in";
+    /** Contains all of the given values, supported on collection properties and on mongo arrays. */
+    QueryOperator["$all"] = "all";
     /** Greater than. */
     QueryOperator["$gt"] = ">";
     /** Greater than or equal to. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.1.16-dev.6",
+  "version": "7.1.16-dev.8",
   "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.",
   "keywords": [
     "data-mapper",

package/typings.d.ts

@@ -314,6 +314,7 @@ export type OperatorMap<T> = {
     $ne?: ExpandScalar<T> | readonly ExpandScalar<T>[] | Subquery;
     $in?: readonly ExpandScalar<T>[] | readonly Primary<T>[] | Raw | Subquery;
     $nin?: readonly ExpandScalar<T>[] | readonly Primary<T>[] | Raw | Subquery;
+    $all?: readonly ExpandQuery<T>[];
     $not?: ExpandQuery<T>;
     $none?: ExpandQuery<T>;
     $some?: ExpandQuery<T>;

package/utils/Utils.js

@@ -153,7 +153,7 @@ export function parseJsonSafe(value) {
 /** Collection of general-purpose utility methods used throughout the ORM. */
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.1.16-dev.6';
+    static #ORM_VERSION = '7.1.16-dev.8';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */