@mikro-orm/sql 7.0.0-dev.168 → 7.0.0-dev.170

package/AbstractSqlDriver.js

@@ -573,6 +573,9 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 if (options.onConflictAction === 'ignore') {
                     qb.ignore();
                 }
+                if (options.onConflictWhere) {
+                    qb.where(options.onConflictWhere);
+                }
             }
             else {
                 qb.update(data).where(where);
@@ -608,6 +611,9 @@ export class AbstractSqlDriver extends DatabaseDriver {
             if (options.onConflictAction === 'ignore') {
                 qb.ignore();
             }
+            if (options.onConflictWhere) {
+                qb.where(options.onConflictWhere);
+            }
             return this.rethrow(qb.execute('run', false));
         }
         const collections = options.processCollections ? data.map(d => this.extractManyToMany(meta, d)) : [];

package/dialects/mysql/MySqlSchemaHelper.d.ts

@@ -1,5 +1,5 @@
 import { type Dictionary, type Type } from '@mikro-orm/core';
-import type { CheckDef, Column, IndexDef, TableDifference, Table, ForeignKey } from '../../typings.js';
+import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference } from '../../typings.js';
 import type { AbstractSqlConnection } from '../../AbstractSqlConnection.js';
 import { SchemaHelper } from '../../schema/SchemaHelper.js';
 import type { DatabaseSchema } from '../../schema/DatabaseSchema.js';
@@ -16,6 +16,8 @@ export declare class MySqlSchemaHelper extends SchemaHelper {
     enableForeignKeysSQL(): string;
     finalizeTable(table: DatabaseTable, charset: string, collate?: string): string;
     getListTablesSQL(): string;
+    getListViewsSQL(schemaName?: string): 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[]>>;
     getCreateIndexSQL(tableName: string, index: IndexDef, partialExpression?: boolean): string;

package/dialects/mysql/MySqlSchemaHelper.js

@@ -33,6 +33,28 @@ 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) {
+        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));
+        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.
+            let definition = view.view_definition?.trim();
+            if (!definition) {
+                const createView = await connection.execute(`show create view \`${view.view_name}\``);
+                if (createView[0]?.['Create View']) {
+                    // Extract SELECT statement from CREATE VIEW ... AS SELECT ...
+                    const match = createView[0]['Create View'].match(/\bAS\s+(.+)$/is);
+                    definition = match?.[1]?.trim();
+                }
+            }
+            if (definition) {
+                schema.addView(view.view_name, view.schema_name ?? undefined, definition);
+            }
+        }
+    }
     async loadInformationSchema(schema, connection, tables) {
         if (tables.length === 0) {
             return;

package/dialects/postgresql/PostgreSqlSchemaHelper.d.ts

@@ -17,6 +17,8 @@ export declare class PostgreSqlSchemaHelper extends SchemaHelper {
     getSchemaBeginning(charset: string, disableForeignKeys?: boolean): string;
     getCreateDatabaseSQL(name: string): string;
     getListTablesSQL(): string;
+    getListViewsSQL(): string;
+    loadViews(schema: DatabaseSchema, connection: AbstractSqlConnection): Promise<void>;
     getNamespaces(connection: AbstractSqlConnection): Promise<string[]>;
     private getIgnoredNamespacesConditionSQL;
     loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[]): Promise<void>;

package/dialects/postgresql/PostgreSqlSchemaHelper.js

@@ -29,6 +29,21 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
             + `and table_name not in (select inhrelid::regclass::text from pg_inherits) `
             + `order by table_name`;
     }
+    getListViewsSQL() {
+        return `select table_name as view_name, table_schema as schema_name, view_definition `
+            + `from information_schema.views `
+            + `where ${this.getIgnoredNamespacesConditionSQL('table_schema')} `
+            + `order by table_name`;
+    }
+    async loadViews(schema, connection) {
+        const views = await connection.execute(this.getListViewsSQL());
+        for (const view of views) {
+            const definition = view.view_definition?.trim().replace(/;$/, '') ?? '';
+            if (definition) {
+                schema.addView(view.view_name, view.schema_name, definition);
+            }
+        }
+    }
     async getNamespaces(connection) {
         const sql = `select schema_name from information_schema.schemata `
             + `where ${this.getIgnoredNamespacesConditionSQL()} `

package/dialects/sqlite/SqliteSchemaHelper.d.ts

@@ -9,6 +9,8 @@ export declare class SqliteSchemaHelper extends SchemaHelper {
     enableForeignKeysSQL(): string;
     supportsSchemaConstraints(): boolean;
     getListTablesSQL(): string;
+    getListViewsSQL(): string;
+    loadViews(schema: DatabaseSchema, connection: AbstractSqlConnection, schemaName?: string): Promise<void>;
     getDropDatabaseSQL(name: string): string;
     loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[]): Promise<void>;
     createTable(table: DatabaseTable, alter?: boolean): string[];

package/dialects/sqlite/SqliteSchemaHelper.js

@@ -14,6 +14,18 @@ export class SqliteSchemaHelper extends SchemaHelper {
         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`;
     }
+    getListViewsSQL() {
+        return `select name as view_name, sql as view_definition from sqlite_master where type = 'view' order by name`;
+    }
+    async loadViews(schema, connection, schemaName) {
+        const views = await connection.execute(this.getListViewsSQL());
+        for (const view of views) {
+            // Extract the definition from CREATE VIEW statement
+            const match = view.view_definition.match(/create\s+view\s+[`"']?\w+[`"']?\s+as\s+(.*)/i);
+            const definition = match ? match[1] : view.view_definition;
+            schema.addView(view.view_name, schemaName, definition);
+        }
+    }
     getDropDatabaseSQL(name) {
         if (name === ':memory:') {
             return '';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.0.0-dev.168",
+  "version": "7.0.0-dev.170",
   "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.168"
+    "@mikro-orm/core": "7.0.0-dev.170"
   }
 }

package/schema/DatabaseSchema.d.ts

@@ -1,6 +1,7 @@
 import { type Configuration, type Dictionary, type EntityMetadata } from '@mikro-orm/core';
 import { DatabaseTable } from './DatabaseTable.js';
 import type { AbstractSqlConnection } from '../AbstractSqlConnection.js';
+import type { DatabaseView } from '../typings.js';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
 /**
  * @internal
@@ -9,6 +10,7 @@ export declare class DatabaseSchema {
     private readonly platform;
     readonly name: string;
     private tables;
+    private views;
     private namespaces;
     private nativeEnums;
     constructor(platform: AbstractSqlPlatform, name: string);
@@ -16,6 +18,10 @@ export declare class DatabaseSchema {
     getTables(): DatabaseTable[];
     getTable(name: string): DatabaseTable | undefined;
     hasTable(name: string): boolean;
+    addView(name: string, schema: string | undefined | null, definition: string): DatabaseView;
+    getViews(): DatabaseView[];
+    getView(name: string): DatabaseView | undefined;
+    hasView(name: string): boolean;
     setNativeEnums(nativeEnums: Dictionary<{
         name: string;
         schema?: string;
@@ -35,7 +41,8 @@ export declare class DatabaseSchema {
     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 fromMetadata(metadata: EntityMetadata[], platform: AbstractSqlPlatform, config: Configuration, schemaName?: string): 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 isTableNameAllowed;

package/schema/DatabaseSchema.js

@@ -7,6 +7,7 @@ export class DatabaseSchema {
     platform;
     name;
     tables = [];
+    views = [];
     namespaces = new Set();
     nativeEnums = {}; // for postgres
     constructor(platform, name) {
@@ -33,6 +34,24 @@ export class DatabaseSchema {
     hasTable(name) {
         return !!this.getTable(name);
     }
+    addView(name, schema, definition) {
+        const namespaceName = schema ?? this.name;
+        const view = { name, schema: namespaceName, definition };
+        this.views.push(view);
+        if (namespaceName != null) {
+            this.namespaces.add(namespaceName);
+        }
+        return view;
+    }
+    getViews() {
+        return this.views;
+    }
+    getView(name) {
+        return this.views.find(v => v.name === name || `${v.schema}.${v.name}` === name);
+    }
+    hasView(name) {
+        return !!this.getView(name);
+    }
     setNativeEnums(nativeEnums) {
         this.nativeEnums = nativeEnums;
         for (const nativeEnum of Object.values(nativeEnums)) {
@@ -64,13 +83,19 @@ export class DatabaseSchema {
         const migrationsSchemaName = parts.length > 1 ? parts[0] : config.get('schema', platform.getDefaultSchemaName());
         const tables = allTables.filter(t => this.isTableNameAllowed(t.table_name, takeTables, skipTables) && (t.table_name !== migrationsTableName || (t.schema_name && t.schema_name !== migrationsSchemaName)));
         await platform.getSchemaHelper().loadInformationSchema(schema, connection, tables, schemas && schemas.length > 0 ? schemas : undefined);
+        // Load views from database
+        await platform.getSchemaHelper().loadViews(schema, connection);
         return schema;
     }
-    static fromMetadata(metadata, platform, config, schemaName) {
+    static fromMetadata(metadata, platform, config, schemaName, em) {
         const schema = new DatabaseSchema(platform, schemaName ?? config.get('schema'));
         const nativeEnums = {};
         const skipColumns = config.get('schemaGenerator').skipColumns || {};
         for (const meta of metadata) {
+            // Skip view entities when collecting native enums
+            if (meta.view) {
+                continue;
+            }
             for (const prop of meta.props) {
                 if (prop.nativeEnumName) {
                     let key = prop.nativeEnumName;
@@ -95,6 +120,14 @@ export class DatabaseSchema {
         }
         schema.setNativeEnums(nativeEnums);
         for (const meta of metadata) {
+            // Handle view entities separately
+            if (meta.view) {
+                const viewDefinition = this.getViewDefinition(meta, em, platform);
+                if (viewDefinition) {
+                    schema.addView(meta.collection, this.getSchemaName(meta, config, schemaName), viewDefinition);
+                }
+                continue;
+            }
             const table = schema.addTable(meta.collection, this.getSchemaName(meta, config, schemaName));
             table.comment = meta.comment;
             for (const prop of meta.props) {
@@ -119,6 +152,35 @@ export class DatabaseSchema {
         }
         return schema;
     }
+    static getViewDefinition(meta, em, platform) {
+        if (typeof meta.expression === 'string') {
+            return meta.expression;
+        }
+        // Expression is a function, need to evaluate it
+        /* v8 ignore next */
+        if (!em) {
+            return undefined;
+        }
+        const result = meta.expression(em, {}, {});
+        // Async expressions are not supported for view entities
+        if (result && typeof result.then === 'function') {
+            throw new Error(`View entity ${meta.className} expression returned a Promise. Async expressions are not supported for view entities.`);
+        }
+        /* v8 ignore next */
+        if (typeof result === 'string') {
+            return result;
+        }
+        /* v8 ignore next */
+        if (isRaw(result)) {
+            return platform.formatQuery(result.sql, result.params);
+        }
+        // Check if it's a QueryBuilder (has getFormattedQuery method)
+        if (result && typeof result.getFormattedQuery === 'function') {
+            return result.getFormattedQuery();
+        }
+        /* v8 ignore next - fallback for unknown result types */
+        return undefined;
+    }
     static getSchemaName(meta, config, schema) {
         return (meta.schema === '*' ? schema : meta.schema) ?? config.get('schema');
     }
@@ -171,9 +233,15 @@ export class DatabaseSchema {
                 || table.schema === schema // specified schema matches the table's one
                 || (!schema && !wildcardSchemaTables.includes(table.name)); // no schema specified and the table has fixed one provided
         });
-        // remove namespaces of ignored tables
+        this.views = this.views.filter(view => {
+            /* v8 ignore next */
+            return (!schema && !hasWildcardSchema)
+                || view.schema === schema
+                || (!schema && !wildcardSchemaTables.includes(view.name));
+        });
+        // remove namespaces of ignored tables and views
         for (const ns of this.namespaces) {
-            if (!this.tables.some(t => t.schema === ns) && !Object.values(this.nativeEnums).some(e => e.schema === ns)) {
+            if (!this.tables.some(t => t.schema === ns) && !this.views.some(v => v.schema === ns) && !Object.values(this.nativeEnums).some(e => e.schema === ns)) {
                 this.namespaces.delete(ns);
             }
         }

package/schema/SchemaComparator.js

@@ -1,4 +1,4 @@
-import { ArrayType, BooleanType, DateTimeType, JsonType, parseJsonSafe, Utils, inspect, } from '@mikro-orm/core';
+import { ArrayType, BooleanType, DateTimeType, inspect, JsonType, parseJsonSafe, Utils, } from '@mikro-orm/core';
 /**
  * Compares two Schemas and return an instance of SchemaDifference.
  */
@@ -23,6 +23,9 @@ export class SchemaComparator {
             newTables: {},
             removedTables: {},
             changedTables: {},
+            newViews: {},
+            changedViews: {},
+            removedViews: {},
             orphanedForeignKeys: [],
             newNativeEnums: [],
             removedNativeEnums: [],
@@ -109,6 +112,29 @@ export class SchemaComparator {
                 }
             }
         }
+        // Compare views
+        for (const toView of toSchema.getViews()) {
+            const viewName = toView.schema ? `${toView.schema}.${toView.name}` : toView.name;
+            if (!fromSchema.hasView(toView.name) && !fromSchema.hasView(viewName)) {
+                diff.newViews[viewName] = toView;
+                this.log(`view ${viewName} added`);
+            }
+            else {
+                const fromView = fromSchema.getView(toView.name) ?? fromSchema.getView(viewName);
+                if (fromView && this.diffExpression(fromView.definition, toView.definition)) {
+                    diff.changedViews[viewName] = { from: fromView, to: toView };
+                    this.log(`view ${viewName} changed`);
+                }
+            }
+        }
+        // Check for removed views
+        for (const fromView of fromSchema.getViews()) {
+            const viewName = fromView.schema ? `${fromView.schema}.${fromView.name}` : fromView.name;
+            if (!toSchema.hasView(fromView.name) && !toSchema.hasView(viewName)) {
+                diff.removedViews[viewName] = fromView;
+                this.log(`view ${viewName} removed`);
+            }
+        }
         return diff;
     }
     /**
@@ -510,9 +536,30 @@ export class SchemaComparator {
             return str
                 ?.replace(/_\w+'(.*?)'/g, '$1')
                 .replace(/in\s*\((.*?)\)/ig, '= any (array[$1])')
-                .replace(/['"`()\n[\]]|::\w+| +/g, '')
+                // MySQL normalizes count(*) to count(0)
+                .replace(/\bcount\s*\(\s*0\s*\)/gi, 'count(*)')
+                // Remove quotes first so we can process identifiers
+                .replace(/['"`]/g, '')
+                // MySQL adds table/alias prefixes to columns (e.g., a.name or table_name.column vs just column)
+                // Strip these prefixes - match word.word patterns and keep only the last part
+                .replace(/\b\w+\.(\w+)/g, '$1')
+                // Normalize JOIN syntax: inner join -> join (equivalent in SQL)
+                .replace(/\binner\s+join\b/gi, 'join')
+                // Remove redundant column aliases like `title AS title` -> `title`
+                .replace(/\b(\w+)\s+as\s+\1\b/gi, '$1')
+                // Remove AS keyword (optional in SQL, MySQL may add/remove it)
+                .replace(/\bas\b/gi, '')
+                // Remove remaining special chars, parentheses, type casts, asterisks, and normalize whitespace
+                .replace(/[()\n[\]*]|::\w+| +/g, '')
                 .replace(/anyarray\[(.*)]/ig, '$1')
-                .toLowerCase();
+                .toLowerCase()
+                // PostgreSQL adds default aliases to aggregate functions (e.g., count(*) AS count)
+                // After removing AS and whitespace, this results in duplicate adjacent words
+                // Remove these duplicates: "countcount" -> "count", "minmin" -> "min"
+                // Use lookahead to match repeated patterns of 3+ chars (avoid false positives on short sequences)
+                .replace(/(\w{3,})\1/g, '$1')
+                // Remove trailing semicolon (PostgreSQL adds it to view definitions)
+                .replace(/;$/, '');
         };
         return simplify(expr1) !== simplify(expr2);
     }

package/schema/SchemaHelper.d.ts

@@ -21,7 +21,9 @@ export declare abstract class SchemaHelper {
     getDropNativeEnumSQL(name: string, schema?: string): string;
     getAlterNativeEnumSQL(name: string, schema?: string, value?: string, items?: string[], oldItems?: string[]): string;
     abstract loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[]): Promise<void>;
-    getListTablesSQL(schemaName?: string): string;
+    getListTablesSQL(): string;
+    getListViewsSQL(): string;
+    loadViews(schema: DatabaseSchema, connection: AbstractSqlConnection): Promise<void>;
     getRenameColumnSQL(tableName: string, oldColumnName: string, to: Column, schemaName?: string): string;
     getCreateIndexSQL(tableName: string, index: IndexDef): string;
     getDropIndexSQL(tableName: string, index: IndexDef): string;
@@ -75,4 +77,6 @@ export declare abstract class SchemaHelper {
     dropIndex(table: string, index: IndexDef, oldIndexName?: string): string;
     dropConstraint(table: string, name: string): string;
     dropTableIfExists(name: string, schema?: string): string;
+    createView(name: string, schema: string | undefined, definition: string): string;
+    dropViewIfExists(name: string, schema?: string): string;
 }

package/schema/SchemaHelper.js

@@ -62,7 +62,13 @@ export class SchemaHelper {
     getAlterNativeEnumSQL(name, schema, value, items, oldItems) {
         throw new Error('Not supported by given driver');
     }
-    getListTablesSQL(schemaName) {
+    getListTablesSQL() {
+        throw new Error('Not supported by given driver');
+    }
+    getListViewsSQL() {
+        throw new Error('Not supported by given driver');
+    }
+    async loadViews(schema, connection) {
         throw new Error('Not supported by given driver');
     }
     getRenameColumnSQL(tableName, oldColumnName, to, schemaName) {
@@ -541,4 +547,15 @@ export class SchemaHelper {
         }
         return sql;
     }
+    createView(name, schema, definition) {
+        const viewName = this.quote(this.getTableName(name, schema));
+        return `create view ${viewName} as ${definition}`;
+    }
+    dropViewIfExists(name, schema) {
+        let sql = `drop view if exists ${this.quote(this.getTableName(name, schema))}`;
+        if (this.platform.usesCascadeStatement()) {
+            sql += ' cascade';
+        }
+        return sql;
+    }
 }

package/schema/SqlSchemaGenerator.d.ts

@@ -63,5 +63,11 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
     private append;
     private matchName;
     private isTableSkipped;
+    /**
+     * Sorts views by their dependencies so that views depending on other views are created after their dependencies.
+     * Uses topological sort based on view definition string matching.
+     */
+    private sortViewsByDependencies;
+    private escapeRegExp;
 }
 export { SqlSchemaGenerator as SchemaGenerator };

package/schema/SqlSchemaGenerator.js

@@ -1,4 +1,4 @@
-import { AbstractSchemaGenerator, Utils, } from '@mikro-orm/core';
+import { AbstractSchemaGenerator, CommitOrderCalculator, Utils, } from '@mikro-orm/core';
 import { DatabaseSchema } from './DatabaseSchema.js';
 import { SchemaComparator } from './SchemaComparator.js';
 export class SqlSchemaGenerator extends AbstractSchemaGenerator {
@@ -45,7 +45,7 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
     getTargetSchema(schema) {
         const metadata = this.getOrderedMetadata(schema);
         const schemaName = schema ?? this.config.get('schema') ?? this.platform.getDefaultSchemaName();
-        return DatabaseSchema.fromMetadata(metadata, this.platform, this.config, schemaName);
+        return DatabaseSchema.fromMetadata(metadata, this.platform, this.config, schemaName, this.em);
     }
     getOrderedMetadata(schema) {
         const metadata = super.getOrderedMetadata(schema);
@@ -87,6 +87,12 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
                 this.append(ret, fks, true);
             }
         }
+        // Create views after tables (views may depend on tables)
+        // Sort views by dependencies (views depending on other views come later)
+        const sortedViews = this.sortViewsByDependencies(toSchema.getViews());
+        for (const view of sortedViews) {
+            this.append(ret, this.helper.createView(view.name, view.schema, view.definition), true);
+        }
         return this.wrapSchema(ret, options);
     }
     async drop(options = {}) {
@@ -130,6 +136,13 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         const schemas = this.getTargetSchema(options.schema).getNamespaces();
         const schema = await DatabaseSchema.create(this.connection, this.platform, this.config, options.schema, schemas);
         const ret = [];
+        // Drop views first (views may depend on tables)
+        // Drop in reverse dependency order (dependent views first)
+        const targetSchema = this.getTargetSchema(options.schema);
+        const sortedViews = this.sortViewsByDependencies(targetSchema.getViews()).reverse();
+        for (const view of sortedViews) {
+            this.append(ret, this.helper.dropViewIfExists(view.name, view.schema));
+        }
         // remove FKs explicitly if we can't use a cascading statement and we don't disable FK checks (we need this for circular relations)
         for (const meta of metadata) {
             if (!this.platform.usesCascadeStatement() && (!this.options.disableForeignKeys || options.dropForeignKeys)) {
@@ -217,6 +230,21 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
                 this.append(ret, sql);
             }
         }
+        // Drop removed and changed views first (before modifying tables they may depend on)
+        // Drop in reverse dependency order (dependent views first)
+        if (options.dropTables && !options.safe) {
+            const sortedRemovedViews = this.sortViewsByDependencies(Object.values(schemaDiff.removedViews)).reverse();
+            for (const view of sortedRemovedViews) {
+                this.append(ret, this.helper.dropViewIfExists(view.name, view.schema));
+            }
+        }
+        // Drop changed views (they will be recreated after table changes)
+        // Also in reverse dependency order
+        const changedViewsFrom = Object.values(schemaDiff.changedViews).map(v => v.from);
+        const sortedChangedViewsFrom = this.sortViewsByDependencies(changedViewsFrom).reverse();
+        for (const view of sortedChangedViewsFrom) {
+            this.append(ret, this.helper.dropViewIfExists(view.name, view.schema));
+        }
         if (!options.safe && this.options.createForeignKeyConstraints) {
             for (const orphanedForeignKey of schemaDiff.orphanedForeignKeys) {
                 const [schemaName, tableName] = this.helper.splitTableName(orphanedForeignKey.localTableName, true);
@@ -272,6 +300,18 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
                 this.append(ret, sql);
             }
         }
+        // Create new views after all table changes are done
+        // Sort views by dependencies (views depending on other views come later)
+        const sortedNewViews = this.sortViewsByDependencies(Object.values(schemaDiff.newViews));
+        for (const view of sortedNewViews) {
+            this.append(ret, this.helper.createView(view.name, view.schema, view.definition), true);
+        }
+        // Recreate changed views (also sorted by dependencies)
+        const changedViews = Object.values(schemaDiff.changedViews).map(v => v.to);
+        const sortedChangedViews = this.sortViewsByDependencies(changedViews);
+        for (const view of sortedChangedViews) {
+            this.append(ret, this.helper.createView(view.name, view.schema, view.definition), true);
+        }
         return this.wrapSchema(ret, options);
     }
     /**
@@ -370,6 +410,57 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         const fullTableName = schemaName ? `${schemaName}.${tableName}` : tableName;
         return skipTables.some(pattern => this.matchName(tableName, pattern) || this.matchName(fullTableName, pattern));
     }
+    /**
+     * Sorts views by their dependencies so that views depending on other views are created after their dependencies.
+     * Uses topological sort based on view definition string matching.
+     */
+    sortViewsByDependencies(views) {
+        if (views.length <= 1) {
+            return views;
+        }
+        // Use CommitOrderCalculator for topological sort
+        const calc = new CommitOrderCalculator();
+        // Map views to numeric indices for the calculator
+        const viewToIndex = new Map();
+        const indexToView = new Map();
+        for (let i = 0; i < views.length; i++) {
+            viewToIndex.set(views[i], i);
+            indexToView.set(i, views[i]);
+            calc.addNode(i);
+        }
+        // Check each view's definition for references to other view names
+        for (const view of views) {
+            const definition = view.definition.toLowerCase();
+            const viewIndex = viewToIndex.get(view);
+            for (const otherView of views) {
+                if (otherView === view) {
+                    continue;
+                }
+                // Check if the definition references the other view's name
+                // Use word boundary matching to avoid false positives
+                const patterns = [
+                    new RegExp(`\\b${this.escapeRegExp(otherView.name.toLowerCase())}\\b`),
+                ];
+                if (otherView.schema) {
+                    patterns.push(new RegExp(`\\b${this.escapeRegExp(`${otherView.schema}.${otherView.name}`.toLowerCase())}\\b`));
+                }
+                for (const pattern of patterns) {
+                    if (pattern.test(definition)) {
+                        // view depends on otherView, so otherView must come first
+                        // addDependency(from, to) puts `from` before `to` in result
+                        const otherIndex = viewToIndex.get(otherView);
+                        calc.addDependency(otherIndex, viewIndex, 1);
+                        break;
+                    }
+                }
+            }
+        }
+        // Sort and map back to views
+        return calc.sort().map(index => indexToView.get(index));
+    }
+    escapeRegExp(string) {
+        return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
 }
 // for back compatibility
 export { SqlSchemaGenerator as SchemaGenerator };