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

package/entity/defineEntity.js

@@ -1,5 +1,7 @@
 import { types } from '../types/index.js';
 import { EntitySchema } from '../metadata/EntitySchema.js';
+// Parameter-level sync assertion lives in tests/defineEntity.test.ts to avoid
+// instantiating the full builder class in production builds (~680 instantiations).
 /** @internal */
 export class UniversalPropertyOptionsBuilder {
     '~options';
@@ -82,9 +84,6 @@ export class UniversalPropertyOptionsBuilder {
     scale(scale) {
         return this.assignOptions({ scale });
     }
-    /**
-     * Explicitly specify the auto increment of the primary key.
-     */
     autoincrement(autoincrement = true) {
         return this.assignOptions({ autoincrement });
     }
@@ -143,8 +142,8 @@ export class UniversalPropertyOptionsBuilder {
     /**
      * Set column as nullable for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}.
      */
-    nullable(nullable = true) {
-        return this.assignOptions({ nullable });
+    nullable() {
+        return this.assignOptions({ nullable: true });
     }
     /**
      * Set column as unsigned for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
@@ -152,9 +151,6 @@ export class UniversalPropertyOptionsBuilder {
     unsigned(unsigned = true) {
         return this.assignOptions({ unsigned });
     }
-    /**
-     * Set false to define {@link https://mikro-orm.io/docs/serializing#shadow-properties Shadow Property}.
-     */
     persist(persist = true) {
         return this.assignOptions({ persist });
     }
@@ -167,20 +163,20 @@ export class UniversalPropertyOptionsBuilder {
     /**
      * Enable `ScalarReference` wrapper for lazy values. Use this in combination with `lazy: true` to have a type-safe accessor object in place of the value.
      */
-    ref(ref = true) {
-        return this.assignOptions({ ref });
+    ref() {
+        return this.assignOptions({ ref: true });
     }
     /**
      * Set to true to omit the property when {@link https://mikro-orm.io/docs/serializing Serializing}.
      */
-    hidden(hidden = true) {
-        return this.assignOptions({ hidden });
+    hidden() {
+        return this.assignOptions({ hidden: true });
     }
     /**
      * Set to true to enable {@link https://mikro-orm.io/docs/transactions#optimistic-locking Optimistic Locking} via version field. (SQL only)
      */
-    version(version = true) {
-        return this.assignOptions({ version });
+    version() {
+        return this.assignOptions({ version: true });
     }
     /**
      * Set to true to enable {@link https://mikro-orm.io/docs/transactions#optimistic-locking Optimistic Locking} via concurrency fields.
@@ -213,16 +209,16 @@ export class UniversalPropertyOptionsBuilder {
      *
      * @see https://mikro-orm.io/docs/defining-entities#lazy-scalar-properties
      */
-    lazy(lazy = true, ref = true) {
-        return this.assignOptions({ lazy, ref });
+    lazy() {
+        return this.assignOptions({ lazy: true });
     }
     /**
      * Set true to define entity's unique primary key identifier.
      *
      * @see https://mikro-orm.io/docs/decorators#primarykey
      */
-    primary(primary = true) {
-        return this.assignOptions({ primary });
+    primary() {
+        return this.assignOptions({ primary: true });
     }
     /**
      * Set true to define the properties as setter. (virtual)
@@ -321,8 +317,8 @@ export class UniversalPropertyOptionsBuilder {
     ignoreSchemaChanges(...ignoreSchemaChanges) {
         return this.assignOptions({ ignoreSchemaChanges });
     }
-    array(array = true) {
-        return this.assignOptions({ array });
+    array() {
+        return this.assignOptions({ array: true });
     }
     /** for postgres, by default it uses text column with check constraint */
     nativeEnumName(nativeEnumName) {
@@ -350,8 +346,8 @@ export class UniversalPropertyOptionsBuilder {
         return this.assignOptions({ strategy });
     }
     /** 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(owner = true) {
-        return this.assignOptions({ owner });
+    owner() {
+        return this.assignOptions({ owner: true });
     }
     /** For polymorphic relations. Specifies the property name that stores the entity type discriminator. Defaults to the property name. */
     discriminator(discriminator) {
@@ -430,8 +426,8 @@ export class UniversalPropertyOptionsBuilder {
         return this.assignOptions({ updateRule });
     }
     /** Map this relation to the primary key value instead of an entity. */
-    mapToPk(mapToPk = true) {
-        return this.assignOptions({ mapToPk });
+    mapToPk() {
+        return this.assignOptions({ mapToPk: true });
     }
     /** Set the constraint type. Immediate constraints are checked for each statement, while deferred ones are only checked at the end of the transaction. Only for postgres unique constraints. */
     deferMode(deferMode) {

package/index.d.ts

@@ -2,8 +2,8 @@
  * @packageDocumentation
  * @module core
  */
-export { EntityMetadata, PrimaryKeyProp, EntityRepositoryType, OptionalProps, EagerProps, HiddenProps, Config } from './typings.js';
-export type { CompiledFunctions, Constructor, ConnectionType, Dictionary, Primary, IPrimaryKey, ObjectQuery, FilterQuery, IWrappedEntity, EntityName, EntityData, Highlighter, MaybePromise, AnyEntity, EntityClass, EntityProperty, PopulateOptions, Populate, Loaded, New, LoadedReference, LoadedCollection, IMigrator, IMigrationGenerator, MigratorEvent, GetRepository, MigrationObject, DeepPartial, PrimaryProperty, Cast, IsUnknown, EntityDictionary, EntityDTO, MigrationDiff, GenerateOptions, FilterObject, IEntityGenerator, ISeedManager, RequiredEntityData, CheckCallback, IndexCallback, FormulaCallback, FormulaTable, SchemaTable, SchemaColumns, SimpleColumnMeta, Rel, Ref, ScalarRef, EntityRef, ISchemaGenerator, UmzugMigration, MigrateOptions, MigrationResult, MigrationRow, EntityKey, EntityValue, EntityDataValue, FilterKey, EntityType, FromEntityType, Selected, IsSubset, EntityProps, ExpandProperty, ExpandScalar, FilterItemValue, ExpandQuery, Scalar, ExpandHint, FilterValue, MergeLoaded, MergeSelected, TypeConfig, AnyString, ClearDatabaseOptions, CreateSchemaOptions, EnsureDatabaseOptions, UpdateSchemaOptions, DropSchemaOptions, RefreshDatabaseOptions, AutoPath, UnboxArray, MetadataProcessor, ImportsResolver, RequiredNullable, DefineConfig, Opt, Hidden, EntitySchemaWithMeta, InferEntity, CheckConstraint, GeneratedColumnCallback, FilterDef, EntityCtor, Subquery, PopulateHintOptions, Prefixes, } from './typings.js';
+export { EntityMetadata, PrimaryKeyProp, EntityRepositoryType, OptionalProps, EagerProps, HiddenProps, Config, EntityName } from './typings.js';
+export type { CompiledFunctions, Constructor, ConnectionType, Dictionary, Primary, IPrimaryKey, ObjectQuery, FilterQuery, IWrappedEntity, InferEntityName, EntityData, Highlighter, MaybePromise, AnyEntity, EntityClass, EntityProperty, PopulateOptions, Populate, Loaded, New, LoadedReference, LoadedCollection, IMigrator, IMigrationGenerator, MigratorEvent, GetRepository, MigrationObject, DeepPartial, PrimaryProperty, Cast, IsUnknown, EntityDictionary, EntityDTO, EntityDTOFlat, EntityDTOProp, SerializeDTO, MigrationDiff, GenerateOptions, FilterObject, IMigrationRunner, IEntityGenerator, ISeedManager, SeederObject, IMigratorStorage, RequiredEntityData, CheckCallback, IndexCallback, FormulaCallback, FormulaTable, SchemaTable, SchemaColumns, SimpleColumnMeta, Rel, Ref, ScalarRef, EntityRef, ISchemaGenerator, MigrationInfo, MigrateOptions, MigrationResult, MigrationRow, EntityKey, EntityValue, EntityDataValue, FilterKey, EntityType, FromEntityType, Selected, IsSubset, EntityProps, ExpandProperty, ExpandScalar, FilterItemValue, ExpandQuery, Scalar, ExpandHint, FilterValue, MergeLoaded, MergeSelected, TypeConfig, AnyString, ClearDatabaseOptions, CreateSchemaOptions, EnsureDatabaseOptions, UpdateSchemaOptions, DropSchemaOptions, RefreshDatabaseOptions, AutoPath, UnboxArray, MetadataProcessor, ImportsResolver, RequiredNullable, DefineConfig, Opt, Hidden, EntitySchemaWithMeta, InferEntity, CheckConstraint, GeneratedColumnCallback, FilterDef, EntityCtor, Subquery, PopulateHintOptions, Prefixes, } from './typings.js';
 export * from './enums.js';
 export * from './errors.js';
 export * from './exceptions.js';

package/index.js

@@ -2,7 +2,7 @@
  * @packageDocumentation
  * @module core
  */
-export { EntityMetadata, PrimaryKeyProp, EntityRepositoryType, OptionalProps, EagerProps, HiddenProps, Config } from './typings.js';
+export { EntityMetadata, PrimaryKeyProp, EntityRepositoryType, OptionalProps, EagerProps, HiddenProps, Config, EntityName } from './typings.js';
 export * from './enums.js';
 export * from './errors.js';
 export * from './exceptions.js';

package/metadata/EntitySchema.d.ts

@@ -108,6 +108,6 @@ export declare class EntitySchema<Entity = any, Base = never, Class extends Enti
      * });
      * ```
      */
-    addHook<Event extends EventType | `${EventType}`>(event: Event, handler: NonNullable<EventSubscriber<Entity>[Event]>): this;
+    addHook<Event extends EventType | `${EventType}`, T extends Entity = Entity>(event: Event, handler: NonNullable<EventSubscriber<T>[Event]>): this;
 }
 export {};

package/metadata/MetadataDiscovery.js

@@ -1474,7 +1474,7 @@ export class MetadataDiscovery {
         }
         /* v8 ignore next */
         if (prop.default != null) {
-            return '' + this.platform.quoteVersionValue(prop.default, prop);
+            return '' + this.platform.convertVersionValue(prop.default, prop);
         }
         this.initCustomType(meta, prop, true);
         const type = prop.customType?.runtimeType ?? prop.runtimeType ?? prop.type;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-rc.1",
+  "version": "7.0.0-rc.2",
   "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",
@@ -13,7 +13,10 @@
     "./fs-utils": {
       "node": "./utils/fs-utils.js",
       "browser": "./not-supported.js"
-    }
+    },
+    "./migrations": "./utils/AbstractMigrator.js",
+    "./schema": "./utils/AbstractSchemaGenerator.js",
+    "./dataloader": "./utils/DataloaderUtils.js"
   },
   "repository": {
     "type": "git",

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;

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() {

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/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/typings.d.ts

@@ -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;
@@ -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;
@@ -385,9 +389,10 @@ 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;
@@ -951,7 +989,7 @@ type IsTrue<T> = IsNever<T> extends true ? false : T extends boolean ? T extends
 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;
+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

package/unit-of-work/ChangeSetPersister.js

@@ -272,7 +272,7 @@ export class ChangeSetPersister {
             return this.driver.nativeUpdate(changeSet.meta.class, cond, changeSet.payload, options);
         }
         if (meta.versionProperty) {
-            cond[meta.versionProperty] = this.platform.quoteVersionValue(changeSet.entity[meta.versionProperty], meta.properties[meta.versionProperty]);
+            cond[meta.versionProperty] = this.platform.convertVersionValue(changeSet.entity[meta.versionProperty], meta.properties[meta.versionProperty]);
         }
         this.checkConcurrencyKeys(meta, changeSet, cond);
         return this.driver.nativeUpdate(changeSet.meta.class, cond, changeSet.payload, options);
@@ -287,7 +287,7 @@ export class ChangeSetPersister {
             const cond = Utils.getPrimaryKeyCond(cs.originalEntity, meta.primaryKeys.concat(...meta.concurrencyCheckKeys));
             if (meta.versionProperty) {
                 // @ts-ignore
-                cond[meta.versionProperty] = this.platform.quoteVersionValue(cs.entity[meta.versionProperty], meta.properties[meta.versionProperty]);
+                cond[meta.versionProperty] = this.platform.convertVersionValue(cs.entity[meta.versionProperty], meta.properties[meta.versionProperty]);
             }
             return cond;
         });

package/utils/AbstractMigrator.d.ts

@@ -0,0 +1,101 @@
+import type { Constructor, IMigrationGenerator, IMigrationRunner, IMigrator, IMigratorStorage, MaybePromise, Migration, MigrationInfo, MigrationRow, MigratorEvent } from '../typings.js';
+import type { Transaction } from '../connections/Connection.js';
+import type { Configuration, MigrationsOptions } from './Configuration.js';
+import type { EntityManagerType, IDatabaseDriver } from '../drivers/IDatabaseDriver.js';
+interface RunnableMigration {
+    name: string;
+    path?: string;
+    up: () => MaybePromise<void>;
+    down: () => MaybePromise<void>;
+}
+type MigrateOptions = {
+    from?: string | number;
+    to?: string | number;
+    migrations?: string[];
+    transaction?: Transaction;
+};
+export declare abstract class AbstractMigrator<D extends IDatabaseDriver> implements IMigrator {
+    protected readonly em: D[typeof EntityManagerType];
+    protected runner: IMigrationRunner;
+    protected storage: IMigratorStorage;
+    protected generator: IMigrationGenerator;
+    protected readonly driver: D;
+    protected readonly config: Configuration;
+    protected readonly options: MigrationsOptions;
+    protected absolutePath: string;
+    protected initialized: boolean;
+    private readonly listeners;
+    constructor(em: D[typeof EntityManagerType]);
+    protected abstract createRunner(): IMigrationRunner;
+    protected abstract createStorage(): IMigratorStorage;
+    protected abstract getDefaultGenerator(): IMigrationGenerator;
+    abstract create(path?: string, blank?: boolean, initial?: boolean, name?: string): Promise<{
+        fileName: string;
+        code: string;
+        diff: {
+            up: string[];
+            down: string[];
+        };
+    }>;
+    abstract checkSchema(): Promise<boolean>;
+    abstract createInitial(path?: string, name?: string, blank?: boolean): Promise<{
+        fileName: string;
+        code: string;
+        diff: {
+            up: string[];
+            down: string[];
+        };
+    }>;
+    /**
+     * @inheritDoc
+     */
+    on(eventName: MigratorEvent, listener: (event: MigrationInfo) => MaybePromise<void>): this;
+    /**
+     * @inheritDoc
+     */
+    off(eventName: MigratorEvent, listener: (event: MigrationInfo) => MaybePromise<void>): this;
+    /**
+     * @inheritDoc
+     */
+    getExecuted(): Promise<MigrationRow[]>;
+    /**
+     * @inheritDoc
+     */
+    getPending(): Promise<MigrationInfo[]>;
+    /**
+     * @inheritDoc
+     */
+    up(options?: string | string[] | MigrateOptions): Promise<MigrationInfo[]>;
+    /**
+     * @inheritDoc
+     */
+    down(options?: string | string[] | Omit<MigrateOptions, 'from'>): Promise<MigrationInfo[]>;
+    abstract getStorage(): IMigratorStorage;
+    protected init(): Promise<void>;
+    protected initServices(): void;
+    protected resolve(params: {
+        name: string;
+        path: string;
+    }): RunnableMigration;
+    protected initialize(MigrationClass: Constructor<Migration>, name: string): RunnableMigration;
+    /**
+     * Checks if `src` folder exists, it so, tries to adjust the migrations and seeders paths automatically to use it.
+     * If there is a `dist` or `build` folder, it will be used for the JS variant (`path` option), while the `src` folder will be
+     * used for the TS variant (`pathTs` option).
+     *
+     * If the default folder exists (e.g. `/migrations`), the config will respect that, so this auto-detection should not
+     * break existing projects, only help with the new ones.
+     */
+    private detectSourceFolder;
+    private registerDefaultListeners;
+    private emit;
+    private discoverMigrations;
+    private executeMigrations;
+    private filterUp;
+    private filterDown;
+    private getMigrationFilename;
+    private prefix;
+    private runMigrations;
+    private runInTransaction;
+}
+export {};