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

package/src/migrations/generate.ts

@@ -18,7 +18,6 @@ import {
   summonByName,
   typeToField,
   validateCheckConstraint,
-  validateExcludeConstraint,
 } from '../models/utils';
 import { getColumnName } from '../resolvers';
 import { Value } from '../values';
@@ -42,10 +41,6 @@ export class MigrationGenerator {
   private columns: Record<string, Column[]> = {};
   /** table name -> constraint name -> check clause expression */
   private existingCheckConstraints: Record<string, Map<string, string>> = {};
-  /** table name -> constraint name -> { normalized, raw } */
-  private existingExcludeConstraints: Record<string, Map<string, { normalized: string; raw: string }>> = {};
-  /** table name -> constraint name -> { normalized, raw } */
-  private existingConstraintTriggers: Record<string, Map<string, { normalized: string; raw: string }>> = {};
   private uuidUsed?: boolean;
   private nowUsed?: boolean;
   public needsMigration = false;
@@ -88,66 +83,9 @@ export 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: { table_name: string; constraint_name: string; constraint_def: string }[] =
-      'rows' in excludeResult && Array.isArray((excludeResult as { rows: unknown }).rows)
-        ? (excludeResult as { rows: { table_name: string; constraint_name: string; constraint_def: string }[] }).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] = 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: { table_name: string; constraint_name: string; trigger_def: string }[] =
-      'rows' in triggerResult && Array.isArray((triggerResult as { rows: unknown }).rows)
-        ? (triggerResult as { rows: { table_name: string; constraint_name: string; trigger_def: string }[] }).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] = new Map();
-      }
-      this.existingConstraintTriggers[tableName].set(row.constraint_name, {
-        normalized: this.normalizeTriggerDef(row.trigger_def),
-        raw: row.trigger_def,
-      });
-    }
-
     const up: Callbacks = [];
     const down: Callbacks = [];
 
-    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((enm) => !enums.includes(lowerFirst(enm.name))),
       up,
@@ -240,22 +178,10 @@ export 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);
                 });
               }
             }
@@ -311,83 +237,38 @@ export 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 === undefined) {
-                  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 existing = existingExcludeMap?.get(constraintName);
-                if (existing === undefined) {
-                  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 === undefined) {
-                  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();
-                  });
-                }
+              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);
+                });
               }
             }
           }
@@ -880,249 +761,203 @@ export class MigrationGenerator {
     this.writer.writeLine(`table.renameColumn('${from}', '${to}');`);
   }
 
-  private getConstraintName(model: EntityModel, entry: { kind: string; name: string }, index: number): string {
+  private getCheckConstraintName(model: EntityModel, entry: { kind: string; name: string }, index: number): string {
     return `${model.name}_${entry.name}_${entry.kind}_${index}`;
   }
 
-  private static readonly SQL_KEYWORDS = 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',
-  ]);
-
-  private static readonly LITERAL_PLACEHOLDER = '\uE000';
-
-  private normalizeSqlIdentifiers(s: string): string {
-    const literals: string[] = [];
-    let result = s.replace(/'([^']|'')*'/g, (lit) => {
-      literals.push(lit);
-
-      return `${MigrationGenerator.LITERAL_PLACEHOLDER}${literals.length - 1}${MigrationGenerator.LITERAL_PLACEHOLDER}`;
-    });
-    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(`${MigrationGenerator.LITERAL_PLACEHOLDER}${i}${MigrationGenerator.LITERAL_PLACEHOLDER}`, 'g'),
-        literals[i],
-      );
+  private normalizeCheckExpression(expr: string): string {
+    let normalized = expr.replace(/\s+/g, ' ').trim();
+    while (this.isWrappedByOuterParentheses(normalized)) {
+      normalized = normalized.slice(1, -1).trim();
     }
 
-    return result;
+    return normalized;
   }
 
-  private stripOuterParens(s: string): string {
-    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--;
-        }
-        if (depth === 0 && i < s.length - 1) {
-          match = false;
-          break;
+  private isWrappedByOuterParentheses(expr: string): boolean {
+    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;
         }
+        inSingleQuote = !inSingleQuote;
+        continue;
       }
-      if (!match || depth !== 0) {
-        break;
-      }
-      s = s.slice(1, -1).trim();
-    }
 
-    return s;
-  }
+      if (inSingleQuote) {
+        continue;
+      }
 
-  private splitAtTopLevel(s: string, sep: string): string[] {
-    const parts: string[] = [];
-    let depth = 0;
-    let start = 0;
-    const sepLen = sep.length;
-    for (let i = 0; i <= s.length - sepLen; i++) {
-      if (s[i] === '(') {
+      if (char === '(') {
         depth++;
-      } else if (s[i] === ')') {
+      } else if (char === ')') {
         depth--;
-      }
-      if (depth === 0 && s.slice(i, i + sepLen).toLowerCase() === sep.toLowerCase()) {
-        parts.push(s.slice(start, i).trim());
-        start = i + sepLen;
-        i += sepLen - 1;
+        if (depth === 0 && i !== expr.length - 1) {
+          return false;
+        }
+        if (depth < 0) {
+          return false;
+        }
       }
     }
-    parts.push(s.slice(start).trim());
 
-    return parts.filter(Boolean);
+    return depth === 0;
   }
 
-  private normalizeCheckExpression(expr: string): string {
-    let s = expr.replace(/\s+/g, ' ').trim();
-    const normalizeParts = (str: string, separator: string): string =>
-      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);
-  }
+  private findExistingConstraint(
+    table: string,
+    entry: { kind: 'check'; name: string; expression: string },
+    preferredConstraintName: string,
+  ): { constraintName: string; expression: string } | null {
+    const existingMap = this.existingCheckConstraints[table];
+    if (!existingMap) {
+      return null;
+    }
 
-  private normalizeExcludeDef(def: string): string {
-    const s = def
-      .replace(/\s+/g, ' ')
-      .replace(/\s*\(\s*/g, '(')
-      .replace(/\s*\)\s*/g, ')')
-      .trim();
+    const preferredExpression = existingMap.get(preferredConstraintName);
+    if (preferredExpression !== undefined) {
+      return {
+        constraintName: preferredConstraintName,
+        expression: preferredExpression,
+      };
+    }
 
-    return this.normalizeSqlIdentifiers(s);
-  }
+    const normalizedNewExpression = this.normalizeCheckExpression(entry.expression);
+    const constraintPrefix = `${table}_${entry.name}_${entry.kind}_`;
 
-  private normalizeTriggerDef(def: string): string {
-    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();
-  }
+    for (const [constraintName, expression] of existingMap.entries()) {
+      if (!constraintName.startsWith(constraintPrefix)) {
+        continue;
+      }
+      if (this.normalizeCheckExpression(expression) !== normalizedNewExpression) {
+        continue;
+      }
 
-  /** Escape expression for embedding inside a template literal in generated code */
-  private escapeExpressionForRaw(expr: string): string {
-    return expr.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$/g, '\\$');
+      return { constraintName, expression };
+    }
+
+    return null;
   }
 
-  private addCheckConstraint(
+  private async equalExpressions(
     table: string,
     constraintName: string,
-    expression: string,
-    deferrable?: 'INITIALLY DEFERRED' | 'INITIALLY IMMEDIATE',
-  ) {
-    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}\`);`,
-    );
-    this.writer.blankLine();
+    existingExpression: string,
+    newExpression: string,
+  ): Promise<boolean> {
+    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;
+    }
   }
 
-  private dropCheckConstraint(table: string, constraintName: string) {
-    this.writer.writeLine(`await knex.raw('ALTER TABLE "${table}" DROP CONSTRAINT "${constraintName}"');`);
-    this.writer.blankLine();
+  private async canonicalizeCheckExpressionWithPostgres(table: string, expression: string): Promise<string> {
+    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: { constraint_definition: string }[] =
+        'rows' in result && Array.isArray((result as { rows: unknown }).rows)
+          ? (result as { rows: { constraint_definition: string }[] }).rows
+          : [];
+      const definition = rows[0]?.constraint_definition;
+      if (!definition) {
+        throw new Error(`Could not read canonical check definition for expression: ${expression}`);
+      }
+
+      return this.normalizeCheckExpression(this.extractCheckExpressionFromDefinition(definition));
+    } finally {
+      try {
+        await trx.rollback();
+      } catch {
+        // no-op: transaction may already be closed by driver after failure
+      }
+    }
   }
 
-  private buildExcludeDef(entry: {
-    using: string;
-    elements: ({ column: string; operator: string } | { expression: string; operator: string })[];
-    where?: string;
-    deferrable?: 'INITIALLY DEFERRED' | 'INITIALLY IMMEDIATE';
-  }): string {
-    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}`;
+  private extractCheckExpressionFromDefinition(definition: string): string {
+    const trimmed = definition.trim();
+    const match = trimmed.match(/^CHECK\s*\(([\s\S]*)\)$/i);
+    if (!match) {
+      return trimmed;
+    }
+
+    return match[1];
   }
 
-  private addExcludeConstraint(
-    table: string,
-    constraintName: string,
-    entry: {
-      using: string;
-      elements: ({ column: string; operator: string } | { expression: string; operator: string })[];
-      where?: string;
-      deferrable?: 'INITIALLY DEFERRED' | 'INITIALLY IMMEDIATE';
-    },
-  ) {
-    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();
+  private quoteIdentifier(identifier: string): string {
+    return `"${identifier.replace(/"/g, '""')}"`;
   }
 
-  private dropExcludeConstraint(table: string, constraintName: string) {
-    this.writer.writeLine(`await knex.raw('ALTER TABLE "${table}" DROP CONSTRAINT "${constraintName}"');`);
-    this.writer.blankLine();
+  private quoteQualifiedIdentifier(identifier: string): string {
+    return identifier
+      .split('.')
+      .map((part) => this.quoteIdentifier(part))
+      .join('.');
   }
 
-  private buildConstraintTriggerDef(
-    table: string,
-    constraintName: string,
-    entry: {
-      when: 'AFTER' | 'BEFORE';
-      events: ('INSERT' | 'UPDATE')[];
-      forEach: 'ROW' | 'STATEMENT';
-      deferrable?: 'INITIALLY DEFERRED' | 'INITIALLY IMMEDIATE';
-      function: { name: string; args?: string[] };
-    },
-  ): string {
-    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}`;
+  /** Escape expression for embedding inside a template literal in generated code */
+  private escapeExpressionForRaw(expr: string): string {
+    return expr.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$/g, '\\$');
   }
 
-  private addConstraintTrigger(
-    table: string,
-    constraintName: string,
-    entry: {
-      when: 'AFTER' | 'BEFORE';
-      events: ('INSERT' | 'UPDATE')[];
-      forEach: 'ROW' | 'STATEMENT';
-      deferrable?: 'INITIALLY DEFERRED' | 'INITIALLY IMMEDIATE';
-      function: { name: string; args?: string[] };
-    },
-  ) {
-    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}()`;
+  private addCheckConstraint(table: string, constraintName: string, expression: string) {
+    const escaped = this.escapeExpressionForRaw(expression);
     this.writer.writeLine(
-      `await knex.raw(\`CREATE CONSTRAINT TRIGGER "${constraintName}" ${entry.when} ${eventsStr} ON "${table}"${deferrableClause} FOR EACH ${entry.forEach} ${executeClause}\`);`,
+      `await knex.raw(\`ALTER TABLE "${table}" ADD CONSTRAINT "${constraintName}" CHECK (${escaped})\`);`,
     );
     this.writer.blankLine();
   }
 
-  private dropConstraintTrigger(table: string, constraintName: string) {
+  private dropCheckConstraint(table: string, constraintName: string) {
     this.writer.writeLine(`await knex.raw('ALTER TABLE "${table}" DROP CONSTRAINT "${constraintName}"');`);
     this.writer.blankLine();
   }

package/src/migrations/update-functions.ts

@@ -68,7 +68,6 @@ export const getDatabaseFunctions = async (knex: Knex): Promise<DatabaseFunction
     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)
   `);
 
@@ -85,7 +84,6 @@ export const getDatabaseFunctions = async (knex: Knex): Promise<DatabaseFunction
     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)
   `);