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

package/dialects/postgresql/PostgreSqlSchemaHelper.d.ts

@@ -69,6 +69,8 @@ export declare class PostgreSqlSchemaHelper extends SchemaHelper {
     createTrigger(table: DatabaseTable, trigger: SqlTriggerDef): string;
     /** Generates SQL to drop a PostgreSQL trigger and its associated function. */
     dropTrigger(table: DatabaseTable, trigger: SqlTriggerDef): string;
+    /** Flattens `;\n` inside the dollar-quoted blocks of a raw DDL expression, which are not statement boundaries. */
+    private flattenDollarQuotedBodies;
     createRoutine(routine: SqlRoutineDef): string;
     dropRoutine(routine: SqlRoutineDef): string;
     getAllRoutines(connection: AbstractSqlConnection, schemas?: string[]): Promise<SqlRoutineDef[]>;
@@ -131,6 +133,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

@@ -3,6 +3,8 @@ import { SchemaHelper, stripStatementNewlines } from '../../schema/SchemaHelper.
 import { normalizePartitionBound, normalizePartitionDefinition } from '../../schema/partitioning.js';
 /** PostGIS system views that should be automatically ignored */
 const POSTGIS_VIEWS = ['geography_columns', 'geometry_columns'];
+/** Dollar-quote delimiter, e.g. `$$` or `$body$`, captured so `split` keeps it. */
+const DOLLAR_QUOTE_TAG = /(\$(?:[A-Za-z_]\w*)?\$)/;
 export class PostgreSqlSchemaHelper extends SchemaHelper {
     static DEFAULT_VALUES = {
         'now()': ['now()', 'current_timestamp'],
@@ -505,7 +507,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
     /** Generates SQL to create a PostgreSQL trigger and its associated function. */
     createTrigger(table, trigger) {
         if (trigger.expression) {
-            return trigger.expression;
+            return this.flattenDollarQuotedBodies(trigger.expression);
         }
         const timing = trigger.timing.toUpperCase();
         const events = trigger.events.map(e => e.toUpperCase()).join(' OR ');
@@ -523,9 +525,24 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         const fnName = this.getSchemaQualifiedTriggerFnName(table, trigger);
         return `drop trigger if exists ${triggerName} on ${table.getQuotedName()};\ndrop function if exists ${fnName}()`;
     }
+    /** Flattens `;\n` inside the dollar-quoted blocks of a raw DDL expression, which are not statement boundaries. */
+    flattenDollarQuotedBodies(ddl) {
+        let openTag = '';
+        return ddl
+            .split(DOLLAR_QUOTE_TAG)
+            .map((part, i) => {
+            // the capture group puts the delimiters on the odd indexes
+            if (i % 2 === 1) {
+                openTag = openTag === part ? '' : openTag || part;
+                return part;
+            }
+            return openTag ? stripStatementNewlines(part) : part;
+        })
+            .join('');
+    }
     createRoutine(routine) {
         if (routine.expression) {
-            return routine.expression;
+            return this.flattenDollarQuotedBodies(routine.expression);
         }
         const qualifiedName = this.qualifiedRoutineName(routine);
         const params = this.formatRoutineParams(routine);
@@ -1118,6 +1135,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.10",
   "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",
@@ -47,13 +47,13 @@
     "copy": "node ../../scripts/copy.mjs"
   },
   "dependencies": {
-    "kysely": "0.29.4"
+    "kysely": "0.29.5"
   },
   "devDependencies": {
     "@mikro-orm/core": "^7.1.11"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.12-dev.0"
+    "@mikro-orm/core": "7.1.12-dev.10"
   },
   "engines": {
     "node": ">= 22.17.0"

package/schema/DatabaseTable.js

@@ -1030,8 +1030,12 @@ export class DatabaseTable {
             // mysql stores decimal defaults padded to scale (`0` → `0.00`); collapse to canonical numeric form
             // so the metadata-side (`0`) and introspection-side (`0.00`) snapshots agree
             let defaultValue = c.default ?? null;
-            if (defaultValue != null && c.mappedType instanceof DecimalType && Number.isFinite(+defaultValue)) {
-                defaultValue = this.#platform.formatDecimal(defaultValue, c.scale).toString();
+            if (defaultValue != null && c.mappedType instanceof DecimalType) {
+                // string defaults like `default: '0.00'` are quoted in metadata, so strip the quotes first
+                const unquoted = defaultValue.replace(/^'(.*)'$/, '$1');
+                if (Number.isFinite(+unquoted)) {
+                    defaultValue = this.#platform.formatDecimal(unquoted, c.scale).toString();
+                }
             }
             const normalized = {
                 name: c.name,

package/schema/SchemaComparator.d.ts

@@ -89,6 +89,7 @@ export declare class SchemaComparator {
     private diffViewExpression;
     private diffTrigger;
     parseJsonDefault(defaultValue?: string | null): Dictionary | string | null;
+    private parseDecimalDefault;
     hasSameDefaultValue(from: Column, to: Column): boolean;
     private mapColumnToProperty;
     private log;

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 ?? '')) {
@@ -989,6 +993,10 @@ export class SchemaComparator {
         const val = defaultValue.replace(/^(_\w+\\)?'(.*?)\\?'$/, '$2').replace(/^\(?'(.*?)'\)?$/, '$1');
         return parseJsonSafe(val);
     }
+    parseDecimalDefault(defaultValue) {
+        const value = +('' + defaultValue).replace(/^'(.+)'$/, '$1');
+        return Number.isFinite(value) ? value : null;
+    }
     hasSameDefaultValue(from, to) {
         if (from.default == null ||
             from.default.toString().toLowerCase() === 'null' ||
@@ -1014,10 +1022,15 @@ export class SchemaComparator {
             const defaultValueTo = to.default.toLowerCase().replace('current_timestamp', 'now').replace(/\(\)$/, '');
             return defaultValueFrom === defaultValueTo;
         }
-        // mysql stores decimal defaults padded to scale (`0` → `0.00`); compare numerically so the
-        // entity-side raw literal and the introspected padded form don't churn the no-op migration
-        if (to.mappedType instanceof DecimalType && Number.isFinite(+from.default) && Number.isFinite(+to.default)) {
-            return (this.#platform.formatDecimal(from.default, to.scale) === this.#platform.formatDecimal(to.default, to.scale));
+        // mysql pads decimal defaults to scale (`0` → `0.00`) and postgres reports them unquoted
+        // while metadata keeps them quoted; compare numerically so neither churns a no-op migration
+        if (to.mappedType instanceof DecimalType) {
+            const defaultValueFrom = this.parseDecimalDefault(from.default);
+            const defaultValueTo = this.parseDecimalDefault(to.default);
+            if (defaultValueFrom != null && defaultValueTo != null) {
+                return (this.#platform.formatDecimal(defaultValueFrom, to.scale) ===
+                    this.#platform.formatDecimal(defaultValueTo, to.scale));
+            }
         }
         if (from.default && to.default) {
             return from.default.toString().toLowerCase() === to.default.toString().toLowerCase();

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