@mikro-orm/sql 7.2.0-dev.6 → 7.2.0-dev.7

package/SqlEntityManager.js

@@ -75,8 +75,7 @@ export class SqlEntityManager extends EntityManager {
      */
     async countBy(entityName, groupBy, options = {}) {
         const em = this.getContext(false);
-        options = { ...options };
-        em.prepareOptions(options);
+        options = em.prepareOptions(options);
         const meta = em.getMetadata().find(entityName);
         const fields = Utils.asArray(groupBy);
         const { where: rawWhere, ...countOptions } = options;

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.2.0-dev.6",
+  "version": "7.2.0-dev.7",
   "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.2.0-dev.6"
+    "@mikro-orm/core": "7.2.0-dev.7"
   },
   "engines": {
     "node": ">= 22.17.0"

package/query/QueryBuilder.d.ts

@@ -152,11 +152,10 @@ type ContextFilterKeys<Context> = {
 type RawFilterKeys<RawAliases extends string> = {
     [K in RawAliases]?: AliasedFilterValue;
 };
-type NestedFilterCondition<Entity, RootAlias extends string, Context, RawAliases extends string> = ObjectQuery<Entity> & (IsNever<RootAlias> extends true ? {} : string extends RootAlias ? {} : RootAliasFilterKeys<RootAlias, Entity>) & ([Context] extends [never] ? {} : ContextFilterKeys<Context>) & (IsNever<RawAliases> extends true ? {} : string extends RawAliases ? {} : RawFilterKeys<RawAliases>);
 type GroupOperators<RootAlias extends string, Context, Entity, RawAliases extends string> = {
-    $and?: NestedFilterCondition<Entity, RootAlias, Context, RawAliases>[];
-    $or?: NestedFilterCondition<Entity, RootAlias, Context, RawAliases>[];
-    $not?: NestedFilterCondition<Entity, RootAlias, Context, RawAliases>;
+    $and?: QBFilterQuery<Entity, RootAlias, Context, RawAliases>[];
+    $or?: QBFilterQuery<Entity, RootAlias, Context, RawAliases>[];
+    $not?: QBFilterQuery<Entity, RootAlias, Context, RawAliases>;
 };
 export type AliasedFilterCondition<RootAlias extends string, Context, Entity, RawAliases extends string = never> = (IsNever<RootAlias> extends true ? {} : string extends RootAlias ? {} : RootAliasFilterKeys<RootAlias, Entity>) & ([Context] extends [never] ? {} : ContextFilterKeys<Context>) & (IsNever<RawAliases> extends true ? {} : string extends RawAliases ? {} : RawFilterKeys<RawAliases>) & GroupOperators<RootAlias, Context, Entity, RawAliases>;
 export type QBFilterQuery<Entity, RootAlias extends string = never, Context = never, RawAliases extends string = never> = FilterObject<Entity> & AliasedFilterCondition<RootAlias, Context, Entity, RawAliases>;

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

package/schema/SqlSchemaGenerator.js

@@ -308,22 +308,6 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         for (const newTable of Object.values(schemaDiff.newTables)) {
             this.append(ret, this.helper.createTable(newTable, true), true);
         }
-        if (this.helper.supportsSchemaConstraints()) {
-            for (const newTable of Object.values(schemaDiff.newTables)) {
-                const sql = [];
-                if (this.options.createForeignKeyConstraints) {
-                    const fks = Object.values(newTable.getForeignKeys()).map(fk => this.helper.createForeignKey(newTable, fk));
-                    this.append(sql, fks);
-                }
-                for (const check of newTable.getChecks()) {
-                    this.append(sql, this.helper.createCheck(newTable, check));
-                }
-                for (const trigger of newTable.getTriggers()) {
-                    this.append(sql, this.helper.createTrigger(newTable, trigger));
-                }
-                this.append(ret, sql, true);
-            }
-        }
         if (options.dropTables && !options.safe) {
             for (const table of Object.values(schemaDiff.removedTables)) {
                 // Drop triggers before the table so driver-specific cleanup runs (e.g. PostgreSQL function removal)
@@ -353,6 +337,23 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         for (const changedTable of alteredTables) {
             this.append(ret, this.helper.getPostAlterTable(changedTable, options.safe), true);
         }
+        // after the alters, so a new table's FK can reference a unique constraint an existing table gains in the same diff
+        if (this.helper.supportsSchemaConstraints()) {
+            for (const newTable of Object.values(schemaDiff.newTables)) {
+                const sql = [];
+                if (this.options.createForeignKeyConstraints) {
+                    const fks = Object.values(newTable.getForeignKeys()).map(fk => this.helper.createForeignKey(newTable, fk));
+                    this.append(sql, fks);
+                }
+                for (const check of newTable.getChecks()) {
+                    this.append(sql, this.helper.createCheck(newTable, check));
+                }
+                for (const trigger of newTable.getTriggers()) {
+                    this.append(sql, this.helper.createTrigger(newTable, trigger));
+                }
+                this.append(ret, sql, true);
+            }
+        }
         if (!options.safe && this.platform.supportsNativeEnums()) {
             for (const removedNativeEnum of schemaDiff.removedNativeEnums) {
                 this.append(ret, this.helper.getDropNativeEnumSQL(removedNativeEnum.name, removedNativeEnum.schema));