@mikro-orm/sql 7.1.12-dev.0 → 7.1.12-dev.2

package/dialects/postgresql/PostgreSqlSchemaHelper.d.ts

@@ -131,6 +131,8 @@ export declare class PostgreSqlSchemaHelper extends SchemaHelper {
      * Build the column list for a PostgreSQL index.
      */
     protected getIndexColumns(index: IndexDef): string;
+    /** Non-default index access methods (gin, gist, brin, hash, ...), normalized to lower case. */
+    getIndexAccessMethod(index: IndexDef): string;
     /**
      * PostgreSQL-specific index options like fill factor.
      */

package/dialects/postgresql/PostgreSqlSchemaHelper.js

@@ -1118,6 +1118,14 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         })
             .join(', ');
     }
+    /** Non-default index access methods (gin, gist, brin, hash, ...), normalized to lower case. */
+    getIndexAccessMethod(index) {
+        // `fulltext` is a cross-dialect alias handled via `getFullTextIndexExpression`, not a pg access method
+        if (typeof index.type !== 'string' || ['', 'btree', 'fulltext'].includes(index.type.toLowerCase())) {
+            return '';
+        }
+        return index.type.toLowerCase();
+    }
     /**
      * PostgreSQL-specific index options like fill factor.
      */

package/package.json

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

package/schema/SchemaComparator.js

@@ -820,6 +820,10 @@ export class SchemaComparator {
         if (!!index1.clustered !== !!index2.clustered) {
             return false;
         }
+        // Compare the index access method (e.g. `using gin` on PostgreSQL); unset means the platform default
+        if (this.#helper.getIndexAccessMethod(index1) !== this.#helper.getIndexAccessMethod(index2)) {
+            return false;
+        }
         // Compare WHERE predicate of partial indexes structurally (whitespace/quoting/casing
         // are normalized via the same helper used for check constraints).
         if (this.diffExpression(index1.where ?? '', index2.where ?? '')) {

package/schema/SchemaHelper.d.ts

@@ -70,6 +70,13 @@ export declare abstract class SchemaHelper {
      * Hook for adding driver-specific index options (e.g., fill factor for PostgreSQL).
      */
     protected getCreateIndexSuffix(_index: IndexDef): string;
+    /**
+     * Normalized index access method (e.g. `gin` on PostgreSQL), empty string when the
+     * platform default applies. Used for both DDL emission and index diffing.
+     */
+    getIndexAccessMethod(_index: IndexDef): string;
+    /** Emits the access method between the table name and the column list (e.g. ` using gin`). */
+    protected getIndexAccessMethodClause(index: IndexDef): string;
     /**
      * Default emits ` where <predicate>` for partial indexes. Only Oracle overrides this to
      * return `''` (it emulates partials via CASE-WHEN columns). MySQL sidesteps the whole path

package/schema/SchemaHelper.js

@@ -167,13 +167,14 @@ export class SchemaHelper {
         tableName = this.quote(tableName);
         const keyName = this.quote(index.keyName);
         const defer = index.deferMode ? ` deferrable initially ${index.deferMode}` : '';
-        let sql = `create ${index.unique ? 'unique ' : ''}index ${keyName} on ${tableName}`;
+        const using = this.getIndexAccessMethodClause(index);
+        let sql = `create ${index.unique ? 'unique ' : ''}index ${keyName} on ${tableName}${using}`;
         if (index.unique && index.constraint) {
             sql = `alter table ${tableName} add constraint ${keyName} unique`;
         }
         if (index.columnNames.some(column => column.includes('.'))) {
             // JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them
-            sql = `create ${index.unique ? 'unique ' : ''}index ${keyName} on ${tableName}`;
+            sql = `create ${index.unique ? 'unique ' : ''}index ${keyName} on ${tableName}${using}`;
             const columns = this.platform.getJsonIndexDefinition(index);
             return `${sql} (${columns.join(', ')})${this.getCreateIndexSuffix(index)}${this.getIndexWhereClause(index)}${defer}`;
         }
@@ -192,6 +193,18 @@ export class SchemaHelper {
     getCreateIndexSuffix(_index) {
         return '';
     }
+    /**
+     * Normalized index access method (e.g. `gin` on PostgreSQL), empty string when the
+     * platform default applies. Used for both DDL emission and index diffing.
+     */
+    getIndexAccessMethod(_index) {
+        return '';
+    }
+    /** Emits the access method between the table name and the column list (e.g. ` using gin`). */
+    getIndexAccessMethodClause(index) {
+        const method = this.getIndexAccessMethod(index);
+        return method ? ` using ${method}` : '';
+    }
     /**
      * Default emits ` where <predicate>` for partial indexes. Only Oracle overrides this to
      * return `''` (it emulates partials via CASE-WHEN columns). MySQL sidesteps the whole path