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

package/src/migrations/generate.ts

@@ -18,6 +18,7 @@ import {
   summonByName,
   typeToField,
   validateCheckConstraint,
+  validateExcludeConstraint,
 } from '../models/utils';
 import { getColumnName } from '../resolvers';
 import { Value } from '../values';
@@ -41,6 +42,10 @@ 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;
@@ -83,9 +88,66 @@ 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,
@@ -178,10 +240,22 @@ export class MigrationGenerator {
               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, expression);
+                  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.addConstraintTrigger(table, constraintName, entry);
                 });
               }
             }
@@ -237,38 +311,86 @@ export class MigrationGenerator {
           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 === 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();
+                  });
+                }
               }
             }
           }
@@ -761,10 +883,141 @@ export class MigrationGenerator {
     this.writer.writeLine(`table.renameColumn('${from}', '${to}');`);
   }
 
-  private getCheckConstraintName(model: EntityModel, entry: { kind: string; name: string }, index: number): string {
+  private getConstraintName(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 static readonly IDENT_PLACEHOLDER = '\uE001';
+
+  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}`;
+    });
+    const quotedIdents: string[] = [];
+    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;
+  }
+
+  private normalizeExcludeDef(def: string): string {
+    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);
+  }
+
+  private findMatchingParen(s: string, openIndex: number): number {
+    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;
+  }
+
+  private normalizeTriggerDef(def: string): string {
+    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);
+  }
+
   private normalizeCheckExpression(expr: string): string {
     let normalized = expr.replace(/\s+/g, ' ').trim();
     while (this.isWrappedByOuterParentheses(normalized)) {
@@ -949,10 +1202,16 @@ export class MigrationGenerator {
     return expr.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$/g, '\\$');
   }
 
-  private addCheckConstraint(table: string, constraintName: string, expression: string) {
+  private addCheckConstraint(
+    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})\`);`,
+      `await knex.raw(\`ALTER TABLE "${table}" ADD CONSTRAINT "${constraintName}" CHECK (${escaped})${deferrableClause}\`);`,
     );
     this.writer.blankLine();
   }
@@ -962,6 +1221,91 @@ export class MigrationGenerator {
     this.writer.blankLine();
   }
 
+  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 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 dropExcludeConstraint(table: string, constraintName: string) {
+    this.writer.writeLine(`await knex.raw('ALTER TABLE "${table}" DROP CONSTRAINT "${constraintName}"');`);
+    this.writer.blankLine();
+  }
+
+  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}`;
+  }
+
+  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}()`;
+    this.writer.writeLine(
+      `await knex.raw(\`CREATE CONSTRAINT TRIGGER "${constraintName}" ${entry.when} ${eventsStr} ON "${table}"${deferrableClause} FOR EACH ${entry.forEach} ${executeClause}\`);`,
+    );
+    this.writer.blankLine();
+  }
+
+  private dropConstraintTrigger(table: string, constraintName: string) {
+    this.writer.writeLine(`await knex.raw('ALTER TABLE "${table}" DROP CONSTRAINT "${constraintName}"');`);
+    this.writer.blankLine();
+  }
+
   private value(value: Value) {
     if (typeof value === 'string') {
       return `'${value}'`;

package/src/migrations/update-functions.ts

@@ -68,6 +68,7 @@ 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)
   `);
 
@@ -84,6 +85,7 @@ 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)
   `);
 

package/src/models/model-definitions.ts

@@ -165,7 +165,26 @@ export type ModelDefinition = {
        */
       manyToManyRelation?: boolean;
 
-      constraints?: { kind: 'check'; name: string; expression: string }[];
+      constraints?: (
+        | { kind: 'check'; name: string; expression: string; deferrable?: 'INITIALLY DEFERRED' | 'INITIALLY IMMEDIATE' }
+        | {
+            kind: 'exclude';
+            name: string;
+            using: 'gist';
+            elements: ({ column: string; operator: '=' } | { expression: string; operator: '&&' })[];
+            where?: string;
+            deferrable?: 'INITIALLY DEFERRED' | 'INITIALLY IMMEDIATE';
+          }
+        | {
+            kind: 'constraint_trigger';
+            name: string;
+            when: 'AFTER' | 'BEFORE';
+            events: ('INSERT' | 'UPDATE')[];
+            forEach: 'ROW' | 'STATEMENT';
+            deferrable?: 'INITIALLY DEFERRED' | 'INITIALLY IMMEDIATE';
+            function: { name: string; args?: string[] };
+          }
+      )[];
 
       // temporary fields for the generation of migrations
       deleted?: true;

package/src/models/models.ts

@@ -40,6 +40,7 @@ import {
   summonByName,
   typeToField,
   validateCheckConstraint,
+  validateExcludeConstraint,
 } from './utils';
 
 // These might one day become classes
@@ -357,7 +358,7 @@ export class EntityModel extends Model {
   defaultOrderBy?: OrderBy[];
   fields: EntityField[];
 
-  constraints?: { kind: 'check'; name: string; expression: string }[];
+  constraints?: EntityModelDefinition['constraints'];
 
   // temporary fields for the generation of migrations
   deleted?: true;
@@ -392,6 +393,8 @@ export class EntityModel extends Model {
       for (const constraint of this.constraints) {
         if (constraint.kind === 'check') {
           validateCheckConstraint(this, constraint);
+        } else if (constraint.kind === 'exclude') {
+          validateExcludeConstraint(this, constraint);
         }
       }
     }

package/src/models/utils.ts

@@ -259,3 +259,23 @@ export const validateCheckConstraint = (model: EntityModel, constraint: { name:
     }
   }
 };
+
+export const validateExcludeConstraint = (
+  model: EntityModel,
+  constraint: {
+    name: string;
+    elements: ({ column: string; operator: string } | { expression: string; operator: string })[];
+  },
+): void => {
+  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}`,
+        );
+      }
+    }
+  }
+};

package/tests/unit/constraints.spec.ts

@@ -1,7 +1,11 @@
 import { ModelDefinitions, Models } from '../../src/models';
-import { extractColumnReferencesFromCheckExpression, validateCheckConstraint } from '../../src/models/utils';
+import {
+  extractColumnReferencesFromCheckExpression,
+  validateCheckConstraint,
+  validateExcludeConstraint,
+} from '../../src/models/utils';
 
-describe('check constraints', () => {
+describe('constraints', () => {
   const modelDefinitions: ModelDefinitions = [
     {
       kind: 'entity',
@@ -80,4 +84,96 @@ describe('check constraints', () => {
       ).toThrow(/Valid columns:.*\bscore\b.*\bstatus\b/);
     });
   });
+
+  describe('validateExcludeConstraint', () => {
+    it('does not throw when column elements reference valid columns', () => {
+      expect(() =>
+        validateExcludeConstraint(productModel, {
+          name: 'valid',
+          elements: [
+            { column: 'score', operator: '=' },
+            { expression: 'tsrange("startDate", "endDate")', operator: '&&' },
+          ],
+        }),
+      ).not.toThrow();
+    });
+
+    it('does not throw when only expression elements', () => {
+      expect(() =>
+        validateExcludeConstraint(productModel, {
+          name: 'valid',
+          elements: [{ expression: 'tsrange(now(), now())', operator: '&&' }],
+        }),
+      ).not.toThrow();
+    });
+
+    it('uses relation column name when validating', () => {
+      expect(() =>
+        validateExcludeConstraint(productModel, {
+          name: 'valid',
+          elements: [{ column: 'parentId', operator: '=' }],
+        }),
+      ).not.toThrow();
+    });
+
+    it('throws when column element references missing column', () => {
+      expect(() =>
+        validateExcludeConstraint(productModel, {
+          name: 'bad',
+          elements: [{ column: 'unknown_column', operator: '=' }],
+        }),
+      ).toThrow(
+        /Exclude constraint "bad" references column "unknown_column" which does not exist on model Product/,
+      );
+    });
+  });
+
+  describe('exclude and constraint_trigger constraints', () => {
+    const allocationDefinitions: ModelDefinitions = [
+      {
+        kind: 'entity',
+        name: 'PortfolioAllocation',
+        fields: [
+          { name: 'portfolio', kind: 'relation', type: 'Portfolio', reverse: 'allocations' },
+          { name: 'startDate', type: 'DateTime' },
+          { name: 'endDate', type: 'DateTime' },
+          { name: 'deleted', type: 'Boolean', nonNull: true, defaultValue: false },
+        ],
+        constraints: [
+          {
+            kind: 'exclude',
+            name: 'no_overlap_per_portfolio',
+            using: 'gist',
+            elements: [
+              { column: 'portfolioId', operator: '=' },
+              {
+                expression: 'tsrange("startDate", COALESCE("endDate", \'infinity\'::timestamptz))',
+                operator: '&&',
+              },
+            ],
+            where: '"deleted" = false',
+            deferrable: 'INITIALLY DEFERRED',
+          },
+          {
+            kind: 'constraint_trigger',
+            name: 'contiguous_periods',
+            when: 'AFTER',
+            events: ['INSERT', 'UPDATE'],
+            forEach: 'ROW',
+            deferrable: 'INITIALLY DEFERRED',
+            function: { name: 'contiguous_periods_check' },
+          },
+        ],
+      },
+      {
+        kind: 'entity',
+        name: 'Portfolio',
+        fields: [{ name: 'name', type: 'String' }],
+      },
+    ];
+
+    it('constructs models with exclude and constraint_trigger without throwing', () => {
+      expect(() => new Models(allocationDefinitions)).not.toThrow();
+    });
+  });
 });