@mikro-orm/sql 7.0.7-dev.10 → 7.0.7-dev.11

package/dialects/postgresql/PostgreSqlSchemaHelper.js

@@ -51,17 +51,26 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         }
     }
     getListMaterializedViewsSQL() {
-        return (`select matviewname as view_name, schemaname as schema_name, definition as view_definition ` +
+        return (`select matviewname as view_name, schemaname as schema_name, definition as view_definition, ispopulated as is_populated ` +
             `from pg_matviews ` +
             `where ${this.getIgnoredNamespacesConditionSQL('schemaname')} ` +
             `order by matviewname`);
     }
     async loadMaterializedViews(schema, connection, schemaName) {
         const views = await connection.execute(this.getListMaterializedViewsSQL());
-        for (const view of views) {
-            const definition = view.view_definition?.trim().replace(/;$/, '') ?? '';
+        if (views.length === 0) {
+            return;
+        }
+        const tables = views.map(v => ({ table_name: v.view_name, schema_name: v.schema_name }));
+        const indexes = await this.getAllIndexes(connection, tables);
+        for (let i = 0; i < views.length; i++) {
+            const definition = views[i].view_definition?.trim().replace(/;$/, '') ?? '';
             if (definition) {
-                schema.addView(view.view_name, view.schema_name, definition, true);
+                const dbView = schema.addView(views[i].view_name, views[i].schema_name, definition, true, views[i].is_populated);
+                const key = this.getTableKey(tables[i]);
+                if (indexes[key]?.length) {
+                    dbView.indexes = indexes[key];
+                }
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.0.7-dev.10",
+  "version": "7.0.7-dev.11",
   "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.6"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.7-dev.10"
+    "@mikro-orm/core": "7.0.7-dev.11"
   },
   "engines": {
     "node": ">= 22.17.0"

package/schema/DatabaseSchema.js

@@ -147,7 +147,27 @@ export class DatabaseSchema {
             if (meta.view) {
                 const viewDefinition = this.getViewDefinition(meta, em, platform);
                 if (viewDefinition) {
-                    schema.addView(meta.collection, this.getSchemaName(meta, config, schemaName), viewDefinition, meta.materialized, meta.withData);
+                    const view = schema.addView(meta.collection, this.getSchemaName(meta, config, schemaName), viewDefinition, meta.materialized, meta.withData);
+                    if (meta.materialized) {
+                        // Use a DatabaseTable to resolve property names → field names for indexes.
+                        // addIndex only needs meta + table name, not actual columns.
+                        const indexTable = new DatabaseTable(platform, meta.collection, this.getSchemaName(meta, config, schemaName));
+                        meta.indexes.forEach(index => indexTable.addIndex(meta, index, 'index'));
+                        meta.uniques.forEach(index => indexTable.addIndex(meta, index, 'unique'));
+                        const pkProps = meta.props.filter(prop => prop.primary);
+                        indexTable.addIndex(meta, { properties: pkProps.map(prop => prop.name) }, 'primary');
+                        // Materialized views don't have primary keys or constraints in the DB,
+                        // convert to match what PostgreSQL stores.
+                        view.indexes = indexTable.getIndexes().map(idx => {
+                            if (idx.primary) {
+                                return { ...idx, primary: false, unique: true, constraint: false };
+                            }
+                            if (idx.constraint) {
+                                return { ...idx, constraint: false };
+                            }
+                            return idx;
+                        });
+                    }
                 }
                 continue;
             }

package/schema/SchemaComparator.d.ts

@@ -1,7 +1,7 @@
 import { type Dictionary } from '@mikro-orm/core';
 import type { Column, ForeignKey, IndexDef, SchemaDifference, TableDifference } from '../typings.js';
 import type { DatabaseSchema } from './DatabaseSchema.js';
-import type { DatabaseTable } from './DatabaseTable.js';
+import { DatabaseTable } from './DatabaseTable.js';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
 /**
  * Compares two Schemas and return an instance of SchemaDifference.

package/schema/SchemaComparator.js

@@ -1,4 +1,5 @@
 import { ArrayType, BooleanType, DateTimeType, inspect, JsonType, parseJsonSafe, Utils, } from '@mikro-orm/core';
+import { DatabaseTable } from './DatabaseTable.js';
 /**
  * Compares two Schemas and return an instance of SchemaDifference.
  */
@@ -114,15 +115,16 @@ export class SchemaComparator {
                 }
             }
         }
-        // Compare views
+        // Compare views — prefer schema-qualified lookup to avoid matching
+        // views with the same name in different schemas
         for (const toView of toSchema.getViews()) {
             const viewName = toView.schema ? `${toView.schema}.${toView.name}` : toView.name;
-            if (!fromSchema.hasView(toView.name) && !fromSchema.hasView(viewName)) {
+            if (!fromSchema.hasView(viewName) && !fromSchema.hasView(toView.name)) {
                 diff.newViews[viewName] = toView;
                 this.log(`view ${viewName} added`);
             }
             else {
-                const fromView = fromSchema.getView(toView.name) ?? fromSchema.getView(viewName);
+                const fromView = fromSchema.getView(viewName) ?? fromSchema.getView(toView.name);
                 if (fromView && this.diffViewExpression(fromView.definition, toView.definition)) {
                     diff.changedViews[viewName] = { from: fromView, to: toView };
                     this.log(`view ${viewName} changed`);
@@ -132,11 +134,34 @@ export class SchemaComparator {
         // 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)) {
+            if (!toSchema.hasView(viewName) && !toSchema.hasView(fromView.name)) {
                 diff.removedViews[viewName] = fromView;
                 this.log(`view ${viewName} removed`);
             }
         }
+        // Diff materialized view indexes using the existing table diff infrastructure.
+        // Build transient DatabaseTable objects from view indexes so diffTable handles
+        // added/removed/changed/renamed index detection and alterTable emits correct DDL.
+        for (const toView of toSchema.getViews()) {
+            if (!toView.materialized || toView.withData === false) {
+                continue;
+            }
+            const viewName = toView.schema ? `${toView.schema}.${toView.name}` : toView.name;
+            // New or definition-changed views have indexes handled during create/recreate
+            if (diff.newViews[viewName] || diff.changedViews[viewName]) {
+                continue;
+            }
+            // If we get here, the view exists in fromSchema (otherwise it would be in diff.newViews)
+            const fromView = fromSchema.getView(viewName) ?? fromSchema.getView(toView.name);
+            const fromTable = new DatabaseTable(this.#platform, fromView.name, fromView.schema);
+            fromTable.init([], fromView.indexes ?? [], [], []);
+            const toTable = new DatabaseTable(this.#platform, toView.name, toView.schema);
+            toTable.init([], toView.indexes ?? [], [], []);
+            const tableDiff = this.diffTable(fromTable, toTable);
+            if (tableDiff) {
+                diff.changedTables[viewName] = tableDiff;
+            }
+        }
         return diff;
     }
     /**

package/schema/SchemaHelper.d.ts

@@ -84,7 +84,8 @@ export declare abstract class SchemaHelper {
     getReferencedTableName(referencedTableName: string, schema?: string): string;
     createIndex(index: IndexDef, table: DatabaseTable, createPrimary?: boolean): string;
     createCheck(table: DatabaseTable, check: CheckDef): string;
-    protected getTableName(table: string, schema?: string): string;
+    /** @internal */
+    getTableName(table: string, schema?: string): string;
     getTablesGroupedBySchemas(tables: Table[]): Map<string | undefined, Table[]>;
     get options(): NonNullable<Options['schemaGenerator']>;
     protected processComment(comment: string): string;

package/schema/SchemaHelper.js

@@ -593,6 +593,7 @@ export class SchemaHelper {
     createCheck(table, check) {
         return `alter table ${table.getQuotedName()} add constraint ${this.quote(check.name)} check (${check.expression})`;
     }
+    /** @internal */
     getTableName(table, schema) {
         if (schema && schema !== this.platform.getDefaultSchemaName()) {
             return `${schema}.${table}`;

package/schema/SqlSchemaGenerator.d.ts

@@ -62,6 +62,7 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
      * Uses topological sort based on view definition string matching.
      */
     private sortViewsByDependencies;
+    private appendViewCreation;
     private escapeRegExp;
 }
 export { SqlSchemaGenerator as SchemaGenerator };

package/schema/SqlSchemaGenerator.js

@@ -89,16 +89,9 @@ 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) {
-            if (view.materialized) {
-                this.append(ret, this.helper.createMaterializedView(view.name, view.schema, view.definition, view.withData ?? true));
-            }
-            else {
-                this.append(ret, this.helper.createView(view.name, view.schema, view.definition), true);
-            }
+            this.appendViewCreation(ret, view);
         }
         return this.wrapSchema(ret, options);
     }
@@ -338,27 +331,14 @@ 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) {
-            if (view.materialized) {
-                this.append(ret, this.helper.createMaterializedView(view.name, view.schema, view.definition, view.withData ?? true));
-            }
-            else {
-                this.append(ret, this.helper.createView(view.name, view.schema, view.definition), true);
-            }
+            this.appendViewCreation(ret, view);
         }
-        // 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) {
-            if (view.materialized) {
-                this.append(ret, this.helper.createMaterializedView(view.name, view.schema, view.definition, view.withData ?? true));
-            }
-            else {
-                this.append(ret, this.helper.createView(view.name, view.schema, view.definition), true);
-            }
+            this.appendViewCreation(ret, view);
         }
         return this.wrapSchema(ret, options);
     }
@@ -511,6 +491,22 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         // Sort and map back to views
         return calc.sort().map(index => indexToView.get(index));
     }
+    appendViewCreation(ret, view) {
+        if (view.materialized) {
+            this.append(ret, this.helper.createMaterializedView(view.name, view.schema, view.definition, view.withData ?? true));
+            // Skip indexes for WITH NO DATA views — they have no data to index yet.
+            // Indexes will be created on the next schema:update after REFRESH populates data.
+            if (view.withData !== false) {
+                const viewName = this.helper.getTableName(view.name, view.schema);
+                for (const index of view.indexes ?? []) {
+                    this.append(ret, this.helper.getCreateIndexSQL(viewName, index));
+                }
+            }
+        }
+        else {
+            this.append(ret, this.helper.createView(view.name, view.schema, view.definition), true);
+        }
+    }
     escapeRegExp(string) {
         return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
     }

package/typings.d.ts

@@ -142,6 +142,8 @@ export interface DatabaseView {
     materialized?: boolean;
     /** For materialized views, whether data was populated on creation. */
     withData?: boolean;
+    /** Indexes on the materialized view. Only materialized views support indexes. */
+    indexes?: IndexDef[];
 }
 export interface SchemaDifference {
     newNamespaces: Set<string>;