@mikro-orm/sql 7.1.0-dev.24 → 7.1.0-dev.26

package/dialects/mysql/MySqlSchemaHelper.d.ts

@@ -13,6 +13,10 @@ export declare class MySqlSchemaHelper extends SchemaHelper {
     };
     private static readonly PARTIAL_INDEX_RE;
     getSchemaBeginning(charset: string, disableForeignKeys?: boolean): string;
+    getSetSchemaSQL(schema: string): string;
+    getResetSchemaSQL(defaultSchema: string): string;
+    supportsMigrationSchema(): boolean;
+    tableExists(connection: AbstractSqlConnection, tableName: string, schemaName: string | undefined, ctx?: Transaction): Promise<boolean>;
     disableForeignKeysSQL(): string;
     enableForeignKeysSQL(): string;
     finalizeTable(table: DatabaseTable, charset: string, collate?: string): string;

package/dialects/mysql/MySqlSchemaHelper.js

@@ -17,6 +17,24 @@ export class MySqlSchemaHelper extends SchemaHelper {
         }
         return `set names ${charset};\n\n`;
     }
+    getSetSchemaSQL(schema) {
+        return `use ${this.quote(schema)}`;
+    }
+    getResetSchemaSQL(defaultSchema) {
+        return `use ${this.quote(defaultSchema)}`;
+    }
+    supportsMigrationSchema() {
+        return true;
+    }
+    async tableExists(connection, tableName, schemaName, ctx) {
+        // MySQL "schema" = database — when none is requested, probe the connection's current DB
+        // via `schema()` rather than the base impl's `getDefaultSchemaName()` (which is undefined here).
+        const schemaClause = schemaName
+            ? `table_schema = ${this.platform.quoteValue(schemaName)}`
+            : `table_schema = schema()`;
+        const rows = await connection.execute(`select 1 from information_schema.tables where ${schemaClause} and table_name = ${this.platform.quoteValue(tableName)}`, [], 'all', ctx);
+        return rows.length > 0;
+    }
     disableForeignKeysSQL() {
         return 'set foreign_key_checks = 0;';
     }

package/dialects/postgresql/PostgreSqlSchemaHelper.d.ts

@@ -17,6 +17,9 @@ export declare class PostgreSqlSchemaHelper extends SchemaHelper {
     private static readonly PARTIAL_WHERE_RE;
     private static readonly FUNCTIONAL_COL_RE;
     getSchemaBeginning(charset: string, disableForeignKeys?: boolean): string;
+    getSetSchemaSQL(schema: string): string;
+    getResetSchemaSQL(_defaultSchema: string): string;
+    supportsMigrationSchema(): boolean;
     getCreateDatabaseSQL(name: string): string;
     getListTablesSQL(): string;
     private getIgnoredViewsCondition;

package/dialects/postgresql/PostgreSqlSchemaHelper.js

@@ -21,6 +21,17 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         }
         return `set names '${charset}';\n\n`;
     }
+    getSetSchemaSQL(schema) {
+        // session-level `SET` (not `SET LOCAL`) so it also works outside a transaction; the runner
+        // emits `getResetSchemaSQL` afterwards to avoid leaking onto the pooled connection
+        return `set search_path to ${this.quote(schema)}`;
+    }
+    getResetSchemaSQL(_defaultSchema) {
+        return 'reset search_path';
+    }
+    supportsMigrationSchema() {
+        return true;
+    }
     getCreateDatabaseSQL(name) {
         return `create database ${this.quote(name)}`;
     }

package/dialects/sqlite/SqliteSchemaHelper.d.ts

@@ -11,6 +11,7 @@ export declare class SqliteSchemaHelper extends SchemaHelper {
     supportsSchemaConstraints(): boolean;
     getCreateNamespaceSQL(name: string): string;
     getDropNamespaceSQL(name: string): string;
+    tableExists(connection: AbstractSqlConnection, tableName: string, _schemaName: string | undefined, ctx?: Transaction): Promise<boolean>;
     getListTablesSQL(): string;
     getAllTables(connection: AbstractSqlConnection, schemas?: string[], ctx?: Transaction): Promise<Table[]>;
     getNamespaces(connection: AbstractSqlConnection, ctx?: Transaction): Promise<string[]>;

package/dialects/sqlite/SqliteSchemaHelper.js

@@ -31,6 +31,10 @@ export class SqliteSchemaHelper extends SchemaHelper {
     getDropNamespaceSQL(name) {
         return '';
     }
+    async tableExists(connection, tableName, _schemaName, ctx) {
+        const rows = await connection.execute(`select name from sqlite_master where type = 'table' and name = ${this.platform.quoteValue(tableName)}`, [], 'all', ctx);
+        return rows.length > 0;
+    }
     getListTablesSQL() {
         return (`select name as table_name from sqlite_master where type = 'table' and name != 'sqlite_sequence' and name != 'geometry_columns' and name != 'spatial_ref_sys' ` +
             `union all select name as table_name from sqlite_temp_master where type = 'table' order by name`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.1.0-dev.24",
+  "version": "7.1.0-dev.26",
   "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",
@@ -53,7 +53,7 @@
     "@mikro-orm/core": "^7.0.13"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.0-dev.24"
+    "@mikro-orm/core": "7.1.0-dev.26"
   },
   "engines": {
     "node": ">= 22.17.0"

package/schema/SchemaHelper.d.ts

@@ -16,6 +16,14 @@ export declare abstract class SchemaHelper {
     enableForeignKeysSQL(): string;
     /** Returns SQL to append to schema migration scripts (e.g., re-enabling FK checks). */
     getSchemaEnd(disableForeignKeys?: boolean): string;
+    /** Sets the current schema for the session (e.g. `SET search_path`). */
+    getSetSchemaSQL(_schema: string): string;
+    /** Whether the driver supports setting a runtime schema per migration run. */
+    supportsMigrationSchema(): boolean;
+    /** Restores the session's schema to the connection's default after a migration. */
+    getResetSchemaSQL(_defaultSchema: string): string;
+    /** Returns `undefined` for schemaless drivers, throws for drivers that have schemas but no session switch. */
+    resolveMigrationSchema(schema: string | undefined): string | undefined;
     finalizeTable(table: DatabaseTable, charset: string, collate?: string): string;
     appendComments(table: DatabaseTable): string[];
     supportsSchemaConstraints(): boolean;
@@ -31,6 +39,8 @@ export declare abstract class SchemaHelper {
     getListTablesSQL(): string;
     /** Retrieves all tables from the database. */
     getAllTables(connection: AbstractSqlConnection, schemas?: string[], ctx?: Transaction): Promise<Table[]>;
+    /** Checks whether a specific table exists in a given schema (not the connection's current schema). */
+    tableExists(connection: AbstractSqlConnection, tableName: string, schemaName: string | undefined, ctx?: Transaction): Promise<boolean>;
     getListViewsSQL(): string;
     loadViews(schema: DatabaseSchema, connection: AbstractSqlConnection, schemaName?: string, ctx?: Transaction): Promise<void>;
     /** Returns SQL to rename a column in a table. */

package/schema/SchemaHelper.js

@@ -27,6 +27,32 @@ export class SchemaHelper {
         }
         return '';
     }
+    /** Sets the current schema for the session (e.g. `SET search_path`). */
+    getSetSchemaSQL(_schema) {
+        return '';
+    }
+    /** Whether the driver supports setting a runtime schema per migration run. */
+    supportsMigrationSchema() {
+        return false;
+    }
+    /** Restores the session's schema to the connection's default after a migration. */
+    getResetSchemaSQL(_defaultSchema) {
+        return '';
+    }
+    /** Returns `undefined` for schemaless drivers, throws for drivers that have schemas but no session switch. */
+    resolveMigrationSchema(schema) {
+        if (!schema) {
+            return undefined;
+        }
+        if (this.supportsMigrationSchema()) {
+            return schema;
+        }
+        if (!this.platform.supportsSchemas()) {
+            return undefined;
+        }
+        const driverName = this.platform.constructor.name.replace(/Platform$/, 'Driver');
+        throw new Error(`Runtime schema for migrations is not supported by the ${driverName}`);
+    }
     finalizeTable(table, charset, collate) {
         return '';
     }
@@ -75,6 +101,13 @@ export class SchemaHelper {
     async getAllTables(connection, schemas, ctx) {
         return connection.execute(this.getListTablesSQL(), [], 'all', ctx);
     }
+    /** Checks whether a specific table exists in a given schema (not the connection's current schema). */
+    async tableExists(connection, tableName, schemaName, ctx) {
+        const qv = (v) => this.platform.quoteValue(v ?? '');
+        const resolved = schemaName ?? this.platform.getDefaultSchemaName();
+        const rows = await connection.execute(`select 1 from information_schema.tables where table_schema = ${qv(resolved)} and table_name = ${qv(tableName)}`, [], 'all', ctx);
+        return rows.length > 0;
+    }
     getListViewsSQL() {
         throw new Error('Not supported by given driver');
     }

package/schema/SqlSchemaGenerator.d.ts

@@ -15,8 +15,8 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
      * Returns true if the database was created.
      */
     ensureDatabase(options?: EnsureDatabaseOptions): Promise<boolean>;
-    getTargetSchema(schema?: string): DatabaseSchema;
-    protected getOrderedMetadata(schema?: string): EntityMetadata[];
+    getTargetSchema(schema?: string, includeWildcardSchema?: boolean): DatabaseSchema;
+    protected getOrderedMetadata(schema?: string, includeWildcardSchema?: boolean): EntityMetadata[];
     getCreateSchemaSQL(options?: CreateSchemaOptions): Promise<string>;
     drop(options?: DropSchemaOptions): Promise<void>;
     createNamespace(name: string): Promise<void>;

package/schema/SqlSchemaGenerator.js

@@ -44,13 +44,13 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         }
         return false;
     }
-    getTargetSchema(schema) {
-        const metadata = this.getOrderedMetadata(schema);
+    getTargetSchema(schema, includeWildcardSchema = false) {
+        const metadata = this.getOrderedMetadata(schema, includeWildcardSchema);
         const schemaName = schema ?? this.config.get('schema') ?? this.platform.getDefaultSchemaName();
         return DatabaseSchema.fromMetadata(metadata, this.platform, this.config, schemaName, this.em);
     }
-    getOrderedMetadata(schema) {
-        const metadata = super.getOrderedMetadata(schema);
+    getOrderedMetadata(schema, includeWildcardSchema = false) {
+        const metadata = super.getOrderedMetadata(schema, includeWildcardSchema);
         // Filter out skipped tables
         return metadata.filter(meta => {
             const tableName = meta.tableName;
@@ -59,7 +59,7 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         });
     }
     async getCreateSchemaSQL(options = {}) {
-        const toSchema = this.getTargetSchema(options.schema);
+        const toSchema = this.getTargetSchema(options.schema, options.includeWildcardSchema);
         const ret = [];
         for (const namespace of toSchema.getNamespaces()) {
             if (namespace === this.platform.getDefaultSchemaName()) {
@@ -225,13 +225,13 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
     async prepareSchemaForComparison(options) {
         options.safe ??= false;
         options.dropTables ??= true;
-        const toSchema = this.getTargetSchema(options.schema);
+        const toSchema = this.getTargetSchema(options.schema, options.includeWildcardSchema);
         const schemas = toSchema.getNamespaces();
         const fromSchema = options.fromSchema ??
             (await DatabaseSchema.create(this.connection, this.platform, this.config, options.schema, schemas, undefined, this.options.skipTables, this.options.skipViews));
-        const wildcardSchemaTables = [...this.metadata.getAll().values()]
-            .filter(meta => meta.schema === '*')
-            .map(meta => meta.tableName);
+        const wildcardSchemaTables = options.includeWildcardSchema
+            ? []
+            : [...this.metadata.getAll().values()].filter(meta => meta.schema === '*').map(meta => meta.tableName);
         fromSchema.prune(options.schema, wildcardSchemaTables);
         toSchema.prune(options.schema, wildcardSchemaTables);
         return { fromSchema, toSchema };