Skip to main content
Version: Next

@mikro-orm/core

Index

Classes

Enumerations

Functions

Interfaces

Type Aliases

Variables

Type Aliases

AnyEntity

AnyEntity<T>: Partial<T>

Type parameters

  • T = any

AutoPath

AutoPath<O, P, E, D>: P extends boolean ? P : [D] extends [never] ? never : P extends any ? P extends string ? ((P & `${string}.`) extends never ? P : P & `${string}.`) extends infer Q ? Q extends `${infer A}.${infer B}` ? A extends StringKeys<O, E> ? `${A}.${AutoPath<NonNullable<GetStringKey<..., ..., ...>>, B, E, Prev[D]>}` : never : Q extends StringKeys<O, E> ? (NonNullable<...> extends unknown ? Exclude<..., ...> : never) | (StringKeys<..., ...> extends never ? never : `${...}.`) : StringKeys<O, E> | `${CollectionKeys<O>}:ref` : never : never : never

Type parameters

  • O
  • P: string | boolean
  • E: string = never
  • D: Prev[number] = 9

Cast

Cast<T, R>: T extends R ? T : R

Type parameters

  • T
  • R

CheckCallback

CheckCallback<T>: (columns: Record<keyof T, string>) => string

Type parameters

  • T

Type declaration

    • (columns: Record<keyof T, string>): string

    • Parameters

      • columns: Record<keyof T, string>

      Returns string

CheckOptions

CheckOptions<T>: CheckConstraint<T>

Type parameters

  • T = any

ConnectionType

ConnectionType: read | write

Constructor

Constructor<T>: new (...args: any[]) => T

Type parameters

  • T = unknown

Type declaration

    • new (...args: any[]): T

    • Parameters

      • rest...args: any[]

      Returns T

DeepPartial

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]> }

Type parameters

  • T

DefineConfig

DefineConfig<T>: T & { [___config]?: 1 }

Type parameters

Dictionary

Dictionary<T>: {}

Type parameters

  • T = any

Type declaration

  • [k string]: T

EmbeddableOptions

EmbeddableOptions: { abstract?: boolean; discriminatorColumn?: string; discriminatorMap?: Dictionary<string>; discriminatorValue?: number | string }

Type declaration

  • optionalabstract?: boolean
  • optionaldiscriminatorColumn?: string
  • optionaldiscriminatorMap?: Dictionary<string>
  • optionaldiscriminatorValue?: number | string

EmbeddedOptions

EmbeddedOptions: { array?: boolean; entity?: string | () => AnyEntity | AnyEntity[]; groups?: string[]; hidden?: boolean; nullable?: boolean; object?: boolean; persist?: boolean; prefix?: string | boolean; prefixMode?: EmbeddedPrefixMode; serializedName?: string; serializer?: (value: any) => any; type?: string }

Type declaration

  • optionalarray?: boolean
  • optionalentity?: string | () => AnyEntity | AnyEntity[]
  • optionalgroups?: string[]
  • optionalhidden?: boolean
  • optionalnullable?: boolean
  • optionalobject?: boolean
  • optionalpersist?: boolean
  • optionalprefix?: string | boolean
  • optionalprefixMode?: EmbeddedPrefixMode
  • optionalserializedName?: string
  • optionalserializer?: (value: any) => any
      • (value: any): any

      • Parameters

        • value: any

        Returns any

  • optionaltype?: string

EmbeddedPrefixMode

EmbeddedPrefixMode: absolute | relative

With absolute the prefix is set at the root of the entity (regardless of the nesting level)

EntityClass

EntityClass<T>: Function & { prototype: T }

Type parameters

  • T

EntityClassGroup

EntityClassGroup<T>: { entity: EntityClass<T>; schema: EntityMetadata<T> | EntitySchema<T> }

Type parameters

  • T

Type declaration

EntityDTO

EntityDTO<T, C>: { [ K in keyof T as DTORequiredKeys<T, K> ]: EntityDTOProp<T, T[K], C> | AddOptional<T[K]> } & { [ K in keyof T as DTOOptionalKeys<T, K> ]?: EntityDTOProp<T, T[K], C> | AddOptional<T[K]> }

Type parameters

EntityData

EntityData<T, C>: { [ K in EntityKey<T> ]?: EntityDataItem<T[K], C> }

Type parameters

  • T
  • C: boolean = false

EntityDictionary

EntityDictionary<T>: EntityData<T> & Record<any, any>

Type parameters

  • T

EntityField

EntityField<T, P>: keyof T | PopulatePath.ALL | AutoPath<T, P, `${PopulatePath.ALL}`>

Type parameters

  • T
  • P: string = PopulatePath.ALL

EntityKey

EntityKey<T, B>: string & { [ K in keyof T ]-?: CleanKeys<T, K, B> extends never ? never : K }[keyof T]

Type parameters

  • T = unknown
  • B: boolean = false

EntityLoaderOptions

EntityLoaderOptions<Entity, Fields, Excludes>: { connectionType?: ConnectionType; convertCustomTypes?: boolean; exclude?: readonly EntityField<Entity, Excludes>[]; fields?: readonly EntityField<Entity, Fields>[]; filters?: Dictionary<boolean | Dictionary> | string[] | boolean; ignoreLazyScalarProperties?: boolean; lockMode?: Exclude<LockMode, LockMode.OPTIMISTIC>; logging?: LoggingOptions; lookup?: boolean; orderBy?: QueryOrderMap<Entity> | QueryOrderMap<Entity>[]; populateWhere?: PopulateHint | `${PopulateHint}`; refresh?: boolean; schema?: string; strategy?: LoadStrategy; validate?: boolean; where?: FilterQuery<Entity> }

Type parameters

  • Entity
  • Fields: string = PopulatePath.ALL
  • Excludes: string = never

Type declaration

EntityName

EntityName<T>: string | EntityClass<T> | EntitySchema<T, any> | { name: string }

Type parameters

  • T

EntityOptions

EntityOptions<T>: { abstract?: boolean; collection?: string; comment?: string; discriminatorColumn?: string; discriminatorMap?: Dictionary<string>; discriminatorValue?: number | string; expression?: string | (em: any, where: FilterQuery<T>, options: FindOptions<T, any, any, any>) => object; forceConstructor?: boolean; readonly?: boolean; repository?: () => Constructor; schema?: string; tableName?: string; virtual?: boolean }

Type parameters

  • T

Type declaration

  • optionalabstract?: boolean
  • optionalcollection?: string
  • optionalcomment?: string
  • optionaldiscriminatorColumn?: string
  • optionaldiscriminatorMap?: Dictionary<string>
  • optionaldiscriminatorValue?: number | string
  • optionalexpression?: string | (em: any, where: FilterQuery<T>, options: FindOptions<T, any, any, any>) => object
  • optionalforceConstructor?: boolean
  • optionalreadonly?: boolean
  • optionalrepository?: () => Constructor
  • optionalschema?: string
  • optionaltableName?: string
  • optionalvirtual?: boolean

EntityProps

EntityProps<T>: { -readonly [ K in EntityKey<T> ]?: T[K] }

Type parameters

  • T

EntityRef

EntityRef<T>: true extends IsUnknown<PrimaryProperty<T>> ? Reference<T> : IsAny<T> extends true ? Reference<T> : { [ K in PrimaryProperty<T> & keyof T ]: T[K] } & Reference<T>

Alias for Reference<T> & { id: number } (see Ref).

Type parameters

  • T: object

EntitySchemaMetadata

EntitySchemaMetadata<Entity, Base>: Omit<Partial<EntityMetadata<Entity>>, name | properties | extends> & ({ name: string } | { class: EntityClass<Entity>; name?: string }) & { extends?: string | EntitySchema<Base> } & { properties?: { [ Key in keyof OmitBaseProps<Entity, Base> as CleanKeys<OmitBaseProps<Entity, Base>, Key> ]-?: EntitySchemaProperty<ExpandProperty<NonNullable<Entity[Key]>>, Entity> } }

Type parameters

  • Entity
  • Base = never

EntitySchemaProperty

EntitySchemaProperty<Target, Owner>: ({ kind: ReferenceKind.MANY_TO_ONE | m:1 } & TypeDef<Target> & ManyToOneOptions<Owner, Target>) | ({ kind: ReferenceKind.ONE_TO_ONE | 1:1 } & TypeDef<Target> & OneToOneOptions<Owner, Target>) | ({ kind: ReferenceKind.ONE_TO_MANY | 1:m } & TypeDef<Target> & OneToManyOptions<Owner, Target>) | ({ kind: ReferenceKind.MANY_TO_MANY | m:n } & TypeDef<Target> & ManyToManyOptions<Owner, Target>) | ({ kind: ReferenceKind.EMBEDDED | embedded } & EmbeddedTypeDef<Target> & EmbeddedOptions & PropertyOptions<Owner>) | ({ enum: true } & EnumOptions<Owner>) | (TypeDef<Target> & PropertyOptions<Owner>)

Type parameters

  • Target
  • Owner

EntityType

EntityType<T>: T | LoadedEntityType<T>

Type parameters

  • T

EntityValue

EntityValue<T>: T[EntityKey<T>]

Type parameters

  • T

ExpandHint

ExpandHint<T, L>: L | AddEager<T>

Type parameters

  • T
  • L: string

ExpandProperty

ExpandProperty<T>: T extends Reference<infer U> ? NonNullable<U> : T extends Collection<infer U, any> ? NonNullable<U> : T extends infer U[] ? NonNullable<U> : NonNullable<T>

Type parameters

  • T

ExpandQuery

ExpandQuery<T>: T extends object ? T extends Scalar ? never : FilterQuery<T> : FilterValue<T>

Type parameters

  • T

ExpandScalar

ExpandScalar<T>: null | (T extends string ? T | RegExp : T extends Date ? Date | string : T extends bigint ? bigint | string | number : T)

Type parameters

  • T

FilterItemValue

FilterItemValue<T>: T | ExpandScalar<T> | Primary<T>

Type parameters

  • T

FilterKey

FilterKey<T>: keyof FilterQuery<T>

Type parameters

  • T

FilterObject

FilterObject<T>: { -readonly [ K in EntityKey<T> ]?: ExpandQuery<ExpandProperty<T[K]>> | FilterValue<ExpandProperty<T[K]>> | null }

Type parameters

  • T

FilterOptions

FilterOptions: Dictionary<boolean | Dictionary> | string[] | boolean

FilterQuery

FilterQuery<T>: ObjectQuery<T> | NonNullable<ExpandScalar<Primary<T>>> | NonNullable<EntityProps<T> & OperatorMap<T>> | FilterQuery<T>[]

Type parameters

  • T

FilterValue

FilterValue<T>: OperatorMap<FilterItemValue<T>> | FilterItemValue<T> | FilterItemValue<T>[] | null

Type parameters

  • T

FromEntityType

FromEntityType<T>: T extends LoadedEntityType<infer U> ? U : T

Type parameters

  • T

GetRepository

GetRepository<Entity, Fallback>: Entity[typeof EntityRepositoryType] extends EntityRepository<Entity> | undefined ? NonNullable<Entity[typeof EntityRepositoryType]> : Fallback

Type parameters

  • Entity: {}
  • Fallback

Hidden

Hidden<T>: T & { [___hidden]?: 1 }

Type parameters

  • T = unknown

IPrimaryKey

IPrimaryKey<T>: T

Type parameters

  • T: IPrimaryKeyValue = IPrimaryKeyValue

IType

IType<Runtime, Raw, Serialized>: Runtime & { __raw?: Raw; __runtime?: Runtime; __serialized?: Serialized }

Type parameters

  • Runtime
  • Raw
  • Serialized = Raw

ImportsResolver

ImportsResolver: (alias: string, basePath: string, extension: .js | , originFileName: string) => { name: string; path: string } | undefined

Type declaration

    • (alias: string, basePath: string, extension: .js | , originFileName: string): { name: string; path: string } | undefined

    • Parameters

      • alias: string
      • basePath: string
      • extension: .js |
      • originFileName: string

      Returns { name: string; path: string } | undefined

IsSubset

IsSubset<T, U>: keyof U extends keyof T ? {} : Dictionary extends U ? {} : { [ K in keyof U as K extends keyof T ? never : CleanKeys<U, K> ]: never }

Type parameters

  • T
  • U

IsUnknown

IsUnknown<T>: T extends unknown ? unknown extends T ? true : never : never

Type parameters

  • T

Loaded

Loaded<T, L, F, E>: LoadedInternal<T, L, F, E> & { [___loadedType]?: T }

Represents entity with its loaded relations (populate hint) and selected properties (fields hint).

Type parameters

  • T
  • L: string = never
  • F: string = *
  • E: string = never

LoggerNamespace

LoggerNamespace: query | query-params | schema | discovery | info

LoggingOptions

LoggingOptions: Pick<LogContext, label | enabled | debugMode>

Logger options to modify format output and overrides, including a label and additional properties that can be accessed by custom loggers.

Differs from LoggerOptions in terms of how they are used; this type is primarily a public type meant to be used within methods like em.find().

@example
await em.findOne(User, 1, { logger: { label: 'user middleware' } };
// [query] (user middleware) select * from user where id = 1;

MergeLoaded

MergeLoaded<T, U, P, F, E, R>: T extends Loaded<U, infer PP, infer FF, infer EE> ? string extends FF ? Loaded<T, P, F, AnyStringToNever<EE> | E> : string extends P ? Loaded<U, never, F | (FF & string), MergeExcludes<F | (FF & string), EE | E>> : Loaded<U, P | AnyStringToNever<PP>, MergeFields<F, AnyStringToNever<FF>, P, PP>, MergeExcludes<MergeFields<F, AnyStringToNever<FF>, P, PP>, (R extends true ? never : EE) | E>> : Loaded<T, P, F>

Type parameters

  • T
  • U
  • P: string
  • F: string
  • E: string
  • R: boolean = false

MergeSelected

MergeSelected<T, U, F>: T extends Loaded<infer TT, infer P, infer FF, infer E> ? IsNever<Exclude<E, F>> extends true ? Loaded<TT, P, AnyStringToNever<F> | AnyStringToNever<FF>> : Loaded<TT, AnyStringToNever<P>, AnyStringToNever<FF>, AnyStringToNever<Exclude<E, F>>> : T

Type parameters

  • T
  • U
  • F: string

MetadataProcessor

MetadataProcessor: (metadata: EntityMetadata[], platform: Platform) => MaybePromise<void>

Type declaration

MigrateOptions

MigrateOptions: { from?: string | number; migrations?: string[]; to?: string | number; transaction?: Transaction }

Type declaration

  • optionalfrom?: string | number
  • optionalmigrations?: string[]
  • optionalto?: string | number
  • optionaltransaction?: Transaction

MigrationResult

MigrationResult: { code: string; diff: MigrationDiff; fileName: string }

Type declaration

MigrationRow

MigrationRow: { executed_at: Date; name: string }

Type declaration

  • executed_at: Date
  • name: string

MigrationsOptions

MigrationsOptions: { allOrNothing?: boolean; disableForeignKeys?: boolean; dropTables?: boolean; emit?: js | ts | cjs; fileName?: (timestamp: string, name?: string) => string; generator?: Constructor<IMigrationGenerator>; glob?: string; migrationsList?: (MigrationObject | Constructor<Migration>)[]; path?: string; pathTs?: string; safe?: boolean; silent?: boolean; snapshot?: boolean; snapshotName?: string; tableName?: string; transactional?: boolean }

Type declaration

  • optionalallOrNothing?: boolean
  • optionaldisableForeignKeys?: boolean
  • optionaldropTables?: boolean
  • optionalemit?: js | ts | cjs
  • optionalfileName?: (timestamp: string, name?: string) => string
      • (timestamp: string, name?: string): string

      • Parameters

        • timestamp: string
        • optionalname: string

        Returns string

  • optionalgenerator?: Constructor<IMigrationGenerator>
  • optionalglob?: string
  • optionalmigrationsList?: (MigrationObject | Constructor<Migration>)[]
  • optionalpath?: string
  • optionalpathTs?: string
  • optionalsafe?: boolean
  • optionalsilent?: boolean
  • optionalsnapshot?: boolean
  • optionalsnapshotName?: string
  • optionaltableName?: string
  • optionaltransactional?: boolean

New

New<T, P>: Loaded<T, P>

Type parameters

  • T
  • P: string = string

NoInfer

NoInfer<T>: [T][T extends any ? 0 : never]

Type parameters

  • T

ObjectQuery

ObjectQuery<T>: OperatorMap<T> & FilterObject<T>

Type parameters

  • T

Opt

Opt<T>: T & { [___optional]?: 1 }

Type parameters

  • T = unknown

Options

Options<D, EM>: Pick<MikroORMOptions<D, EM>, Exclude<keyof MikroORMOptions<D, EM>, keyof typeof Configuration.DEFAULTS>> & Partial<MikroORMOptions<D, EM>>

Type parameters

OrderDefinition

OrderDefinition<T>: (QueryOrderMap<T> & { 0?: never }) | QueryOrderMap<T>[]

Type parameters

  • T

Populate

Populate<T, P>: readonly AutoPath<T, P, `${PopulatePath}`>[] | false

Type parameters

  • T
  • P: string = never

PopulateOptions

PopulateOptions<T>: { all?: boolean; children?: PopulateOptions<T[keyof T]>[]; field: EntityKey<T>; filter?: boolean; strategy?: LoadStrategy }

Type parameters

  • T

Type declaration

Primary

Primary<T>: IsAny<T> extends true ? any : T extends { [PrimaryKeyProp]?: infer PK } ? PK extends keyof T ? ReadonlyPrimary<UnwrapPrimary<T[PK]>> : PK extends keyof T[] ? ReadonlyPrimary<PrimaryPropToType<T, PK>> : PK : T extends { _id?: infer PK } ? ReadonlyPrimary<PK> | string : T extends { uuid?: infer PK } ? ReadonlyPrimary<PK> : T extends { id?: infer PK } ? ReadonlyPrimary<PK> : T

Type parameters

  • T

PrimaryProperty

PrimaryProperty<T>: T extends { [PrimaryKeyProp]?: infer PK } ? PK extends keyof T ? PK : PK extends any[] ? PK[number] : never : T extends { _id?: any } ? T extends { id?: any } ? id | _id : _id : T extends { uuid?: any } ? uuid : T extends { id?: any } ? id : never

Type parameters

  • T

QBFilterQuery

QBFilterQuery<T>: ObjectQuery<T> | Dictionary

Type parameters

  • T = any

QBQueryOrderMap

QBQueryOrderMap<T>: QueryOrderMap<T> | Dictionary

Type parameters

  • T

QueryOrderKeys

QueryOrderKeys<T>: QueryOrderKeysFlat | QueryOrderMap<T>

Type parameters

  • T

QueryOrderKeysFlat

QueryOrderKeysFlat: QueryOrder | QueryOrderNumeric | keyof typeof QueryOrder

QueryOrderMap

QueryOrderMap<T>: { [ K in EntityKey<T> ]?: QueryOrderKeys<ExpandProperty<T[K]>> }

Type parameters

  • T

Ref

Ref<T>: T extends any ? IsAny<T> extends true ? Reference<T & object> : T extends Scalar ? ScalarReference<T> : EntityRef<T & object> : never

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.

Type parameters

  • T

Rel

Rel<T>: T

Identity type that can be used to get around issues with cycles in bidirectional relations. It will disable reflect-metadata inference.

Type parameters

  • T

RequiredEntityData

RequiredEntityData<T, I, C>: { [ K in keyof T as RequiredKeys<T, K, I> ]: T[K] | RequiredEntityDataProp<T[K], T, C> | Primary<T[K]> } & { [ K in keyof T as OptionalKeys<T, K, I> ]?: T[K] | RequiredEntityDataProp<T[K], T, C> | Primary<T[K]> | null }

Type parameters

  • T
  • I = never
  • C: boolean = false

Scalar

Scalar: boolean | number | string | bigint | symbol | Date | RegExp | Uint8Array | { toHexString: any }

ScalarRef

ScalarRef<T>: ScalarReference<T>

Alias for ScalarReference (see Ref).

Type parameters

  • T

Selected

Selected<T, L, F>: { [ 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] } & { [___selectedType]?: T }

Type parameters

  • T
  • L: string = never
  • F: string = *

Transaction

Transaction<T>: T

Type parameters

  • T = any

TransactionEventType

TransactionEventType: EventType.beforeTransactionStart | EventType.afterTransactionStart | EventType.beforeTransactionCommit | EventType.afterTransactionCommit | EventType.beforeTransactionRollback | EventType.afterTransactionRollback

UmzugMigration

UmzugMigration: { name: string; path?: string }

Type declaration

  • name: string
  • optionalpath?: string

UnboxArray

UnboxArray<T>: T extends any[] ? ArrayElement<T> : T

Type parameters

  • T

Variables

constARRAY_OPERATORS

ARRAY_OPERATORS: string[] = ...

constConfig

Config: typeof Config = ...

constEagerProps

EagerProps: typeof EagerProps = ...

constEntityManagerType

EntityManagerType: typeof EntityManagerType = ...

constEntityRepositoryType

EntityRepositoryType: typeof EntityRepositoryType = ...

constEventTypeMap

EventTypeMap: Record<EventType, number> = ...

constHiddenProps

HiddenProps: typeof HiddenProps = ...

constJSON_KEY_OPERATORS

JSON_KEY_OPERATORS: string[] = ...

constJsonProperty

JsonProperty: typeof JsonProperty = ...

constObjectBindingPattern

ObjectBindingPattern: typeof ObjectBindingPattern = ...

constOptionalProps

OptionalProps: typeof OptionalProps = ...

constPrimaryKeyProp

PrimaryKeyProp: typeof PrimaryKeyProp = ...

constSCALAR_TYPES

SCALAR_TYPES: string[] = ...

constt

t: { array: typeof ArrayType; bigint: typeof BigIntType; blob: typeof BlobType; boolean: typeof BooleanType; character: typeof CharacterType; date: typeof DateType; datetime: typeof DateTimeType; decimal: typeof DecimalType; double: typeof DoubleType; enum: typeof EnumType; enumArray: typeof EnumArrayType; float: typeof FloatType; integer: typeof IntegerType; interval: typeof IntervalType; json: typeof JsonType; mediumint: typeof MediumIntType; smallint: typeof SmallIntType; string: typeof StringType; text: typeof TextType; time: typeof TimeType; tinyint: typeof TinyIntType; uint8array: typeof Uint8ArrayType; unknown: typeof UnknownType; uuid: typeof UuidType } = types

Type declaration

consttypes

types: { array: typeof ArrayType; bigint: typeof BigIntType; blob: typeof BlobType; boolean: typeof BooleanType; character: typeof CharacterType; date: typeof DateType; datetime: typeof DateTimeType; decimal: typeof DecimalType; double: typeof DoubleType; enum: typeof EnumType; enumArray: typeof EnumArrayType; float: typeof FloatType; integer: typeof IntegerType; interval: typeof IntervalType; json: typeof JsonType; mediumint: typeof MediumIntType; smallint: typeof SmallIntType; string: typeof StringType; text: typeof TextType; time: typeof TimeType; tinyint: typeof TinyIntType; uint8array: typeof Uint8ArrayType; unknown: typeof UnknownType; uuid: typeof UuidType } = ...

Type declaration

Page Options