@mikro-orm/core 7.2.7-dev.6 → 7.2.7-dev.7

package/EntityManager.js

@@ -743,10 +743,15 @@ export class EntityManager {
         if (Utils.isEmpty(options.orderBy) && !Raw.hasObjectFragments(options.orderBy)) {
             throw new Error('Explicit `orderBy` option required');
         }
+        const meta = this.metadata.get(entityName);
+        // same merge as em.find, so the cursor and the query see the same orderBy
+        if (meta.orderBy) {
+            options.orderBy = QueryHelper.mergeOrderBy(options.orderBy, meta.orderBy);
+        }
         const [entities, count] = options.includeCount !== false
             ? await em.findAndCount(entityName, options.where, options)
             : [await em.find(entityName, options.where, options)];
-        return new Cursor(entities, count, options, this.metadata.get(entityName));
+        return new Cursor(entities, count, options, meta);
     }
     /**
      * Refreshes the persistent state of an entity from the database, overriding any local changes that have not yet been

package/entity/EntityLoader.js

@@ -679,12 +679,20 @@ export class EntityLoader {
         const subCond = Utils.isPlainObject(where[prop.name]) ? { ...where[prop.name] } : {};
         const meta2 = prop.targetMeta;
         const pk = Utils.getPrimaryKeyHash(meta2.primaryKeys);
+        // `$not` wrapping entity conditions stays on the target entity, only operators on the relation itself map to its PK
+        const isRelationOperator = (key, value) => {
+            if (key === '$not' && Utils.isPlainObject(value)) {
+                return Utils.getObjectQueryKeys(value).every(k => Utils.isOperator(k, false));
+            }
+            return Utils.isOperator(key, false);
+        };
         ['$and', '$or'].forEach(op => {
             if (where[op]) {
                 const child = where[op]
                     .map((cond) => cond[prop.name])
                     .filter((sub) => sub != null &&
-                    !(Utils.isPlainObject(sub) && Utils.getObjectQueryKeys(sub).every(key => Utils.isOperator(key, false))))
+                    !(Utils.isPlainObject(sub) &&
+                        Utils.getObjectQueryKeys(sub).every(key => isRelationOperator(key, sub[key]))))
                     .map((cond) => {
                     if (Utils.isPrimaryKey(cond)) {
                         return { [pk]: cond };
@@ -697,7 +705,7 @@ export class EntityLoader {
                 }
             }
         });
-        const operators = Object.keys(subCond).filter(key => Utils.isOperator(key, false));
+        const operators = Object.keys(subCond).filter(key => isRelationOperator(key, subCond[key]));
         if (operators.length > 0) {
             subCond[pk] = Utils.isPlainObject(subCond[pk]) ? { ...subCond[pk] } : (subCond[pk] ?? {});
             operators.forEach(op => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.2.7-dev.6",
+  "version": "7.2.7-dev.7",
   "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/platforms/Platform.d.ts

@@ -204,6 +204,8 @@ export declare abstract class Platform {
     supportsUnionWhere(): boolean;
     /** Returns the SQL type declaration used for array storage. */
     getArrayDeclarationSQL(): string;
+    /** Whether array columns support the `&&` (overlap) operator. */
+    supportsArrayOverlap(): boolean;
     /** Serializes a string array into its database storage format. */
     marshallArray(values: string[]): string;
     /** Deserializes a database-stored array string back into a string array. */

package/platforms/Platform.js

@@ -360,6 +360,10 @@ export class Platform {
     getArrayDeclarationSQL() {
         return 'text';
     }
+    /** Whether array columns support the `&&` (overlap) operator. */
+    supportsArrayOverlap() {
+        return false;
+    }
     /** Serializes a string array into its database storage format. */
     marshallArray(values) {
         return values.map(v => (/[,",\\]/.test(v) ? JSON.stringify(v) : v)).join(',');

package/typings.d.ts

@@ -356,12 +356,15 @@ type ElemMatchCondition<T extends Record<string, any>> = {
     $and?: ElemMatchCondition<T>[];
     $not?: ElemMatchCondition<T>;
 };
-type ElemMatchFilter<T> = T extends readonly (infer E)[] ? E extends Record<string, any> ? {
+type ArrayFilter<T> = T extends readonly (infer E)[] ? [E] extends [Scalar] ? {
+    $in?: readonly (readonly ExpandScalar<E>[])[];
+    $nin?: readonly (readonly ExpandScalar<E>[])[];
+} : E extends Record<string, any> ? {
     $elemMatch: ElemMatchCondition<E>;
 } : never : never;
 /** Object form of a filter query, mapping entity keys to their filter conditions. */
 export type FilterObject<T> = {
-    -readonly [K in EntityKey<T>]?: ExpandQuery<ExpandProperty<FilterObjectProp<T, K>>> | ExpandQueryMerged<ExpandProperty<FilterObjectProp<T, K>>> | FilterValue<ExpandProperty<FilterObjectProp<T, K>>> | ElemMatchFilter<FilterObjectProp<T, K>> | null;
+    -readonly [K in EntityKey<T>]?: ExpandQuery<ExpandProperty<FilterObjectProp<T, K>>> | ExpandQueryMerged<ExpandProperty<FilterObjectProp<T, K>>> | FilterValue<ExpandProperty<FilterObjectProp<T, K>>> | ArrayFilter<FilterObjectProp<T, K>> | null;
 };
 /** Recursively expands a type into its `FilterQuery` form for nested object filtering. */
 export type ExpandQuery<T> = T extends object ? (T extends Scalar ? never : FilterQuery<T>) : FilterValue<T>;
@@ -381,7 +384,7 @@ export type FilterQuery<T> = ObjectQuery<T> | NonNullable<ExpandScalar<Primary<T
  * Used when `using` option is set in `FindOptions` to enforce type-safe index usage.
  */
 export type IndexFilterQuery<T, Using extends string> = [Using] extends [never] ? FilterQuery<T> : (OperatorMap<T> & {
-    -readonly [K in Extract<EntityKey<T>, IndexColumns<T, Using>>]?: ExpandQuery<ExpandProperty<FilterObjectProp<T, K>>> | ExpandQueryMerged<ExpandProperty<FilterObjectProp<T, K>>> | FilterValue<ExpandProperty<FilterObjectProp<T, K>>> | ElemMatchFilter<FilterObjectProp<T, K>> | null;
+    -readonly [K in Extract<EntityKey<T>, IndexColumns<T, Using>>]?: ExpandQuery<ExpandProperty<FilterObjectProp<T, K>>> | ExpandQueryMerged<ExpandProperty<FilterObjectProp<T, K>>> | FilterValue<ExpandProperty<FilterObjectProp<T, K>>> | ArrayFilter<FilterObjectProp<T, K>> | null;
 }) | NonNullable<ExpandScalar<Primary<T>>> | IndexFilterQuery<T, Using>[];
 /** Replaces `where` and `using` on an options type with index-aware variants when `Using` is specified. */
 export type WithUsingOptions<Opts, Entity, Using extends string> = Omit<Opts, 'where' | 'using'> & {

package/unit-of-work/UnitOfWork.js

@@ -600,19 +600,27 @@ export class UnitOfWork {
                 this.findEarlyUpdates(cs, inserts[cs.meta.uniqueName]);
             }
         }
+        // hashes of the inserts' PKs and unique values per type, built lazily, so matching a removed entity is a set lookup
+        const insertHashes = {};
         for (const entity of this.#removeStack) {
             const wrapped = helper(entity);
             /* v8 ignore next */
             if (wrapped.__processing) {
                 continue;
             }
-            const deletePkHash = [wrapped.getSerializedPrimaryKey(), ...this.expandUniqueProps(entity)];
-            let type = ChangeSetType.DELETE;
-            for (const cs of inserts[wrapped.__meta.uniqueName] ?? []) {
-                if (deletePkHash.some(hash => hash === cs.getSerializedPrimaryKey() || this.expandUniqueProps(cs.entity).find(child => hash === child))) {
-                    type = ChangeSetType.DELETE_EARLY;
+            const uniqueName = wrapped.__meta.uniqueName;
+            let hashes = insertHashes[uniqueName];
+            if (!hashes) {
+                hashes = insertHashes[uniqueName] = new Set();
+                for (const cs of inserts[uniqueName] ?? []) {
+                    hashes.add(cs.getSerializedPrimaryKey());
+                    for (const hash of this.expandUniqueProps(cs.entity)) {
+                        hashes.add(hash);
+                    }
                 }
             }
+            const deletePkHash = [wrapped.getSerializedPrimaryKey(), ...this.expandUniqueProps(entity)];
+            const type = deletePkHash.some(hash => hashes.has(hash)) ? ChangeSetType.DELETE_EARLY : ChangeSetType.DELETE;
             this.computeChangeSet(entity, type);
         }
     }

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.2.7-dev.6';
+    static #ORM_VERSION = '7.2.7-dev.7';
     /** Default session variable name backing an RLS filter argument (`current_setting('mikro.<filter>.<arg>')`). */
     static getRlsSettingName(filterName, argName) {
         return `mikro.${filterName}.${argName}`;