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

package/src/migrations/generate.ts

@@ -9,8 +9,8 @@ import {
   and,
   get,
   isCreatableModel,
-  isGenerateAsField,
   isInherited,
+  isStoredInDatabase,
   isUpdatableField,
   isUpdatableModel,
   modelNeedsTable,
@@ -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 -> exclude definition (normalized) */
+  private existingExcludeConstraints: Record<string, Map<string, string>> = {};
+  /** table name -> constraint name -> trigger definition (normalized) */
+  private existingConstraintTriggers: Record<string, Map<string, string>> = {};
   private uuidUsed?: boolean;
   private nowUsed?: boolean;
   public needsMigration = false;
@@ -83,9 +88,56 @@ 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, 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: { 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, this.normalizeTriggerDef(row.trigger_def));
+    }
+
     const up: Callbacks = [];
     const down: Callbacks = [];
 
+    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((enm) => !enums.includes(lowerFirst(enm.name))),
       up,
@@ -178,10 +230,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,35 +301,83 @@ export class MigrationGenerator {
           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 === undefined) {
-                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 === 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 existingDef = existingExcludeMap?.get(constraintName);
+                if (existingDef === undefined) {
+                  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 === undefined) {
+                  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();
+                  });
+                }
               }
             }
           }
@@ -299,9 +411,7 @@ export class MigrationGenerator {
                             writer.writeLine(`deleteRootId: row.deleteRootId,`);
                           }
 
-                          for (const { name, kind } of model.fields
-                            .filter(isUpdatableField)
-                            .filter(not(isGenerateAsField))) {
+                          for (const { name, kind } of model.fields.filter(and(isUpdatableField, isStoredInDatabase))) {
                             const col = kind === 'relation' ? `${name}Id` : name;
 
                             writer.writeLine(`${col}: row.${col},`);
@@ -332,11 +442,9 @@ export class MigrationGenerator {
             );
 
             const missingRevisionFields = model.fields
-              .filter(isUpdatableField)
-              .filter(not(isGenerateAsField))
+              .filter(and(isUpdatableField, isStoredInDatabase))
               .filter(
                 ({ name, ...field }) =>
-                  field.kind !== 'custom' &&
                   !this.getColumn(revisionTable, field.kind === 'relation' ? field.foreignKey || `${name}Id` : name),
               );
 
@@ -535,7 +643,7 @@ export class MigrationGenerator {
     });
 
     if (isUpdatableModel(model)) {
-      const updatableFields = fields.filter(isUpdatableField).filter(not(isGenerateAsField));
+      const updatableFields = fields.filter(and(isUpdatableField, isStoredInDatabase));
       if (!updatableFields.length) {
         return;
       }
@@ -589,7 +697,7 @@ export class MigrationGenerator {
     });
 
     if (isUpdatableModel(model)) {
-      const updatableFields = fields.filter(isUpdatableField).filter(not(isGenerateAsField));
+      const updatableFields = fields.filter(and(isUpdatableField, isStoredInDatabase));
       if (!updatableFields.length) {
         return;
       }
@@ -633,7 +741,7 @@ export class MigrationGenerator {
         }
       }
 
-      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 });
       }
     });
@@ -762,7 +870,7 @@ 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}`;
   }
 
@@ -770,15 +878,37 @@ export class MigrationGenerator {
     return expr.replace(/\s+/g, ' ').trim();
   }
 
+  private normalizeExcludeDef(def: string): string {
+    return def
+      .replace(/\s+/g, ' ')
+      .replace(/\s*\(\s*/g, '(')
+      .replace(/\s*\)\s*/g, ')')
+      .trim();
+  }
+
+  private normalizeTriggerDef(def: string): string {
+    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 */
   private escapeExpressionForRaw(expr: string): string {
     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();
   }
@@ -788,6 +918,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}" FOR EACH ${entry.forEach}${deferrableClause} ${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}" FOR EACH ${entry.forEach}${deferrableClause} ${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/index.ts

@@ -1,5 +1,6 @@
 // created from 'create-ts-index'
 
-export * from './generate';
 export * from './generate-functions';
+export * from './generate';
+export * from './types';
 export * from './update-functions';

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

@@ -59,9 +59,9 @@ export const isInputModel = (model: Model): model is InputModel => model instanc
 
 export const isInterfaceModel = (model: Model): model is InterfaceModel => model instanceof InterfaceModel;
 
-export const isCreatableModel = (model: EntityModel) => model.creatable && model.fields.some(isCreatableField);
+export const isCreatableModel = (model: EntityModel) => !!model.creatable && model.fields.some(isCreatableField);
 
-export const isUpdatableModel = (model: EntityModel) => model.updatable && model.fields.some(isUpdatableField);
+export const isUpdatableModel = (model: EntityModel) => !!model.updatable && model.fields.some(isUpdatableField);
 
 export const isCreatableField = (field: EntityField) => !field.inherited && !!field.creatable;
 
@@ -88,19 +88,18 @@ export const isQueriableField = ({ queriable }: EntityField) => queriable !== fa
 
 export const isCustomField = (field: EntityField): field is CustomField => field.kind === 'custom';
 
-/** True if field is computed (generateAs); not user-settable in insert/update. */
-export const isGenerateAsField = (field: EntityField) => !!field.generateAs;
+export const isDynamicField = (field: EntityField) => !!field.generateAs || isCustomField(field);
 
-/** True if field exists as a column in the DB (excludes expression-only fields). */
-export const isStoredInDatabase = (field: EntityField) => field.generateAs?.type !== 'expression';
+/** True if field exists as a column in the DB (excludes custom and expression-only fields). */
+export const isStoredInDatabase = (field: EntityField) => !isCustomField(field) && field.generateAs?.type !== 'expression';
 
 export const isVisible = ({ hidden }: EntityField) => hidden !== true;
 
 export const isSimpleField = and(not(isRelation), not(isCustomField));
 
-export const isUpdatable = ({ updatable }: EntityField) => !!updatable;
+export const isUpdatable = ({ updatable }: EntityField | EntityModel) => !!updatable;
 
-export const isCreatable = ({ creatable }: EntityField) => !!creatable;
+export const isCreatable = ({ creatable }: EntityField | EntityModel) => !!creatable;
 
 export const isQueriableBy = (role: string) => (field: EntityField) =>
   field.queriable !== false &&
@@ -260,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/src/permissions/check.ts

@@ -2,7 +2,7 @@ import { Knex } from 'knex';
 import { FullContext } from '../context';
 import { NotFoundError, PermissionError } from '../errors';
 import { EntityModel } from '../models/models';
-import { get, isGenerateAsField, isRelation, not } from '../models/utils';
+import { get, isRelation, isStoredInDatabase } from '../models/utils';
 import { AliasGenerator, getColumnName, hash, ors } from '../resolvers/utils';
 import { PermissionAction, PermissionLink, PermissionStack } from './generate';
 
@@ -156,7 +156,7 @@ export const checkCanWrite = async (
   let linked = false;
 
   for (const field of model.fields
-    .filter(not(isGenerateAsField))
+    .filter(isStoredInDatabase)
     .filter((field) => field.generated || (action === 'CREATE' ? field.creatable : field.updatable))) {
     const fieldPermissions = field[action === 'CREATE' ? 'creatable' : 'updatable'];
     const role = getRole(ctx);

package/src/resolvers/mutations.ts

@@ -4,7 +4,7 @@ import { Context } from '../context';
 import { ForbiddenError, GraphQLError } from '../errors';
 import { EntityField, EntityModel } from '../models/models';
 import { Entity, MutationContext, Trigger } from '../models/mutation-hook';
-import { get, isGenerateAsField, isPrimitive, it, not, typeToField } from '../models/utils';
+import { and, get, isDynamicField, isPrimitive, isUpdatableField, it, not, typeToField } from '../models/utils';
 import { applyPermissions, checkCanWrite, getEntityToMutate } from '../permissions/check';
 import { anyDateToLuxon } from '../utils';
 import { resolve } from './resolver';
@@ -87,7 +87,7 @@ export const createEntity = async (
     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) {
@@ -101,7 +101,7 @@ export const createEntity = async (
       await ctx.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];
       }
@@ -560,7 +560,7 @@ export const createRevision = async (model: EntityModel, data: Entity, ctx: Muta
     }
     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 value;
       if (field.nonNull && (!(col in data) || col === undefined || col === null)) {
@@ -636,7 +636,7 @@ const doUpdate = async (model: EntityModel, currentEntity: Entity, update: Entit
   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) {
@@ -654,7 +654,7 @@ const doUpdate = async (model: EntityModel, currentEntity: Entity, update: Entit
     }
   } 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];
     }

package/src/resolvers/resolvers.ts

@@ -1,5 +1,5 @@
 import { Models } from '../models/models';
-import { isRootModel, merge, not, typeToField } from '../models/utils';
+import { and, isCreatable, isRootModel, isUpdatable, merge, not, typeToField } from '../models/utils';
 import { mutationResolver } from './mutations';
 import { queryResolver } from './resolver';
 
@@ -27,18 +27,12 @@ export const getResolvers = (models: Models) => {
     ]),
   };
   const mutations = [
-    ...models.entities
-      .filter(not(isRootModel))
-      .filter(({ creatable }) => creatable)
-      .map((model) => ({
-        [`create${model.name}`]: mutationResolver,
-      })),
-    ...models.entities
-      .filter(not(isRootModel))
-      .filter(({ updatable }) => updatable)
-      .map((model) => ({
-        [`update${model.name}`]: mutationResolver,
-      })),
+    ...models.entities.filter(and(not(isRootModel), isCreatable)).map((model) => ({
+      [`create${model.name}`]: mutationResolver,
+    })),
+    ...models.entities.filter(and(not(isRootModel), isUpdatable)).map((model) => ({
+      [`update${model.name}`]: mutationResolver,
+    })),
     ...models.entities
       .filter(not(isRootModel))
       .filter(({ deletable }) => deletable)