@mikro-orm/core 7.0.0-rc.1 → 7.0.0-rc.3

package/package.json

@@ -1,53 +1,56 @@
 {
   "name": "@mikro-orm/core",
-  "type": "module",
-  "version": "7.0.0-rc.1",
+  "version": "7.0.0-rc.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.",
-  "exports": {
-    "./package.json": "./package.json",
-    ".": "./index.js",
-    "./file-discovery": {
-      "node": "./metadata/discover-entities.js",
-      "browser": "./not-supported.js"
-    },
-    "./fs-utils": {
-      "node": "./utils/fs-utils.js",
-      "browser": "./not-supported.js"
-    }
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+ssh://git@github.com/mikro-orm/mikro-orm.git"
-  },
-  "funding": "https://github.com/sponsors/b4nan",
   "keywords": [
-    "orm",
+    "data-mapper",
+    "ddd",
+    "entity",
+    "identity-map",
+    "javascript",
+    "js",
+    "mariadb",
+    "mikro-orm",
     "mongo",
     "mongodb",
     "mysql",
-    "mariadb",
+    "orm",
     "postgresql",
     "sqlite",
     "sqlite3",
     "ts",
     "typescript",
-    "js",
-    "javascript",
-    "entity",
-    "ddd",
-    "mikro-orm",
-    "unit-of-work",
-    "data-mapper",
-    "identity-map"
+    "unit-of-work"
   ],
-  "author": "Martin Adámek",
-  "license": "MIT",
+  "homepage": "https://mikro-orm.io",
   "bugs": {
     "url": "https://github.com/mikro-orm/mikro-orm/issues"
   },
-  "homepage": "https://mikro-orm.io",
-  "engines": {
-    "node": ">= 22.17.0"
+  "license": "MIT",
+  "author": "Martin Adámek",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/mikro-orm/mikro-orm.git"
+  },
+  "funding": "https://github.com/sponsors/b4nan",
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": "./index.js",
+    "./file-discovery": {
+      "node": "./metadata/discover-entities.js",
+      "browser": "./not-supported.js"
+    },
+    "./fs-utils": {
+      "node": "./utils/fs-utils.js",
+      "browser": "./not-supported.js"
+    },
+    "./migrations": "./utils/AbstractMigrator.js",
+    "./schema": "./utils/AbstractSchemaGenerator.js",
+    "./dataloader": "./utils/DataloaderUtils.js"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "scripts": {
     "build": "yarn compile && yarn copy",
@@ -55,9 +58,6 @@
     "compile": "yarn run -T tsc -p tsconfig.build.json",
     "copy": "node ../../scripts/copy.mjs"
   },
-  "publishConfig": {
-    "access": "public"
-  },
   "peerDependencies": {
     "dataloader": "2.2.3"
   },
@@ -65,5 +65,8 @@
     "dataloader": {
       "optional": true
     }
+  },
+  "engines": {
+    "node": ">= 22.17.0"
   }
 }

package/platforms/Platform.d.ts

@@ -66,7 +66,9 @@ export declare abstract class Platform {
         $flags?: string;
     };
     isAllowedTopLevelOperator(operator: string): boolean;
-    quoteVersionValue(value: Date | number, prop: EntityProperty): Date | string | number;
+    convertVersionValue(value: Date | number, prop: EntityProperty): Date | string | number | {
+        $in: (string | number)[];
+    };
     getDefaultVersionLength(): number;
     allowsComparingTuples(): boolean;
     isBigIntProperty(prop: EntityProperty): boolean;
@@ -138,6 +140,7 @@ export declare abstract class Platform {
     getDefaultMappedType(type: string): Type<unknown>;
     supportsMultipleCascadePaths(): boolean;
     supportsMultipleStatements(): boolean;
+    supportsUnionWhere(): boolean;
     getArrayDeclarationSQL(): string;
     marshallArray(values: string[]): string;
     unmarshallArray(value: string): string[];

package/platforms/Platform.js

@@ -113,7 +113,7 @@ export class Platform {
     isAllowedTopLevelOperator(operator) {
         return operator === '$not';
     }
-    quoteVersionValue(value, prop) {
+    convertVersionValue(value, prop) {
         return value;
     }
     getDefaultVersionLength() {
@@ -198,35 +198,58 @@ export class Platform {
         }
         switch (this.extractSimpleType(type)) {
             case 'character':
-            case 'char': return Type.getType(CharacterType);
+            case 'char':
+                return Type.getType(CharacterType);
             case 'string':
-            case 'varchar': return Type.getType(StringType);
-            case 'interval': return Type.getType(IntervalType);
-            case 'text': return Type.getType(TextType);
+            case 'varchar':
+                return Type.getType(StringType);
+            case 'interval':
+                return Type.getType(IntervalType);
+            case 'text':
+                return Type.getType(TextType);
             case 'int':
-            case 'number': return Type.getType(IntegerType);
-            case 'bigint': return Type.getType(BigIntType);
-            case 'smallint': return Type.getType(SmallIntType);
-            case 'tinyint': return Type.getType(TinyIntType);
-            case 'mediumint': return Type.getType(MediumIntType);
-            case 'float': return Type.getType(FloatType);
-            case 'double': return Type.getType(DoubleType);
-            case 'integer': return Type.getType(IntegerType);
+            case 'number':
+                return Type.getType(IntegerType);
+            case 'bigint':
+                return Type.getType(BigIntType);
+            case 'smallint':
+                return Type.getType(SmallIntType);
+            case 'tinyint':
+                return Type.getType(TinyIntType);
+            case 'mediumint':
+                return Type.getType(MediumIntType);
+            case 'float':
+                return Type.getType(FloatType);
+            case 'double':
+                return Type.getType(DoubleType);
+            case 'integer':
+                return Type.getType(IntegerType);
             case 'decimal':
-            case 'numeric': return Type.getType(DecimalType);
-            case 'boolean': return Type.getType(BooleanType);
+            case 'numeric':
+                return Type.getType(DecimalType);
+            case 'boolean':
+                return Type.getType(BooleanType);
             case 'blob':
-            case 'buffer': return Type.getType(BlobType);
-            case 'uint8array': return Type.getType(Uint8ArrayType);
-            case 'uuid': return Type.getType(UuidType);
-            case 'date': return Type.getType(DateType);
+            case 'buffer':
+                return Type.getType(BlobType);
+            case 'uint8array':
+                return Type.getType(Uint8ArrayType);
+            case 'uuid':
+                return Type.getType(UuidType);
+            case 'date':
+                return Type.getType(DateType);
             case 'datetime':
-            case 'timestamp': return Type.getType(DateTimeType);
-            case 'time': return Type.getType(TimeType);
+            case 'timestamp':
+                return Type.getType(DateTimeType);
+            case 'time':
+                return Type.getType(TimeType);
             case 'object':
-            case 'json': return Type.getType(JsonType);
-            case 'enum': return Type.getType(EnumType);
-            default: return Type.getType(UnknownType);
+            case 'json':
+                return Type.getType(JsonType);
+            case 'enum':
+                return Type.getType(EnumType);
+            default:
+                return Type.getType(UnknownType);
         }
     }
     supportsMultipleCascadePaths() {
@@ -235,6 +258,9 @@ export class Platform {
     supportsMultipleStatements() {
         return this.config.get('multipleStatements');
     }
+    supportsUnionWhere() {
+        return false;
+    }
     getArrayDeclarationSQL() {
         return 'text';
     }

package/serialization/EntitySerializer.d.ts

@@ -1,7 +1,7 @@
-import type { ArrayElement, AutoPath, CleanTypeConfig, EntityDTO, FromEntityType, Loaded, TypeConfig, UnboxArray } from '../typings.js';
+import type { ArrayElement, AutoPath, CleanTypeConfig, SerializeDTO, FromEntityType, TypeConfig, UnboxArray } from '../typings.js';
 import { type PopulatePath } from '../enums.js';
 export declare class EntitySerializer {
-    static serialize<T extends object, P extends string = never, E extends string = never>(entity: T, options?: SerializeOptions<T, P, E>): EntityDTO<Loaded<T, P>>;
+    static serialize<T extends object, P extends string = never, E extends string = never>(entity: T, options?: SerializeOptions<T, P, E>): SerializeDTO<T, P, E>;
     private static propertyName;
     private static processProperty;
     private static processCustomType;
@@ -39,4 +39,4 @@ export interface SerializeOptions<T, P extends string = never, E extends string
  * const dto2 = wrap(user).serialize({ exclude: ['id', 'email'], forceObject: true });
  * ```
  */
-export declare function serialize<Entity extends object, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Populate extends string = never, Exclude extends string = never, Config extends TypeConfig = never>(entity: Entity, options?: Config & SerializeOptions<UnboxArray<Entity>, Populate, Exclude>): Naked extends object[] ? EntityDTO<Loaded<ArrayElement<Naked>, Populate>, CleanTypeConfig<Config>>[] : EntityDTO<Loaded<Naked, Populate>, CleanTypeConfig<Config>>;
+export declare function serialize<Entity extends object, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Populate extends string = never, Exclude extends string = never, Config extends TypeConfig = never>(entity: Entity, options?: Config & SerializeOptions<UnboxArray<Entity>, Populate, Exclude>): Naked extends object[] ? SerializeDTO<ArrayElement<Naked>, Populate, Exclude, CleanTypeConfig<Config>>[] : SerializeDTO<Naked, Populate, Exclude, CleanTypeConfig<Config>>;

package/serialization/EntitySerializer.js

@@ -9,7 +9,8 @@ function isVisible(meta, propName, options) {
     if (options.groups && prop?.groups) {
         return prop.groups.some(g => options.groups.includes(g));
     }
-    if (Array.isArray(options.populate) && options.populate?.find(item => item === propName || item.startsWith(propName + '.') || item === '*')) {
+    if (Array.isArray(options.populate) &&
+        options.populate?.find(item => item === propName || item.startsWith(propName + '.') || item === '*')) {
         return true;
     }
     if (options.exclude?.find(item => item === propName)) {
@@ -20,7 +21,8 @@ function isVisible(meta, propName, options) {
     return visible && !prefixed;
 }
 function isPopulated(propName, options) {
-    if (typeof options.populate !== 'boolean' && options.populate?.find(item => item === propName || item.startsWith(propName + '.') || item === '*')) {
+    if (typeof options.populate !== 'boolean' &&
+        options.populate?.find(item => item === propName || item.startsWith(propName + '.') || item === '*')) {
         return true;
     }
     if (typeof options.populate === 'boolean') {
@@ -176,7 +178,9 @@ export class EntitySerializer {
     static extractChildOptions(options, prop) {
         return {
             ...options,
-            populate: Array.isArray(options.populate) ? Utils.extractChildElements(options.populate, prop, '*') : options.populate,
+            populate: Array.isArray(options.populate)
+                ? Utils.extractChildElements(options.populate, prop, '*')
+                : options.populate,
             exclude: Array.isArray(options.exclude) ? Utils.extractChildElements(options.exclude, prop) : options.exclude,
         };
     }

package/serialization/EntityTransformer.js

@@ -58,10 +58,12 @@ export class EntityTransformer {
                 continue;
             }
             const populated = root.isMarkedAsPopulated(meta.class, prop);
-            const partiallyLoaded = root.isPartiallyLoaded(meta.class, prop);
-            const isPrimary = includePrimaryKeys && meta.properties[prop].primary;
-            if (!partiallyLoaded && !populated && !isPrimary) {
-                continue;
+            if (!raw) {
+                const partiallyLoaded = root.isPartiallyLoaded(meta.class, prop);
+                const isPrimary = includePrimaryKeys && meta.properties[prop].primary;
+                if (!partiallyLoaded && !populated && !isPrimary) {
+                    continue;
+                }
             }
             const cycle = root.visit(meta.class, prop);
             if (cycle && visited) {

package/serialization/SerializationContext.js

@@ -104,7 +104,7 @@ export class SerializationContext {
             }
             fields = fields
                 .filter(field => field.startsWith(`${segment[1]}.`) || field === '*')
-                .map(field => field === '*' ? field : field.substring(segment[1].length + 1));
+                .map(field => (field === '*' ? field : field.substring(segment[1].length + 1)));
         }
         return fields.some(p => p === prop || p === '*');
     }

package/typings.d.ts

@@ -36,11 +36,11 @@ export type Compute<T> = {
     [K in keyof T]: T[K];
 } & {};
 type InternalKeys = 'EntityRepositoryType' | 'PrimaryKeyProp' | 'OptionalProps' | 'EagerProps' | 'HiddenProps' | '__selectedType' | '__loadedType';
-export type CleanKeys<T, K extends keyof T, B extends boolean = false> = (T[K] & {}) extends Function ? never : K extends symbol | InternalKeys ? never : B extends true ? (T[K] & {}) extends Scalar ? never : K : K;
+export type CleanKeys<T, K extends keyof T, B extends boolean = false> = T[K] & {} extends Function ? never : K extends symbol | InternalKeys ? never : B extends true ? T[K] & {} extends Scalar ? never : K : K;
 export type FunctionKeys<T, K extends keyof T> = T[K] extends Function ? K : never;
 export type Cast<T, R> = T extends R ? T : R;
-export type IsUnknown<T> = T extends unknown ? unknown extends T ? true : never : never;
-export type IsAny<T> = 0 extends (1 & T) ? true : false;
+export type IsUnknown<T> = T extends unknown ? (unknown extends T ? true : never) : never;
+export type IsAny<T> = 0 extends 1 & T ? true : false;
 export type IsNever<T, True = true, False = false> = [T] extends [never] ? True : False;
 export type MaybePromise<T> = T | Promise<T>;
 /**
@@ -98,9 +98,9 @@ type LoadableShape = CollectionShape | ReferenceShape | readonly any[];
 export type UnionKeys<T> = T extends any ? keyof T : never;
 export type UnionPropertyType<T, K extends PropertyKey> = T extends any ? (K extends keyof T ? T[K] : never) : never;
 type IsUnion<T, U = T> = T extends any ? ([U] extends [T] ? false : true) : false;
-export type MergeUnion<T> = [T] extends [object] ? (T extends Scalar ? T : IsUnion<T> extends true ? {
+export type MergeUnion<T> = [T] extends [object] ? T extends Scalar ? T : IsUnion<T> extends true ? {
     [K in UnionKeys<T>]: UnionPropertyType<T, K>;
-} : T) : T;
+} : T : T;
 export type DeepPartial<T> = T & {
     [P in keyof T]?: T[P] extends (infer U)[] ? DeepPartial<U>[] : T[P] extends Readonly<infer U>[] ? Readonly<DeepPartial<U>>[] : DeepPartial<T[P]>;
 };
@@ -110,6 +110,10 @@ export declare const OptionalProps: unique symbol;
 export declare const EagerProps: unique symbol;
 export declare const HiddenProps: unique symbol;
 export declare const Config: unique symbol;
+export declare const EntityName: unique symbol;
+export type InferEntityName<T> = T extends {
+    [EntityName]?: infer Name;
+} ? (Name extends string ? Name : never) : never;
 export type Opt<T = unknown> = T & Opt.Brand;
 export declare namespace Opt {
     const __optional: unique symbol;
@@ -169,11 +173,11 @@ export type Primary<T> = IsAny<T> extends true ? any : T extends {
 /** @internal */
 export type PrimaryProperty<T> = T extends {
     [PrimaryKeyProp]?: infer PK;
-} ? (PK extends keyof T ? PK : (PK extends any[] ? PK[number] : never)) : T extends {
+} ? PK extends keyof T ? PK : PK extends any[] ? PK[number] : never : T extends {
     _id?: any;
-} ? (T extends {
+} ? T extends {
     id?: any;
-} ? 'id' | '_id' : '_id') : T extends {
+} ? 'id' | '_id' : '_id' : T extends {
     id?: any;
 } ? 'id' : T extends {
     uuid?: any;
@@ -233,7 +237,7 @@ type ExpandQueryMerged<T> = [T] extends [object] ? [T] extends [Scalar] ? never
 export type FilterObject<T> = {
     -readonly [K in EntityKey<T>]?: ExpandQuery<ExpandProperty<FilterObjectProp<T, K>>> | ExpandQueryMerged<ExpandProperty<FilterObjectProp<T, K>>> | FilterValue<ExpandProperty<FilterObjectProp<T, K>>> | null;
 };
-export type ExpandQuery<T> = T extends object ? T extends Scalar ? never : FilterQuery<T> : FilterValue<T>;
+export type ExpandQuery<T> = T extends object ? (T extends Scalar ? never : FilterQuery<T>) : FilterValue<T>;
 export type EntityProps<T> = {
     -readonly [K in EntityKey<T>]?: T[K];
 };
@@ -243,7 +247,7 @@ export interface IWrappedEntity<Entity extends object> {
     isInitialized(): boolean;
     isManaged(): boolean;
     populated(populated?: boolean): void;
-    populate<Hint extends string = never>(populate: readonly AutoPath<Entity, Hint, PopulatePath.ALL>[] | false, options?: EntityLoaderOptions<Entity>): Promise<Loaded<Entity, Hint>>;
+    populate<Hint extends string = never, Fields extends string = never>(populate: readonly AutoPath<Entity, Hint, PopulatePath.ALL>[] | false, options?: EntityLoaderOptions<Entity, Fields>): Promise<Loaded<Entity, Hint>>;
     init<Hint extends string = never, Fields extends string = '*', Exclude extends string = never>(options?: FindOneOptions<Entity, Hint, Fields, Exclude>): Promise<Loaded<Entity, Hint, Fields, Exclude> | null>;
     toReference(): Ref<Entity> & LoadedReference<Loaded<Entity, AddEager<Entity>>>;
     toObject(): EntityDTO<Entity>;
@@ -251,7 +255,7 @@ export interface IWrappedEntity<Entity extends object> {
     toObject<Ignored extends EntityKey<Entity>>(ignoreFields: Ignored[]): Omit<EntityDTO<Entity>, Ignored>;
     toJSON(...args: any[]): EntityDTO<Entity>;
     toPOJO(): EntityDTO<Entity>;
-    serialize<Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Hint extends string = never, Exclude extends string = never>(options?: SerializeOptions<Naked, Hint, Exclude>): EntityDTO<Loaded<Naked, Hint>>;
+    serialize<Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Hint extends string = never, Exclude extends string = never>(options?: SerializeOptions<Naked, Hint, Exclude>): SerializeDTO<Naked, Hint, Exclude>;
     setSerializationContext<Hint extends string = never, Fields extends string = '*', Exclude extends string = never>(options: LoadHint<Entity, Hint, Fields, Exclude>): void;
     assign<Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Convert extends boolean = false, Data extends EntityData<Naked, Convert> | Partial<EntityDTO<Naked>> = EntityData<Naked, Convert> | Partial<EntityDTO<Naked>>>(data: Data & IsSubset<EntityData<Naked, Convert>, Data>, options?: AssignOptions<Convert>): MergeSelected<Entity, Naked, keyof Data & string>;
     getSchema(): string | undefined;
@@ -320,11 +324,11 @@ type NonArrayObject = object & {
 export type EntityDataProp<T, C extends boolean> = T extends Date ? string | Date : T extends Scalar ? T : T extends ScalarReference<infer U> ? EntityDataProp<U, C> : T extends {
     __runtime?: infer Runtime;
     __raw?: infer Raw;
-} ? (C extends true ? Raw : Runtime) : T extends ReferenceShape<infer U> ? EntityDataNested<U, C> : T extends CollectionShape<infer U> ? U | U[] | EntityDataNested<U & object, C> | EntityDataNested<U & object, C>[] : T extends readonly (infer U)[] ? U extends NonArrayObject ? U | U[] | EntityDataNested<U, C> | EntityDataNested<U, C>[] : U[] | EntityDataNested<U, C>[] : EntityDataNested<T, C>;
+} ? C extends true ? Raw : Runtime : T extends ReferenceShape<infer U> ? EntityDataNested<U, C> : T extends CollectionShape<infer U> ? U | U[] | EntityDataNested<U & object, C> | EntityDataNested<U & object, C>[] : T extends readonly (infer U)[] ? U extends NonArrayObject ? U | U[] | EntityDataNested<U, C> | EntityDataNested<U, C>[] : U[] | EntityDataNested<U, C>[] : EntityDataNested<T, C>;
 export type RequiredEntityDataProp<T, O, C extends boolean> = T extends Date ? string | Date : Exclude<T, null> extends RequiredNullable.Brand ? T | null : T extends Scalar ? T : T extends ScalarReference<infer U> ? RequiredEntityDataProp<U, O, C> : T extends {
     __runtime?: infer Runtime;
     __raw?: infer Raw;
-} ? (C extends true ? Raw : Runtime) : T extends ReferenceShape<infer U> ? RequiredEntityDataNested<U, O, C> : T extends CollectionShape<infer U> ? U | U[] | RequiredEntityDataNested<U & object, O, C> | RequiredEntityDataNested<U & object, O, C>[] : T extends readonly (infer U)[] ? U extends NonArrayObject ? U | U[] | RequiredEntityDataNested<U, O, C> | RequiredEntityDataNested<U, O, C>[] : U[] | RequiredEntityDataNested<U, O, C>[] : RequiredEntityDataNested<T, O, C>;
+} ? C extends true ? Raw : Runtime : T extends ReferenceShape<infer U> ? RequiredEntityDataNested<U, O, C> : T extends CollectionShape<infer U> ? U | U[] | RequiredEntityDataNested<U & object, O, C> | RequiredEntityDataNested<U & object, O, C>[] : T extends readonly (infer U)[] ? U extends NonArrayObject ? U | U[] | RequiredEntityDataNested<U, O, C> | RequiredEntityDataNested<U, O, C>[] : U[] | RequiredEntityDataNested<U, O, C>[] : RequiredEntityDataNested<T, O, C>;
 export type EntityDataNested<T, C extends boolean = false> = T extends undefined ? never : T extends any[] ? Readonly<T> : EntityData<T, C> | ExpandEntityProp<T, C>;
 type UnwrapScalarRef<T> = T extends ScalarReference<infer U> ? U : T;
 type EntityDataItem<T, C extends boolean> = C extends false ? UnwrapScalarRef<T> | EntityDataProp<T, C> | Raw | null : EntityDataProp<T, C> | Raw | null;
@@ -364,9 +368,9 @@ export type Rel<T> = T;
 /** Alias for `ScalarReference` (see {@apilink Ref}). */
 export type ScalarRef<T> = ScalarReference<T>;
 /** Alias for `Reference<T> & { id: number }` (see {@apilink Ref}). */
-export type EntityRef<T extends object> = true extends IsUnknown<PrimaryProperty<T>> ? Reference<T> : IsAny<T> extends true ? Reference<T> : ({
+export type EntityRef<T extends object> = true extends IsUnknown<PrimaryProperty<T>> ? Reference<T> : IsAny<T> extends true ? Reference<T> : {
     [K in PrimaryProperty<T> & keyof T]: T[K];
-} & Reference<T>);
+} & Reference<T>;
 /**
  * Ref type represents a `Reference` instance, and adds the primary keys to its prototype automatically, so you can do
  * `ref.id` instead of `ref.unwrap().id`. It resolves to either `ScalarRef` or `EntityRef`, based on the type argument.
@@ -380,14 +384,15 @@ type ExtractHiddenProps<T> = (T extends {
 type ExcludeHidden<T, K extends keyof T> = K extends ExtractHiddenProps<T> ? never : K;
 type ExtractConfig<T> = T extends {
     [Config]?: infer K;
-} ? (K & TypeConfig) : TypeConfig;
+} ? K & TypeConfig : TypeConfig;
 type PreferExplicitConfig<E, I> = IsNever<E, I, E>;
 type PrimaryOrObject<T, U, C extends TypeConfig> = PreferExplicitConfig<C, ExtractConfig<T>>['forceObject'] extends true ? {
     [K in PrimaryProperty<U> & keyof U]: U[K];
 } : Primary<U>;
-export type EntityDTOProp<E, T, C extends TypeConfig = never> = T extends Scalar ? T : T extends ScalarReference<infer U> ? U : T extends {
+type DTOWrapper<T, C extends TypeConfig, Flat extends boolean> = Flat extends true ? EntityDTOFlat<T, C> : EntityDTO<T, C>;
+export type EntityDTOProp<E, T, C extends TypeConfig = never, Flat extends boolean = false> = T extends Scalar ? T : T extends ScalarReference<infer U> ? U : T extends {
     __serialized?: infer U;
-} ? (IsUnknown<U> extends false ? U : T) : T extends LoadedReferenceShape<infer U> ? EntityDTO<U, C> : T extends ReferenceShape<infer U> ? PrimaryOrObject<E, U, C> : T extends LoadedCollectionShape<infer U> ? EntityDTO<U & object, C>[] : T extends CollectionShape<infer U> ? PrimaryOrObject<E, U & object, C>[] : T extends readonly (infer U)[] ? U extends Scalar ? T : EntityDTOProp<E, U, C>[] : T extends Relation<T> ? EntityDTO<T, C> : T;
+} ? IsUnknown<U> extends false ? U : T : T extends LoadedReferenceShape<infer U> ? DTOWrapper<U, C, Flat> : T extends ReferenceShape<infer U> ? PrimaryOrObject<E, U, C> : T extends LoadedCollectionShape<infer U> ? DTOWrapper<U & object, C, Flat>[] : T extends CollectionShape<infer U> ? PrimaryOrObject<E, U & object, C>[] : T extends readonly (infer U)[] ? U extends Scalar ? T : EntityDTOProp<E, U, C, Flat>[] : T extends Relation<T> ? DTOWrapper<T, C, Flat> : T;
 type UnwrapLoadedEntity<T> = T extends {
     [__loadedType]?: infer U;
 } ? NonNullable<U> : T;
@@ -400,6 +405,27 @@ export type EntityDTO<T, C extends TypeConfig = never> = {
 } & {
     [K in keyof T as DTOOptionalKeys<T, K>]?: EntityDTOProp<T, T[K], C> | AddOptional<T[K]>;
 };
+/**
+ * @internal
+ * 1-pass variant of EntityDTO — ~2x cheaper to resolve but all keys are required
+ * (optional keys use `| undefined` in value type instead of `?` modifier).
+ * Use only for internal type computations (output types), never as a user-facing
+ * function parameter type where generic assignability checks are needed.
+ */
+export type EntityDTOFlat<T, C extends TypeConfig = never> = {
+    [K in keyof T as ExcludeHidden<T, K> & CleanKeys<T, K>]: EntityDTOProp<T, T[K], C, true> | AddOptional<T[K]>;
+};
+/**
+ * @internal
+ * Single-pass fused type that combines Loaded + EntityDTO into one mapped type.
+ * ~40x faster than `EntityDTO<Loaded<T, H>>` for populated entities.
+ */
+type SerializeTopHints<H extends string> = H extends `${infer Top}.${string}` ? Top : H;
+type SerializeSubHints<K extends string, H extends string> = H extends `${K}.${infer Rest}` ? Rest : never;
+type SerializePropValue<T, K extends keyof T, H extends string, C extends TypeConfig = never> = K & string extends SerializeTopHints<H> ? NonNullable<T[K]> extends CollectionShape<infer U> ? SerializeDTO<U & object, SerializeSubHints<K & string, H>, never, C>[] : SerializeDTO<ExpandProperty<T[K]>, SerializeSubHints<K & string, H>, never, C> | Extract<T[K], null | undefined> : EntityDTOProp<T, T[K], C>;
+export type SerializeDTO<T, H extends string = never, E extends string = never, C extends TypeConfig = never> = string extends H ? EntityDTOFlat<T, C> : {
+    [K in keyof T as ExcludeHidden<T, K> & CleanKeys<T, K> & (IsNever<E> extends true ? K : Exclude<K, E>)]: SerializePropValue<T, K, H, C> | Extract<T[K], null | undefined>;
+};
 type TargetKeys<T> = T extends EntityClass<infer P> ? keyof P : keyof T;
 type PropertyName<T> = IsUnknown<T> extends false ? TargetKeys<T> : string;
 export type FormulaTable = {
@@ -792,7 +818,7 @@ export interface GenerateOptions {
 export interface IEntityGenerator {
     generate(options?: GenerateOptions): Promise<string[]>;
 }
-export type UmzugMigration = {
+export type MigrationInfo = {
     name: string;
     path?: string;
 };
@@ -812,6 +838,14 @@ export type MigrationRow = {
     name: string;
     executed_at: Date;
 };
+/**
+ * @internal
+ */
+export interface IMigrationRunner {
+    run(migration: Migration, method: 'up' | 'down'): Promise<void>;
+    setMasterMigration(trx: Transaction): void;
+    unsetMasterMigration(): void;
+}
 /**
  * @internal
  */
@@ -852,23 +886,23 @@ export interface IMigrator {
     /**
      * Returns list of pending (not yet executed) migrations found in the migration directory.
      */
-    getPending(): Promise<UmzugMigration[]>;
+    getPending(): Promise<MigrationInfo[]>;
     /**
      * Executes specified migrations. Without parameter it will migrate up to the latest version.
      */
-    up(options?: string | string[] | MigrateOptions): Promise<UmzugMigration[]>;
+    up(options?: string | string[] | MigrateOptions): Promise<MigrationInfo[]>;
     /**
      * Executes down migrations to the given point. Without parameter it will migrate one version down.
      */
-    down(options?: string | string[] | MigrateOptions): Promise<UmzugMigration[]>;
+    down(options?: string | string[] | Omit<MigrateOptions, 'from'>): Promise<MigrationInfo[]>;
     /**
      * Registers event handler.
      */
-    on(event: MigratorEvent, listener: (event: UmzugMigration) => MaybePromise<void>): IMigrator;
+    on(event: MigratorEvent, listener: (event: MigrationInfo) => MaybePromise<void>): IMigrator;
     /**
      * Removes event handler.
      */
-    off(event: MigratorEvent, listener: (event: UmzugMigration) => MaybePromise<void>): IMigrator;
+    off(event: MigratorEvent, listener: (event: MigrationInfo) => MaybePromise<void>): IMigrator;
     /**
      * @internal
      */
@@ -896,6 +930,10 @@ export interface IMigrationGenerator {
 export interface Migration {
     up(): Promise<void> | void;
     down(): Promise<void> | void;
+    isTransactional(): boolean;
+    reset(): void;
+    setTransactionContext(ctx: Transaction): void;
+    getQueries?(): any[];
 }
 export interface MigrationObject {
     name: string;
@@ -937,7 +975,7 @@ type ExtractStringKeys<T> = {
  * Simplified to just check `T extends object` since ExtractType handles the unwrapping.
  */
 type StringKeys<T, E extends string = never> = T extends object ? ExtractStringKeys<ExtractType<T>> | E : never;
-type GetStringKey<T, K extends StringKeys<T, string>, E extends string> = K extends keyof T ? ExtractType<T[K]> : (K extends E ? keyof T : never);
+type GetStringKey<T, K extends StringKeys<T, string>, E extends string> = K extends keyof T ? ExtractType<T[K]> : K extends E ? keyof T : never;
 type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
 type RelationKeys<T> = T extends object ? {
     [K in keyof T]-?: CleanKeys<T, K, true>;
@@ -947,12 +985,12 @@ export type UnboxArray<T> = T extends any[] ? ArrayElement<T> : T;
 export type ArrayElement<ArrayType extends unknown[]> = ArrayType extends (infer ElementType)[] ? ElementType : never;
 export type ExpandProperty<T> = T extends ReferenceShape<infer U> ? NonNullable<U> : T extends CollectionShape<infer U> ? NonNullable<U> : T extends (infer U)[] ? NonNullable<U> : NonNullable<T>;
 type LoadedLoadable<T, E extends object> = T extends CollectionShape ? LoadedCollection<E> : T extends ScalarReference<infer U> ? LoadedScalarReference<U> : T extends ReferenceShape ? T & LoadedReference<E> : T extends Scalar ? T : T extends (infer U)[] ? U extends Scalar ? T : E[] : E;
-type IsTrue<T> = IsNever<T> extends true ? false : T extends boolean ? T extends true ? true : false : false;
-type StringLiteral<T> = T extends string ? string extends T ? never : T : never;
-type Prefix<T, K> = K extends `${infer S}.${string}` ? S : (K extends '*' ? keyof T : K);
+type IsTrue<T> = IsNever<T> extends true ? false : T extends boolean ? (T extends true ? true : false) : false;
+type StringLiteral<T> = T extends string ? (string extends T ? never : T) : never;
+type Prefix<T, K> = K extends `${infer S}.${string}` ? S : K extends '*' ? keyof T : K;
 type IsPrefixedExclude<T, K extends keyof T, E extends string> = K extends E ? never : K;
-export type IsPrefixed<T, K extends keyof T, L extends string, E extends string = never> = IsNever<E> extends false ? IsPrefixedExclude<T, K, E> : K extends symbol ? never : IsTrue<L> extends true ? (T[K] & {} extends LoadableShape ? K : never) : IsNever<StringLiteral<L>> extends true ? never : L extends '*' ? K : K extends Prefix<T, L> ? K : K extends PrimaryProperty<T> ? K : never;
-type Suffix<Key, Hint extends string, All = true | '*'> = Hint extends `${infer Pref}.${infer Suf}` ? (Pref extends Key ? Suf : never) : Hint extends All ? Hint : never;
+export type IsPrefixed<T, K extends keyof T, L extends string, E extends string = never> = IsNever<E> extends false ? IsPrefixedExclude<T, K, E> : K extends symbol ? never : IsTrue<L> extends true ? T[K] & {} extends LoadableShape ? K : never : IsNever<StringLiteral<L>> extends true ? never : '*' extends L ? K : K extends Prefix<T, L> ? K : K extends PrimaryProperty<T> ? K : never;
+type Suffix<Key, Hint extends string, All = true | '*'> = Hint extends `${infer Pref}.${infer Suf}` ? Pref extends Key ? Suf : never : Hint extends All ? Hint : never;
 export type IsSubset<T, U> = keyof U extends keyof T ? {} : string extends keyof U ? {} : {
     [K in keyof U as K extends keyof T ? never : CleanKeys<U, K>]: never;
 };
@@ -981,9 +1019,7 @@ type LoadedProp<T, L extends string = never, F extends string = '*', E extends s
 export type AddEager<T> = ExtractEagerProps<T> & string;
 export type ExpandHint<T, L extends string> = L | AddEager<T>;
 export type Selected<T, L extends string = never, F extends string = '*'> = {
-    [K in keyof T as IsPrefixed<T, K, L | F | AddEager<T>>]: LoadedProp<NonNullable<T[K]>, Suffix<K, L, true>, Suffix<K, F, true>> | AddOptional<T[K]>;
-} & {
-    [K in keyof T as FunctionKeys<T, K>]: T[K];
+    [K in keyof T as IsPrefixed<T, K, L | F | AddEager<T>> | FunctionKeys<T, K>]: T[K] extends Function ? T[K] : NonNullable<T[K]> extends Scalar ? T[K] : LoadedProp<NonNullable<T[K]>, Suffix<K, L, true>, Suffix<K, F, true>> | AddOptional<T[K]>;
 } & {
     [__selectedType]?: T;
 };
@@ -1056,6 +1092,10 @@ export interface ISeedManager {
 export interface Seeder<T extends Dictionary = Dictionary> {
     run(em: EntityManager, context?: T): void | Promise<void>;
 }
+export interface SeederObject {
+    name: string;
+    class: Constructor<Seeder>;
+}
 export type ConnectionType = 'read' | 'write';
 export type MetadataProcessor = (metadata: EntityMetadata[], platform: Platform) => MaybePromise<void>;
 export type MaybeReturnType<T> = T extends (...args: any[]) => infer R ? R : T;

package/typings.js

@@ -11,6 +11,8 @@ export const OptionalProps = Symbol('OptionalProps');
 export const EagerProps = Symbol('EagerProps');
 export const HiddenProps = Symbol('HiddenProps');
 export const Config = Symbol('Config');
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export const EntityName = Symbol('EntityName');
 export class EntityMetadata {
     static counter = 0;
     _id = 1000 * EntityMetadata.counter++; // keep the id >= 1000 to allow computing cache keys by simple addition
@@ -29,11 +31,9 @@ export class EntityMetadata {
         Object.assign(this, meta);
         const name = meta.className ?? meta.name;
         if (!this.class && name) {
-            const Class = this.extends === BaseEntity
-                ? ({ [name]: class extends BaseEntity {
-                    } })[name]
-                : ({ [name]: class {
-                    } })[name];
+            const Class = this.extends === BaseEntity ? { [name]: class extends BaseEntity {
+                } }[name] : { [name]: class {
+                } }[name];
             this.class = Class;
         }
     }
@@ -106,9 +106,7 @@ export class EntityMetadata {
      */
     createSchemaColumnMappingObject() {
         // For TPT entities, only include properties that belong to this entity's table
-        const props = this.inheritanceType === 'tpt' && this.ownProps
-            ? this.ownProps
-            : Object.values(this.properties);
+        const props = this.inheritanceType === 'tpt' && this.ownProps ? this.ownProps : Object.values(this.properties);
         return props.reduce((o, prop) => {
             if (prop.fieldNames) {
                 o[prop.name] = prop.fieldNames[0];
@@ -206,7 +204,11 @@ export class EntityMetadata {
                         const hydrator = wrapped.hydrator;
                         const entity = Reference.unwrapReference(val ?? wrapped.__data[prop.name]);
                         const old = Reference.unwrapReference(wrapped.__data[prop.name]);
-                        if (old && old !== entity && prop.kind === ReferenceKind.MANY_TO_ONE && prop.inversedBy && old[prop.inversedBy]) {
+                        if (old &&
+                            old !== entity &&
+                            prop.kind === ReferenceKind.MANY_TO_ONE &&
+                            prop.inversedBy &&
+                            old[prop.inversedBy]) {
                             old[prop.inversedBy].removeWithoutPropagation(this);
                         }
                         wrapped.__data[prop.name] = Reference.wrapReference(val, prop);

package/unit-of-work/ChangeSet.js

@@ -27,10 +27,10 @@ export class ChangeSet {
         else {
             this.primaryKey = this.originalEntity[this.meta.primaryKeys[0]];
         }
-        if (!this.meta.compositePK
-            && this.meta.getPrimaryProp().targetMeta?.compositePK
-            && typeof this.primaryKey === 'object'
-            && this.primaryKey !== null) {
+        if (!this.meta.compositePK &&
+            this.meta.getPrimaryProp().targetMeta?.compositePK &&
+            typeof this.primaryKey === 'object' &&
+            this.primaryKey !== null) {
             this.primaryKey = this.meta.getPrimaryProp().targetMeta.primaryKeys.map(childPK => {
                 return this.primaryKey[childPK];
             });