@mikro-orm/sql 7.1.2-dev.1 → 7.1.2-dev.10

package/dialects/postgresql/PostgreSqlSchemaHelper.js

@@ -479,8 +479,11 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
             }
             seen.add(dedupeKey);
             ret[key] ??= [];
+            // CHECK: unwrap the `CHECK ((<predicate>))` shell and drop pg-added `::type` casts so the
+            // inner predicate matches the user's metadata. EXCLUDE bodies are kept verbatim — the user's
+            // `@Check` expression is the full body (see SchemaHelper.createCheck).
             const m = /^check \(\((.*)\)\)$/is.exec(check.expression);
-            const def = m?.[1].replace(/\((.*?)\)::\w+/g, '$1');
+            const def = m ? m[1].replace(/\((.*?)\)::\w+/g, '$1') : check.expression;
             ret[key].push({
                 name: check.name,
                 columnName: check.column_name,
@@ -1073,16 +1076,31 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
       join pg_am as am on am.oid = i.relam
       left join pg_constraint as c on c.conname = i.relname
       where indrelid in (${tables.map(t => `${this.platform.quoteValue(`${this.quote(t.schema_name)}.${this.quote(t.table_name)}`)}::regclass`).join(', ')})
+        and (c.contype is null or c.contype <> 'x')
       order by relname`;
     }
     getChecksSQL(tablesBySchemas) {
+        const checkFilter = [...tablesBySchemas.entries()]
+            .map(([schema, tables]) => `ccu.table_name in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(',')}) and ccu.table_schema = ${this.platform.quoteValue(schema)}`)
+            .join(' or ');
+        // EXCLUDE constraints don't appear in information_schema.constraint_column_usage, so the second
+        // branch resolves the table from pg_class/pg_namespace directly.
+        const excludeFilter = [...tablesBySchemas.entries()]
+            .map(([schema, tables]) => `cls.relname in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(',')}) and nsp.nspname = ${this.platform.quoteValue(schema)}`)
+            .join(' or ');
         return `select ccu.table_name as table_name, ccu.table_schema as schema_name, pgc.conname as name, conrelid::regclass as table_from, ccu.column_name as column_name, pg_get_constraintdef(pgc.oid) as expression
       from pg_constraint pgc
       join pg_namespace nsp on nsp.oid = pgc.connamespace
       join pg_class cls on pgc.conrelid = cls.oid
       join information_schema.constraint_column_usage ccu on pgc.conname = ccu.constraint_name and nsp.nspname = ccu.constraint_schema and cls.relname = ccu.table_name
-      where contype = 'c' and (${[...tablesBySchemas.entries()].map(([schema, tables]) => `ccu.table_name in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(',')}) and ccu.table_schema = ${this.platform.quoteValue(schema)}`).join(' or ')})
-      order by pgc.conname`;
+      where pgc.contype = 'c' and (${checkFilter})
+      union all
+      select cls.relname as table_name, nsp.nspname as schema_name, pgc.conname as name, conrelid::regclass as table_from, null as column_name, pg_get_constraintdef(pgc.oid) as expression
+      from pg_constraint pgc
+      join pg_namespace nsp on nsp.oid = pgc.connamespace
+      join pg_class cls on pgc.conrelid = cls.oid
+      where pgc.contype = 'x' and (${excludeFilter})
+      order by name`;
     }
     inferLengthFromColumnType(type) {
         const match = /^(\w+(?:\s+\w+)*)\s*(?:\(\s*(\d+)\s*\)|$)/.exec(type);

package/package.json

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

package/query/QueryBuilder.d.ts

@@ -826,8 +826,9 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     getResultAndCount(): Promise<[Loaded<Entity, Hint, Fields>[], number]>;
     /**
      * Returns native query builder instance with sub-query aliased with given alias.
+     * The alias literal is preserved in the type so `addSelect()` exposes it on `execute()` results.
      */
-    as(alias: string): NativeQueryBuilder;
+    as<Alias extends string>(alias: Alias): NativeQueryBuilder & RawQueryFragment<Alias>;
     /**
      * Returns native query builder instance with sub-query aliased with given alias.
      * You can provide the target entity name as the first parameter and use the second parameter to point to an existing property to infer its field name.
@@ -1050,17 +1051,28 @@ type PopulatedDTO<T, K extends keyof T> = NonNullable<T[K]> extends Collection<i
 type SubFields<F extends string, Rel extends string> = F extends `${Rel}.${infer Sub}` ? Sub : never;
 type RootFields<F extends string, H extends string> = F extends `${string}.${string}` ? F extends `${H}.${string}` ? never : F : F;
 type JoinDTO<T, K extends keyof T, F extends string> = NonNullable<T[K]> extends Collection<infer U> ? SubFields<F, K & string> extends never ? EntityDTOProp<T, Collection<U>> : DirectDTO<U, (SubFields<F, K & string> | PrimaryProperty<U>) & keyof U>[] : SubFields<F, K & string> extends never ? EntityDTOProp<T, T[K]> : DirectDTO<NonNullable<T[K]>, (SubFields<F, K & string> | PrimaryProperty<NonNullable<T[K]>>) & keyof NonNullable<T[K]>> | Extract<T[K], null | undefined>;
-type ExecuteDTO<T, H extends string, F extends string> = [H] extends [never] ? [F] extends ['*'] ? EntityDTOFlat<T> : DirectDTO<T, F & keyof T> : [F] extends ['*'] ? true extends (H extends `${string}.${string}` ? true : false) ? SerializeDTO<T, H> : Omit<EntityDTOFlat<T>, H & keyof EntityDTOFlat<T>> & {
+/**
+ * Raw aliases (`sql`...`.as('x')`, `'col as x'`, or aliased sub-queries) are not entity keys,
+ * so they never appear in the selected-fields DTO. They are tracked in the `RawAliases` generic
+ * (preserved across joins), so expose them on the result as `unknown` — their value type is not
+ * known at the type level. Only intersected when raw aliases are present, to keep the plain DTO
+ * untouched when there are none.
+ */
+type WithRawAliases<DTO, RawAliases extends string> = [RawAliases] extends [never] ? DTO : DTO & {
+    [K in RawAliases]: unknown;
+};
+type ExecuteDTOInner<T, H extends string, F extends string> = [H] extends [never] ? [F] extends ['*'] ? EntityDTOFlat<T> : DirectDTO<T, F & keyof T> : [F] extends ['*'] ? true extends (H extends `${string}.${string}` ? true : false) ? SerializeDTO<T, H> : Omit<EntityDTOFlat<T>, H & keyof EntityDTOFlat<T>> & {
     [K in H & keyof T as K & keyof EntityDTOFlat<T>]: PopulatedDTO<T, K> | Extract<T[K], null | undefined>;
 } : true extends (H extends `${string}.${string}` ? true : false) ? EntityDTOFlat<Loaded<T, H, F>> : DirectDTO<T, (RootFields<F, H> | PrimaryProperty<T>) & keyof T> & {
     [K in H & keyof T]: JoinDTO<T, K, F>;
 };
+type ExecuteDTO<T, H extends string, F extends string, RawAliases extends string = never> = WithRawAliases<ExecuteDTOInner<T, H, F>, RawAliases>;
 /** Shorthand for `QueryBuilder` with all generic parameters set to `any`. */
 export type AnyQueryBuilder<T extends object = AnyEntity> = QueryBuilder<T, any, any, any, any, any, any>;
 export interface SelectQueryBuilder<Entity extends object = AnyEntity, RootAlias extends string = never, Hint extends string = never, Context extends object = never, RawAliases extends string = never, Fields extends string = '*', CTEs extends Record<string, object> = {}> extends QueryBuilder<Entity, RootAlias, Hint, Context, RawAliases, Fields, CTEs> {
-    execute<Result = ExecuteDTO<Entity, Hint, Fields>[]>(method?: 'all' | 'get' | 'run', mapResults?: boolean): Promise<Result>;
-    execute<Result = ExecuteDTO<Entity, Hint, Fields>[]>(method: 'all', mapResults?: boolean): Promise<Result>;
-    execute<Result = ExecuteDTO<Entity, Hint, Fields>>(method: 'get', mapResults?: boolean): Promise<Result>;
+    execute<Result = ExecuteDTO<Entity, Hint, Fields, RawAliases>[]>(method?: 'all' | 'get' | 'run', mapResults?: boolean): Promise<Result>;
+    execute<Result = ExecuteDTO<Entity, Hint, Fields, RawAliases>[]>(method: 'all', mapResults?: boolean): Promise<Result>;
+    execute<Result = ExecuteDTO<Entity, Hint, Fields, RawAliases>>(method: 'get', mapResults?: boolean): Promise<Result>;
     execute<Result = QueryResult<Entity>>(method: 'run', mapResults?: boolean): Promise<Result>;
 }
 export interface CountQueryBuilder<Entity extends object> extends QueryBuilder<Entity, any, any> {

package/schema/DatabaseTable.js

@@ -982,6 +982,15 @@ export class DatabaseTable {
             const normOptions = { length: c.length, precision: c.precision, scale: c.scale };
             const type = this.#platform.normalizeColumnType(c.type ?? '', normOptions)?.toLowerCase() || rawType;
             const fixedPrecision = isFixedPrecisionFamily(c.mappedType);
+            // only emit `length` for types that actually use one — text/enum/json/etc. don't, but mysql
+            // information_schema still reports `character_maximum_length` for them (65535 for text, etc.)
+            const hasMeaningfulLength = typeof c.mappedType.getDefaultLength !== 'undefined';
+            // 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();
+            }
             const normalized = {
                 name: c.name,
                 type,
@@ -990,26 +999,26 @@ export class DatabaseTable {
                 primary: primaryColumns.has(c.name) || !!c.primary,
                 nullable: !!c.nullable,
                 unique: uniqueColumns.has(c.name) || !!c.unique,
-                length: c.length || null,
+                length: hasMeaningfulLength ? c.length || null : null,
                 precision: fixedPrecision ? null : (c.precision ?? null),
                 scale: fixedPrecision ? null : (c.scale ?? null),
-                default: c.default ?? null,
-                comment: c.comment ?? null,
+                default: defaultValue,
+                comment: c.comment || null,
                 collation: c.collation ?? null,
                 enumItems: c.enumItems ?? [],
                 mappedType: Utils.keys(t).find(k => t[k] === c.mappedType.constructor),
             };
-            for (const field of [
-                'generated',
-                'nativeEnumName',
-                'extra',
-                'ignoreSchemaChanges',
-                'defaultConstraint',
-            ]) {
+            for (const field of ['generated', 'nativeEnumName', 'ignoreSchemaChanges', 'defaultConstraint']) {
                 if (c[field]) {
                     normalized[field] = c[field];
                 }
             }
+            // `extra` casing varies between metadata (user-supplied, typically uppercase like
+            // `ON UPDATE CURRENT_TIMESTAMP`) and mysql introspection (returns it lowercased) — the
+            // comparator already lowercases both sides when diffing, mirror that in the snapshot
+            if (c.extra) {
+                normalized.extra = c.extra.toLowerCase();
+            }
             o[col] = normalized;
             return o;
         }, {});
@@ -1082,8 +1091,9 @@ export class DatabaseTable {
             checks: sortedChecks,
             triggers: sortedTriggers,
             foreignKeys: sortedForeignKeys,
-            // emit `comment` even when unset so introspection (which always reads it) matches metadata
-            comment: this.comment ?? null,
+            // emit `comment` even when unset so introspection (which always reads it) matches metadata;
+            // collapse mysql's `""` for unset comments to `null` so both sources agree
+            comment: this.comment || null,
         };
     }
 }

package/schema/SchemaComparator.js

@@ -1,4 +1,4 @@
-import { ArrayType, BooleanType, DateTimeType, inspect, JsonType, parseJsonSafe, Utils, } from '@mikro-orm/core';
+import { ArrayType, BooleanType, DateTimeType, DecimalType, inspect, JsonType, parseJsonSafe, Utils, } from '@mikro-orm/core';
 import { DatabaseTable } from './DatabaseTable.js';
 import { diffPartitioning } from './partitioning.js';
 /**
@@ -996,6 +996,11 @@ 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));
+        }
         if (from.default && to.default) {
             return from.default.toString().toLowerCase() === to.default.toString().toLowerCase();
         }

package/schema/SchemaHelper.d.ts

@@ -138,6 +138,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;
+    /** True for `@Check` expressions that are a full table-constraint body (e.g. PostgreSQL `exclude using gist (...)`) and must be emitted verbatim instead of wrapped in `check (...)`. */
+    private isRawConstraintBody;
     /**
      * Generates SQL to create a database trigger on a table.
      * Override in driver-specific helpers for custom DDL (e.g., PostgreSQL function wrapping).

package/schema/SchemaHelper.js

@@ -813,7 +813,13 @@ export class SchemaHelper {
         return this.getCreateIndexSQL(table.getShortestName(), index);
     }
     createCheck(table, check) {
-        return `alter table ${table.getQuotedName()} add constraint ${this.quote(check.name)} check (${check.expression})`;
+        const expression = check.expression;
+        const body = this.isRawConstraintBody(expression) ? expression : `check (${expression})`;
+        return `alter table ${table.getQuotedName()} add constraint ${this.quote(check.name)} ${body}`;
+    }
+    /** True for `@Check` expressions that are a full table-constraint body (e.g. PostgreSQL `exclude using gist (...)`) and must be emitted verbatim instead of wrapped in `check (...)`. */
+    isRawConstraintBody(expression) {
+        return /^\s*exclude\b/i.test(expression);
     }
     /**
      * Generates SQL to create a database trigger on a table.