@smartive/graphql-magic 23.6.1-next.2 → 23.7.0-next.1

package/.gqmrc.json

@@ -4,5 +4,6 @@
   "graphqlQueriesPath": "tests",
   "gqmModule": "../../../src",
   "knexfilePath": "knexfile.ts",
-  "dateLibrary": "luxon"
+  "dateLibrary": "luxon",
+  "functionsPath": "tests/functions.ts"
 }

package/CHANGELOG.md

@@ -1,5 +1,5 @@
-## [23.6.1-next.2](https://github.com/smartive/graphql-magic/compare/v23.6.1-next.1...v23.6.1-next.2) (2026-02-24)
+## [23.7.0-next.1](https://github.com/smartive/graphql-magic/compare/v23.6.1...v23.7.0-next.1) (2026-03-04)
 
-### Bug Fixes
+### Features
 
-* Correct mock module name in unit tests for generateAs functionality ([bcf21db](https://github.com/smartive/graphql-magic/commit/bcf21dbcd083340cb07bf10080f6390f4b370bc2))
+* Exclude constraints and triggers ([f399d34](https://github.com/smartive/graphql-magic/commit/f399d3489c82cba7c043d03139db2da965c5a74a))

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);
         }
       }
     }
@@ -558,8 +560,8 @@ var getLabel = (s) => (0, import_startCase.default)((0, import_camelCase.default
 var and = (...predicates) => (field) => predicates.every((predicate) => predicate(field));
 var not = (predicate) => (field) => !predicate(field);
 var isRootModel = (model) => !!model.root;
-var isCreatableModel = (model) => model.creatable && model.fields.some(isCreatableField);
-var isUpdatableModel = (model) => model.updatable && model.fields.some(isUpdatableField);
+var isCreatableModel = (model) => !!model.creatable && model.fields.some(isCreatableField);
+var isUpdatableModel = (model) => !!model.updatable && model.fields.some(isUpdatableField);
 var isCreatableField = (field) => !field.inherited && !!field.creatable;
 var isUpdatableField = (field) => !field.inherited && !!field.updatable;
 var modelNeedsTable = (model) => model.fields.some((field) => !field.inherited);
@@ -568,9 +570,11 @@ var isInherited = (field) => !!field.inherited;
 var isInTable = (field) => field.name === "id" || !field.inherited;
 var isQueriableField = ({ queriable }) => queriable !== false;
 var isCustomField = (field) => field.kind === "custom";
-var isGenerateAsField = (field) => !!field.generateAs;
-var isStoredInDatabase = (field) => field.generateAs?.type !== "expression";
+var isDynamicField = (field) => !!field.generateAs || isCustomField(field);
+var isStoredInDatabase = (field) => !isCustomField(field) && field.generateAs?.type !== "expression";
 var isSimpleField = and(not(isRelation), not(isCustomField));
+var isUpdatable = ({ updatable }) => !!updatable;
+var isCreatable = ({ creatable }) => !!creatable;
 var summonByName = (array, value2) => summonByKey(array, "name", value2);
 var summonByKey = (array, key, value2) => summon(array, (element) => (0, import_get.default)(element, key) === value2, `No element found with ${key} ${value2}`);
 var summon = (array, cb, errorMessage) => {
@@ -642,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);
@@ -696,12 +713,12 @@ var generateDBModels = (models, dateLibrary) => {
   for (const model of models.entities) {
     const fields2 = model.relations.some((relation) => relation.field.foreignKey === "id") ? model.fields.filter((field) => field.name !== "id") : model.fields;
     writer.write(`export type ${model.name} = `).inlineBlock(() => {
-      for (const field of fields2.filter(not(isCustomField)).filter(isStoredInDatabase)) {
+      for (const field of fields2.filter(isStoredInDatabase)) {
         writer.write(`'${getColumnName(field)}': ${getFieldType(field, dateLibrary)}${field.nonNull ? "" : " | null"};`).newLine();
       }
     }).blankLine();
     writer.write(`export type ${model.name}Initializer = `).inlineBlock(() => {
-      for (const field of fields2.filter(not(isCustomField)).filter(isInTable).filter(not(isGenerateAsField))) {
+      for (const field of fields2.filter(and(isInTable, not(isDynamicField)))) {
         writer.write(
           `'${getColumnName(field)}'${field.nonNull && field.defaultValue === void 0 ? "" : "?"}: ${getFieldType(
             field,
@@ -712,7 +729,7 @@ var generateDBModels = (models, dateLibrary) => {
       }
     }).blankLine();
     writer.write(`export type ${model.name}Mutator = `).inlineBlock(() => {
-      for (const field of fields2.filter(not(isCustomField)).filter(isInTable).filter(not(isGenerateAsField))) {
+      for (const field of fields2.filter(and(isInTable, not(isDynamicField)))) {
         writer.write(
           `'${getColumnName(field)}'?: ${getFieldType(field, dateLibrary, true)}${field.list ? " | string" : ""}${field.nonNull ? "" : " | null"};`
         ).newLine();
@@ -720,7 +737,7 @@ var generateDBModels = (models, dateLibrary) => {
     }).blankLine();
     if (!isRootModel(model)) {
       writer.write(`export type ${model.name}Seed = `).inlineBlock(() => {
-        for (const field of fields2.filter(not(isCustomField)).filter(not(isGenerateAsField))) {
+        for (const field of fields2.filter(not(isDynamicField))) {
           if (model.parent && field.name === "type") {
             continue;
           }
@@ -781,6 +798,75 @@ var generateKnexTables = (models) => {
   return writer.toString();
 };
 
+// src/migrations/generate-functions.ts
+var generateFunctionsFromDatabase = async (knex2) => {
+  const regularFunctions = await knex2.raw(`
+    SELECT 
+      pg_get_functiondef(p.oid) as definition
+    FROM pg_proc p
+    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)
+    ORDER BY p.proname, pg_get_function_identity_arguments(p.oid)
+  `);
+  const aggregateFunctions = await knex2.raw(`
+    SELECT 
+      p.proname as name,
+      pg_get_function_identity_arguments(p.oid) as arguments,
+      a.aggtransfn::regproc::text as trans_func,
+      a.aggfinalfn::regproc::text as final_func,
+      a.agginitval as init_val,
+      pg_catalog.format_type(a.aggtranstype, NULL) as state_type
+    FROM pg_proc p
+    JOIN pg_aggregate a ON p.oid = a.aggfnoid
+    JOIN pg_namespace n ON p.pronamespace = n.oid
+    WHERE n.nspname = 'public'
+    ORDER BY p.proname, pg_get_function_identity_arguments(p.oid)
+  `);
+  const functions = [];
+  for (const row of regularFunctions.rows || []) {
+    if (row.definition) {
+      functions.push(row.definition.trim());
+    }
+  }
+  for (const row of aggregateFunctions.rows || []) {
+    const name2 = row.name || "";
+    const argumentsStr = row.arguments || "";
+    const transFunc = row.trans_func || "";
+    const finalFunc = row.final_func || "";
+    const initVal = row.init_val;
+    const stateType = row.state_type || "";
+    if (!name2 || !transFunc || !stateType) {
+      continue;
+    }
+    let aggregateDef = `CREATE AGGREGATE ${name2}(${argumentsStr}) (
+`;
+    aggregateDef += `  SFUNC = ${transFunc},
+`;
+    aggregateDef += `  STYPE = ${stateType}`;
+    if (finalFunc) {
+      aggregateDef += `,
+  FINALFUNC = ${finalFunc}`;
+    }
+    if (initVal !== null && initVal !== void 0) {
+      const initValStr = typeof initVal === "string" ? `'${initVal}'` : String(initVal);
+      aggregateDef += `,
+  INITCOND = ${initValStr}`;
+    }
+    aggregateDef += "\n);";
+    functions.push(aggregateDef);
+  }
+  if (functions.length === 0) {
+    return `export const functions: string[] = [];
+`;
+  }
+  const functionsArrayString = functions.map((func) => `  ${JSON.stringify(func)}`).join(",\n");
+  return `export const functions: string[] = [
+${functionsArrayString},
+];
+`;
+};
+
 // src/migrations/generate.ts
 var import_code_block_writer2 = __toESM(require("code-block-writer"), 1);
 var import_knex_schema_inspector = require("knex-schema-inspector");
@@ -1013,6 +1099,10 @@ var MigrationGenerator = class {
   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;
@@ -1040,8 +1130,46 @@ 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, 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 needsBtreeGist = models.entities.some(
+      (model) => model.constraints?.some((c) => c.kind === "exclude" && c.elements.some((el) => "column" in el && el.operator === "="))
+    );
+    if (needsBtreeGist) {
+      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,
@@ -1120,10 +1248,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);
                 });
               }
             }
@@ -1163,33 +1303,81 @@ var MigrationGenerator = class {
           );
           this.updateFields(model, existingFields, up, down);
           if (model.constraints?.length) {
-            const existingMap = this.existingCheckConstraints[model.name];
+            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.getCheckConstraintName(model, entry, i);
-              const newExpression = entry.expression;
-              const existingExpression = existingMap?.get(constraintName);
-              if (existingExpression === void 0) {
-                up.push(() => {
-                  this.addCheckConstraint(table, constraintName, newExpression);
-                });
-                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);
-                });
-                down.push(() => {
-                  this.dropCheckConstraint(table, constraintName);
-                  this.addCheckConstraint(table, constraintName, existingExpression);
-                });
+              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();
+                  });
+                }
               }
             }
           }
@@ -1215,7 +1403,7 @@ var MigrationGenerator = class {
                         writer.writeLine(`deleteRootType: row.deleteRootType,`);
                         writer.writeLine(`deleteRootId: row.deleteRootId,`);
                       }
-                      for (const { name: name2, kind } of model.fields.filter(isUpdatableField).filter(not(isGenerateAsField))) {
+                      for (const { name: name2, kind } of model.fields.filter(and(isUpdatableField, isStoredInDatabase))) {
                         const col = kind === "relation" ? `${name2}Id` : name2;
                         writer.writeLine(`${col}: row.${col},`);
                       }
@@ -1235,8 +1423,8 @@ var MigrationGenerator = class {
               up,
               down
             );
-            const missingRevisionFields = model.fields.filter(isUpdatableField).filter(not(isGenerateAsField)).filter(
-              ({ name: name2, ...field }) => field.kind !== "custom" && !this.getColumn(revisionTable, field.kind === "relation" ? field.foreignKey || `${name2}Id` : name2)
+            const missingRevisionFields = model.fields.filter(and(isUpdatableField, isStoredInDatabase)).filter(
+              ({ name: name2, ...field }) => !this.getColumn(revisionTable, field.kind === "relation" ? field.foreignKey || `${name2}Id` : name2)
             );
             this.createRevisionFields(model, missingRevisionFields, up, down);
             const revisionFieldsToRemove = model.fields.filter(
@@ -1394,7 +1582,7 @@ var MigrationGenerator = class {
       });
     });
     if (isUpdatableModel(model)) {
-      const updatableFields = fields2.filter(isUpdatableField).filter(not(isGenerateAsField));
+      const updatableFields = fields2.filter(and(isUpdatableField, isStoredInDatabase));
       if (!updatableFields.length) {
         return;
       }
@@ -1442,7 +1630,7 @@ var MigrationGenerator = class {
       });
     });
     if (isUpdatableModel(model)) {
-      const updatableFields = fields2.filter(isUpdatableField).filter(not(isGenerateAsField));
+      const updatableFields = fields2.filter(and(isUpdatableField, isStoredInDatabase));
       if (!updatableFields.length) {
         return;
       }
@@ -1480,7 +1668,7 @@ var MigrationGenerator = class {
           writer.writeLine(`table.uuid('deleteRootId');`);
         }
       }
-      for (const field of model.fields.filter(and(isUpdatableField, not(isInherited))).filter(not(isGenerateAsField))) {
+      for (const field of model.fields.filter(and(isUpdatableField, not(isInherited), isStoredInDatabase))) {
         this.column(field, { setUnique: false, setDefault: false });
       }
     });
@@ -1564,20 +1752,27 @@ 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}`;
   }
   normalizeCheckExpression(expr) {
     return expr.replace(/\s+/g, " ").trim();
   }
+  normalizeExcludeDef(def) {
+    return def.replace(/\s+/g, " ").replace(/\s*\(\s*/g, "(").replace(/\s*\)\s*/g, ")").trim();
+  }
+  normalizeTriggerDef(def) {
+    return def.replace(/\s+/g, " ").replace(/\s*\(\s*/g, "(").replace(/\s*\)\s*/g, ")").trim();
+  }
   /** 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) {
+  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();
   }
@@ -1585,6 +1780,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}" FOR EACH ${entry.forEach}${deferrableClause} ${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}" FOR EACH ${entry.forEach}${deferrableClause} ${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}'`;
@@ -1922,75 +2154,6 @@ var getMigrationDate = () => {
   return `${year}${month}${day}${hours}${minutes}${seconds}`;
 };
 
-// src/migrations/generate-functions.ts
-var generateFunctionsFromDatabase = async (knex2) => {
-  const regularFunctions = await knex2.raw(`
-    SELECT 
-      pg_get_functiondef(p.oid) as definition
-    FROM pg_proc p
-    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)
-    ORDER BY p.proname, pg_get_function_identity_arguments(p.oid)
-  `);
-  const aggregateFunctions = await knex2.raw(`
-    SELECT 
-      p.proname as name,
-      pg_get_function_identity_arguments(p.oid) as arguments,
-      a.aggtransfn::regproc::text as trans_func,
-      a.aggfinalfn::regproc::text as final_func,
-      a.agginitval as init_val,
-      pg_catalog.format_type(a.aggtranstype, NULL) as state_type
-    FROM pg_proc p
-    JOIN pg_aggregate a ON p.oid = a.aggfnoid
-    JOIN pg_namespace n ON p.pronamespace = n.oid
-    WHERE n.nspname = 'public'
-    ORDER BY p.proname, pg_get_function_identity_arguments(p.oid)
-  `);
-  const functions = [];
-  for (const row of regularFunctions.rows || []) {
-    if (row.definition) {
-      functions.push(row.definition.trim());
-    }
-  }
-  for (const row of aggregateFunctions.rows || []) {
-    const name2 = row.name || "";
-    const argumentsStr = row.arguments || "";
-    const transFunc = row.trans_func || "";
-    const finalFunc = row.final_func || "";
-    const initVal = row.init_val;
-    const stateType = row.state_type || "";
-    if (!name2 || !transFunc || !stateType) {
-      continue;
-    }
-    let aggregateDef = `CREATE AGGREGATE ${name2}(${argumentsStr}) (
-`;
-    aggregateDef += `  SFUNC = ${transFunc},
-`;
-    aggregateDef += `  STYPE = ${stateType}`;
-    if (finalFunc) {
-      aggregateDef += `,
-  FINALFUNC = ${finalFunc}`;
-    }
-    if (initVal !== null && initVal !== void 0) {
-      const initValStr = typeof initVal === "string" ? `'${initVal}'` : String(initVal);
-      aggregateDef += `,
-  INITCOND = ${initValStr}`;
-    }
-    aggregateDef += "\n);";
-    functions.push(aggregateDef);
-  }
-  if (functions.length === 0) {
-    return `export const functions: string[] = [];
-`;
-  }
-  const functionsArrayString = functions.map((func) => `  ${JSON.stringify(func)}`).join(",\n");
-  return `export const functions: string[] = [
-${functionsArrayString},
-];
-`;
-};
-
 // src/permissions/generate.ts
 var ACTIONS = ["READ", "CREATE", "UPDATE", "DELETE", "RESTORE", "LINK"];
 
@@ -2255,7 +2418,7 @@ var generateDefinitions = ({
           types.push(
             input(
               `Create${model.name}`,
-              model.fields.filter(({ creatable }) => creatable).filter(not(isGenerateAsField)).map(
+              model.fields.filter(and(isCreatable, isStoredInDatabase)).map(
                 (field) => field.kind === "relation" ? { name: `${field.name}Id`, type: "ID", nonNull: field.nonNull } : {
                   name: field.name,
                   type: field.kind === "json" ? `Create${field.type}` : field.type,
@@ -2270,7 +2433,7 @@ var generateDefinitions = ({
           types.push(
             input(
               `Update${model.name}`,
-              model.fields.filter(({ updatable }) => updatable).filter(not(isGenerateAsField)).map(
+              model.fields.filter(and(isUpdatable, isStoredInDatabase)).map(
                 (field) => field.kind === "relation" ? { name: `${field.name}Id`, type: "ID" } : {
                   name: field.name,
                   type: field.kind === "json" ? `Update${field.type}` : field.type,