@mikro-orm/sql 7.1.2-dev.2 → 7.1.2-dev.4

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

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.