@mikro-orm/core 7.0.0-dev.229 → 7.0.0-dev.230

package/EntityManager.js

@@ -117,7 +117,13 @@ export class EntityManager {
         await em.tryFlush(entityName, options);
         where = await em.processWhere(entityName, where, options, 'read');
         validateParams(where);
-        options.orderBy = options.orderBy || {};
+        const meta = this.metadata.get(entityName);
+        if (meta.orderBy) {
+            options.orderBy = QueryHelper.mergeOrderBy(options.orderBy, meta.orderBy);
+        }
+        else {
+            options.orderBy ??= {};
+        }
         options.populate = await em.preparePopulate(entityName, options);
         const populate = options.populate;
         const cacheKey = em.cacheKey(entityName, options, 'em.find', where);
@@ -131,7 +137,6 @@ export class EntityManager {
             });
             return cached.data;
         }
-        const meta = this.metadata.get(entityName);
         options = { ...options };
         // save the original hint value so we know it was infer/all
         options._populateWhere = options.populateWhere ?? this.config.get('populateWhere');

package/entity/Collection.d.ts

@@ -62,7 +62,6 @@ export declare class Collection<T extends object, O extends object = object> {
     init<TT extends T, P extends string = never>(options?: InitCollectionOptions<TT, P>): Promise<LoadedCollection<Loaded<TT, P>>>;
     private getEntityManager;
     private createCondition;
-    private createOrderBy;
     private createManyToManyCondition;
     private createLoadCountCondition;
     private checkInitialized;

package/entity/Collection.js

@@ -4,7 +4,6 @@ import { DataloaderType, ReferenceKind } from '../enums.js';
 import { Reference } from './Reference.js';
 import { helper, wrap } from './wrap.js';
 import { QueryHelper } from '../utils/QueryHelper.js';
-import { Raw } from '../utils/RawQueryFragment.js';
 import { inspect } from '../logging/inspect.js';
 export class Collection {
     owner;
@@ -93,9 +92,10 @@ export class Collection {
     async matching(options) {
         const em = this.getEntityManager();
         const { where, ctx, ...opts } = options;
-        opts.orderBy = this.createOrderBy(opts.orderBy);
         let items;
         if (this.property.kind === ReferenceKind.MANY_TO_MANY && em.getPlatform().usesPivotTable()) {
+            // M:N via pivot table bypasses em.find(), so merge all 3 levels here
+            opts.orderBy = QueryHelper.mergeOrderBy(opts.orderBy, this.property.orderBy, this.property.targetMeta?.orderBy);
             options.populate = await em.preparePopulate(this.property.targetMeta.class, options);
             const cond = await em.applyFilters(this.property.targetMeta.class, where, options.filters ?? {}, 'read');
             const map = await em.getDriver().loadFromPivotTable(this.property, [helper(this.owner).__primaryKeys], cond, opts.orderBy, ctx, options);
@@ -103,6 +103,8 @@ export class Collection {
             await em.populate(items, options.populate, options);
         }
         else {
+            // em.find() merges entity-level orderBy, so only merge runtime + relation here
+            opts.orderBy = QueryHelper.mergeOrderBy(opts.orderBy, this.property.orderBy);
             items = await em.find(this.property.targetMeta.class, this.createCondition(where), opts);
         }
         if (options.store) {
@@ -236,7 +238,7 @@ export class Collection {
         options = { ...options, filters: QueryHelper.mergePropertyFilters(this.property.filters, options.filters) };
         if (options.dataloader ?? [DataloaderType.ALL, DataloaderType.COLLECTION].includes(em.config.getDataloaderType())) {
             const order = [...this.items]; // copy order of references
-            const orderBy = this.createOrderBy(options.orderBy);
+            const orderBy = QueryHelper.mergeOrderBy(options.orderBy, this.property.orderBy, this.property.targetMeta?.orderBy);
             const customOrder = orderBy.length > 0;
             const pivotTable = this.property.kind === ReferenceKind.MANY_TO_MANY && em.getPlatform().usesPivotTable();
             const loader = await em.getDataLoader(pivotTable ? 'm:n' : '1:m');
@@ -300,12 +302,6 @@ export class Collection {
         }
         return cond;
     }
-    createOrderBy(orderBy = []) {
-        if (Utils.isEmpty(orderBy) && !Raw.hasObjectFragments(orderBy) && this.property.orderBy) {
-            orderBy = this.property.orderBy;
-        }
-        return Utils.asArray(orderBy);
-    }
     createManyToManyCondition(cond) {
         const dict = cond;
         if (this.property.owner || this.property.pivotTable) {

package/entity/EntityLoader.js

@@ -141,7 +141,8 @@ export class EntityLoader {
             .flatMap(orderBy => orderBy[prop.name]);
         const where = await this.extractChildCondition(options, prop);
         if (prop.kind === ReferenceKind.MANY_TO_MANY && this.driver.getPlatform().usesPivotTable()) {
-            const res = await this.findChildrenFromPivotTable(filtered, prop, options, innerOrderBy, populate, !!ref);
+            const pivotOrderBy = QueryHelper.mergeOrderBy(innerOrderBy, prop.orderBy, prop.targetMeta?.orderBy);
+            const res = await this.findChildrenFromPivotTable(filtered, prop, options, pivotOrderBy, populate, !!ref);
             return Utils.flatten(res);
         }
         if (prop.polymorphic && prop.polymorphTargets) {
@@ -152,7 +153,8 @@ export class EntityLoader {
             where,
             orderBy: innerOrderBy,
         }, !!(ref || prop.mapToPk));
-        this.initializeCollections(filtered, prop, field, items, innerOrderBy.length > 0, partial);
+        const customOrder = innerOrderBy.length > 0 || !!prop.orderBy || !!prop.targetMeta?.orderBy;
+        this.initializeCollections(filtered, prop, field, items, customOrder, partial);
         return items;
     }
     async populateScalar(meta, filtered, options) {
@@ -327,10 +329,7 @@ export class EntityLoader {
         if (!Utils.isEmpty(prop.where) || Raw.hasObjectFragments(prop.where)) {
             where = { $and: [where, prop.where] };
         }
-        const orderBy = [...Utils.asArray(options.orderBy), ...Utils.asArray(prop.orderBy)].filter((order, idx, array) => {
-            // skip consecutive ordering with the same key to get around mongo issues
-            return idx === 0 || !Utils.equals(Utils.getObjectQueryKeys(array[idx - 1]), Utils.getObjectQueryKeys(order));
-        });
+        const orderBy = QueryHelper.mergeOrderBy(options.orderBy, prop.orderBy);
         const items = await this.em.find(meta.class, where, {
             filters, convertCustomTypes, lockMode, populateWhere, logging,
             orderBy,

package/entity/defineEntity.d.ts

@@ -4,7 +4,7 @@ import type { AnyString, GeneratedColumnCallback, Constructor, CheckCallback, Fi
 import type { Raw } from '../utils/RawQueryFragment.js';
 import type { ScalarReference } from './Reference.js';
 import type { SerializeOptions } from '../serialization/EntitySerializer.js';
-import type { Cascade, DeferMode, EmbeddedPrefixMode, LoadStrategy, QueryOrderMap } from '../enums.js';
+import type { Cascade, DeferMode, EmbeddedPrefixMode, LoadStrategy, QueryOrderKeysFlat, QueryOrderMap } from '../enums.js';
 import type { EventSubscriber } from '../events/EventSubscriber.js';
 import type { IType, Type } from '../types/Type.js';
 import { types } from '../types/index.js';
@@ -419,7 +419,9 @@ declare const propertyBuilders: {
     interval: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
     unknown: () => UniversalPropertyOptionsBuilder<{}, EmptyOptions, IncludeKeysForProperty>;
 };
-export interface EntityMetadataWithProperties<TName extends string, TTableName extends string, TProperties extends Record<string, any>, TPK extends (keyof TProperties)[] | undefined = undefined, TBase = never, TRepository = never> extends Omit<Partial<EntityMetadata<InferEntityFromProperties<TProperties, TPK, TBase, TRepository>>>, 'properties' | 'extends' | 'primaryKeys' | 'hooks' | 'discriminatorColumn' | 'versionProperty' | 'concurrencyCheckKeys' | 'serializedPrimaryKey' | 'indexes' | 'uniques' | 'repository'> {
+/** Own keys + base entity keys (when TBase is not `never`). Guards against `keyof never = string | number | symbol`. */
+type AllKeys<TProperties, TBase> = keyof TProperties | (IsNever<TBase> extends true ? never : keyof TBase);
+export interface EntityMetadataWithProperties<TName extends string, TTableName extends string, TProperties extends Record<string, any>, TPK extends (keyof TProperties)[] | undefined = undefined, TBase = never, TRepository = never> extends Omit<Partial<EntityMetadata<InferEntityFromProperties<TProperties, TPK, TBase, TRepository>>>, 'properties' | 'extends' | 'primaryKeys' | 'hooks' | 'discriminatorColumn' | 'versionProperty' | 'concurrencyCheckKeys' | 'serializedPrimaryKey' | 'indexes' | 'uniques' | 'repository' | 'orderBy'> {
     name: TName;
     tableName?: TTableName;
     extends?: {
@@ -430,10 +432,15 @@ export interface EntityMetadataWithProperties<TName extends string, TTableName e
     hooks?: DefineEntityHooks;
     repository?: () => TRepository;
     inheritance?: 'tpt';
-    discriminatorColumn?: keyof TProperties;
-    versionProperty?: keyof TProperties;
-    concurrencyCheckKeys?: Set<keyof TProperties>;
-    serializedPrimaryKey?: keyof TProperties;
+    orderBy?: {
+        [K in Extract<AllKeys<TProperties, TBase>, string>]?: QueryOrderKeysFlat;
+    } | {
+        [K in Extract<AllKeys<TProperties, TBase>, string>]?: QueryOrderKeysFlat;
+    }[];
+    discriminatorColumn?: string;
+    versionProperty?: AllKeys<TProperties, TBase>;
+    concurrencyCheckKeys?: Set<AllKeys<TProperties, TBase>>;
+    serializedPrimaryKey?: AllKeys<TProperties, TBase>;
     indexes?: {
         properties?: keyof TProperties | (keyof TProperties)[];
         name?: string;

package/metadata/types.d.ts

@@ -11,6 +11,17 @@ export type EntityOptions<T, E = T extends EntityClass<infer P> ? P : T> = {
     schema?: string;
     /** Override default collection/table name. Alias for `tableName`. */
     collection?: string;
+    /**
+     * Set default ordering for this entity. This ordering is applied when:
+     * - Querying the entity directly via `em.find()`, `em.findAll()`, etc.
+     * - Populating the entity as a relation
+     *
+     * All orderings are combined together. Precedence (highest to lowest):
+     * 1. Runtime `FindOptions.orderBy`
+     * 2. Relation-level `@OneToMany({ orderBy })` / `@ManyToMany({ orderBy })`
+     * 3. Entity-level `@Entity({ orderBy })`
+     */
+    orderBy?: QueryOrderMap<E> | QueryOrderMap<E>[];
     /** For {@doclink inheritance-mapping#single-table-inheritance | Single Table Inheritance}. */
     discriminatorColumn?: (T extends EntityClass<infer P> ? keyof P : string) | AnyString;
     /** For {@doclink inheritance-mapping#single-table-inheritance | Single Table Inheritance}. */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.229",
+  "version": "7.0.0-dev.230",
   "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/typings.d.ts

@@ -681,6 +681,11 @@ export interface EntityMetadata<Entity = any, Class extends EntityCtor<Entity> =
     /** For TPT: properties defined only in THIS entity (not inherited from parent). */
     ownProps?: EntityProperty<Entity>[];
     hasTriggers?: boolean;
+    /**
+     * Default ordering for this entity. Applied when querying this entity directly
+     * or when it's populated as a relation. Combined with other orderings based on precedence.
+     */
+    orderBy?: QueryOrderMap<Entity> | QueryOrderMap<Entity>[];
     /** @internal can be used for computed numeric cache keys */
     readonly _id: number;
 }

package/utils/QueryHelper.d.ts

@@ -1,4 +1,5 @@
 import type { Dictionary, EntityMetadata, EntityName, EntityProperty, FilterDef, FilterQuery } from '../typings.js';
+import { type QueryOrderMap } from '../enums.js';
 import type { Platform } from '../platforms/Platform.js';
 import type { MetadataStorage } from '../metadata/MetadataStorage.js';
 import type { FilterOptions } from '../drivers/IDatabaseDriver.js';
@@ -26,6 +27,11 @@ export declare class QueryHelper {
     private static processJsonCondition;
     private static getValueType;
     static findProperty<T>(fieldName: string, options: ProcessWhereOptions<T>): EntityProperty<T> | undefined;
+    /**
+     * Merges multiple orderBy sources with key-level deduplication (first-seen key wins).
+     * RawQueryFragment symbol keys are never deduped (each is unique).
+     */
+    static mergeOrderBy<T>(...sources: (QueryOrderMap<T> | QueryOrderMap<T>[] | undefined)[]): QueryOrderMap<T>[];
 }
 interface ProcessWhereOptions<T> {
     where: FilterQuery<T>;

package/utils/QueryHelper.js

@@ -300,4 +300,29 @@ export class QueryHelper {
         const meta = entityName ? options.metadata.find(entityName) : undefined;
         return meta?.properties[propName];
     }
+    /**
+     * Merges multiple orderBy sources with key-level deduplication (first-seen key wins).
+     * RawQueryFragment symbol keys are never deduped (each is unique).
+     */
+    static mergeOrderBy(...sources) {
+        const result = [];
+        const seenKeys = new Set();
+        for (const source of sources) {
+            if (source == null) {
+                continue;
+            }
+            for (const item of Utils.asArray(source)) {
+                for (const key of Utils.getObjectQueryKeys(item)) {
+                    if (typeof key === 'symbol') {
+                        result.push({ [key]: item[key] });
+                    }
+                    else if (!seenKeys.has(key)) {
+                        seenKeys.add(key);
+                        result.push({ [key]: item[key] });
+                    }
+                }
+            }
+        }
+        return result;
+    }
 }

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.229';
+    static #ORM_VERSION = '7.0.0-dev.230';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */