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

package/dist/cjs/index.cjs

@@ -133,12 +133,12 @@ __export(index_exports, {
   isCreatableField: () => isCreatableField,
   isCreatableModel: () => isCreatableModel,
   isCustomField: () => isCustomField,
+  isDynamicField: () => isDynamicField,
   isEntityModel: () => isEntityModel,
   isEnum: () => isEnum,
   isEnumModel: () => isEnumModel,
   isFieldNode: () => isFieldNode,
   isFragmentSpreadNode: () => isFragmentSpreadNode,
-  isGenerateAsField: () => isGenerateAsField,
   isInTable: () => isInTable,
   isInherited: () => isInherited,
   isInlineFragmentNode: () => isInlineFragmentNode,
@@ -198,6 +198,7 @@ __export(index_exports, {
   updateEntity: () => updateEntity,
   updateFunctions: () => updateFunctions,
   validateCheckConstraint: () => validateCheckConstraint,
+  validateExcludeConstraint: () => validateExcludeConstraint,
   value: () => value
 });
 module.exports = __toCommonJS(index_exports);
@@ -654,6 +655,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);
         }
       }
     }
@@ -833,8 +836,8 @@ var isScalarModel = (model) => model instanceof ScalarModel;
 var isObjectModel = (model) => model instanceof ObjectModel;
 var isInputModel = (model) => model instanceof InputModel;
 var isInterfaceModel = (model) => model instanceof InterfaceModel;
-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);
@@ -847,8 +850,8 @@ var isInTable = (field) => field.name === "id" || !field.inherited;
 var isToOneRelation = (field) => isRelation(field) && !!field.toOne;
 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 isVisible = ({ hidden }) => hidden !== true;
 var isSimpleField = and(not(isRelation), not(isCustomField));
 var isUpdatable = ({ updatable }) => !!updatable;
@@ -952,6 +955,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/client/queries.ts
 var fieldIsSearchable = (model, fieldName) => {
@@ -1072,12 +1088,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,
@@ -1088,7 +1104,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();
@@ -1096,7 +1112,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;
           }
@@ -1157,6 +1173,75 @@ var generateKnexTables = (models) => {
   return writer.toString();
 };
 
+// src/migrations/generate-functions.ts
+var generateFunctionsFromDatabase = async (knex) => {
+  const regularFunctions = await knex.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 knex.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");
@@ -1790,7 +1875,7 @@ var checkCanWrite = async (ctx, model, data, action) => {
   }
   const query = ctx.knex.first();
   let linked = false;
-  for (const field of model.fields.filter(not(isGenerateAsField)).filter((field2) => field2.generated || (action === "CREATE" ? field2.creatable : field2.updatable))) {
+  for (const field of model.fields.filter(isStoredInDatabase).filter((field2) => field2.generated || (action === "CREATE" ? field2.creatable : field2.updatable))) {
     const fieldPermissions = field[action === "CREATE" ? "creatable" : "updatable"];
     const role2 = getRole(ctx);
     if (getColumnName(field) in data && fieldPermissions && typeof fieldPermissions === "object" && !fieldPermissions.roles?.includes(role2)) {
@@ -2302,7 +2387,7 @@ var createEntity = async (modelName, input2, ctx, trigger = "direct-call") => wi
   if (model.parent) {
     const rootInput = {};
     const childInput = { id };
-    for (const field of model.fields.filter(not(isGenerateAsField))) {
+    for (const field of model.fields.filter(not(isDynamicField))) {
       const columnName = field.kind === "relation" ? `${field.name}Id` : field.name;
       if (columnName in normalizedInput) {
         if (field.inherited) {
@@ -2316,7 +2401,7 @@ var createEntity = async (modelName, input2, ctx, trigger = "direct-call") => wi
     await ctx2.knex(model.name).insert(childInput);
   } else {
     const insertData = { ...normalizedInput };
-    for (const field of model.fields.filter(isGenerateAsField)) {
+    for (const field of model.fields.filter(isDynamicField)) {
       const columnName = field.kind === "relation" ? `${field.name}Id` : field.name;
       delete insertData[columnName];
     }
@@ -2682,7 +2767,7 @@ var createRevision = async (model, data, ctx) => {
       rootRevisionData.deleted = data.deleted || false;
     }
     const childRevisionData = { id: revisionId };
-    for (const field of model.fields.filter(({ updatable }) => updatable).filter(not(isGenerateAsField))) {
+    for (const field of model.fields.filter(and(isUpdatableField, not(isDynamicField)))) {
       const col = field.kind === "relation" ? `${field.name}Id` : field.name;
       let value2;
       if (field.nonNull && (!(col in data) || col === void 0 || col === null)) {
@@ -2746,7 +2831,7 @@ var doUpdate = async (model, currentEntity, update, ctx) => {
   if (model.parent) {
     const rootInput = {};
     const childInput = {};
-    for (const field of model.fields.filter(not(isGenerateAsField))) {
+    for (const field of model.fields.filter(not(isDynamicField))) {
       const columnName = field.kind === "relation" ? `${field.name}Id` : field.name;
       if (columnName in update) {
         if (field.inherited) {
@@ -2764,7 +2849,7 @@ var doUpdate = async (model, currentEntity, update, ctx) => {
     }
   } else {
     const updateData = { ...update };
-    for (const field of model.fields.filter(isGenerateAsField)) {
+    for (const field of model.fields.filter(isDynamicField)) {
       const columnName = field.kind === "relation" ? `${field.name}Id` : field.name;
       delete updateData[columnName];
     }
@@ -2792,10 +2877,10 @@ var getResolvers = (models) => {
     ])
   };
   const mutations = [
-    ...models.entities.filter(not(isRootModel)).filter(({ creatable }) => creatable).map((model) => ({
+    ...models.entities.filter(and(not(isRootModel), isCreatable)).map((model) => ({
       [`create${model.name}`]: mutationResolver
     })),
-    ...models.entities.filter(not(isRootModel)).filter(({ updatable }) => updatable).map((model) => ({
+    ...models.entities.filter(and(not(isRootModel), isUpdatable)).map((model) => ({
       [`update${model.name}`]: mutationResolver
     })),
     ...models.entities.filter(not(isRootModel)).filter(({ deletable }) => deletable).map((model) => ({
@@ -3029,6 +3114,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;
@@ -3056,8 +3145,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,
@@ -3136,10 +3263,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.addCheckConstraint(table, constraintName, expression);
+                  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);
                 });
               }
             }
@@ -3179,33 +3318,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();
+                  });
+                }
               }
             }
           }
@@ -3231,7 +3418,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},`);
                       }
@@ -3251,8 +3438,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(
@@ -3410,7 +3597,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;
       }
@@ -3458,7 +3645,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;
       }
@@ -3496,7 +3683,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 });
       }
     });
@@ -3580,20 +3767,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();
   }
@@ -3601,6 +3795,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}'`;
@@ -3938,75 +4169,6 @@ var getMigrationDate = () => {
   return `${year}${month}${day}${hours}${minutes}${seconds}`;
 };
 
-// src/migrations/generate-functions.ts
-var generateFunctionsFromDatabase = async (knex) => {
-  const regularFunctions = await knex.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 knex.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"];
 var generatePermissions = (models, config) => {
@@ -4364,7 +4526,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,
@@ -4379,7 +4541,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,
@@ -4631,12 +4793,12 @@ var printSchemaFromModels = (models) => printSchema((0, import_graphql6.buildAST
   isCreatableField,
   isCreatableModel,
   isCustomField,
+  isDynamicField,
   isEntityModel,
   isEnum,
   isEnumModel,
   isFieldNode,
   isFragmentSpreadNode,
-  isGenerateAsField,
   isInTable,
   isInherited,
   isInlineFragmentNode,
@@ -4696,5 +4858,6 @@ var printSchemaFromModels = (models) => printSchema((0, import_graphql6.buildAST
   updateEntity,
   updateFunctions,
   validateCheckConstraint,
+  validateExcludeConstraint,
   value
 });