@mikro-orm/core 7.1.0-dev.25 → 7.1.0-dev.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.1.0-dev.25",
+  "version": "7.1.0-dev.27",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "keywords": [
     "data-mapper",

package/typings.d.ts

@@ -985,6 +985,11 @@ export interface EntityMetadata<Entity = any, Class extends EntityCtor<Entity> =
 export interface CreateSchemaOptions {
     wrap?: boolean;
     schema?: string;
+    /**
+     * When true, entities with a wildcard schema (`schema: '*'`) are included in the generated DDL.
+     * Without this, wildcard tables are skipped.
+     */
+    includeWildcardSchema?: boolean;
 }
 /** Options for `ISchemaGenerator.clear()` to truncate/clear database tables. */
 export interface ClearDatabaseOptions {
@@ -1014,6 +1019,13 @@ export interface UpdateSchemaOptions<DatabaseSchema = unknown> {
     dropTables?: boolean;
     schema?: string;
     fromSchema?: DatabaseSchema;
+    /**
+     * When true, entities with a wildcard schema (`schema: '*'`) are included in the diff so migrations
+     * can be generated for them. The emitted SQL is unqualified — and therefore safe to apply against
+     * any schema at runtime — only when neither `options.schema` nor `config.schema` is set; otherwise
+     * wildcard tables inherit that schema qualifier.
+     */
+    includeWildcardSchema?: boolean;
 }
 /** Options for `ISchemaGenerator.refresh()` which drops and recreates the schema. */
 export interface RefreshDatabaseOptions extends CreateSchemaOptions {
@@ -1094,6 +1106,12 @@ export type MigrateOptions = {
     to?: string | number;
     migrations?: string[];
     transaction?: Transaction;
+    /**
+     * Target schema to run migrations against. Issues a driver-specific "set current schema"
+     * statement (e.g. `SET search_path` on PostgreSQL) before each migration, and places the
+     * tracking table in this schema. Overrides `migrations.schema` from config. Not supported on MSSQL.
+     */
+    schema?: string;
 };
 /** Result of creating a new migration file, including the generated code and schema diff. */
 export type MigrationResult = {
@@ -1114,6 +1132,8 @@ export interface IMigrationRunner {
     run(migration: Migration, method: 'up' | 'down'): Promise<void>;
     setMasterMigration(trx: Transaction): void;
     unsetMasterMigration(): void;
+    setRunSchema?(schema?: string): void;
+    unsetRunSchema?(): void;
 }
 /**
  * @internal
@@ -1126,6 +1146,8 @@ export interface IMigratorStorage {
     ensureTable?(): Promise<void>;
     setMasterMigration(trx: Transaction): void;
     unsetMasterMigration(): void;
+    setRunSchema?(schema?: string): void;
+    unsetRunSchema?(): void;
     getMigrationName(name: string): string;
     getTableName?(): {
         schemaName?: string;
@@ -1152,11 +1174,15 @@ export interface IMigrator {
     /**
      * Returns list of already executed migrations.
      */
-    getExecuted(): Promise<MigrationRow[]>;
+    getExecuted(options?: {
+        schema?: string;
+    }): Promise<MigrationRow[]>;
     /**
      * Returns list of pending (not yet executed) migrations found in the migration directory.
      */
-    getPending(): Promise<MigrationInfo[]>;
+    getPending(options?: {
+        schema?: string;
+    }): Promise<MigrationInfo[]>;
     /**
      * Executes specified migrations. Without parameter it will migrate up to the latest version.
      */

package/utils/AbstractMigrator.d.ts

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

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
@@ -487,13 +501,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));
         }
@@ -506,23 +524,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

@@ -238,6 +238,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.

package/utils/Utils.js

@@ -141,7 +141,7 @@ export function parseJsonSafe(value) {
 /** Collection of general-purpose utility methods used throughout the ORM. */
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.1.0-dev.25';
+    static #ORM_VERSION = '7.1.0-dev.27';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */