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

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, 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 Driver[typeof EntityManagerType] & EntityManager<Driver> = Driver[typeof EntityManagerType] & EntityManager<Driver>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<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,16 +21,14 @@ 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 D[typeof EntityManagerType] & EntityManager<D> = D[typeof EntityManagerType] & EntityManager<D>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<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)
      * - no loading of the `config` file, `options` parameter is mandatory
      * - 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>;
-    constructor(options: Options<Driver, EM>);
+    constructor(options: Options<Driver, EM, Entities>);
     /**
      * Connects to the database.
      */
@@ -36,7 +36,7 @@ export declare class MikroORM<Driver extends IDatabaseDriver = IDatabaseDriver,
     /**
      * Reconnects, possibly to a different database.
      */
-    reconnect(options?: Options): Promise<void>;
+    reconnect(options?: Partial<Options<Driver, EM, Entities>>): Promise<void>;
     /**
      * Checks whether the database connection is active.
      */

package/MikroORM.js

@@ -1,6 +1,5 @@
 import { MetadataDiscovery } from './metadata/MetadataDiscovery.js';
 import { MetadataStorage } from './metadata/MetadataStorage.js';
-import { MetadataValidator } from './metadata/MetadataValidator.js';
 import { ReflectMetadataProvider } from './metadata/ReflectMetadataProvider.js';
 import { Configuration } from './utils/Configuration.js';
 import { ConfigurationLoader } from './utils/ConfigurationLoader.js';
@@ -23,39 +22,14 @@ export class MikroORM {
      * If you omit the `options` parameter, your CLI config will be used.
      */
     static async init(options) {
-        ConfigurationLoader.registerDotenv(options);
-        const coreVersion = ConfigurationLoader.checkPackageVersion();
-        const env = await ConfigurationLoader.loadEnvironmentVars();
+        /* v8 ignore next 3 */
         if (!options) {
-            const configPathFromArg = ConfigurationLoader.configPathsFromArg();
-            const config = (await ConfigurationLoader.getConfiguration(process.env.MIKRO_ORM_CONTEXT_NAME ?? 'default', configPathFromArg ?? ConfigurationLoader.getConfigPaths()));
-            options = config.getAll();
-            if (configPathFromArg) {
-                config.getLogger().warn('deprecated', 'Path for config file was inferred from the command line arguments. Instead, you should set the MIKRO_ORM_CLI_CONFIG environment variable to specify the path, or if you really must use the command line arguments, import the config manually based on them, and pass it to init.', { label: 'D0001' });
-            }
-        }
-        options = Utils.mergeConfig(options, env);
-        ConfigurationLoader.commonJSCompat(options);
-        if ('DRIVER' in this && !options.driver) {
-            options.driver = this.DRIVER;
+            throw new Error(`options parameter is required`);
         }
-        const orm = new MikroORM(options);
-        orm.logger.log('info', `MikroORM version: ${colors.green(coreVersion)}`);
-        // we need to allow global context here as we are not in a scope of requests yet
-        const allowGlobalContext = orm.config.get('allowGlobalContext');
-        orm.config.set('allowGlobalContext', true);
+        options.discovery ??= {};
+        options.discovery.skipSyncDiscovery ??= true;
+        const orm = new this(options);
         await orm.discoverEntities();
-        orm.config.set('allowGlobalContext', allowGlobalContext);
-        orm.driver.getPlatform().init(orm);
-        if (orm.config.get('connect')) {
-            await orm.connect();
-        }
-        for (const extension of orm.config.get('extensions')) {
-            extension.register(orm);
-        }
-        if (orm.config.get('connect') && orm.config.get('ensureIndexes')) {
-            await orm.getSchemaGenerator().ensureIndexes();
-        }
         return orm;
     }
     /**
@@ -63,28 +37,12 @@ export class MikroORM {
      * - database connection will be established when you first interact with the database (or you can use `orm.connect()` explicitly)
      * - no loading of the `config` file, `options` parameter is mandatory
      * - no support for folder based discovery
-     * - no check for mismatched package versions
      */
-    static initSync(options) {
+    constructor(options) {
         ConfigurationLoader.registerDotenv(options);
         const env = ConfigurationLoader.loadEnvironmentVarsSync();
+        const coreVersion = ConfigurationLoader.checkPackageVersion();
         options = Utils.merge(options, env);
-        if ('DRIVER' in this && !options.driver) {
-            options.driver = this.DRIVER;
-        }
-        const orm = new MikroORM(options);
-        // we need to allow global context here as we are not in a scope of requests yet
-        const allowGlobalContext = orm.config.get('allowGlobalContext');
-        orm.config.set('allowGlobalContext', true);
-        orm.discoverEntitiesSync();
-        orm.config.set('allowGlobalContext', allowGlobalContext);
-        orm.driver.getPlatform().init(orm);
-        for (const extension of orm.config.get('extensions')) {
-            extension.register(orm);
-        }
-        return orm;
-    }
-    constructor(options) {
         this.config = new Configuration(options);
         const discovery = this.config.get('discovery');
         if (discovery.disableDynamicFileAccess) {
@@ -94,26 +52,21 @@ export class MikroORM {
         }
         this.driver = this.config.getDriver();
         this.logger = this.config.getLogger();
+        this.logger.log('info', `MikroORM version: ${colors.green(coreVersion)}`);
         this.discovery = new MetadataDiscovery(new MetadataStorage(), this.driver.getPlatform(), this.config);
+        this.driver.getPlatform().init(this);
+        for (const extension of this.config.get('extensions')) {
+            extension.register(this);
+        }
+        if (!discovery.skipSyncDiscovery) {
+            this.discoverEntitiesSync();
+        }
     }
     /**
      * Connects to the database.
      */
     async connect() {
-        const connection = await this.driver.connect();
-        const clientUrl = connection.getClientUrl();
-        const dbName = this.config.get('dbName');
-        const db = dbName + (clientUrl ? ' on ' + clientUrl : '');
-        if (this.config.get('ensureDatabase')) {
-            const options = this.config.get('ensureDatabase');
-            await this.schema.ensureDatabase(typeof options === 'boolean' ? {} : { ...options, forceCheck: true });
-        }
-        if (await this.isConnected()) {
-            this.logger.log('info', `MikroORM successfully connected to database ${colors.green(db)}`);
-        }
-        else {
-            this.logger.error('info', `MikroORM failed to connect to database ${db}`);
-        }
+        await this.driver.connect();
         return this.driver;
     }
     /**
@@ -142,9 +95,7 @@ export class MikroORM {
      * Closes the database connection.
      */
     async close(force = false) {
-        if (await this.isConnected()) {
-            await this.driver.close(force);
-        }
+        await this.driver.close(force);
         if (this.config.getMetadataCacheAdapter()?.close) {
             await this.config.getMetadataCacheAdapter().close();
         }
@@ -163,12 +114,21 @@ export class MikroORM {
         return this.metadata;
     }
     async discoverEntities() {
-        this.metadata = await this.discovery.discover(this.config.get('preferTs'));
+        // we need to allow global context here as we are not in a scope of requests yet
+        const allowGlobalContext = this.config.get('allowGlobalContext');
+        this.config.set('allowGlobalContext', true);
+        const preferTs = this.config.get('preferTs', Utils.detectTypeScriptSupport());
+        this.metadata = await this.discovery.discover(preferTs);
         this.createEntityManager();
+        this.config.set('allowGlobalContext', allowGlobalContext);
     }
     discoverEntitiesSync() {
-        this.metadata = this.discovery.discoverSync(this.config.get('preferTs'));
+        // we need to allow global context here as we are not in a scope of requests yet
+        const allowGlobalContext = this.config.get('allowGlobalContext');
+        this.config.set('allowGlobalContext', true);
+        this.metadata = this.discovery.discoverSync();
         this.createEntityManager();
+        this.config.set('allowGlobalContext', allowGlobalContext);
     }
     createEntityManager() {
         this.driver.setMetadata(this.metadata);
@@ -181,19 +141,16 @@ export class MikroORM {
      * Allows dynamically discovering new entity by reference, handy for testing schema diffing.
      */
     discoverEntity(entities, reset) {
-        entities = Utils.asArray(entities);
         for (const className of Utils.asArray(reset)) {
             this.metadata.reset(className);
             this.discovery.reset(className);
         }
-        const tmp = this.discovery.discoverReferences(entities);
-        const options = this.config.get('discovery');
-        new MetadataValidator().validateDiscovered([...Object.values(this.metadata.getAll()), ...tmp], options);
+        const tmp = this.discovery.discoverReferences(Utils.asArray(entities));
         const metadata = this.discovery.processDiscoveredEntities(tmp);
-        metadata.forEach(meta => {
+        for (const meta of metadata) {
             this.metadata.set(meta.className, meta);
             meta.root = this.metadata.get(meta.root.className);
-        });
+        }
         this.metadata.decorate(this.em);
     }
     /**

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,17 @@
-import globby from 'globby';
 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 +52,7 @@ export class FileCacheAdapter {
      */
     clear() {
         const path = this.path('*');
-        const files = globby.sync(path);
+        const files = Utils.glob(path);
         files.forEach(file => unlinkSync(file));
         this.cache = {};
     }
@@ -77,6 +78,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

@@ -17,7 +17,9 @@ export declare abstract class Connection {
     /**
      * Establishes connection to database
      */
-    abstract connect(): void | Promise<void>;
+    abstract connect(options?: {
+        skipOnConnect?: boolean;
+    }): void | Promise<void>;
     /**
      * Are we connected to the database
      */
@@ -37,26 +39,28 @@ export declare abstract class Connection {
      */
     close(force?: boolean): Promise<void>;
     /**
-     * Ensure the connection exists, this is used to support lazy connect when using `MikroORM.initSync()`
+     * Ensure the connection exists, this is used to support lazy connect when using `new MikroORM()` instead of the async `init` method.
      */
     ensureConnection(): Promise<void>;
+    protected onConnect(): Promise<void>;
     transactional<T>(cb: (trx: Transaction) => Promise<T>, options?: {
-        isolationLevel?: IsolationLevel;
+        isolationLevel?: IsolationLevel | `${IsolationLevel}`;
         readOnly?: boolean;
         ctx?: Transaction;
         eventBroadcaster?: TransactionEventBroadcaster;
+        loggerContext?: LogContext;
     }): Promise<T>;
     begin(options?: {
-        isolationLevel?: IsolationLevel;
+        isolationLevel?: 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;
     setMetadata(metadata: MetadataStorage): void;
     setPlatform(platform: Platform): void;
     getPlatform(): Platform;

package/connections/Connection.js

@@ -33,23 +33,35 @@ export class Connection {
             .forEach(k => delete this.options[k]);
     }
     /**
-     * Ensure the connection exists, this is used to support lazy connect when using `MikroORM.initSync()`
+     * Ensure the connection exists, this is used to support lazy connect when using `new MikroORM()` instead of the async `init` method.
      */
     async ensureConnection() {
         if (!this.connected) {
             await this.connect();
         }
     }
+    async onConnect() {
+        const schemaGenerator = this.config.getExtension('@mikro-orm/schema-generator');
+        if (this.type === 'write' && schemaGenerator) {
+            if (this.config.get('ensureDatabase')) {
+                const options = this.config.get('ensureDatabase');
+                await schemaGenerator.ensureDatabase(typeof options === 'boolean' ? {} : { ...options, forceCheck: true });
+            }
+            if (this.config.get('ensureIndexes')) {
+                await schemaGenerator.ensureIndexes();
+            }
+        }
+    }
     async transactional(cb, options) {
         throw new Error(`Transactions are not supported by current driver`);
     }
     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() {
@@ -67,7 +79,7 @@ export class Connection {
             }
         }
         else {
-            const url = new URL(this.config.getClientUrl());
+            const url = new URL(this.config.get('clientUrl'));
             this.options.host = ret.host = this.options.host ?? this.config.get('host', decodeURIComponent(url.hostname));
             this.options.port = ret.port = this.options.port ?? this.config.get('port', +url.port);
             this.options.user = ret.user = this.options.user ?? this.config.get('user', decodeURIComponent(url.username));
@@ -76,15 +88,6 @@ export class Connection {
         }
         return ret;
     }
-    getClientUrl() {
-        const options = this.getConnectionOptions();
-        const url = new URL(this.config.getClientUrl(true));
-        const password = options.password ? ':*****' : '';
-        const schema = options.schema && options.schema !== this.platform.getDefaultSchemaName()
-            ? `?schema=${options.schema}`
-            : '';
-        return `${url.protocol}//${options.user}${password}@${options.host}:${options.port}${schema}`;
-    }
     setMetadata(metadata) {
         this.metadata = metadata;
     }

package/decorators/Embeddable.d.ts

@@ -1,6 +1,8 @@
 import type { AnyString, Dictionary, EntityClass } from '../typings.js';
 export declare function Embeddable<T>(options?: EmbeddableOptions<T>): (target: T) => T;
 export interface EmbeddableOptions<T> {
+    /** Specify constructor parameters to be used in `em.create` or when `forceConstructor` is enabled. Those should be names of declared entity properties in the same order as your constructor uses them. The ORM tries to infer those automatically, use this option in case the inference fails. */
+    constructorParams?: (T extends EntityClass<infer P> ? keyof P : string)[];
     discriminatorColumn?: (T extends EntityClass<infer P> ? keyof P : string) | AnyString;
     discriminatorMap?: Dictionary<string>;
     discriminatorValue?: number | string;

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 interface 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,35 @@
-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 constructor parameters to be used in `em.create` or when `forceConstructor` is enabled. Those should be names of declared entity properties in the same order as your constructor uses them. The ORM tries to infer those automatically, use this option in case the inference fails. */
+    constructorParams?: (T extends EntityClass<infer P> ? keyof P : string)[];
+    /** 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/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

@@ -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

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

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

@@ -3,6 +3,7 @@ import type { EntityName, Constructor, CheckCallback, GeneratedColumnCallback, A
 import type { Type, types } from '../types/index.js';
 import type { EntityManager } from '../EntityManager.js';
 import type { SerializeOptions } from '../serialization/EntitySerializer.js';
+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> {
     /**
@@ -112,12 +113,6 @@ export interface PropertyOptions<Owner> {
      * 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?: boolean;
-    /**
-     * Set false to disable change tracking on a property level.
-     *
-     * @see https://mikro-orm.io/docs/unit-of-work#change-tracking-and-performance-considerations
-     */
-    trackChanges?: boolean;
     /**
      * Set to true to omit the property when {@link https://mikro-orm.io/docs/serializing Serializing}.
      */
@@ -161,7 +156,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 +168,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 +181,7 @@ export interface PropertyOptions<Owner> {
      * to the method name.
      *
      * @example
-     * ```
+     * ```ts
      * @Property({ getter: true })
      * getFullName() {
      *   return this.firstName + this.lastName;
@@ -194,6 +189,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 +284,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