@smartive/graphql-magic 23.7.0 → 23.8.0-next.2

package/CHANGELOG.md

@@ -1,5 +1,5 @@
-## [23.7.0](https://github.com/smartive/graphql-magic/compare/v23.6.1...v23.7.0) (2026-03-04)
+## [23.8.0-next.2](https://github.com/smartive/graphql-magic/compare/v23.8.0-next.1...v23.8.0-next.2) (2026-03-04)
 
-### Features
+### Bug Fixes
 
-* Enhance check constraint handling in migration generator ([#430](https://github.com/smartive/graphql-magic/issues/430)) ([b23a885](https://github.com/smartive/graphql-magic/commit/b23a8858ec46182b90cdb220e444c782f46201fc))
+* normalize EXCLUDE defs so identical constraints produce empty migration ([0f42eb8](https://github.com/smartive/graphql-magic/commit/0f42eb8b9df1d1ce40a1905b6f52332165540943))

package/dist/bin/gqm.cjs

@@ -389,6 +389,8 @@ var EntityModel = class extends Model {
       for (const constraint of this.constraints) {
         if (constraint.kind === "check") {
           validateCheckConstraint(this, constraint);
+        } else if (constraint.kind === "exclude") {
+          validateExcludeConstraint(this, constraint);
         }
       }
     }
@@ -644,6 +646,19 @@ var validateCheckConstraint = (model, constraint) => {
     }
   }
 };
+var validateExcludeConstraint = (model, constraint) => {
+  const validColumnNames = new Set(model.fields.map((f) => getColumnName(f)));
+  for (const el of constraint.elements) {
+    if ("column" in el) {
+      if (!validColumnNames.has(el.column)) {
+        const validList = [...validColumnNames].sort().join(", ");
+        throw new Error(
+          `Exclude constraint "${constraint.name}" references column "${el.column}" which does not exist on model ${model.name}. Valid columns: ${validList}`
+        );
+      }
+    }
+  }
+};
 
 // src/db/generate.ts
 var import_code_block_writer = __toESM(require("code-block-writer"), 1);
@@ -792,6 +807,7 @@ var generateFunctionsFromDatabase = async (knex2) => {
     JOIN pg_namespace n ON p.pronamespace = n.oid
     WHERE n.nspname = 'public'
     AND NOT EXISTS (SELECT 1 FROM pg_aggregate a WHERE a.aggfnoid = p.oid)
+    AND NOT EXISTS (SELECT 1 FROM pg_depend d WHERE d.objid = p.oid AND d.deptype = 'e')
     ORDER BY p.proname, pg_get_function_identity_arguments(p.oid)
   `);
   const aggregateFunctions = await knex2.raw(`
@@ -806,6 +822,7 @@ var generateFunctionsFromDatabase = async (knex2) => {
     JOIN pg_aggregate a ON p.oid = a.aggfnoid
     JOIN pg_namespace n ON p.pronamespace = n.oid
     WHERE n.nspname = 'public'
+    AND NOT EXISTS (SELECT 1 FROM pg_depend d WHERE d.objid = p.oid AND d.deptype = 'e')
     ORDER BY p.proname, pg_get_function_identity_arguments(p.oid)
   `);
   const functions = [];
@@ -910,6 +927,7 @@ var getDatabaseFunctions = async (knex2) => {
     JOIN pg_namespace n ON p.pronamespace = n.oid
     WHERE n.nspname = 'public'
     AND NOT EXISTS (SELECT 1 FROM pg_aggregate a WHERE a.aggfnoid = p.oid)
+    AND NOT EXISTS (SELECT 1 FROM pg_depend d WHERE d.objid = p.oid AND d.deptype = 'e')
     ORDER BY p.proname, pg_get_function_identity_arguments(p.oid)
   `);
   const aggregateFunctions = await knex2.raw(`
@@ -925,6 +943,7 @@ var getDatabaseFunctions = async (knex2) => {
     JOIN pg_aggregate a ON p.oid = a.aggfnoid
     JOIN pg_namespace n ON p.pronamespace = n.oid
     WHERE n.nspname = 'public'
+    AND NOT EXISTS (SELECT 1 FROM pg_depend d WHERE d.objid = p.oid AND d.deptype = 'e')
     ORDER BY p.proname, pg_get_function_identity_arguments(p.oid)
   `);
   const result = [];
@@ -1068,7 +1087,7 @@ Summary: ${updatedCount} updated, ${skippedCount} skipped`);
 };
 
 // src/migrations/generate.ts
-var MigrationGenerator = class {
+var MigrationGenerator = class _MigrationGenerator {
   constructor(knex2, models, parsedFunctions) {
     this.models = models;
     this.parsedFunctions = parsedFunctions;
@@ -1084,6 +1103,10 @@ var MigrationGenerator = class {
   columns = {};
   /** table name -> constraint name -> check clause expression */
   existingCheckConstraints = {};
+  /** table name -> constraint name -> { normalized, raw } */
+  existingExcludeConstraints = {};
+  /** table name -> constraint name -> { normalized, raw } */
+  existingConstraintTriggers = {};
   uuidUsed;
   nowUsed;
   needsMigration = false;
@@ -1111,8 +1134,56 @@ var MigrationGenerator = class {
       }
       this.existingCheckConstraints[tableName].set(row.constraint_name, row.check_clause);
     }
+    const excludeResult = await schema.knex.raw(
+      `SELECT c.conrelid::regclass::text as table_name, c.conname as constraint_name, pg_get_constraintdef(c.oid) as constraint_def
+       FROM pg_constraint c
+       JOIN pg_namespace n ON c.connamespace = n.oid
+       WHERE n.nspname = 'public' AND c.contype = 'x'`
+    );
+    const excludeRows = "rows" in excludeResult && Array.isArray(excludeResult.rows) ? excludeResult.rows : [];
+    for (const row of excludeRows) {
+      const tableName = row.table_name.split(".").pop()?.replace(/^"|"$/g, "") ?? row.table_name;
+      if (!this.existingExcludeConstraints[tableName]) {
+        this.existingExcludeConstraints[tableName] = /* @__PURE__ */ new Map();
+      }
+      this.existingExcludeConstraints[tableName].set(row.constraint_name, {
+        normalized: this.normalizeExcludeDef(row.constraint_def),
+        raw: row.constraint_def
+      });
+    }
+    const triggerResult = await schema.knex.raw(
+      `SELECT c.conrelid::regclass::text as table_name, c.conname as constraint_name, pg_get_triggerdef(t.oid) as trigger_def
+       FROM pg_constraint c
+       JOIN pg_trigger t ON t.tgconstraint = c.oid
+       JOIN pg_namespace n ON c.connamespace = n.oid
+       WHERE n.nspname = 'public' AND c.contype = 't'`
+    );
+    const triggerRows = "rows" in triggerResult && Array.isArray(triggerResult.rows) ? triggerResult.rows : [];
+    for (const row of triggerRows) {
+      const tableName = row.table_name.split(".").pop()?.replace(/^"|"$/g, "") ?? row.table_name;
+      if (!this.existingConstraintTriggers[tableName]) {
+        this.existingConstraintTriggers[tableName] = /* @__PURE__ */ new Map();
+      }
+      this.existingConstraintTriggers[tableName].set(row.constraint_name, {
+        normalized: this.normalizeTriggerDef(row.trigger_def),
+        raw: row.trigger_def
+      });
+    }
     const up = [];
     const down = [];
+    const wantsBtreeGist = models.entities.some(
+      (model) => model.constraints?.some((c) => c.kind === "exclude" && c.elements.some((el) => "column" in el && el.operator === "="))
+    );
+    if (wantsBtreeGist) {
+      const extResult = await schema.knex("pg_extension").where("extname", "btree_gist").select("oid").first();
+      const btreeGistInstalled = !!extResult;
+      if (!btreeGistInstalled) {
+        up.unshift(() => {
+          this.writer.writeLine(`await knex.raw('CREATE EXTENSION IF NOT EXISTS btree_gist');`);
+          this.writer.blankLine();
+        });
+      }
+    }
     this.createEnums(
       this.models.enums.filter((enm2) => !enums.includes((0, import_lowerFirst.default)(enm2.name))),
       up,
@@ -1191,10 +1262,22 @@ var MigrationGenerator = class {
               if (entry.kind === "check") {
                 validateCheckConstraint(model, entry);
                 const table = model.name;
-                const constraintName = this.getCheckConstraintName(model, entry, i);
-                const expression = entry.expression;
+                const constraintName = this.getConstraintName(model, entry, i);
+                up.push(() => {
+                  this.addCheckConstraint(table, constraintName, entry.expression, entry.deferrable);
+                });
+              } else if (entry.kind === "exclude") {
+                validateExcludeConstraint(model, entry);
+                const table = model.name;
+                const constraintName = this.getConstraintName(model, entry, i);
+                up.push(() => {
+                  this.addExcludeConstraint(table, constraintName, entry);
+                });
+              } else if (entry.kind === "constraint_trigger") {
+                const table = model.name;
+                const constraintName = this.getConstraintName(model, entry, i);
                 up.push(() => {
-                  this.addCheckConstraint(table, constraintName, expression);
+                  this.addConstraintTrigger(table, constraintName, entry);
                 });
               }
             }
@@ -1234,36 +1317,84 @@ var MigrationGenerator = class {
           );
           this.updateFields(model, existingFields, up, down);
           if (model.constraints?.length) {
+            const existingExcludeMap = this.existingExcludeConstraints[model.name];
+            const existingTriggerMap = this.existingConstraintTriggers[model.name];
             for (let i = 0; i < model.constraints.length; i++) {
               const entry = model.constraints[i];
-              if (entry.kind !== "check") {
-                continue;
-              }
-              validateCheckConstraint(model, entry);
               const table = model.name;
-              const constraintName = this.getCheckConstraintName(model, entry, i);
-              const existingConstraint = this.findExistingConstraint(table, entry, constraintName);
-              if (!existingConstraint) {
-                up.push(() => {
-                  this.addCheckConstraint(table, constraintName, entry.expression);
-                });
-                down.push(() => {
-                  this.dropCheckConstraint(table, constraintName);
-                });
-              } else if (!await this.equalExpressions(
-                table,
-                existingConstraint.constraintName,
-                existingConstraint.expression,
-                entry.expression
-              )) {
-                up.push(() => {
-                  this.dropCheckConstraint(table, existingConstraint.constraintName);
-                  this.addCheckConstraint(table, constraintName, entry.expression);
-                });
-                down.push(() => {
-                  this.dropCheckConstraint(table, constraintName);
-                  this.addCheckConstraint(table, existingConstraint.constraintName, existingConstraint.expression);
-                });
+              const constraintName = this.getConstraintName(model, entry, i);
+              if (entry.kind === "check") {
+                validateCheckConstraint(model, entry);
+                const existingConstraint = this.findExistingConstraint(table, entry, constraintName);
+                if (!existingConstraint) {
+                  up.push(() => {
+                    this.addCheckConstraint(table, constraintName, entry.expression, entry.deferrable);
+                  });
+                  down.push(() => {
+                    this.dropCheckConstraint(table, constraintName);
+                  });
+                } else if (!await this.equalExpressions(
+                  table,
+                  existingConstraint.constraintName,
+                  existingConstraint.expression,
+                  entry.expression
+                )) {
+                  up.push(() => {
+                    this.dropCheckConstraint(table, existingConstraint.constraintName);
+                    this.addCheckConstraint(table, constraintName, entry.expression, entry.deferrable);
+                  });
+                  down.push(() => {
+                    this.dropCheckConstraint(table, constraintName);
+                    this.addCheckConstraint(table, existingConstraint.constraintName, existingConstraint.expression);
+                  });
+                }
+              } else if (entry.kind === "exclude") {
+                validateExcludeConstraint(model, entry);
+                const newDef = this.normalizeExcludeDef(this.buildExcludeDef(entry));
+                const existing = existingExcludeMap?.get(constraintName);
+                if (existing === void 0) {
+                  up.push(() => {
+                    this.addExcludeConstraint(table, constraintName, entry);
+                  });
+                  down.push(() => {
+                    this.dropExcludeConstraint(table, constraintName);
+                  });
+                } else if (existing.normalized !== newDef) {
+                  up.push(() => {
+                    this.dropExcludeConstraint(table, constraintName);
+                    this.addExcludeConstraint(table, constraintName, entry);
+                  });
+                  down.push(() => {
+                    this.dropExcludeConstraint(table, constraintName);
+                    const escaped = this.escapeExpressionForRaw(existing.raw);
+                    this.writer.writeLine(
+                      `await knex.raw(\`ALTER TABLE "${table}" ADD CONSTRAINT "${constraintName}" ${escaped}\`);`
+                    );
+                    this.writer.blankLine();
+                  });
+                }
+              } else if (entry.kind === "constraint_trigger") {
+                const newDef = this.normalizeTriggerDef(this.buildConstraintTriggerDef(table, constraintName, entry));
+                const existing = existingTriggerMap?.get(constraintName);
+                if (existing === void 0) {
+                  up.push(() => {
+                    this.addConstraintTrigger(table, constraintName, entry);
+                  });
+                  down.push(() => {
+                    this.dropConstraintTrigger(table, constraintName);
+                  });
+                } else if (existing.normalized !== newDef) {
+                  up.push(() => {
+                    this.dropConstraintTrigger(table, constraintName);
+                    this.addConstraintTrigger(table, constraintName, entry);
+                  });
+                  down.push(() => {
+                    this.dropConstraintTrigger(table, constraintName);
+                    const escaped = existing.raw.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
+                    this.writer.writeLine(`await knex.raw(\`${escaped}\`);`);
+                    this.writer.blankLine();
+                  });
+                }
               }
             }
           }
@@ -1638,9 +1769,113 @@ var MigrationGenerator = class {
   renameColumn(from, to) {
     this.writer.writeLine(`table.renameColumn('${from}', '${to}');`);
   }
-  getCheckConstraintName(model, entry, index) {
+  getConstraintName(model, entry, index) {
     return `${model.name}_${entry.name}_${entry.kind}_${index}`;
   }
+  static SQL_KEYWORDS = /* @__PURE__ */ new Set([
+    "and",
+    "or",
+    "not",
+    "in",
+    "is",
+    "null",
+    "true",
+    "false",
+    "between",
+    "like",
+    "exists",
+    "all",
+    "any",
+    "asc",
+    "desc",
+    "with",
+    "using",
+    "as",
+    "on",
+    "infinity",
+    "extract",
+    "current_date",
+    "current_timestamp"
+  ]);
+  static LITERAL_PLACEHOLDER = "\uE000";
+  static IDENT_PLACEHOLDER = "\uE001";
+  normalizeSqlIdentifiers(s) {
+    const literals = [];
+    let result = s.replace(/'([^']|'')*'/g, (lit) => {
+      literals.push(lit);
+      return `${_MigrationGenerator.LITERAL_PLACEHOLDER}${literals.length - 1}${_MigrationGenerator.LITERAL_PLACEHOLDER}`;
+    });
+    const quotedIdents = [];
+    result = result.replace(/"([^"]*)"/g, (_, ident) => {
+      quotedIdents.push(`"${ident.toLowerCase()}"`);
+      return `${_MigrationGenerator.IDENT_PLACEHOLDER}${quotedIdents.length - 1}${_MigrationGenerator.IDENT_PLACEHOLDER}`;
+    });
+    result = result.replace(
+      /\b([a-zA-Z_][a-zA-Z0-9_]*)\b(?!\s*\()/g,
+      (match) => _MigrationGenerator.SQL_KEYWORDS.has(match.toLowerCase()) ? match : `"${match.toLowerCase()}"`
+    );
+    for (let i = 0; i < quotedIdents.length; i++) {
+      result = result.replace(
+        new RegExp(`${_MigrationGenerator.IDENT_PLACEHOLDER}${i}${_MigrationGenerator.IDENT_PLACEHOLDER}`, "g"),
+        quotedIdents[i]
+      );
+    }
+    for (let i = 0; i < literals.length; i++) {
+      result = result.replace(
+        new RegExp(`${_MigrationGenerator.LITERAL_PLACEHOLDER}${i}${_MigrationGenerator.LITERAL_PLACEHOLDER}`, "g"),
+        literals[i]
+      );
+    }
+    return result;
+  }
+  normalizeExcludeDef(def) {
+    let s = def.replace(/\s+/g, " ").replace(/\s*\(\s*/g, "(").replace(/\s*\)\s*/g, ")").replace(/::\s*timestamp\s+with\s+time\s+zone\b/gi, "::timestamptz").replace(/::\s*timestamp\s+without\s+time\s+zone\b/gi, "::timestamp").trim();
+    const whereMatch = s.match(/\bWHERE\s*\(/i);
+    if (whereMatch) {
+      const openParen = (whereMatch.index ?? 0) + whereMatch[0].length - 1;
+      const closeParen = this.findMatchingParen(s, openParen);
+      if (closeParen !== -1) {
+        let cond = s.slice(openParen + 1, closeParen).trim();
+        while (this.isWrappedByOuterParentheses(cond)) {
+          cond = cond.slice(1, -1).trim();
+        }
+        s = s.slice(0, openParen + 1) + cond + s.slice(closeParen);
+      }
+    }
+    return this.normalizeSqlIdentifiers(s);
+  }
+  findMatchingParen(s, openIndex) {
+    let depth = 1;
+    let inSingleQuote = false;
+    for (let i = openIndex + 1; i < s.length; i++) {
+      const char = s[i];
+      const next = s[i + 1];
+      if (char === "'") {
+        if (inSingleQuote && next === "'") {
+          i++;
+          continue;
+        }
+        inSingleQuote = !inSingleQuote;
+        continue;
+      }
+      if (inSingleQuote) {
+        continue;
+      }
+      if (char === "(") {
+        depth++;
+      } else if (char === ")") {
+        depth--;
+        if (depth === 0) {
+          return i;
+        }
+      }
+    }
+    return -1;
+  }
+  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)) {
@@ -1776,10 +2011,11 @@ var MigrationGenerator = class {
   escapeExpressionForRaw(expr) {
     return expr.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
   }
-  addCheckConstraint(table, constraintName, expression) {
+  addCheckConstraint(table, constraintName, expression, deferrable) {
     const escaped = this.escapeExpressionForRaw(expression);
+    const deferrableClause = deferrable ? ` DEFERRABLE ${deferrable}` : "";
     this.writer.writeLine(
-      `await knex.raw(\`ALTER TABLE "${table}" ADD CONSTRAINT "${constraintName}" CHECK (${escaped})\`);`
+      `await knex.raw(\`ALTER TABLE "${table}" ADD CONSTRAINT "${constraintName}" CHECK (${escaped})${deferrableClause}\`);`
     );
     this.writer.blankLine();
   }
@@ -1787,6 +2023,43 @@ var MigrationGenerator = class {
     this.writer.writeLine(`await knex.raw('ALTER TABLE "${table}" DROP CONSTRAINT "${constraintName}"');`);
     this.writer.blankLine();
   }
+  buildExcludeDef(entry) {
+    const elementsStr = entry.elements.map((el) => "column" in el ? `"${el.column}" WITH ${el.operator}` : `${el.expression} WITH ${el.operator}`).join(", ");
+    const whereClause = entry.where ? ` WHERE (${entry.where})` : "";
+    const deferrableClause = entry.deferrable ? ` DEFERRABLE ${entry.deferrable}` : "";
+    return `EXCLUDE USING ${entry.using} (${elementsStr})${whereClause}${deferrableClause}`;
+  }
+  addExcludeConstraint(table, constraintName, entry) {
+    const def = this.buildExcludeDef(entry);
+    const escaped = this.escapeExpressionForRaw(def);
+    this.writer.writeLine(`await knex.raw(\`ALTER TABLE "${table}" ADD CONSTRAINT "${constraintName}" ${escaped}\`);`);
+    this.writer.blankLine();
+  }
+  dropExcludeConstraint(table, constraintName) {
+    this.writer.writeLine(`await knex.raw('ALTER TABLE "${table}" DROP CONSTRAINT "${constraintName}"');`);
+    this.writer.blankLine();
+  }
+  buildConstraintTriggerDef(table, constraintName, entry) {
+    const eventsStr = entry.events.join(" OR ");
+    const deferrableClause = entry.deferrable ? ` DEFERRABLE ${entry.deferrable}` : "";
+    const argsStr = entry.function.args?.length ? entry.function.args.map((a) => `"${a}"`).join(", ") : "";
+    const executeClause = argsStr ? `EXECUTE FUNCTION ${entry.function.name}(${argsStr})` : `EXECUTE FUNCTION ${entry.function.name}()`;
+    return `CREATE CONSTRAINT TRIGGER "${constraintName}" ${entry.when} ${eventsStr} ON "${table}"${deferrableClause} FOR EACH ${entry.forEach} ${executeClause}`;
+  }
+  addConstraintTrigger(table, constraintName, entry) {
+    const eventsStr = entry.events.join(" OR ");
+    const deferrableClause = entry.deferrable ? ` DEFERRABLE ${entry.deferrable}` : "";
+    const argsStr = entry.function.args?.length ? entry.function.args.map((a) => `"${a}"`).join(", ") : "";
+    const executeClause = argsStr ? `EXECUTE FUNCTION ${entry.function.name}(${argsStr})` : `EXECUTE FUNCTION ${entry.function.name}()`;
+    this.writer.writeLine(
+      `await knex.raw(\`CREATE CONSTRAINT TRIGGER "${constraintName}" ${entry.when} ${eventsStr} ON "${table}"${deferrableClause} FOR EACH ${entry.forEach} ${executeClause}\`);`
+    );
+    this.writer.blankLine();
+  }
+  dropConstraintTrigger(table, constraintName) {
+    this.writer.writeLine(`await knex.raw('ALTER TABLE "${table}" DROP CONSTRAINT "${constraintName}"');`);
+    this.writer.blankLine();
+  }
   value(value2) {
     if (typeof value2 === "string") {
       return `'${value2}'`;