@mikro-orm/core 7.0.17-dev.9 → 7.0.18-dev.0

package/typings.js

@@ -4,7 +4,6 @@ import { EntityHelper } from './entity/EntityHelper.js';
 import { helper } from './entity/wrap.js';
 import { Utils } from './utils/Utils.js';
 import { EntityComparator } from './utils/EntityComparator.js';
-import { BaseEntity } from './entity/BaseEntity.js';
 /** Symbol used to declare a custom repository type on an entity class (e.g., `[EntityRepositoryType]?: BookRepository`). */
 export const EntityRepositoryType = Symbol('EntityRepositoryType');
 /** Symbol used to declare the primary key property name(s) on an entity (e.g., `[PrimaryKeyProp]?: 'id'`). */
@@ -22,6 +21,16 @@ export const Config = Symbol('Config');
 /** Symbol used to declare the entity name as a string literal type (used by `defineEntity`). */
 // eslint-disable-next-line @typescript-eslint/no-redeclare
 export const EntityName = Symbol('EntityName');
+/**
+ * Symbol used to declare index-to-column mappings on an entity type.
+ * For decorator entities, declare as a phantom property:
+ * ```typescript
+ * [IndexHints]?: { idx_email: 'email'; idx_name_age: 'name' | 'age' };
+ * ```
+ * For `defineEntity` entities, index hints are inferred automatically from
+ * named indexes (property-level `.index('name')` and entity-level `indexes`/`uniques`).
+ */
+export const IndexHints = Symbol('IndexHints');
 /**
  * Runtime metadata for an entity, holding its properties, relations, indexes, hooks, and more.
  * Created during metadata discovery and used throughout the ORM lifecycle.
@@ -39,12 +48,20 @@ export class EntityMetadata {
         this.indexes = [];
         this.uniques = [];
         this.checks = [];
+        this.triggers = [];
         this.referencingProperties = [];
         this.concurrencyCheckKeys = new Set();
         Object.assign(this, meta);
         const name = meta.className ?? meta.name;
         if (!this.class && name) {
-            const Class = this.extends === BaseEntity ? { [name]: class extends BaseEntity {
+            let Parent;
+            if (typeof this.extends === 'function') {
+                Parent = this.extends;
+            }
+            else if (this.extends != null && typeof this.extends.class === 'function') {
+                Parent = this.extends.class;
+            }
+            const Class = Parent ? { [name]: class extends Parent {
                 } }[name] : { [name]: class {
                 } }[name];
             this.class = Class;
@@ -264,8 +281,8 @@ export class EntityMetadata {
         }, { __gettersDefined: { value: true, enumerable: false } });
     }
     initIndexes(prop) {
-        const simpleIndex = this.indexes.find(index => index.properties === prop.name && !index.options && !index.type && !index.expression);
-        const simpleUnique = this.uniques.find(index => index.properties === prop.name && !index.options);
+        const simpleIndex = this.indexes.find(index => index.properties === prop.name && !index.options && !index.type && !index.expression && index.where == null);
+        const simpleUnique = this.uniques.find(index => index.properties === prop.name && !index.options && !index.expression && index.where == null);
         const owner = prop.kind === ReferenceKind.MANY_TO_ONE;
         if (!prop.index && simpleIndex) {
             Utils.defaultValue(simpleIndex, 'name', true);

package/unit-of-work/UnitOfWork.js

@@ -36,6 +36,13 @@ export class UnitOfWork {
     #flushQueue = [];
     #working = false;
     #em;
+    /**
+     * UoW lives in `@mikro-orm/core` alongside `EntityManager` and reaches `getAbortOptions`
+     * (TS-protected) via cast — TS has no `friend` keyword, so this is the documented escape hatch.
+     */
+    get #abortOptions() {
+        return this.#em.getAbortOptions();
+    }
     constructor(em) {
         this.#em = em;
         this.#metadata = this.#em.getMetadata();
@@ -1002,7 +1009,7 @@ export class UnitOfWork {
             this.findExtraUpdates(changeSet, props);
             await this.runHooks(EventType.beforeCreate, changeSet, true);
         }
-        await this.#changeSetPersister.executeInserts(changeSets, { ctx });
+        await this.#changeSetPersister.executeInserts(changeSets, { ctx, ...this.#abortOptions });
         for (const changeSet of changeSets) {
             // For TPT entities, use the full entity snapshot instead of the partial changeset payload,
             // since each table's changeset only contains its own properties. Without this, the snapshot
@@ -1071,7 +1078,7 @@ export class UnitOfWork {
         for (const changeSet of changeSets) {
             await this.runHooks(EventType.beforeUpdate, changeSet, true);
         }
-        await this.#changeSetPersister.executeUpdates(changeSets, batched, { ctx });
+        await this.#changeSetPersister.executeUpdates(changeSets, batched, { ctx, ...this.#abortOptions });
         for (const changeSet of changeSets) {
             const wrapped = helper(changeSet.entity);
             wrapped.__originalEntityData = this.#comparator.prepareEntity(changeSet.entity);
@@ -1094,7 +1101,7 @@ export class UnitOfWork {
         for (const changeSet of changeSets) {
             await this.runHooks(EventType.beforeDelete, changeSet, true);
         }
-        await this.#changeSetPersister.executeDeletes(changeSets, { ctx });
+        await this.#changeSetPersister.executeDeletes(changeSets, { ctx, ...this.#abortOptions });
         for (const changeSet of changeSets) {
             this.unsetIdentity(changeSet.entity);
             await this.runHooks(EventType.afterDelete, changeSet);
@@ -1132,6 +1139,7 @@ export class UnitOfWork {
             ctx,
             schema: this.#em.schema,
             loggerContext,
+            ...this.#abortOptions,
         });
         for (const coll of this.#collectionUpdates) {
             coll.takeSnapshot();

package/utils/AbstractMigrator.d.ts

@@ -1,4 +1,4 @@
-import type { Constructor, IMigrationGenerator, IMigrationRunner, IMigrator, IMigratorStorage, MaybePromise, Migration, MigrationInfo, MigrationRow, MigratorEvent } from '../typings.js';
+import type { Constructor, IMigrationGenerator, IMigrationRunner, IMigrator, IMigratorStorage, MaybePromise, Migration, MigrationInfo, MigrationResult, MigrationRow, MigratorEvent } from '../typings.js';
 import type { Transaction } from '../connections/Connection.js';
 import type { Configuration, MigrationsOptions } from './Configuration.js';
 import type { EntityManagerType, IDatabaseDriver } from '../drivers/IDatabaseDriver.js';
@@ -13,6 +13,7 @@ type MigrateOptions = {
     to?: string | number;
     migrations?: string[];
     transaction?: Transaction;
+    schema?: string;
 };
 export declare abstract class AbstractMigrator<D extends IDatabaseDriver> implements IMigrator {
     #private;
@@ -57,11 +58,15 @@ export declare abstract class AbstractMigrator<D extends IDatabaseDriver> implem
     /**
      * @inheritDoc
      */
-    getExecuted(): Promise<MigrationRow[]>;
+    getExecuted(options?: {
+        schema?: string;
+    }): Promise<MigrationRow[]>;
     /**
      * @inheritDoc
      */
-    getPending(): Promise<MigrationInfo[]>;
+    getPending(options?: {
+        schema?: string;
+    }): Promise<MigrationInfo[]>;
     /**
      * @inheritDoc
      */
@@ -70,7 +75,25 @@ export declare abstract class AbstractMigrator<D extends IDatabaseDriver> implem
      * @inheritDoc
      */
     down(options?: string | string[] | Omit<MigrateOptions, 'from'>): Promise<MigrationInfo[]>;
+    /**
+     * @inheritDoc
+     */
+    rollup(migrations?: string[]): Promise<MigrationResult>;
+    /**
+     * Extracts the body of a method from migration source code using brace counting.
+     * Returns the raw lines between the opening and closing braces, or empty string if not found.
+     * @internal
+     */
+    private extractMethodBody;
     abstract getStorage(): IMigratorStorage;
+    /**
+     * @inheritDoc
+     */
+    logMigration(name: string): Promise<void>;
+    /**
+     * @inheritDoc
+     */
+    unlogMigration(name: string): Promise<void>;
     protected init(): Promise<void>;
     protected initPaths(): Promise<void>;
     protected initServices(): void;

package/utils/AbstractMigrator.js

@@ -38,18 +38,32 @@ export class AbstractMigrator {
     /**
      * @inheritDoc
      */
-    async getExecuted() {
+    async getExecuted(options) {
         await this.init();
-        return this.storage.getExecutedMigrations();
+        const schema = options?.schema ?? this.options.schema;
+        this.storage.setRunSchema?.(schema);
+        try {
+            return await this.storage.getExecutedMigrations();
+        }
+        finally {
+            this.storage.unsetRunSchema?.();
+        }
     }
     /**
      * @inheritDoc
      */
-    async getPending() {
+    async getPending(options) {
         await this.init();
-        const all = await this.discoverMigrations();
-        const executed = new Set(await this.storage.executed());
-        return all.filter(m => !executed.has(m.name)).map(m => ({ name: m.name, path: m.path }));
+        const schema = options?.schema ?? this.options.schema;
+        this.storage.setRunSchema?.(schema);
+        try {
+            const all = await this.discoverMigrations();
+            const executed = new Set(await this.storage.executed());
+            return all.filter(m => !executed.has(m.name)).map(m => ({ name: m.name, path: m.path }));
+        }
+        finally {
+            this.storage.unsetRunSchema?.();
+        }
     }
     /**
      * @inheritDoc
@@ -63,6 +77,225 @@ export class AbstractMigrator {
     async down(options) {
         return this.runMigrations('down', options);
     }
+    /**
+     * @inheritDoc
+     */
+    async rollup(migrations) {
+        await this.init();
+        const { fs } = await import('@mikro-orm/core/fs-utils');
+        const all = await this.discoverMigrations();
+        const executedSet = new Set(await this.storage.executed());
+        let toRollup;
+        if (migrations && migrations.length > 0) {
+            const requested = new Set(migrations.map(m => this.getMigrationFilename(m)));
+            toRollup = all.filter(m => requested.has(m.name));
+            const found = new Set(toRollup.map(m => m.name));
+            const notFound = [...requested].filter(name => !found.has(name));
+            if (notFound.length > 0) {
+                throw new Error(`Migrations not found: ${notFound.join(', ')}`);
+            }
+            const notExecuted = toRollup.filter(m => !executedSet.has(m.name));
+            if (notExecuted.length > 0) {
+                throw new Error(`Cannot roll up migrations that have not been executed: ${notExecuted.map(m => m.name).join(', ')}`);
+            }
+        }
+        else {
+            toRollup = all.filter(m => executedSet.has(m.name));
+        }
+        if (toRollup.length < 2) {
+            throw new Error('At least 2 executed migrations are required for rollup');
+        }
+        const withoutPath = toRollup.filter(m => !m.path);
+        if (withoutPath.length > 0) {
+            throw new Error(`Cannot roll up migrations without file paths (class-based migrations): ${withoutPath.map(m => m.name).join(', ')}`);
+        }
+        const upBodies = [];
+        const downBodies = [];
+        const placeholder = `__mikro_orm_rollup_${Date.now()}__`;
+        for (const migration of toRollup) {
+            const source = await fs.readFile(migration.path);
+            const upBody = this.extractMethodBody(source, 'up');
+            const downBody = this.extractMethodBody(source, 'down');
+            if (upBody) {
+                upBodies.push(`    // --- merged from ${migration.name} ---\n${upBody}`);
+            }
+            if (downBody) {
+                downBodies.unshift(`    // --- merged from ${migration.name} ---\n${downBody}`);
+            }
+        }
+        const diff = {
+            up: [placeholder],
+            down: downBodies.length > 0 ? [placeholder] : [],
+        };
+        const [templateCode, fileName] = await this.generator.generate(diff);
+        const placeholderRe = new RegExp(`^.*${placeholder}.*$`, 'm');
+        let code = templateCode.replace(placeholderRe, upBodies.join('\n'));
+        if (downBodies.length > 0) {
+            code = code.replace(placeholderRe, downBodies.join('\n'));
+        }
+        await fs.writeFile(fs.normalizePath(this.absolutePath, fileName), code, { flush: true });
+        const updateStorage = async () => {
+            for (const migration of toRollup) {
+                await this.storage.unlogMigration({ name: migration.name });
+            }
+            await this.storage.logMigration({ name: fileName.replace(/\.[jt]s$/, '') });
+        };
+        if (this.options.transactional) {
+            await this.driver.getConnection().transactional(async (trx) => {
+                this.storage.setMasterMigration(trx);
+                try {
+                    await updateStorage();
+                }
+                finally {
+                    this.storage.unsetMasterMigration();
+                }
+            });
+        }
+        else {
+            await updateStorage();
+        }
+        await Promise.all(toRollup.map(migration => fs.unlink(migration.path)));
+        return { fileName, code, diff: { up: [], down: [] } };
+    }
+    /**
+     * Extracts the body of a method from migration source code using brace counting.
+     * Returns the raw lines between the opening and closing braces, or empty string if not found.
+     * @internal
+     */
+    extractMethodBody(source, methodName) {
+        const lines = source.split('\n');
+        // match method declarations, not occurrences in comments/strings — require preceding whitespace or keyword
+        const methodPattern = new RegExp(`^\\s+(?:override\\s+|async\\s+)*${methodName}\\s*\\(`);
+        let methodLine = -1;
+        for (let i = 0; i < lines.length; i++) {
+            if (methodPattern.test(lines[i])) {
+                methodLine = i;
+                break;
+            }
+        }
+        if (methodLine === -1) {
+            return '';
+        }
+        let braceCount = 0;
+        let bodyStart = -1;
+        let bodyEnd = -1;
+        let bodyStartCol = -1;
+        let bodyEndCol = -1;
+        let inBacktick = false;
+        let inBlockComment = false;
+        // stack tracks brace depth at which each template expression `${...}` was entered
+        const templateExprStack = [];
+        for (let i = methodLine; i < lines.length; i++) {
+            const line = lines[i];
+            for (let j = 0; j < line.length; j++) {
+                // handle multi-line block comments
+                if (inBlockComment) {
+                    if (line[j] === '*' && j + 1 < line.length && line[j + 1] === '/') {
+                        inBlockComment = false;
+                        j++;
+                    }
+                    continue;
+                }
+                // handle multi-line template literals
+                if (inBacktick) {
+                    if (line[j] === '\\') {
+                        j++;
+                    }
+                    else if (line[j] === '`') {
+                        inBacktick = false;
+                    }
+                    else if (line[j] === '$' && j + 1 < line.length && line[j + 1] === '{') {
+                        // entering template expression — resume brace counting
+                        templateExprStack.push(braceCount);
+                        inBacktick = false;
+                        j++; // skip the {
+                        braceCount++;
+                    }
+                    continue;
+                }
+                const ch = line[j];
+                // single/double quoted strings (single-line only)
+                if (ch === "'" || ch === '"') {
+                    const quote = ch;
+                    j++;
+                    while (j < line.length) {
+                        if (line[j] === '\\') {
+                            j++;
+                        }
+                        else if (line[j] === quote) {
+                            break;
+                        }
+                        j++;
+                    }
+                    continue;
+                }
+                // template literal start
+                if (ch === '`') {
+                    inBacktick = true;
+                    continue;
+                }
+                // single-line comment
+                if (ch === '/' && j + 1 < line.length && line[j + 1] === '/') {
+                    break;
+                }
+                // block comment start
+                if (ch === '/' && j + 1 < line.length && line[j + 1] === '*') {
+                    inBlockComment = true;
+                    j++;
+                    continue;
+                }
+                if (ch === '{') {
+                    if (braceCount === 0) {
+                        bodyStart = i;
+                        bodyStartCol = j + 1;
+                    }
+                    braceCount++;
+                }
+                else if (ch === '}') {
+                    braceCount--;
+                    // closing a template expression — re-enter backtick mode
+                    if (templateExprStack.length > 0 && braceCount === templateExprStack[templateExprStack.length - 1]) {
+                        templateExprStack.pop();
+                        inBacktick = true;
+                        continue;
+                    }
+                    if (braceCount === 0) {
+                        bodyEnd = i;
+                        bodyEndCol = j;
+                        break;
+                    }
+                }
+            }
+            if (bodyEnd !== -1) {
+                break;
+            }
+        }
+        if (bodyStart === -1 || bodyEnd === -1) {
+            return '';
+        }
+        // single-line method body: extract content between braces on the same line
+        if (bodyStart === bodyEnd) {
+            const content = lines[bodyStart].slice(bodyStartCol, bodyEndCol).trim();
+            return content ? `    ${content}` : '';
+        }
+        return lines.slice(bodyStart + 1, bodyEnd).join('\n');
+    }
+    /**
+     * @inheritDoc
+     */
+    async logMigration(name) {
+        await this.init();
+        await this.storage.ensureTable?.();
+        await this.storage.logMigration({ name });
+    }
+    /**
+     * @inheritDoc
+     */
+    async unlogMigration(name) {
+        await this.init();
+        await this.storage.ensureTable?.();
+        await this.storage.unlogMigration({ name });
+    }
     async init() {
         if (this.initialized) {
             return;
@@ -270,13 +503,17 @@ export class AbstractMigrator {
         return /^\d{14}$/.exec(name) ? this.options.fileName(name) : name;
     }
     prefix(options) {
+        const base = {};
+        if (this.options.schema) {
+            base.schema = this.options.schema;
+        }
         if (typeof options === 'string' || Array.isArray(options)) {
-            return { migrations: Utils.asArray(options).map(name => this.getMigrationFilename(name)) };
+            return { ...base, migrations: Utils.asArray(options).map(name => this.getMigrationFilename(name)) };
         }
         if (!options) {
-            return {};
+            return base;
         }
-        const result = {};
+        const result = base;
         if (options.migrations) {
             result.migrations = options.migrations.map(name => this.getMigrationFilename(name));
         }
@@ -289,23 +526,35 @@ export class AbstractMigrator {
         else if (options.to === 0) {
             result.to = 0;
         }
+        if (options.schema !== undefined) {
+            result.schema = options.schema;
+        }
         return result;
     }
     async runMigrations(method, options) {
         await this.init();
-        if (!this.options.transactional || !this.options.allOrNothing) {
-            return this.executeMigrations(method, this.prefix(options));
+        const normalized = this.prefix(options);
+        this.runner.setRunSchema?.(normalized.schema);
+        this.storage.setRunSchema?.(normalized.schema);
+        try {
+            if (!this.options.transactional || !this.options.allOrNothing) {
+                return await this.executeMigrations(method, normalized);
+            }
+            if (Utils.isObject(options) && options.transaction) {
+                return await this.runInTransaction(options.transaction, method, normalized);
+            }
+            return await this.driver.getConnection().transactional(trx => this.runInTransaction(trx, method, normalized));
         }
-        if (Utils.isObject(options) && options.transaction) {
-            return this.runInTransaction(options.transaction, method, options);
+        finally {
+            this.runner.unsetRunSchema?.();
+            this.storage.unsetRunSchema?.();
         }
-        return this.driver.getConnection().transactional(trx => this.runInTransaction(trx, method, options));
     }
     async runInTransaction(trx, method, options) {
         this.runner.setMasterMigration(trx);
         this.storage.setMasterMigration(trx);
         try {
-            return await this.executeMigrations(method, this.prefix(options));
+            return await this.executeMigrations(method, options);
         }
         finally {
             this.runner.unsetMasterMigration();

package/utils/AbstractSchemaGenerator.d.ts

@@ -34,6 +34,6 @@ export declare abstract class AbstractSchemaGenerator<D extends IDatabaseDriver>
     dropDatabase(name?: string): Promise<void>;
     execute(query: string): Promise<void>;
     ensureIndexes(): Promise<void>;
-    protected getOrderedMetadata(schema?: string): EntityMetadata[];
+    protected getOrderedMetadata(schema?: string, includeWildcardSchema?: boolean): EntityMetadata[];
     protected notImplemented(): never;
 }

package/utils/AbstractSchemaGenerator.js

@@ -89,7 +89,7 @@ export class AbstractSchemaGenerator {
     async ensureIndexes() {
         this.notImplemented();
     }
-    getOrderedMetadata(schema) {
+    getOrderedMetadata(schema, includeWildcardSchema = false) {
         const metadata = [...this.metadata.getAll().values()].filter(meta => {
             const isRootEntity = meta.root.class === meta.class;
             const isTPTChild = meta.inheritanceType === 'tpt' && meta.tptParent;
@@ -116,6 +116,9 @@ export class AbstractSchemaGenerator {
             .sort()
             .map(cls => this.metadata.getById(cls))
             .filter(meta => {
+            if (includeWildcardSchema && meta.schema === '*') {
+                return true;
+            }
             const targetSchema = meta.schema ?? this.config.get('schema', this.platform.getDefaultSchemaName());
             return schema ? [schema, '*'].includes(targetSchema) : meta.schema !== '*';
         });

package/utils/Configuration.d.ts

@@ -6,6 +6,7 @@ import { type Logger, type LoggerNamespace, type LoggerOptions } from '../loggin
 import type { EntityManager } from '../EntityManager.js';
 import type { Platform } from '../platforms/Platform.js';
 import type { EntitySchema } from '../metadata/EntitySchema.js';
+import { Routine } from '../metadata/Routine.js';
 import { MetadataProvider } from '../metadata/MetadataProvider.js';
 import type { MetadataStorage } from '../metadata/MetadataStorage.js';
 import type { EventSubscriber } from '../events/EventSubscriber.js';
@@ -18,7 +19,7 @@ import type { MikroORM } from '../MikroORM.js';
 /** Holds and validates all ORM configuration options, providing access to drivers, loggers, cache adapters, and other services. */
 export declare class Configuration<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager<D> = D[typeof EntityManagerType] & EntityManager<D>> {
     #private;
-    constructor(options: Partial<Options>, validate?: boolean);
+    constructor(options: Partial<Options<any, any, any>>, validate?: boolean);
     /** Returns the database platform instance. */
     getPlatform(): ReturnType<D['getPlatform']>;
     /**
@@ -27,6 +28,10 @@ export declare class Configuration<D extends IDatabaseDriver = IDatabaseDriver,
     get<T extends keyof Options<D, EM>, U extends Options<D, EM>[T]>(key: T, defaultValue?: U): U;
     /** Returns all configuration options. */
     getAll(): Options<D, EM>;
+    /** Validates the `routines` config option on first access and throws on duplicate `(schema, name)` pairs or non-Routine entries. */
+    getRoutines(): readonly Routine[];
+    hasRoutine(routine: Routine): boolean;
+    private normaliseRoutines;
     /**
      * Overrides specified configuration value.
      */
@@ -99,7 +104,7 @@ export declare class Configuration<D extends IDatabaseDriver = IDatabaseDriver,
 /**
  * Type helper to make it easier to use `mikro-orm.config.js`.
  */
-export declare function defineConfig<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager<D> = EntityManager<D>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]>(options: Partial<Options<D, EM, Entities>>): Partial<Options<D, EM, Entities>>;
+export declare function defineConfig<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager<D> = EntityManager<D>, Entities extends readonly (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]>(options: Partial<Options<D, EM, Entities>>): Partial<Options<D, EM, Entities>>;
 /**
  * Connection configuration options for database connections.
  * @see https://mikro-orm.io/docs/configuration#connection
@@ -238,6 +243,24 @@ export type MigrationsOptions = {
     fileName?: (timestamp: string, name?: string) => string;
     /** List of migration classes or objects to use instead of file-based discovery. */
     migrationsList?: (MigrationObject | Constructor<Migration>)[];
+    /**
+     * Target schema used when running migrations. When set, the driver's "set current schema" statement
+     * (e.g. `SET search_path` on PostgreSQL) is issued before each migration, and the migration tracking
+     * table lives in this schema. Can be overridden per call via `migrator.up({ schema })`.
+     *
+     * Intended for per-deployment-one-schema setups (e.g. PR previews) and for applying a single
+     * unqualified migration to multiple schemas (see `includeWildcardSchema`). Not supported on MSSQL.
+     */
+    schema?: string;
+    /**
+     * When set, entities with a wildcard schema (`schema: '*'`) are included in generated migrations.
+     * The emitted SQL is unqualified — and therefore safe to apply against any schema at runtime via
+     * `migrator.up({ schema })` — only when neither `options.schema` nor the ORM's `config.schema`
+     * is set. If `config.schema` is set, wildcard tables are qualified with it (useful for local
+     * dev runs); in that case, generate migrations from an environment where `config.schema` is unset.
+     * @default false
+     */
+    includeWildcardSchema?: boolean;
 };
 /**
  * Configuration options for database seeders.
@@ -352,7 +375,7 @@ export interface MetadataDiscoveryOptions {
  * MikroORM configuration options.
  * @see https://mikro-orm.io/docs/configuration
  */
-export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager<Driver> & Driver[typeof EntityManagerType] = EntityManager<Driver> & Driver[typeof EntityManagerType], Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> extends ConnectionOptions {
+export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager<Driver> & Driver[typeof EntityManagerType] = EntityManager<Driver> & Driver[typeof EntityManagerType], Entities extends readonly (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> extends ConnectionOptions {
     /** Connection pool configuration. */
     pool: PoolConfig;
     /**
@@ -390,6 +413,13 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
      * Can be class references or instances.
      */
     subscribers: Iterable<EventSubscriber | Constructor<EventSubscriber>>;
+    /**
+     * Stored procedures and functions, declared as {@link Routine} instances.
+     *
+     * @example
+     * routines: [HashUser, AddRecord]
+     */
+    routines: Iterable<Routine>;
     /**
      * Global entity filters to apply.
      * Filters are applied by default unless explicitly disabled.
@@ -529,6 +559,13 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
      * @default false
      */
     forceUndefined: boolean;
+    /**
+     * Initialize nullable properties to `null` (or `undefined` when `forceUndefined` is set)
+     * during `em.create()` when they are not provided in the data. Without this option,
+     * nullable properties remain `undefined` until the entity is loaded from the database.
+     * @default false
+     */
+    initNullableProperties: boolean;
     /**
      * Property `onCreate` hooks are normally executed during `flush` operation.
      * With this option, they will be processed early inside `em.create()` method.