@smartive/graphql-magic 23.7.0-next.4 → 23.7.0

package/CHANGELOG.md

@@ -1,5 +1,5 @@
-## [23.7.0-next.4](https://github.com/smartive/graphql-magic/compare/v23.7.0-next.3...v23.7.0-next.4) (2026-03-04)
+## [23.7.0](https://github.com/smartive/graphql-magic/compare/v23.6.1...v23.7.0) (2026-03-04)
 
-### Bug Fixes
+### Features
 
-* normalize identifier quoting in constraint comparison ([3c23cbd](https://github.com/smartive/graphql-magic/commit/3c23cbdad56bafe2ff7018338314673ffff2200c))
+* 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))

package/dist/bin/gqm.cjs

@@ -389,8 +389,6 @@ 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);
         }
       }
     }
@@ -646,19 +644,6 @@ 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);
@@ -807,7 +792,6 @@ 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(`
@@ -822,7 +806,6 @@ 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 = [];
@@ -927,7 +910,6 @@ 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(`
@@ -943,7 +925,6 @@ 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 = [];
@@ -1087,7 +1068,7 @@ Summary: ${updatedCount} updated, ${skippedCount} skipped`);
 };
 
 // src/migrations/generate.ts
-var MigrationGenerator = class _MigrationGenerator {
+var MigrationGenerator = class {
   constructor(knex2, models, parsedFunctions) {
     this.models = models;
     this.parsedFunctions = parsedFunctions;
@@ -1103,10 +1084,6 @@ var MigrationGenerator = class _MigrationGenerator {
   columns = {};
   /** table name -> constraint name -> check clause expression */
   existingCheckConstraints = {};
-  /** table name -> constraint name -> exclude definition (normalized) */
-  existingExcludeConstraints = {};
-  /** table name -> constraint name -> trigger definition (normalized) */
-  existingConstraintTriggers = {};
   uuidUsed;
   nowUsed;
   needsMigration = false;
@@ -1134,50 +1111,8 @@ var MigrationGenerator = class _MigrationGenerator {
       }
       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, this.normalizeExcludeDef(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, this.normalizeTriggerDef(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,
@@ -1256,22 +1191,10 @@ var MigrationGenerator = class _MigrationGenerator {
               if (entry.kind === "check") {
                 validateCheckConstraint(model, entry);
                 const table = model.name;
-                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);
+                const constraintName = this.getCheckConstraintName(model, entry, i);
+                const expression = entry.expression;
                 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.addConstraintTrigger(table, constraintName, entry);
+                  this.addCheckConstraint(table, constraintName, expression);
                 });
               }
             }
@@ -1311,81 +1234,36 @@ 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++) {
               const entry = model.constraints[i];
+              if (entry.kind !== "check") {
+                continue;
+              }
+              validateCheckConstraint(model, entry);
               const table = model.name;
-              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) {
-                  up.push(() => {
-                    this.addCheckConstraint(table, constraintName, newExpression, entry.deferrable);
-                  });
-                  down.push(() => {
-                    this.dropCheckConstraint(table, constraintName);
-                  });
-                } else if (this.normalizeCheckExpression(existingExpression) !== this.normalizeCheckExpression(newExpression)) {
-                  up.push(() => {
-                    this.dropCheckConstraint(table, constraintName);
-                    this.addCheckConstraint(table, constraintName, newExpression, entry.deferrable);
-                  });
-                  down.push(() => {
-                    this.dropCheckConstraint(table, constraintName);
-                    this.addCheckConstraint(table, constraintName, existingExpression);
-                  });
-                }
-              } else if (entry.kind === "exclude") {
-                validateExcludeConstraint(model, entry);
-                const newDef = this.normalizeExcludeDef(this.buildExcludeDef(entry));
-                const existingDef = existingExcludeMap?.get(constraintName);
-                if (existingDef === void 0) {
-                  up.push(() => {
-                    this.addExcludeConstraint(table, constraintName, entry);
-                  });
-                  down.push(() => {
-                    this.dropExcludeConstraint(table, constraintName);
-                  });
-                } else if (existingDef !== newDef) {
-                  up.push(() => {
-                    this.dropExcludeConstraint(table, constraintName);
-                    this.addExcludeConstraint(table, constraintName, entry);
-                  });
-                  down.push(() => {
-                    this.dropExcludeConstraint(table, constraintName);
-                    const escaped = this.escapeExpressionForRaw(existingDef);
-                    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 existingDef = existingTriggerMap?.get(constraintName);
-                if (existingDef === void 0) {
-                  up.push(() => {
-                    this.addConstraintTrigger(table, constraintName, entry);
-                  });
-                  down.push(() => {
-                    this.dropConstraintTrigger(table, constraintName);
-                  });
-                } else if (existingDef !== newDef) {
-                  up.push(() => {
-                    this.dropConstraintTrigger(table, constraintName);
-                    this.addConstraintTrigger(table, constraintName, entry);
-                  });
-                  down.push(() => {
-                    this.dropConstraintTrigger(table, constraintName);
-                    const escaped = existingDef.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
-                    this.writer.writeLine(`await knex.raw(\`${escaped}\`);`);
-                    this.writer.blankLine();
-                  });
-                }
+              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);
+                });
               }
             }
           }
@@ -1760,90 +1638,148 @@ var MigrationGenerator = class _MigrationGenerator {
   renameColumn(from, to) {
     this.writer.writeLine(`table.renameColumn('${from}', '${to}');`);
   }
-  getConstraintName(model, entry, index) {
+  getCheckConstraintName(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"
-  ]);
-  normalizeSqlIdentifiers(s) {
-    const literals = [];
-    let result = s.replace(/'([^']|'')*'/g, (lit) => {
-      literals.push(lit);
-      return `\0L${literals.length - 1}\0`;
-    });
-    result = result.replace(/"([^"]*)"/g, (_, ident) => `"${ident.toLowerCase()}"`);
-    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 < literals.length; i++) {
-      result = result.replace(new RegExp(`\0L${i}\0`, "g"), literals[i]);
+  normalizeCheckExpression(expr) {
+    let normalized = expr.replace(/\s+/g, " ").trim();
+    while (this.isWrappedByOuterParentheses(normalized)) {
+      normalized = normalized.slice(1, -1).trim();
     }
-    return result;
+    return normalized;
   }
-  normalizeCheckExpression(expr) {
-    let s = expr.replace(/\s+/g, " ").trim();
-    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--;
+  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;
+      }
+      return { constraintName, expression };
+    }
+    return null;
+  }
+  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}`);
       }
-      s = s.slice(1, -1).trim();
+      return this.normalizeCheckExpression(this.extractCheckExpressionFromDefinition(definition));
+    } finally {
+      try {
+        await trx.rollback();
+      } catch {
+      }
+    }
+  }
+  extractCheckExpressionFromDefinition(definition) {
+    const trimmed = definition.trim();
+    const match = trimmed.match(/^CHECK\s*\(([\s\S]*)\)$/i);
+    if (!match) {
+      return trimmed;
     }
-    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);
+    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, ")").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) {
     return expr.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
   }
-  addCheckConstraint(table, constraintName, expression, deferrable) {
+  addCheckConstraint(table, constraintName, expression) {
     const escaped = this.escapeExpressionForRaw(expression);
-    const deferrableClause = deferrable ? ` DEFERRABLE ${deferrable}` : "";
     this.writer.writeLine(
-      `await knex.raw(\`ALTER TABLE "${table}" ADD CONSTRAINT "${constraintName}" CHECK (${escaped})${deferrableClause}\`);`
+      `await knex.raw(\`ALTER TABLE "${table}" ADD CONSTRAINT "${constraintName}" CHECK (${escaped})\`);`
     );
     this.writer.blankLine();
   }
@@ -1851,43 +1787,6 @@ var MigrationGenerator = class _MigrationGenerator {
     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}'`;