@smartive/graphql-magic 23.7.0-next.5 → 23.8.0-next.1

package/CHANGELOG.md

@@ -1,5 +1,12 @@
-## [23.7.0-next.5](https://github.com/smartive/graphql-magic/compare/v23.7.0-next.4...v23.7.0-next.5) (2026-03-04)
+## [23.8.0-next.1](https://github.com/smartive/graphql-magic/compare/v23.7.0...v23.8.0-next.1) (2026-03-04)
+
+### Features
+
+* Exclude constraints and triggers ([12f5d85](https://github.com/smartive/graphql-magic/commit/12f5d85470bdf1107e023700d5a11012df69d098))
 
 ### Bug Fixes
 
-* constraint normalization for empty migration when schema in sync ([1a8e419](https://github.com/smartive/graphql-magic/commit/1a8e419f82899a9045f08ab96dbc9249e49dd773))
+* constraint normalization for empty migration when schema in sync ([77a8283](https://github.com/smartive/graphql-magic/commit/77a828367abc78c07708556d7d751d780b785a9a))
+* gen ([80bb12d](https://github.com/smartive/graphql-magic/commit/80bb12da6f7eb0aa231fb13c22019995f5811a6c))
+* normalize identifier quoting in constraint comparison ([689136b](https://github.com/smartive/graphql-magic/commit/689136b1ef07874b24986c4596aae37acc92d74b))
+* produce empty migration when schema is in sync ([e8e8e88](https://github.com/smartive/graphql-magic/commit/e8e8e8825a1d4ac833886f993a702c187364ea6f))

package/dist/bin/gqm.cjs

@@ -1317,7 +1317,6 @@ var MigrationGenerator = class _MigrationGenerator {
           );
           this.updateFields(model, existingFields, up, down);
           if (model.constraints?.length) {
-            const existingCheckMap = this.existingCheckConstraints[model.name];
             const existingExcludeMap = this.existingExcludeConstraints[model.name];
             const existingTriggerMap = this.existingConstraintTriggers[model.name];
             for (let i = 0; i < model.constraints.length; i++) {
@@ -1326,23 +1325,31 @@ var MigrationGenerator = class _MigrationGenerator {
               const constraintName = this.getConstraintName(model, entry, i);
               if (entry.kind === "check") {
                 validateCheckConstraint(model, entry);
-                const newExpression = entry.expression;
-                const existingExpression = existingCheckMap?.get(constraintName);
-                if (existingExpression === void 0) {
+                const existingConstraint = this.findExistingConstraint(table, entry, constraintName);
+                if (!existingConstraint) {
                   up.push(() => {
-                    this.addCheckConstraint(table, constraintName, newExpression, entry.deferrable);
+                    this.addCheckConstraint(table, constraintName, entry.expression, entry.deferrable);
                   });
                   down.push(() => {
                     this.dropCheckConstraint(table, constraintName);
                   });
-                } else if (this.normalizeCheckExpression(existingExpression) !== this.normalizeCheckExpression(newExpression)) {
+                } else if (!await this.equalExpressions(
+                  table,
+                  existingConstraint.constraintName,
+                  existingConstraint.expression,
+                  entry.expression
+                )) {
                   up.push(() => {
-                    this.dropCheckConstraint(table, constraintName);
-                    this.addCheckConstraint(table, constraintName, newExpression, entry.deferrable);
+                    this.dropCheckConstraint(table, existingConstraint.constraintName);
+                    this.addCheckConstraint(table, constraintName, entry.expression, entry.deferrable);
                   });
                   down.push(() => {
                     this.dropCheckConstraint(table, constraintName);
-                    this.addCheckConstraint(table, constraintName, existingExpression);
+                    this.addCheckConstraint(
+                      table,
+                      existingConstraint.constraintName,
+                      existingConstraint.expression
+                    );
                   });
                 }
               } else if (entry.kind === "exclude") {
@@ -1814,64 +1821,144 @@ var MigrationGenerator = class _MigrationGenerator {
     }
     return result;
   }
-  stripOuterParens(s) {
-    while (s.length >= 2 && s.startsWith("(") && s.endsWith(")")) {
-      let depth = 0;
-      let match = true;
-      for (let i = 0; i < s.length; i++) {
-        if (s[i] === "(") {
-          depth++;
-        } else if (s[i] === ")") {
-          depth--;
+  normalizeExcludeDef(def) {
+    const s = def.replace(/\s+/g, " ").replace(/\s*\(\s*/g, "(").replace(/\s*\)\s*/g, ")").trim();
+    return this.normalizeSqlIdentifiers(s);
+  }
+  normalizeTriggerDef(def) {
+    const s = def.replace(/\s+/g, " ").replace(/\s*\(\s*/g, "(").replace(/\s*\)\s*/g, ")").replace(/\bON\s+[a-zA-Z_][a-zA-Z0-9_]*\./gi, "ON ").trim();
+    return this.normalizeSqlIdentifiers(s);
+  }
+  normalizeCheckExpression(expr) {
+    let normalized = expr.replace(/\s+/g, " ").trim();
+    while (this.isWrappedByOuterParentheses(normalized)) {
+      normalized = normalized.slice(1, -1).trim();
+    }
+    return normalized;
+  }
+  isWrappedByOuterParentheses(expr) {
+    if (!expr.startsWith("(") || !expr.endsWith(")")) {
+      return false;
+    }
+    let depth = 0;
+    let inSingleQuote = false;
+    for (let i = 0; i < expr.length; i++) {
+      const char = expr[i];
+      const next = expr[i + 1];
+      if (char === "'") {
+        if (inSingleQuote && next === "'") {
+          i++;
+          continue;
         }
-        if (depth === 0 && i < s.length - 1) {
-          match = false;
-          break;
+        inSingleQuote = !inSingleQuote;
+        continue;
+      }
+      if (inSingleQuote) {
+        continue;
+      }
+      if (char === "(") {
+        depth++;
+      } else if (char === ")") {
+        depth--;
+        if (depth === 0 && i !== expr.length - 1) {
+          return false;
+        }
+        if (depth < 0) {
+          return false;
         }
       }
-      if (!match || depth !== 0) {
-        break;
+    }
+    return depth === 0;
+  }
+  findExistingConstraint(table, entry, preferredConstraintName) {
+    const existingMap = this.existingCheckConstraints[table];
+    if (!existingMap) {
+      return null;
+    }
+    const preferredExpression = existingMap.get(preferredConstraintName);
+    if (preferredExpression !== void 0) {
+      return {
+        constraintName: preferredConstraintName,
+        expression: preferredExpression
+      };
+    }
+    const normalizedNewExpression = this.normalizeCheckExpression(entry.expression);
+    const constraintPrefix = `${table}_${entry.name}_${entry.kind}_`;
+    for (const [constraintName, expression] of existingMap.entries()) {
+      if (!constraintName.startsWith(constraintPrefix)) {
+        continue;
+      }
+      if (this.normalizeCheckExpression(expression) !== normalizedNewExpression) {
+        continue;
       }
-      s = s.slice(1, -1).trim();
+      return { constraintName, expression };
     }
-    return s;
+    return null;
   }
-  splitAtTopLevel(s, sep) {
-    const parts = [];
-    let depth = 0;
-    let start = 0;
-    const sepLen = sep.length;
-    for (let i = 0; i <= s.length - sepLen; i++) {
-      if (s[i] === "(") {
-        depth++;
-      } else if (s[i] === ")") {
-        depth--;
+  async equalExpressions(table, constraintName, existingExpression, newExpression) {
+    try {
+      const [canonicalExisting, canonicalNew] = await Promise.all([
+        this.canonicalizeCheckExpressionWithPostgres(table, existingExpression),
+        this.canonicalizeCheckExpressionWithPostgres(table, newExpression)
+      ]);
+      return canonicalExisting === canonicalNew;
+    } catch (error) {
+      console.warn(
+        `Failed to canonicalize check constraint "${constraintName}" on table "${table}". Treating it as changed.`,
+        error
+      );
+      return false;
+    }
+  }
+  async canonicalizeCheckExpressionWithPostgres(table, expression) {
+    const sourceTableIdentifier = table.split(".").map((part) => this.quoteIdentifier(part)).join(".");
+    const uniqueSuffix = `${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+    const tableSlug = table.toLowerCase().replace(/[^a-z0-9_]/g, "_");
+    const tempTableName = `gqm_tmp_check_${tableSlug}_${uniqueSuffix}`;
+    const tempTableIdentifier = this.quoteIdentifier(tempTableName);
+    const constraintName = `gqm_tmp_check_${uniqueSuffix}`;
+    const constraintIdentifier = this.quoteIdentifier(constraintName);
+    const trx = await this.knex.transaction();
+    try {
+      await trx.raw(`CREATE TEMP TABLE ${tempTableIdentifier} (LIKE ${sourceTableIdentifier}) ON COMMIT DROP`);
+      await trx.raw(`ALTER TABLE ${tempTableIdentifier} ADD CONSTRAINT ${constraintIdentifier} CHECK (${expression})`);
+      const result = await trx.raw(
+        `SELECT pg_get_constraintdef(c.oid, true) AS constraint_definition
+         FROM pg_constraint c
+         JOIN pg_class t
+           ON t.oid = c.conrelid
+         WHERE t.relname = ?
+           AND c.conname = ?
+         ORDER BY c.oid DESC
+         LIMIT 1`,
+        [tempTableName, constraintName]
+      );
+      const rows = "rows" in result && Array.isArray(result.rows) ? result.rows : [];
+      const definition = rows[0]?.constraint_definition;
+      if (!definition) {
+        throw new Error(`Could not read canonical check definition for expression: ${expression}`);
       }
-      if (depth === 0 && s.slice(i, i + sepLen).toLowerCase() === sep.toLowerCase()) {
-        parts.push(s.slice(start, i).trim());
-        start = i + sepLen;
-        i += sepLen - 1;
+      return this.normalizeCheckExpression(this.extractCheckExpressionFromDefinition(definition));
+    } finally {
+      try {
+        await trx.rollback();
+      } catch {
       }
     }
-    parts.push(s.slice(start).trim());
-    return parts.filter(Boolean);
   }
-  normalizeCheckExpression(expr) {
-    let s = expr.replace(/\s+/g, " ").trim();
-    const normalizeParts = (str, separator) => this.splitAtTopLevel(str, separator).map((p) => this.stripOuterParens(p)).join(separator);
-    s = this.stripOuterParens(s);
-    s = normalizeParts(s, " OR ");
-    s = this.stripOuterParens(s);
-    s = normalizeParts(s, " AND ");
-    s = s.replace(/\s*\(\s*/g, "(").replace(/\s*\)\s*/g, ")").replace(/\s+AND\s+/gi, " AND ").replace(/\s+OR\s+/gi, " OR ").trim();
-    return this.normalizeSqlIdentifiers(s);
+  extractCheckExpressionFromDefinition(definition) {
+    const trimmed = definition.trim();
+    const match = trimmed.match(/^CHECK\s*\(([\s\S]*)\)$/i);
+    if (!match) {
+      return trimmed;
+    }
+    return match[1];
   }
-  normalizeExcludeDef(def) {
-    const s = def.replace(/\s+/g, " ").replace(/\s*\(\s*/g, "(").replace(/\s*\)\s*/g, ")").trim();
-    return this.normalizeSqlIdentifiers(s);
+  quoteIdentifier(identifier) {
+    return `"${identifier.replace(/"/g, '""')}"`;
   }
-  normalizeTriggerDef(def) {
-    return def.replace(/\s+/g, " ").replace(/\s*\(\s*/g, "(").replace(/\s*\)\s*/g, ")").replace(/\bON\s+[a-zA-Z_][a-zA-Z0-9_]*\./gi, "ON ").trim();
+  quoteQualifiedIdentifier(identifier) {
+    return identifier.split(".").map((part) => this.quoteIdentifier(part)).join(".");
   }
   /** Escape expression for embedding inside a template literal in generated code */
   escapeExpressionForRaw(expr) {

package/dist/cjs/index.cjs

@@ -3332,7 +3332,6 @@ var MigrationGenerator = class _MigrationGenerator {
           );
           this.updateFields(model, existingFields, up, down);
           if (model.constraints?.length) {
-            const existingCheckMap = this.existingCheckConstraints[model.name];
             const existingExcludeMap = this.existingExcludeConstraints[model.name];
             const existingTriggerMap = this.existingConstraintTriggers[model.name];
             for (let i = 0; i < model.constraints.length; i++) {
@@ -3341,23 +3340,31 @@ var MigrationGenerator = class _MigrationGenerator {
               const constraintName = this.getConstraintName(model, entry, i);
               if (entry.kind === "check") {
                 validateCheckConstraint(model, entry);
-                const newExpression = entry.expression;
-                const existingExpression = existingCheckMap?.get(constraintName);
-                if (existingExpression === void 0) {
+                const existingConstraint = this.findExistingConstraint(table, entry, constraintName);
+                if (!existingConstraint) {
                   up.push(() => {
-                    this.addCheckConstraint(table, constraintName, newExpression, entry.deferrable);
+                    this.addCheckConstraint(table, constraintName, entry.expression, entry.deferrable);
                   });
                   down.push(() => {
                     this.dropCheckConstraint(table, constraintName);
                   });
-                } else if (this.normalizeCheckExpression(existingExpression) !== this.normalizeCheckExpression(newExpression)) {
+                } else if (!await this.equalExpressions(
+                  table,
+                  existingConstraint.constraintName,
+                  existingConstraint.expression,
+                  entry.expression
+                )) {
                   up.push(() => {
-                    this.dropCheckConstraint(table, constraintName);
-                    this.addCheckConstraint(table, constraintName, newExpression, entry.deferrable);
+                    this.dropCheckConstraint(table, existingConstraint.constraintName);
+                    this.addCheckConstraint(table, constraintName, entry.expression, entry.deferrable);
                   });
                   down.push(() => {
                     this.dropCheckConstraint(table, constraintName);
-                    this.addCheckConstraint(table, constraintName, existingExpression);
+                    this.addCheckConstraint(
+                      table,
+                      existingConstraint.constraintName,
+                      existingConstraint.expression
+                    );
                   });
                 }
               } else if (entry.kind === "exclude") {
@@ -3829,64 +3836,144 @@ var MigrationGenerator = class _MigrationGenerator {
     }
     return result;
   }
-  stripOuterParens(s) {
-    while (s.length >= 2 && s.startsWith("(") && s.endsWith(")")) {
-      let depth = 0;
-      let match = true;
-      for (let i = 0; i < s.length; i++) {
-        if (s[i] === "(") {
-          depth++;
-        } else if (s[i] === ")") {
-          depth--;
+  normalizeExcludeDef(def) {
+    const s = def.replace(/\s+/g, " ").replace(/\s*\(\s*/g, "(").replace(/\s*\)\s*/g, ")").trim();
+    return this.normalizeSqlIdentifiers(s);
+  }
+  normalizeTriggerDef(def) {
+    const s = def.replace(/\s+/g, " ").replace(/\s*\(\s*/g, "(").replace(/\s*\)\s*/g, ")").replace(/\bON\s+[a-zA-Z_][a-zA-Z0-9_]*\./gi, "ON ").trim();
+    return this.normalizeSqlIdentifiers(s);
+  }
+  normalizeCheckExpression(expr) {
+    let normalized = expr.replace(/\s+/g, " ").trim();
+    while (this.isWrappedByOuterParentheses(normalized)) {
+      normalized = normalized.slice(1, -1).trim();
+    }
+    return normalized;
+  }
+  isWrappedByOuterParentheses(expr) {
+    if (!expr.startsWith("(") || !expr.endsWith(")")) {
+      return false;
+    }
+    let depth = 0;
+    let inSingleQuote = false;
+    for (let i = 0; i < expr.length; i++) {
+      const char = expr[i];
+      const next = expr[i + 1];
+      if (char === "'") {
+        if (inSingleQuote && next === "'") {
+          i++;
+          continue;
         }
-        if (depth === 0 && i < s.length - 1) {
-          match = false;
-          break;
+        inSingleQuote = !inSingleQuote;
+        continue;
+      }
+      if (inSingleQuote) {
+        continue;
+      }
+      if (char === "(") {
+        depth++;
+      } else if (char === ")") {
+        depth--;
+        if (depth === 0 && i !== expr.length - 1) {
+          return false;
+        }
+        if (depth < 0) {
+          return false;
         }
       }
-      if (!match || depth !== 0) {
-        break;
+    }
+    return depth === 0;
+  }
+  findExistingConstraint(table, entry, preferredConstraintName) {
+    const existingMap = this.existingCheckConstraints[table];
+    if (!existingMap) {
+      return null;
+    }
+    const preferredExpression = existingMap.get(preferredConstraintName);
+    if (preferredExpression !== void 0) {
+      return {
+        constraintName: preferredConstraintName,
+        expression: preferredExpression
+      };
+    }
+    const normalizedNewExpression = this.normalizeCheckExpression(entry.expression);
+    const constraintPrefix = `${table}_${entry.name}_${entry.kind}_`;
+    for (const [constraintName, expression] of existingMap.entries()) {
+      if (!constraintName.startsWith(constraintPrefix)) {
+        continue;
+      }
+      if (this.normalizeCheckExpression(expression) !== normalizedNewExpression) {
+        continue;
       }
-      s = s.slice(1, -1).trim();
+      return { constraintName, expression };
     }
-    return s;
+    return null;
   }
-  splitAtTopLevel(s, sep) {
-    const parts = [];
-    let depth = 0;
-    let start = 0;
-    const sepLen = sep.length;
-    for (let i = 0; i <= s.length - sepLen; i++) {
-      if (s[i] === "(") {
-        depth++;
-      } else if (s[i] === ")") {
-        depth--;
+  async equalExpressions(table, constraintName, existingExpression, newExpression) {
+    try {
+      const [canonicalExisting, canonicalNew] = await Promise.all([
+        this.canonicalizeCheckExpressionWithPostgres(table, existingExpression),
+        this.canonicalizeCheckExpressionWithPostgres(table, newExpression)
+      ]);
+      return canonicalExisting === canonicalNew;
+    } catch (error) {
+      console.warn(
+        `Failed to canonicalize check constraint "${constraintName}" on table "${table}". Treating it as changed.`,
+        error
+      );
+      return false;
+    }
+  }
+  async canonicalizeCheckExpressionWithPostgres(table, expression) {
+    const sourceTableIdentifier = table.split(".").map((part) => this.quoteIdentifier(part)).join(".");
+    const uniqueSuffix = `${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+    const tableSlug = table.toLowerCase().replace(/[^a-z0-9_]/g, "_");
+    const tempTableName = `gqm_tmp_check_${tableSlug}_${uniqueSuffix}`;
+    const tempTableIdentifier = this.quoteIdentifier(tempTableName);
+    const constraintName = `gqm_tmp_check_${uniqueSuffix}`;
+    const constraintIdentifier = this.quoteIdentifier(constraintName);
+    const trx = await this.knex.transaction();
+    try {
+      await trx.raw(`CREATE TEMP TABLE ${tempTableIdentifier} (LIKE ${sourceTableIdentifier}) ON COMMIT DROP`);
+      await trx.raw(`ALTER TABLE ${tempTableIdentifier} ADD CONSTRAINT ${constraintIdentifier} CHECK (${expression})`);
+      const result = await trx.raw(
+        `SELECT pg_get_constraintdef(c.oid, true) AS constraint_definition
+         FROM pg_constraint c
+         JOIN pg_class t
+           ON t.oid = c.conrelid
+         WHERE t.relname = ?
+           AND c.conname = ?
+         ORDER BY c.oid DESC
+         LIMIT 1`,
+        [tempTableName, constraintName]
+      );
+      const rows = "rows" in result && Array.isArray(result.rows) ? result.rows : [];
+      const definition = rows[0]?.constraint_definition;
+      if (!definition) {
+        throw new Error(`Could not read canonical check definition for expression: ${expression}`);
       }
-      if (depth === 0 && s.slice(i, i + sepLen).toLowerCase() === sep.toLowerCase()) {
-        parts.push(s.slice(start, i).trim());
-        start = i + sepLen;
-        i += sepLen - 1;
+      return this.normalizeCheckExpression(this.extractCheckExpressionFromDefinition(definition));
+    } finally {
+      try {
+        await trx.rollback();
+      } catch {
       }
     }
-    parts.push(s.slice(start).trim());
-    return parts.filter(Boolean);
   }
-  normalizeCheckExpression(expr) {
-    let s = expr.replace(/\s+/g, " ").trim();
-    const normalizeParts = (str, separator) => this.splitAtTopLevel(str, separator).map((p) => this.stripOuterParens(p)).join(separator);
-    s = this.stripOuterParens(s);
-    s = normalizeParts(s, " OR ");
-    s = this.stripOuterParens(s);
-    s = normalizeParts(s, " AND ");
-    s = s.replace(/\s*\(\s*/g, "(").replace(/\s*\)\s*/g, ")").replace(/\s+AND\s+/gi, " AND ").replace(/\s+OR\s+/gi, " OR ").trim();
-    return this.normalizeSqlIdentifiers(s);
+  extractCheckExpressionFromDefinition(definition) {
+    const trimmed = definition.trim();
+    const match = trimmed.match(/^CHECK\s*\(([\s\S]*)\)$/i);
+    if (!match) {
+      return trimmed;
+    }
+    return match[1];
   }
-  normalizeExcludeDef(def) {
-    const s = def.replace(/\s+/g, " ").replace(/\s*\(\s*/g, "(").replace(/\s*\)\s*/g, ")").trim();
-    return this.normalizeSqlIdentifiers(s);
+  quoteIdentifier(identifier) {
+    return `"${identifier.replace(/"/g, '""')}"`;
   }
-  normalizeTriggerDef(def) {
-    return def.replace(/\s+/g, " ").replace(/\s*\(\s*/g, "(").replace(/\s*\)\s*/g, ")").replace(/\bON\s+[a-zA-Z_][a-zA-Z0-9_]*\./gi, "ON ").trim();
+  quoteQualifiedIdentifier(identifier) {
+    return identifier.split(".").map((part) => this.quoteIdentifier(part)).join(".");
   }
   /** Escape expression for embedding inside a template literal in generated code */
   escapeExpressionForRaw(expr) {

package/dist/esm/migrations/generate.d.ts

@@ -38,11 +38,16 @@ export declare class MigrationGenerator {
     private static readonly SQL_KEYWORDS;
     private static readonly LITERAL_PLACEHOLDER;
     private normalizeSqlIdentifiers;
-    private stripOuterParens;
-    private splitAtTopLevel;
-    private normalizeCheckExpression;
     private normalizeExcludeDef;
     private normalizeTriggerDef;
+    private normalizeCheckExpression;
+    private isWrappedByOuterParentheses;
+    private findExistingConstraint;
+    private equalExpressions;
+    private canonicalizeCheckExpressionWithPostgres;
+    private extractCheckExpressionFromDefinition;
+    private quoteIdentifier;
+    private quoteQualifiedIdentifier;
     /** Escape expression for embedding inside a template literal in generated code */
     private escapeExpressionForRaw;
     private addCheckConstraint;