@mikro-orm/core 7.0.0-dev.4 → 7.0.0-dev.6

package/decorators/Check.d.ts

@@ -1,3 +1,3 @@
-import type { CheckConstraint } from '../typings.js';
-export declare function Check<T>(options: CheckOptions<T>): (target: any, propertyName?: string) => any;
+import type { CheckConstraint, EntityClass } from '../typings.js';
+export declare function Check<T>(options: CheckOptions<T>): (target: T, propertyName?: T extends EntityClass<unknown> ? undefined : keyof T) => any;
 export type CheckOptions<T = any> = CheckConstraint<T>;

package/decorators/Embeddable.d.ts

@@ -1,8 +1,8 @@
-import type { Dictionary } from '../typings.js';
-export declare function Embeddable(options?: EmbeddableOptions): <T>(target: T & Dictionary) => T & Dictionary;
-export type EmbeddableOptions = {
-    discriminatorColumn?: string;
+import type { AnyString, Dictionary, EntityClass } from '../typings.js';
+export declare function Embeddable<T>(options?: EmbeddableOptions<T>): (target: T) => T;
+export interface EmbeddableOptions<T> {
+    discriminatorColumn?: (T extends EntityClass<infer P> ? keyof P : string) | AnyString;
     discriminatorMap?: Dictionary<string>;
     discriminatorValue?: number | string;
     abstract?: boolean;
-};
+}

package/decorators/Embeddable.js

@@ -3,7 +3,7 @@ export function Embeddable(options = {}) {
     return function (target) {
         const meta = MetadataStorage.getMetadataFromDecorator(target);
         meta.class = target;
-        meta.name = target.name;
+        meta.name = meta.class.name;
         meta.embeddable = true;
         Object.assign(meta, options);
         return target;

package/decorators/Embedded.d.ts

@@ -2,7 +2,7 @@ import type { AnyEntity } from '../typings.js';
 export declare function Embedded<T extends object>(type?: EmbeddedOptions | (() => AnyEntity), options?: EmbeddedOptions): (target: AnyEntity, propertyName: string) => any;
 /** With `absolute` the prefix is set at the root of the entity (regardless of the nesting level) */
 export type EmbeddedPrefixMode = 'absolute' | 'relative';
-export type EmbeddedOptions = {
+export interface EmbeddedOptions {
     entity?: string | (() => AnyEntity | AnyEntity[]);
     type?: string;
     prefix?: string | boolean;
@@ -15,4 +15,4 @@ export type EmbeddedOptions = {
     serializedName?: string;
     groups?: string[];
     persist?: boolean;
-};
+}

package/decorators/Enum.d.ts

@@ -1,6 +1,6 @@
 import type { PropertyOptions } from './Property.js';
 import type { AnyEntity, Dictionary } from '../typings.js';
-export declare function Enum<T extends object>(options?: EnumOptions<AnyEntity> | (() => Dictionary)): (target: AnyEntity, propertyName: string) => any;
+export declare function Enum<T extends object>(options?: EnumOptions<AnyEntity> | (() => Dictionary)): (target: T, propertyName: string) => any;
 export interface EnumOptions<T> extends PropertyOptions<T> {
     items?: (number | string)[] | (() => Dictionary);
     array?: boolean;

package/decorators/Formula.d.ts

@@ -1,5 +1,4 @@
-import type { AnyEntity } from '../typings.js';
 import type { PropertyOptions } from './Property.js';
-export declare function Formula<T extends object>(formula: string | ((alias: string) => string), options?: FormulaOptions<T>): (target: AnyEntity, propertyName: string) => any;
+export declare function Formula<T extends object>(formula: string | ((alias: string) => string), options?: FormulaOptions<T>): (target: T, propertyName: string) => any;
 export interface FormulaOptions<T> extends PropertyOptions<T> {
 }

package/decorators/ManyToMany.d.ts

@@ -1,7 +1,7 @@
 import type { ReferenceOptions } from './Property.js';
-import type { EntityName, AnyEntity, FilterQuery, AnyString } from '../typings.js';
+import type { EntityName, FilterQuery, AnyString } from '../typings.js';
 import { type QueryOrderMap } from '../enums.js';
-export declare function ManyToMany<T extends object, O>(entity?: ManyToManyOptions<T, O> | string | (() => EntityName<T>), mappedBy?: (string & keyof T) | ((e: T) => any), options?: Partial<ManyToManyOptions<T, O>>): (target: AnyEntity, propertyName: string) => any;
+export declare function ManyToMany<Target extends object, Owner extends object>(entity?: ManyToManyOptions<Owner, Target> | string | (() => EntityName<Target>), mappedBy?: (string & keyof Target) | ((e: Target) => any), options?: Partial<ManyToManyOptions<Owner, Target>>): (target: Owner, propertyName: keyof Owner) => any;
 export interface ManyToManyOptions<Owner, Target> extends ReferenceOptions<Owner, Target> {
     /** Set this side as owning. Owning side is where the foreign key is defined. This option is not required if you use `inversedBy` or `mappedBy` to distinguish owning and inverse side. */
     owner?: boolean;

package/decorators/ManyToOne.d.ts

@@ -1,7 +1,7 @@
 import type { ReferenceOptions } from './Property.js';
 import { type DeferMode } from '../enums.js';
-import type { AnyEntity, AnyString, EntityName } from '../typings.js';
-export declare function ManyToOne<T extends object, O>(entity?: ManyToOneOptions<T, O> | string | ((e?: any) => EntityName<T>), options?: Partial<ManyToOneOptions<T, O>>): (target: AnyEntity, propertyName: string) => any;
+import type { AnyString, EntityName } from '../typings.js';
+export declare function ManyToOne<Target extends object, Owner extends object>(entity?: ManyToOneOptions<Owner, Target> | string | ((e?: any) => EntityName<Target>), options?: Partial<ManyToOneOptions<Owner, Target>>): (target: Owner, propertyName: keyof Owner) => any;
 export interface ManyToOneOptions<Owner, Target> extends ReferenceOptions<Owner, Target> {
     /** Point to the inverse side property name. */
     inversedBy?: (string & keyof Target) | ((e: Target) => any);

package/decorators/OneToMany.d.ts

@@ -1,9 +1,9 @@
 import type { ReferenceOptions } from './Property.js';
 import { ReferenceKind, type QueryOrderMap } from '../enums.js';
-import type { EntityName, AnyEntity, FilterQuery } from '../typings.js';
-export declare function createOneToDecorator<Target, Owner>(entity: OneToManyOptions<Owner, Target> | string | ((e?: any) => EntityName<Target>), mappedBy: (string & keyof Target) | ((e: Target) => any) | undefined, options: Partial<OneToManyOptions<Owner, Target>>, kind: ReferenceKind): (target: AnyEntity, propertyName: string) => any;
-export declare function OneToMany<Target, Owner>(entity: string | ((e?: any) => EntityName<Target>), mappedBy: (string & keyof Target) | ((e: Target) => any), options?: Partial<OneToManyOptions<Owner, Target>>): (target: AnyEntity, propertyName: string) => void;
-export declare function OneToMany<Target, Owner>(options: OneToManyOptions<Owner, Target>): (target: AnyEntity, propertyName: string) => void;
+import type { EntityName, FilterQuery } from '../typings.js';
+export declare function createOneToDecorator<Target, Owner>(entity: OneToManyOptions<Owner, Target> | string | ((e?: any) => EntityName<Target>), mappedBy: (string & keyof Target) | ((e: Target) => any) | undefined, options: Partial<OneToManyOptions<Owner, Target>>, kind: ReferenceKind): (target: Owner, propertyName: string) => any;
+export declare function OneToMany<Target, Owner>(entity: string | ((e?: any) => EntityName<Target>), mappedBy: (string & keyof Target) | ((e: Target) => any), options?: Partial<OneToManyOptions<Owner, Target>>): (target: Owner, propertyName: string) => void;
+export declare function OneToMany<Target, Owner>(options: OneToManyOptions<Owner, Target>): (target: Owner, propertyName: string) => void;
 export interface OneToManyOptions<Owner, Target> extends ReferenceOptions<Owner, Target> {
     /** Remove the entity when it gets disconnected from the relationship (see {@doclink cascading | Cascading}). */
     orphanRemoval?: boolean;

package/decorators/OneToOne.d.ts

@@ -1,7 +1,7 @@
 import { type DeferMode } from '../enums.js';
 import { type OneToManyOptions } from './OneToMany.js';
 import type { AnyString, EntityName } from '../typings.js';
-export declare function OneToOne<Target, Owner>(entity?: OneToOneOptions<Owner, Target> | string | ((e: Owner) => EntityName<Target>), mappedByOrOptions?: (string & keyof Target) | ((e: Target) => any) | Partial<OneToOneOptions<Owner, Target>>, options?: Partial<OneToOneOptions<Owner, Target>>): (target: import("../typings.js").AnyEntity, propertyName: string) => any;
+export declare function OneToOne<Target, Owner>(entity?: OneToOneOptions<Owner, Target> | string | ((e: Owner) => EntityName<Target>), mappedByOrOptions?: (string & keyof Target) | ((e: Target) => any) | Partial<OneToOneOptions<Owner, Target>>, options?: Partial<OneToOneOptions<Owner, Target>>): (target: Owner, propertyName: string) => any;
 export interface OneToOneOptions<Owner, Target> extends Partial<Omit<OneToManyOptions<Owner, Target>, 'orderBy'>> {
     /** Set this side as owning. Owning side is where the foreign key is defined. This option is not required if you use `inversedBy` or `mappedBy` to distinguish owning and inverse side. */
     owner?: boolean;

package/decorators/PrimaryKey.d.ts

@@ -1,7 +1,6 @@
 import type { PropertyOptions } from './Property.js';
-import type { AnyEntity } from '../typings.js';
-export declare function PrimaryKey<T extends object>(options?: PrimaryKeyOptions<T>): (target: AnyEntity, propertyName: string) => any;
-export declare function SerializedPrimaryKey<T extends object>(options?: SerializedPrimaryKeyOptions<T>): (target: AnyEntity, propertyName: string) => any;
+export declare function PrimaryKey<T extends object>(options?: PrimaryKeyOptions<T>): (target: T, propertyName: string) => any;
+export declare function SerializedPrimaryKey<T extends object>(options?: SerializedPrimaryKeyOptions<T>): (target: T, propertyName: string) => any;
 export interface PrimaryKeyOptions<T> extends PropertyOptions<T> {
 }
 export interface SerializedPrimaryKeyOptions<T> extends PropertyOptions<T> {

package/decorators/Property.d.ts

@@ -3,7 +3,7 @@ import type { EntityName, Constructor, CheckCallback, GeneratedColumnCallback, A
 import type { Type, types } from '../types/index.js';
 import type { EntityManager } from '../EntityManager.js';
 import type { SerializeOptions } from '../serialization/EntitySerializer.js';
-export declare function Property<T extends object>(options?: PropertyOptions<T>): (target: any, propertyName: string) => any;
+export declare function Property<T extends object>(options?: PropertyOptions<T>): (target: T, propertyName: string) => any;
 export interface PropertyOptions<Owner> {
     /**
      * Alias for `fieldName`.

package/entity/EntityLoader.js

@@ -249,9 +249,13 @@ export class EntityLoader {
                 }
             }
         }
+        const orderBy = [...Utils.asArray(options.orderBy), ...propOrderBy].filter((order, idx, array) => {
+            // skip consecutive ordering with the same key to get around mongo issues
+            return idx === 0 || !Utils.equals(Object.keys(array[idx - 1]), Object.keys(order));
+        });
         const items = await this.em.find(prop.type, where, {
             filters, convertCustomTypes, lockMode, populateWhere, logging,
-            orderBy: [...Utils.asArray(options.orderBy), ...propOrderBy],
+            orderBy,
             populate: populate.children ?? populate.all ?? [],
             exclude: Array.isArray(options.exclude) ? Utils.extractChildElements(options.exclude, prop.name) : options.exclude,
             strategy, fields, schema, connectionType,

package/metadata/MetadataDiscovery.js

@@ -905,11 +905,13 @@ export class MetadataDiscovery {
         }
         if (!meta.root.discriminatorMap) {
             meta.root.discriminatorMap = {};
-            const children = metadata.filter(m => m.root.className === meta.root.className && !m.abstract);
-            children.forEach(m => {
+            const children = metadata
+                .filter(m => m.root.className === meta.root.className && !m.abstract)
+                .sort((a, b) => a.className.localeCompare(b.className));
+            for (const m of children) {
                 const name = m.discriminatorValue ?? this.namingStrategy.classToTableName(m.className);
                 meta.root.discriminatorMap[name] = m.className;
-            });
+            }
         }
         meta.discriminatorValue = Object.entries(meta.root.discriminatorMap).find(([, className]) => className === meta.className)?.[0];
         if (!meta.root.properties[meta.root.discriminatorColumn]) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.4",
+  "version": "7.0.0-dev.6",
   "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",
@@ -55,7 +55,7 @@
     "dotenv": "16.4.7",
     "esprima": "4.0.1",
     "globby": "11.1.0",
-    "mikro-orm": "7.0.0-dev.4",
+    "mikro-orm": "7.0.0-dev.6",
     "reflect-metadata": "0.2.2"
   }
 }

package/typings.d.ts

@@ -293,7 +293,8 @@ export type EntityDTO<T, C extends TypeConfig = never> = {
 } & {
     [K in keyof T as DTOOptionalKeys<T, K>]?: EntityDTOProp<T, T[K], C> | AddOptional<T[K]>;
 };
-type CheckKey<T> = IsUnknown<T> extends false ? keyof T : string;
+type TargetKeys<T> = T extends EntityClass<infer P> ? keyof P : keyof T;
+type CheckKey<T> = IsUnknown<T> extends false ? TargetKeys<T> : string;
 export type CheckCallback<T> = (columns: Record<CheckKey<T>, string>) => string;
 export type GeneratedColumnCallback<T> = (columns: Record<keyof T, string>) => string;
 export interface CheckConstraint<T = any> {