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

package/MikroORM.d.ts

@@ -3,13 +3,15 @@ import { type EntitySchema } from './metadata/EntitySchema.js';
 import { MetadataStorage } from './metadata/MetadataStorage.js';
 import { Configuration, type Options } from './utils/Configuration.js';
 import type { EntityManager } from './EntityManager.js';
-import type { Constructor, EntityMetadata, EntityName, IEntityGenerator, IMigrator, ISeedManager } from './typings.js';
+import type { AnyEntity, Constructor, EntityClass, EntityClassGroup, EntityMetadata, EntityName, IEntityGenerator, IMigrator, ISeedManager } from './typings.js';
 /**
  * Helper class for bootstrapping the MikroORM.
  */
-export declare class MikroORM<Driver extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager = Driver[typeof EntityManagerType] & EntityManager> {
+export declare class MikroORM<Driver extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager = Driver[typeof EntityManagerType] & EntityManager, Entities extends (string | EntityClass<AnyEntity> | EntityClassGroup<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntityClassGroup<AnyEntity> | EntitySchema)[]> {
     /** The global EntityManager instance. If you are using `RequestContext` helper, it will automatically pick the request specific context under the hood */
-    em: EM;
+    em: EM & {
+        '~entities'?: Entities;
+    };
     readonly driver: Driver;
     readonly config: Configuration<Driver>;
     private metadata;
@@ -19,7 +21,7 @@ export declare class MikroORM<Driver extends IDatabaseDriver = IDatabaseDriver,
      * Initialize the ORM, load entity metadata, create EntityManager and connect to the database.
      * If you omit the `options` parameter, your CLI config will be used.
      */
-    static init<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager>(options?: Options<D, EM>): Promise<MikroORM<D, EM>>;
+    static init<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager, Entities extends (string | EntityClass<AnyEntity> | EntityClassGroup<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntityClassGroup<AnyEntity> | EntitySchema)[]>(options?: Options<D, EM, Entities>): Promise<MikroORM<D, EM, Entities>>;
     /**
      * Synchronous variant of the `init` method with some limitations:
      * - database connection will be established when you first interact with the database (or you can use `orm.connect()` explicitly)
@@ -27,7 +29,7 @@ export declare class MikroORM<Driver extends IDatabaseDriver = IDatabaseDriver,
      * - no support for folder based discovery
      * - no check for mismatched package versions
      */
-    static initSync<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager>(options: Options<D, EM>): MikroORM<D, EM>;
+    static initSync<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager, Entities extends (string | EntityClass<AnyEntity> | EntityClassGroup<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntityClassGroup<AnyEntity> | EntitySchema)[]>(options: Options<D, EM, Entities>): MikroORM<D, EM, Entities>;
     constructor(options: Options<Driver, EM>);
     /**
      * Connects to the database.

package/MikroORM.js

@@ -35,7 +35,6 @@ export class MikroORM {
             }
         }
         options = Utils.mergeConfig(options, env);
-        ConfigurationLoader.commonJSCompat(options);
         if ('DRIVER' in this && !options.driver) {
             options.driver = this.DRIVER;
         }

package/README.md

@@ -11,7 +11,6 @@ TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-or
 [![Chat on discord](https://img.shields.io/discord/1214904142443839538?label=discord&color=blue)](https://discord.gg/w8bjxFHS7X)
 [![Downloads](https://img.shields.io/npm/dm/@mikro-orm/core.svg)](https://www.npmjs.com/package/@mikro-orm/core)
 [![Coverage Status](https://img.shields.io/coveralls/mikro-orm/mikro-orm.svg)](https://coveralls.io/r/mikro-orm/mikro-orm?branch=master)
-[![Maintainability](https://api.codeclimate.com/v1/badges/27999651d3adc47cfa40/maintainability)](https://codeclimate.com/github/mikro-orm/mikro-orm/maintainability)
 [![Build Status](https://github.com/mikro-orm/mikro-orm/workflows/tests/badge.svg?branch=master)](https://github.com/mikro-orm/mikro-orm/actions?workflow=tests)
 
 ## 🤔 Unit of What?
@@ -141,7 +140,7 @@ There is also auto-generated [CHANGELOG.md](CHANGELOG.md) file based on commit m
 - [Composite and Foreign Keys as Primary Key](https://mikro-orm.io/docs/composite-keys)
 - [Filters](https://mikro-orm.io/docs/filters)
 - [Using `QueryBuilder`](https://mikro-orm.io/docs/query-builder)
-- [Preloading Deeply Nested Structures via populate](https://mikro-orm.io/docs/nested-populate)
+- [Populating relations](https://mikro-orm.io/docs/populating-relations)
 - [Property Validation](https://mikro-orm.io/docs/property-validation)
 - [Lifecycle Hooks](https://mikro-orm.io/docs/events#hooks)
 - [Vanilla JS Support](https://mikro-orm.io/docs/usage-with-js)
@@ -382,6 +381,8 @@ See also the list of contributors who [participated](https://github.com/mikro-or
 
 Please ⭐️ this repository if this project helped you!
 
+> If you'd like to support my open-source work, consider sponsoring me directly at [github.com/sponsors/b4nan](https://github.com/sponsors/b4nan).
+
 ## 📝 License
 
 Copyright © 2018 [Martin Adámek](https://github.com/b4nan).

package/cache/FileCacheAdapter.d.ts

@@ -3,12 +3,13 @@ export declare class FileCacheAdapter implements SyncCacheAdapter {
     private readonly options;
     private readonly baseDir;
     private readonly pretty;
+    private readonly hashAlgorithm;
     private readonly VERSION;
     private cache;
     constructor(options: {
         cacheDir: string;
         combined?: boolean | string;
-    }, baseDir: string, pretty?: boolean);
+    }, baseDir: string, pretty?: boolean, hashAlgorithm?: 'md5' | 'sha256');
     /**
      * @inheritDoc
      */

package/cache/FileCacheAdapter.js

@@ -1,16 +1,18 @@
-import globby from 'globby';
+import { globSync } from 'tinyglobby';
 import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'node:fs';
 import { Utils } from '../utils/Utils.js';
 export class FileCacheAdapter {
     options;
     baseDir;
     pretty;
+    hashAlgorithm;
     VERSION = Utils.getORMVersion();
     cache = {};
-    constructor(options, baseDir, pretty = false) {
+    constructor(options, baseDir, pretty = false, hashAlgorithm = 'md5') {
         this.options = options;
         this.baseDir = baseDir;
         this.pretty = pretty;
+        this.hashAlgorithm = hashAlgorithm;
     }
     /**
      * @inheritDoc
@@ -51,7 +53,7 @@ export class FileCacheAdapter {
      */
     clear() {
         const path = this.path('*');
-        const files = globby.sync(path);
+        const files = globSync(path);
         files.forEach(file => unlinkSync(file));
         this.cache = {};
     }
@@ -77,6 +79,6 @@ export class FileCacheAdapter {
             return null;
         }
         const contents = readFileSync(origin);
-        return Utils.hash(contents.toString() + this.VERSION);
+        return Utils.hash(contents.toString() + this.VERSION, undefined, this.hashAlgorithm);
     }
 }

package/connections/Connection.d.ts

@@ -45,15 +45,17 @@ export declare abstract class Connection {
         readOnly?: boolean;
         ctx?: Transaction;
         eventBroadcaster?: TransactionEventBroadcaster;
+        loggerContext?: LogContext;
     }): Promise<T>;
     begin(options?: {
         isolationLevel?: IsolationLevel;
         readOnly?: boolean;
         ctx?: Transaction;
         eventBroadcaster?: TransactionEventBroadcaster;
+        loggerContext?: LogContext;
     }): Promise<Transaction>;
-    commit(ctx: Transaction, eventBroadcaster?: TransactionEventBroadcaster): Promise<void>;
-    rollback(ctx: Transaction, eventBroadcaster?: TransactionEventBroadcaster): Promise<void>;
+    commit(ctx: Transaction, eventBroadcaster?: TransactionEventBroadcaster, loggerContext?: LogContext): Promise<void>;
+    rollback(ctx: Transaction, eventBroadcaster?: TransactionEventBroadcaster, loggerContext?: LogContext): Promise<void>;
     abstract execute<T>(query: string, params?: any[], method?: 'all' | 'get' | 'run', ctx?: Transaction): Promise<QueryResult<T> | any | any[]>;
     getConnectionOptions(): ConnectionConfig;
     getClientUrl(): string;

package/connections/Connection.js

@@ -46,10 +46,10 @@ export class Connection {
     async begin(options) {
         throw new Error(`Transactions are not supported by current driver`);
     }
-    async commit(ctx, eventBroadcaster) {
+    async commit(ctx, eventBroadcaster, loggerContext) {
         throw new Error(`Transactions are not supported by current driver`);
     }
-    async rollback(ctx, eventBroadcaster) {
+    async rollback(ctx, eventBroadcaster, loggerContext) {
         throw new Error(`Transactions are not supported by current driver`);
     }
     getConnectionOptions() {

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

@@ -1,18 +1,12 @@
-import type { AnyEntity } from '../typings.js';
-export declare function Embedded<T extends object>(type?: EmbeddedOptions | (() => AnyEntity), options?: EmbeddedOptions): (target: AnyEntity, propertyName: string) => any;
+import type { AnyEntity, EntityName } from '../typings.js';
+import type { PropertyOptions } from './Property.js';
+export declare function Embedded<Owner extends object, Target>(type?: EmbeddedOptions<Owner, Target> | (() => EntityName<Target> | EntityName<Target>[]), options?: EmbeddedOptions<Owner, Target>): (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 = {
-    entity?: string | (() => AnyEntity | AnyEntity[]);
-    type?: string;
+export interface EmbeddedOptions<Owner, Target> extends PropertyOptions<Owner> {
+    entity?: string | (() => EntityName<Target> | EntityName<Target>[]);
     prefix?: string | boolean;
     prefixMode?: EmbeddedPrefixMode;
-    nullable?: boolean;
     object?: boolean;
     array?: boolean;
-    hidden?: boolean;
-    serializer?: (value: any) => any;
-    serializedName?: string;
-    groups?: string[];
-    persist?: boolean;
-};
+}

package/decorators/Entity.d.ts

@@ -1,18 +1,33 @@
-import type { AnyString, Constructor, Dictionary, EntityClass, FilterQuery } from '../typings.js';
+import type { AnyString, Constructor, Dictionary, EntityClass, ObjectQuery } from '../typings.js';
 import type { FindOptions } from '../drivers/IDatabaseDriver.js';
 export declare function Entity<T extends EntityClass<unknown>>(options?: EntityOptions<T>): (target: T) => void;
-export type EntityOptions<T> = {
+export type EntityOptions<T, E = T extends EntityClass<infer P> ? P : T> = {
+    /** Override default collection/table name. Alias for `collection`. */
     tableName?: string;
+    /** Sets the schema name. */
     schema?: string;
+    /** Override default collection/table name. Alias for `tableName`. */
     collection?: string;
+    /** For {@doclink inheritance-mapping#single-table-inheritance | Single Table Inheritance}. */
     discriminatorColumn?: (T extends EntityClass<infer P> ? keyof P : string) | AnyString;
+    /** For {@doclink inheritance-mapping#single-table-inheritance | Single Table Inheritance}. */
     discriminatorMap?: Dictionary<string>;
+    /** For {@doclink inheritance-mapping#single-table-inheritance | Single Table Inheritance}. */
     discriminatorValue?: number | string;
+    /**	Enforce use of constructor when creating managed entity instances. */
     forceConstructor?: boolean;
+    /** Specify comment to table. (SQL only) */
     comment?: string;
+    /**	Marks entity as abstract, such entities are inlined during discovery. */
     abstract?: boolean;
+    /** Disables change tracking - such entities are ignored during flush. */
     readonly?: boolean;
+    /** Marks entity as {@doclink virtual-entities | virtual}. This is set automatically when you use `expression` option. */
     virtual?: boolean;
-    expression?: string | ((em: any, where: FilterQuery<T>, options: FindOptions<T, any, any, any>) => object);
+    /** Used to make ORM aware of externally defined triggers. This is needed for MS SQL Server multi inserts, ignored in other dialects. */
+    hasTriggers?: boolean;
+    /** SQL query that maps to a {@doclink virtual-entities | virtual entity}. */
+    expression?: string | ((em: any, where: ObjectQuery<E>, options: FindOptions<E, any, any, any>, stream?: boolean) => object);
+    /** Set {@doclink repositories#custom-repository | custom repository class}. */
     repository?: () => Constructor;
 };

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

@@ -1,4 +1,4 @@
-import type { EntityClass, Dictionary, AutoPath } from '../typings.js';
+import type { EntityClass, Dictionary, AutoPath, IndexCallback } from '../typings.js';
 import type { DeferMode } from '../enums.js';
 export declare function Index<T extends object, H extends string>(options?: IndexOptions<T, H>): (target: T, propertyName?: (T extends EntityClass<unknown> ? undefined : keyof T) | undefined) => any;
 export declare function Unique<T extends object, H extends string>(options?: UniqueOptions<T, H>): (target: T, propertyName?: (T extends EntityClass<unknown> ? undefined : keyof T) | undefined) => any;
@@ -8,7 +8,7 @@ interface BaseOptions<T, H extends string> {
     name?: string;
     properties?: (T extends EntityClass<infer P> ? Properties<P, H> : Properties<T, H>);
     options?: Dictionary;
-    expression?: string;
+    expression?: string | (T extends EntityClass<infer P> ? IndexCallback<P> : IndexCallback<T>);
 }
 export interface UniqueOptions<T, H extends string = string> extends BaseOptions<T, H> {
     deferMode?: DeferMode | `${DeferMode}`;

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;
@@ -37,4 +37,6 @@ export interface ManyToManyOptions<Owner, Target> extends ReferenceOptions<Owner
     deleteRule?: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString;
     /** What to do when the reference to the target entity gets updated. */
     updateRule?: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString;
+    /** Enable/disable foreign key constraint creation on this relation */
+    createForeignKeyConstraint?: 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);
@@ -27,4 +27,8 @@ export interface ManyToOneOptions<Owner, Target> extends ReferenceOptions<Owner,
     updateRule?: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString;
     /** 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 | `${DeferMode}`;
+    /** Enable/disable foreign key constraint creation on this relation */
+    createForeignKeyConstraint?: boolean;
+    /** Set a custom foreign key constraint name, overriding NamingStrategy.indexName(). */
+    foreignKeyName?: string;
 }

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;
@@ -21,4 +21,8 @@ export interface OneToOneOptions<Owner, Target> extends Partial<Omit<OneToManyOp
     updateRule?: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString;
     /** 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 | `${DeferMode}`;
+    /** Set a custom foreign key constraint name, overriding NamingStrategy.indexName(). */
+    foreignKeyName?: string;
+    /** Enable/disable foreign key constraint creation on this relation */
+    createForeignKeyConstraint?: 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,8 @@ 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;
+import type { FilterOptions } from '../drivers/IDatabaseDriver.js';
+export declare function Property<T extends object>(options?: PropertyOptions<T>): (target: T, propertyName: string) => any;
 export interface PropertyOptions<Owner> {
     /**
      * Alias for `fieldName`.
@@ -161,7 +162,7 @@ export interface PropertyOptions<Owner> {
      * Set true to define the properties as setter. (virtual)
      *
      * @example
-     * ```
+     * ```ts
      * @Property({ setter: true })
      * set address(value: string) {
      *     this._address = value.toLocaleLowerCase();
@@ -173,7 +174,7 @@ export interface PropertyOptions<Owner> {
      * Set true to define the properties as getter. (virtual)
      *
      * @example
-     * ```
+     * ```ts
      * @Property({ getter: true })
      * get fullName() {
      *   return this.firstName + this.lastName;
@@ -186,7 +187,7 @@ export interface PropertyOptions<Owner> {
      * to the method name.
      *
      * @example
-     * ```
+     * ```ts
      * @Property({ getter: true })
      * getFullName() {
      *   return this.firstName + this.lastName;
@@ -194,6 +195,53 @@ export interface PropertyOptions<Owner> {
      * ```
      */
     getterName?: keyof Owner;
+    /**
+     * When using a private property backed by a public get/set pair, use the `accessor` option to point to the other side.
+     *
+     * > The `fieldName` will be inferred based on the accessor name unless specified explicitly.
+     *
+     * If the `accessor` option points to something, the ORM will use the backing property directly.
+     *
+     * @example
+     * ```ts
+     * @Entity()
+     * export class User {
+     *   // the ORM will use the backing field directly
+     *   @Property({ accessor: 'email' })
+     *   private _email: string;
+     *
+     *   get email() {
+     *     return this._email;
+     *   }
+     *
+     *   set email() {
+     *     return this._email;
+     *   }
+     * }
+     *```
+     *
+     * If you want to the ORM to use your accessor internally too, use `accessor: true` on the get/set property instead.
+     * This is handy if you want to use a native private property for the backing field.
+     *
+     * @example
+     * ```ts
+     * @Entity({ forceConstructor: true })
+     * export class User {
+     *   #email: string;
+     *
+     *   // the ORM will use the accessor internally
+     *   @Property({ accessor: true })
+     *   get email() {
+     *     return this.#email;
+     *   }
+     *
+     *   set email() {
+     *     return this.#email;
+     *   }
+     * }
+     * ```
+     */
+    accessor?: keyof Owner | AnyString | boolean;
     /**
      * Set to define serialized primary key for MongoDB. (virtual)
      * Alias for `@SerializedPrimaryKey()` decorator.
@@ -242,6 +290,8 @@ export interface ReferenceOptions<Owner, Target> extends PropertyOptions<Owner>
     eager?: boolean;
     /** Override the default loading strategy for this property. This option has precedence over the global `loadStrategy`, but can be overridden by `FindOptions.strategy`. */
     strategy?: LoadStrategy | `${LoadStrategy}`;
+    /** Control filter parameters for the relation. This will serve as a default value when processing filters on this relation. It's value can be overridden via `em.fork()` or `FindOptions`. */
+    filters?: FilterOptions;
 }
 /**
  * Inspired by https://github.com/typeorm/typeorm/blob/941b584ba135617e55d6685caef671172ec1dc03/src/driver/types/ColumnTypes.ts

package/decorators/Transactional.d.ts

@@ -2,6 +2,7 @@ import type { TransactionOptions } from '../enums.js';
 import type { ContextProvider } from '../typings.js';
 type TransactionalOptions<T> = TransactionOptions & {
     context?: ContextProvider<T>;
+    contextName?: string;
 };
 /**
  * This decorator wraps the method with `em.transactional()`, so you can provide `TransactionOptions` just like with `em.transactional()`.

package/decorators/Transactional.js

@@ -14,10 +14,10 @@ export function Transactional(options = {}) {
             throw new Error('@Transactional() should be use with async functions');
         }
         descriptor.value = async function (...args) {
-            const { context, ...txOptions } = options;
+            const { context, contextName, ...txOptions } = options;
             const em = (await resolveContextProvider(this, context))
-                || TransactionContext.getEntityManager()
-                || RequestContext.getEntityManager();
+                || TransactionContext.getEntityManager(contextName)
+                || RequestContext.getEntityManager(contextName);
             if (!em) {
                 throw new Error(`@Transactional() decorator can only be applied to methods of classes with \`orm: MikroORM\` property, \`em: EntityManager\` property, or with a callback parameter like \`@Transactional(() => orm)\` that returns one of those types. The parameter will contain a reference to current \`this\`. Returning an EntityRepository from it is also supported.`);
             }

package/decorators/index.d.ts

@@ -3,7 +3,7 @@ export * from './Entity.js';
 export * from './OneToOne.js';
 export * from './ManyToOne.js';
 export * from './ManyToMany.js';
-export { OneToMany, OneToManyOptions } from './OneToMany.js';
+export { OneToMany, type OneToManyOptions } from './OneToMany.js';
 export * from './Property.js';
 export * from './Check.js';
 export * from './Enum.js';

package/drivers/DatabaseDriver.d.ts

@@ -1,5 +1,5 @@
-import { type CountOptions, type DeleteOptions, type DriverMethodOptions, EntityManagerType, type FindOneOptions, type FindOptions, type IDatabaseDriver, type LockOptions, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type OrderDefinition } from './IDatabaseDriver.js';
-import type { ConnectionType, Dictionary, EntityData, EntityDictionary, EntityMetadata, EntityProperty, FilterQuery, PopulateOptions, Primary } from '../typings.js';
+import { type CountOptions, type DeleteOptions, type DriverMethodOptions, EntityManagerType, type FindOneOptions, type FindOptions, type IDatabaseDriver, type LockOptions, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type OrderDefinition, type StreamOptions } from './IDatabaseDriver.js';
+import type { ConnectionType, Dictionary, EntityData, EntityDictionary, EntityMetadata, EntityName, EntityProperty, FilterQuery, PopulateOptions, Primary } from '../typings.js';
 import type { MetadataStorage } from '../metadata/MetadataStorage.js';
 import type { Connection, QueryResult, Transaction } from '../connections/Connection.js';
 import { type Configuration, type ConnectionOptions } from '../utils/Configuration.js';
@@ -30,7 +30,7 @@ export declare abstract class DatabaseDriver<C extends Connection> implements ID
     abstract nativeDelete<T extends object>(entityName: string, where: FilterQuery<T>, options?: DeleteOptions<T>): Promise<QueryResult<T>>;
     abstract count<T extends object, P extends string = never>(entityName: string, where: FilterQuery<T>, options?: CountOptions<T, P>): Promise<number>;
     createEntityManager(useContext?: boolean): this[typeof EntityManagerType];
-    findVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
+    findVirtual<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
     countVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: CountOptions<T, any>): Promise<number>;
     aggregate(entityName: string, pipeline: any[]): Promise<any[]>;
     loadFromPivotTable<T extends object, O extends object>(prop: EntityProperty, owners: Primary<O>[][], where?: FilterQuery<any>, orderBy?: OrderDefinition<T>, ctx?: Transaction, options?: FindOptions<T, any, any, any>, pivotJoin?: boolean): Promise<Dictionary<T[]>>;
@@ -55,6 +55,7 @@ export declare abstract class DatabaseDriver<C extends Connection> implements ID
     protected getPrimaryKeyFields(entityName: string): string[];
     protected createReplicas(cb: (c: ConnectionOptions) => C): C[];
     lockPessimistic<T extends object>(entity: T, options: LockOptions): Promise<void>;
+    abstract stream<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: StreamOptions<T>): AsyncIterableIterator<T>;
     /**
      * @inheritDoc
      */

package/drivers/IDatabaseDriver.d.ts

@@ -1,4 +1,4 @@
-import type { ConnectionType, EntityData, EntityMetadata, EntityProperty, FilterQuery, Primary, Dictionary, QBFilterQuery, IPrimaryKey, PopulateOptions, EntityDictionary, AutoPath, ObjectQuery, FilterObject, Populate } from '../typings.js';
+import type { ConnectionType, EntityData, EntityMetadata, EntityProperty, FilterQuery, Primary, Dictionary, QBFilterQuery, IPrimaryKey, PopulateOptions, EntityDictionary, AutoPath, ObjectQuery, FilterObject, Populate, EntityName } from '../typings.js';
 import type { Connection, QueryResult, Transaction } from '../connections/Connection.js';
 import type { FlushMode, LockMode, QueryOrderMap, QueryFlag, LoadStrategy, PopulateHint, PopulatePath } from '../enums.js';
 import type { Platform } from '../platforms/Platform.js';
@@ -27,6 +27,7 @@ export interface IDatabaseDriver<C extends Connection = Connection> {
      */
     findOne<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: string, where: FilterQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
     findVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
+    stream<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: StreamOptions<T>): AsyncIterableIterator<T>;
     nativeInsert<T extends object>(entityName: string, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
     nativeInsertMany<T extends object>(entityName: string, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>, transform?: (sql: string) => string): Promise<QueryResult<T>>;
     nativeUpdate<T extends object>(entityName: string, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
@@ -68,6 +69,18 @@ export type OrderDefinition<T> = (QueryOrderMap<T> & {
 export interface FindAllOptions<T, P extends string = never, F extends string = '*', E extends string = never> extends FindOptions<T, P, F, E> {
     where?: FilterQuery<T>;
 }
+export interface StreamOptions<Entity, Populate extends string = never, Fields extends string = '*', Exclude extends string = never> extends Omit<FindAllOptions<Entity, Populate, Fields, Exclude>, 'cache' | 'before' | 'after' | 'first' | 'last' | 'overfetch' | 'strategy'> {
+    /**
+     * When populating to-many relations, the ORM streams fully merged entities instead of yielding every row.
+     * You can opt out of this behavior by specifying `mergeResults: false`. This will yield every row from
+     * the SQL result, but still mapped to entities, meaning that to-many collections will contain at most
+     * a single item, and you will get duplicate root entities when they have multiple items in the populated
+     * collection.
+     *
+     * @default true
+     */
+    mergeResults?: boolean;
+}
 export type FilterOptions = Dictionary<boolean | Dictionary> | string[] | boolean;
 export interface LoadHint<Entity, Hint extends string = never, Fields extends string = PopulatePath.ALL, Excludes extends string = never> {
     populate?: Populate<Entity, Hint>;
@@ -146,8 +159,11 @@ export interface FindOptions<Entity, Hint extends string = never, Fields extends
     hintComments?: string | string[];
     loggerContext?: LogContext;
     logging?: LoggingOptions;
+    /** @internal used to apply filters to the auto-joined relations */
+    em?: EntityManager;
 }
-export interface FindByCursorOptions<T extends object, P extends string = never, F extends string = '*', E extends string = never> extends Omit<FindOptions<T, P, F, E>, 'limit' | 'offset'> {
+export interface FindByCursorOptions<T extends object, P extends string = never, F extends string = '*', E extends string = never, I extends boolean = true> extends Omit<FindOptions<T, P, F, E>, 'limit' | 'offset'> {
+    includeCount?: I;
 }
 export interface FindOneOptions<T extends object, P extends string = never, F extends string = '*', E extends string = never> extends Omit<FindOptions<T, P, F, E>, 'limit' | 'lockMode'> {
     lockMode?: LockMode;
@@ -163,6 +179,7 @@ export interface NativeInsertUpdateOptions<T> {
     schema?: string;
     /** `nativeUpdate()` only option */
     upsert?: boolean;
+    loggerContext?: LogContext;
 }
 export interface NativeInsertUpdateManyOptions<T> extends NativeInsertUpdateOptions<T> {
     processCollections?: boolean;
@@ -197,6 +214,8 @@ export interface CountOptions<T extends object, P extends string = never> {
     hintComments?: string | string[];
     loggerContext?: LogContext;
     logging?: LoggingOptions;
+    /** @internal used to apply filters to the auto-joined relations */
+    em?: EntityManager;
 }
 export interface UpdateOptions<T> {
     filters?: FilterOptions;
@@ -218,6 +237,7 @@ export interface LockOptions extends DriverMethodOptions {
 export interface DriverMethodOptions {
     ctx?: Transaction;
     schema?: string;
+    loggerContext?: LogContext;
 }
 export interface GetReferenceOptions {
     wrapped?: boolean;