@mikro-orm/sql 7.0.0-dev.207 → 7.0.0-dev.208

package/dialects/mysql/MySqlSchemaHelper.d.ts

@@ -16,7 +16,7 @@ export declare class MySqlSchemaHelper extends SchemaHelper {
     enableForeignKeysSQL(): string;
     finalizeTable(table: DatabaseTable, charset: string, collate?: string): string;
     getListTablesSQL(): string;
-    getListViewsSQL(schemaName?: string): string;
+    getListViewsSQL(): string;
     loadViews(schema: DatabaseSchema, connection: AbstractSqlConnection, schemaName?: string): Promise<void>;
     loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[]): Promise<void>;
     getAllIndexes(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<IndexDef[]>>;

package/dialects/mysql/MySqlSchemaHelper.js

@@ -33,11 +33,11 @@ export class MySqlSchemaHelper extends SchemaHelper {
     getListTablesSQL() {
         return `select table_name as table_name, nullif(table_schema, schema()) as schema_name, table_comment as table_comment from information_schema.tables where table_type = 'BASE TABLE' and table_schema = schema()`;
     }
-    getListViewsSQL(schemaName) {
+    getListViewsSQL() {
         return `select table_name as view_name, nullif(table_schema, schema()) as schema_name, view_definition from information_schema.views where table_schema = schema()`;
     }
     async loadViews(schema, connection, schemaName) {
-        const views = await connection.execute(this.getListViewsSQL(schemaName));
+        const views = await connection.execute(this.getListViewsSQL());
         for (const view of views) {
             // MySQL information_schema.views.view_definition requires SHOW VIEW privilege
             // and may return NULL. Use SHOW CREATE VIEW as fallback.

package/dialects/postgresql/PostgreSqlSchemaHelper.d.ts

@@ -17,6 +17,7 @@ export declare class PostgreSqlSchemaHelper extends SchemaHelper {
     getSchemaBeginning(charset: string, disableForeignKeys?: boolean): string;
     getCreateDatabaseSQL(name: string): string;
     getListTablesSQL(): string;
+    private getIgnoredViewsCondition;
     getListViewsSQL(): string;
     loadViews(schema: DatabaseSchema, connection: AbstractSqlConnection): Promise<void>;
     getListMaterializedViewsSQL(): string;

package/dialects/postgresql/PostgreSqlSchemaHelper.js

@@ -1,5 +1,7 @@
-import { EnumType, Type, Utils, DeferMode } from '@mikro-orm/core';
+import { DeferMode, EnumType, Type, Utils } from '@mikro-orm/core';
 import { SchemaHelper } from '../../schema/SchemaHelper.js';
+/** PostGIS system views that should be automatically ignored */
+const POSTGIS_VIEWS = ['geography_columns', 'geometry_columns'];
 export class PostgreSqlSchemaHelper extends SchemaHelper {
     static DEFAULT_VALUES = {
         'now()': ['now()', 'current_timestamp'],
@@ -29,10 +31,14 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
             + `and table_name not in (select inhrelid::regclass::text from pg_inherits) `
             + `order by table_name`;
     }
+    getIgnoredViewsCondition() {
+        return POSTGIS_VIEWS.map(v => `table_name != '${v}'`).join(' and ');
+    }
     getListViewsSQL() {
         return `select table_name as view_name, table_schema as schema_name, view_definition `
             + `from information_schema.views `
             + `where ${this.getIgnoredNamespacesConditionSQL('table_schema')} `
+            + `and ${this.getIgnoredViewsCondition()} `
             + `order by table_name`;
     }
     async loadViews(schema, connection) {

package/dialects/sqlite/SqliteSchemaHelper.d.ts

@@ -13,6 +13,7 @@ export declare class SqliteSchemaHelper extends SchemaHelper {
     getListTablesSQL(): string;
     getAllTables(connection: AbstractSqlConnection, schemas?: string[]): Promise<Table[]>;
     getNamespaces(connection: AbstractSqlConnection): Promise<string[]>;
+    private getIgnoredViewsCondition;
     getListViewsSQL(): string;
     loadViews(schema: DatabaseSchema, connection: AbstractSqlConnection, schemaName?: string): Promise<void>;
     getDropDatabaseSQL(name: string): string;

package/dialects/sqlite/SqliteSchemaHelper.js

@@ -1,5 +1,19 @@
 import { Utils } from '@mikro-orm/core';
 import { SchemaHelper } from '../../schema/SchemaHelper.js';
+/** SpatiaLite system views that should be automatically ignored */
+const SPATIALITE_VIEWS = [
+    'geometry_columns',
+    'spatial_ref_sys',
+    'views_geometry_columns',
+    'virts_geometry_columns',
+    'geom_cols_ref_sys',
+    'spatial_ref_sys_aux',
+    'vector_layers',
+    'vector_layers_auth',
+    'vector_layers_field_infos',
+    'vector_layers_statistics',
+    'ElementaryGeometries',
+];
 export class SqliteSchemaHelper extends SchemaHelper {
     disableForeignKeysSQL() {
         return 'pragma foreign_keys = off;';
@@ -43,8 +57,11 @@ export class SqliteSchemaHelper extends SchemaHelper {
     async getNamespaces(connection) {
         return this.getDatabaseList(connection);
     }
+    getIgnoredViewsCondition() {
+        return SPATIALITE_VIEWS.map(v => `name != '${v}'`).join(' and ');
+    }
     getListViewsSQL() {
-        return `select name as view_name, sql as view_definition from sqlite_master where type = 'view' order by name`;
+        return `select name as view_name, sql as view_definition from sqlite_master where type = 'view' and ${this.getIgnoredViewsCondition()} order by name`;
     }
     async loadViews(schema, connection, schemaName) {
         const databases = await this.getDatabaseList(connection);
@@ -62,7 +79,7 @@ export class SqliteSchemaHelper extends SchemaHelper {
         const targetDbs = schemaName ? [schemaName] : databases;
         for (const dbName of targetDbs) {
             const prefix = this.getSchemaPrefix(dbName);
-            const views = await connection.execute(`select name as view_name, sql as view_definition from ${prefix}sqlite_master where type = 'view' order by name`);
+            const views = await connection.execute(`select name as view_name, sql as view_definition from ${prefix}sqlite_master where type = 'view' and ${this.getIgnoredViewsCondition()} order by name`);
             for (const view of views) {
                 schema.addView(view.view_name, dbName, this.extractViewDefinition(view.view_definition));
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.0.0-dev.207",
+  "version": "7.0.0-dev.208",
   "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.",
   "type": "module",
   "exports": {
@@ -56,6 +56,6 @@
     "@mikro-orm/core": "^6.6.4"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.207"
+    "@mikro-orm/core": "7.0.0-dev.208"
   }
 }

package/schema/DatabaseSchema.d.ts

@@ -40,11 +40,12 @@ export declare class DatabaseSchema {
     hasNamespace(namespace: string): boolean;
     hasNativeEnum(name: string): boolean;
     getNamespaces(): string[];
-    static create(connection: AbstractSqlConnection, platform: AbstractSqlPlatform, config: Configuration, schemaName?: string, schemas?: string[], takeTables?: (string | RegExp)[], skipTables?: (string | RegExp)[]): Promise<DatabaseSchema>;
+    static create(connection: AbstractSqlConnection, platform: AbstractSqlPlatform, config: Configuration, schemaName?: string, schemas?: string[], takeTables?: (string | RegExp)[], skipTables?: (string | RegExp)[], skipViews?: (string | RegExp)[]): Promise<DatabaseSchema>;
     static fromMetadata(metadata: EntityMetadata[], platform: AbstractSqlPlatform, config: Configuration, schemaName?: string, em?: any): DatabaseSchema;
     private static getViewDefinition;
     private static getSchemaName;
     private static matchName;
+    private static isNameAllowed;
     private static isTableNameAllowed;
     private static shouldHaveColumn;
     toJSON(): Dictionary;

package/schema/DatabaseSchema.js

@@ -75,7 +75,7 @@ export class DatabaseSchema {
     getNamespaces() {
         return [...this.namespaces];
     }
-    static async create(connection, platform, config, schemaName, schemas, takeTables, skipTables) {
+    static async create(connection, platform, config, schemaName, schemas, takeTables, skipTables, skipViews) {
         const schema = new DatabaseSchema(platform, schemaName ?? config.get('schema') ?? platform.getDefaultSchemaName());
         const allTables = await platform.getSchemaHelper().getAllTables(connection, schemas);
         const parts = config.get('migrations').tableName.split('.');
@@ -89,6 +89,10 @@ export class DatabaseSchema {
         if (platform.supportsMaterializedViews()) {
             await platform.getSchemaHelper().loadMaterializedViews(schema, connection, schemaName);
         }
+        // Filter out skipped views
+        if (skipViews && skipViews.length > 0) {
+            schema.views = schema.views.filter(v => this.isNameAllowed(v.name, skipViews));
+        }
         return schema;
     }
     static fromMetadata(metadata, platform, config, schemaName, em) {
@@ -193,9 +197,12 @@ export class DatabaseSchema {
             ? name.toLocaleLowerCase() === nameToMatch.toLocaleLowerCase()
             : nameToMatch.test(name);
     }
+    static isNameAllowed(name, skipNames) {
+        return !(skipNames?.some(pattern => this.matchName(name, pattern)) ?? false);
+    }
     static isTableNameAllowed(tableName, takeTables, skipTables) {
         return ((takeTables?.some(tableNameToMatch => this.matchName(tableName, tableNameToMatch)) ?? true) &&
-            !(skipTables?.some(tableNameToMatch => this.matchName(tableName, tableNameToMatch)) ?? false));
+            this.isNameAllowed(tableName, skipTables));
     }
     static shouldHaveColumn(meta, prop, skipColumns) {
         if (prop.persist === false || (prop.columnTypes?.length ?? 0) === 0) {

package/schema/SchemaHelper.d.ts

@@ -24,7 +24,7 @@ export declare abstract class SchemaHelper {
     getListTablesSQL(): string;
     getAllTables(connection: AbstractSqlConnection, schemas?: string[]): Promise<Table[]>;
     getListViewsSQL(): string;
-    loadViews(schema: DatabaseSchema, connection: AbstractSqlConnection): Promise<void>;
+    loadViews(schema: DatabaseSchema, connection: AbstractSqlConnection, schemaName?: string): Promise<void>;
     getRenameColumnSQL(tableName: string, oldColumnName: string, to: Column, schemaName?: string): string;
     getCreateIndexSQL(tableName: string, index: IndexDef): string;
     getDropIndexSQL(tableName: string, index: IndexDef): string;
@@ -67,6 +67,7 @@ export declare abstract class SchemaHelper {
         createForeignKeyConstraints?: boolean;
         ignoreSchema?: string[];
         skipTables?: (string | RegExp)[];
+        skipViews?: (string | RegExp)[];
         skipColumns?: Dictionary<(string | RegExp)[]>;
         managementDbName?: string;
         defaultUpdateRule?: "cascade" | "no action" | "set null" | "set default" | "restrict";

package/schema/SchemaHelper.js

@@ -71,7 +71,7 @@ export class SchemaHelper {
     getListViewsSQL() {
         throw new Error('Not supported by given driver');
     }
-    async loadViews(schema, connection) {
+    async loadViews(schema, connection, schemaName) {
         throw new Error('Not supported by given driver');
     }
     getRenameColumnSQL(tableName, oldColumnName, to, schemaName) {

package/schema/SqlSchemaGenerator.d.ts

@@ -9,6 +9,7 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
         createForeignKeyConstraints?: boolean;
         ignoreSchema?: string[];
         skipTables?: (string | RegExp)[];
+        skipViews?: (string | RegExp)[];
         skipColumns?: Dictionary<(string | RegExp)[]>;
         managementDbName?: string;
         defaultUpdateRule?: "cascade" | "no action" | "set null" | "set default" | "restrict";

package/schema/SqlSchemaGenerator.js

@@ -139,7 +139,7 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         await this.ensureDatabase();
         const metadata = this.getOrderedMetadata(options.schema).reverse();
         const schemas = this.getTargetSchema(options.schema).getNamespaces();
-        const schema = await DatabaseSchema.create(this.connection, this.platform, this.config, options.schema, schemas);
+        const schema = await DatabaseSchema.create(this.connection, this.platform, this.config, options.schema, schemas, undefined, this.options.skipTables, this.options.skipViews);
         const ret = [];
         // Drop views first (views may depend on tables)
         // Drop in reverse dependency order (dependent views first)
@@ -219,7 +219,7 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         options.dropTables ??= true;
         const toSchema = this.getTargetSchema(options.schema);
         const schemas = toSchema.getNamespaces();
-        const fromSchema = options.fromSchema ?? (await DatabaseSchema.create(this.connection, this.platform, this.config, options.schema, schemas, undefined, this.options.skipTables));
+        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);
         fromSchema.prune(options.schema, wildcardSchemaTables);
         toSchema.prune(options.schema, wildcardSchemaTables);