@smartive/graphql-magic 5.1.2 → 7.0.0

package/src/migrations/generate.ts

@@ -131,9 +131,9 @@ export class MigrationGenerator {
           model,
           model.fields.filter(
             ({ name, ...field }) =>
-              field.type !== 'raw' &&
+              field.kind !== 'raw' &&
               !this.columns[model.name].some(
-                (col) => col.name === (field.type === 'relation' ? field.foreignKey || `${name}Id` : name)
+                (col) => col.name === (field.kind === 'relation' ? field.foreignKey || `${name}Id` : name)
               )
           ),
           up,
@@ -141,8 +141,8 @@ export class MigrationGenerator {
         );
 
         // Update fields
-        const existingFields = model.fields.filter(({ name, type, nonNull }) => {
-          const col = this.columns[model.name].find((col) => col.name === (type === 'relation' ? `${name}Id` : name));
+        const existingFields = model.fields.filter(({ name, kind, nonNull }) => {
+          const col = this.columns[model.name].find((col) => col.name === (kind === 'relation' ? `${name}Id` : name));
           if (!col) {
             return false;
           }
@@ -177,8 +177,8 @@ export class MigrationGenerator {
                           writer.writeLine(`deleted: row.deleted,`);
                         }
 
-                        for (const { name, type } of model.fields.filter(({ updatable }) => updatable)) {
-                          const col = type === 'relation' ? `${name}Id` : name;
+                        for (const { name, kind } of model.fields.filter(({ updatable }) => updatable)) {
+                          const col = kind === 'relation' ? `${name}Id` : name;
 
                           writer.writeLine(`${col}: row.${col},`);
                         }
@@ -198,10 +198,10 @@ export class MigrationGenerator {
           const revisionTable = `${model.name}Revision`;
           const missingRevisionFields = model.fields.filter(
             ({ name, updatable, ...field }) =>
-              field.type !== 'raw' &&
+              field.kind !== 'raw' &&
               updatable &&
               !this.columns[revisionTable].some(
-                (col) => col.name === (field.type === 'relation' ? field.foreignKey || `${name}Id` : name)
+                (col) => col.name === (field.kind === 'relation' ? field.foreignKey || `${name}Id` : name)
               )
           );
 
@@ -210,11 +210,11 @@ export class MigrationGenerator {
           const revisionFieldsToRemove = model.fields.filter(
             ({ name, updatable, generated, ...field }) =>
               !generated &&
-              field.type !== 'raw' &&
+              field.kind !== 'raw' &&
               !updatable &&
-              !(field.type === 'relation' && field.foreignKey === 'id') &&
+              !(field.kind === 'relation' && field.foreignKey === 'id') &&
               this.columns[revisionTable].some(
-                (col) => col.name === (field.type === 'relation' ? field.foreignKey || `${name}Id` : name)
+                (col) => col.name === (field.kind === 'relation' ? field.foreignKey || `${name}Id` : name)
               )
           );
           this.createRevisionFields(model, revisionFieldsToRemove, down, up);
@@ -276,8 +276,8 @@ export class MigrationGenerator {
       for (const field of fields) {
         this.alterTable(model.name, () => {
           this.renameColumn(
-            field.type === 'relation' ? `${field.oldName}Id` : get(field, 'oldName'),
-            field.type === 'relation' ? `${field.name}Id` : field.name
+            field.kind === 'relation' ? `${field.oldName}Id` : get(field, 'oldName'),
+            field.kind === 'relation' ? `${field.name}Id` : field.name
           );
         });
       }
@@ -287,8 +287,8 @@ export class MigrationGenerator {
       for (const field of fields) {
         this.alterTable(model.name, () => {
           this.renameColumn(
-            field.type === 'relation' ? `${field.name}Id` : field.name,
-            field.type === 'relation' ? `${field.oldName}Id` : get(field, 'oldName')
+            field.kind === 'relation' ? `${field.name}Id` : field.name,
+            field.kind === 'relation' ? `${field.oldName}Id` : get(field, 'oldName')
           );
         });
       }
@@ -296,8 +296,8 @@ export class MigrationGenerator {
 
     for (const field of fields) {
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      summonByName(this.columns[model.name]!, field.type === 'relation' ? `${field.oldName!}Id` : field.oldName!).name =
-        field.type === 'relation' ? `${field.name}Id` : field.name;
+      summonByName(this.columns[model.name]!, field.kind === 'relation' ? `${field.oldName!}Id` : field.oldName!).name =
+        field.kind === 'relation' ? `${field.name}Id` : field.name;
     }
   }
 
@@ -311,10 +311,10 @@ export class MigrationGenerator {
       const updates: Callbacks = [];
       const postAlter: Callbacks = [];
       for (const field of fields) {
-        alter.push(() => this.column(field, { setNonNull: field.default !== undefined }));
+        alter.push(() => this.column(field, { setNonNull: field.defaultValue !== undefined }));
 
         // If the field is not nullable but has no default, write placeholder code
-        if (field.nonNull && field.default === undefined) {
+        if (field.nonNull && field.defaultValue === undefined) {
           updates.push(() => this.writer.write(`${field.name}: 'TODO',`).newLine());
           postAlter.push(() => this.column(field, { alter: true, foreign: false }));
         }
@@ -343,8 +343,8 @@ export class MigrationGenerator {
 
     down.push(() => {
       this.alterTable(model.name, () => {
-        for (const { type, name } of fields) {
-          this.dropColumn(type === 'relation' ? `${name}Id` : name);
+        for (const { kind, name } of fields) {
+          this.dropColumn(kind === 'relation' ? `${name}Id` : name);
         }
       });
     });
@@ -369,7 +369,7 @@ export class MigrationGenerator {
           this.column(
             field,
             { alter: true },
-            summonByName(this.columns[model.name], field.type === 'relation' ? `${field.name}Id` : field.name)
+            summonByName(this.columns[model.name], field.kind === 'relation' ? `${field.name}Id` : field.name)
           );
         }
       });
@@ -395,7 +395,7 @@ export class MigrationGenerator {
             this.column(
               field,
               { alter: true },
-              summonByName(this.columns[model.name], field.type === 'relation' ? `${field.name}Id` : field.name)
+              summonByName(this.columns[model.name], field.kind === 'relation' ? `${field.name}Id` : field.name)
             );
           }
         });
@@ -439,7 +439,7 @@ export class MigrationGenerator {
         this.writer
           .write(`await knex('${model.name}Revision').update(`)
           .inlineBlock(() => {
-            for (const { name, type } of missingRevisionFields) {
+            for (const { name, kind: type } of missingRevisionFields) {
               const col = type === 'relation' ? `${name}Id` : name;
               this.writer
                 .write(
@@ -467,7 +467,7 @@ export class MigrationGenerator {
       down.push(() => {
         this.alterTable(revisionTable, () => {
           for (const field of missingRevisionFields) {
-            this.dropColumn(field.type === 'relation' ? `${field.name}Id` : field.name);
+            this.dropColumn(field.kind === 'relation' ? `${field.name}Id` : field.name);
           }
         });
       });
@@ -565,8 +565,8 @@ export class MigrationGenerator {
           }
         }
       }
-      if (setDefault && field.default !== undefined) {
-        this.writer.write(`.defaultTo(${this.value(field.default)})`);
+      if (setDefault && field.defaultValue !== undefined) {
+        this.writer.write(`.defaultTo(${this.value(field.defaultValue)})`);
       }
       if (primary) {
         this.writer.write('.primary()');
@@ -578,39 +578,44 @@ export class MigrationGenerator {
       }
       this.writer.write(';').newLine();
     };
-    switch (field.type) {
-      case 'Boolean':
-        col(`table.boolean('${name}')`);
-        break;
-      case 'Int':
-        col(`table.integer('${name}')`);
-        break;
-      case 'Float':
-        if (field.double) {
-          col(`table.double('${name}')`);
-        } else {
-          col(`table.decimal('${name}', ${get(field, 'precision')}, ${get(field, 'scale')})`);
-        }
-        break;
-      case 'String':
-        if (field.large) {
-          col(`table.text('${name}')`);
-        } else {
-          col(`table.string('${name}', ${field.maxLength})`);
+    const kind = field.kind;
+    switch (kind) {
+      case 'primitive':
+        switch (field.type) {
+          case 'Boolean':
+            col(`table.boolean('${name}')`);
+            break;
+          case 'Int':
+            col(`table.integer('${name}')`);
+            break;
+          case 'Float':
+            if (field.double) {
+              col(`table.double('${name}')`);
+            } else {
+              col(`table.decimal('${name}', ${get(field, 'precision')}, ${get(field, 'scale')})`);
+            }
+            break;
+          case 'String':
+            if (field.large) {
+              col(`table.text('${name}')`);
+            } else {
+              col(`table.string('${name}', ${field.maxLength})`);
+            }
+            break;
+          case 'DateTime':
+            col(`table.timestamp('${name}')`);
+            break;
+          case 'ID':
+            col(`table.uuid('${name}')`);
+            break;
+          case 'Upload':
+            break;
         }
         break;
-      case 'DateTime':
-        col(`table.timestamp('${name}')`);
-        break;
-      case 'ID':
-        col(`table.uuid('${name}')`);
-        break;
-      case 'Upload':
-        break;
       case 'relation':
         col(`table.uuid('${name}Id')`);
         if (foreign && !alter) {
-          this.writer.writeLine(`table.foreign('${name}Id').references('id').inTable('${field.typeName}');`);
+          this.writer.writeLine(`table.foreign('${name}Id').references('id').inTable('${field.type}');`);
         }
         break;
       case 'enum':
@@ -628,8 +633,15 @@ export class MigrationGenerator {
         }
         col();
         break;
-      default:
-        throw new Error(`Unknown field type ${field.type}`);
+      case 'json':
+        this.writer.write(`table.json('${typeToField(field.type)}')`);
+        break;
+      case 'raw':
+        throw new Error("Raw fields aren't stored in the database");
+      default: {
+        const exhaustiveCheck: never = kind;
+        throw new Error(exhaustiveCheck);
+      }
     }
   }
 }

package/src/models/index.ts

@@ -1,4 +1,5 @@
 // created from 'create-ts-index'
 
 export * from './models';
+export * from './mutation-hook';
 export * from './utils';

package/src/models/models.ts

@@ -1,62 +1,48 @@
-import { DateTime } from 'luxon';
 import { Field } from '..';
-import type { Context } from '../context';
 import type { OrderBy } from '../resolvers/arguments';
 import type { Value } from '../values';
 
 export type RawModels = RawModel[];
 
-export type RawModel = ScalarModel | EnumModel | RawEnumModel | InterfaceModel | ObjectModel | RawObjectModel;
-
-type BaseModel = {
+export type RawModel = {
   name: string;
   plural?: string;
   description?: string;
-};
-
-export type ScalarModel = BaseModel & { type: 'scalar' };
-
-export type EnumModel = BaseModel & { type: 'enum'; values: string[]; deleted?: true };
-
-export type RawEnumModel = BaseModel & { type: 'raw-enum'; values: string[] };
-
-export type InterfaceModel = BaseModel & { type: 'interface'; fields: ModelField[] };
-
-export type RawObjectModel = BaseModel & {
-  type: 'raw';
-  fields: RawObjectField[];
-};
+} & (
+  | { kind: 'scalar' }
+  | { kind: 'enum'; values: string[]; deleted?: true }
+  | { kind: 'raw-enum'; values: string[] }
+  | { kind: 'interface'; fields: ModelField[] }
+  | {
+      kind: 'raw';
+      fields: RawObjectField[];
+    }
+  | {
+      kind: 'object';
+      interfaces?: string[];
+      queriable?: boolean;
+      listQueriable?: boolean;
+      creatable?: boolean | { createdBy?: Partial<RelationField>; createdAt?: Partial<DateTimeField> };
+      updatable?: boolean | { updatedBy?: Partial<RelationField>; updatedAt?: Partial<DateTimeField> };
+      deletable?:
+        | boolean
+        | { deleted?: Partial<BooleanField>; deletedBy?: Partial<RelationField>; deletedAt?: Partial<DateTimeField> };
+      displayField?: string;
+      defaultOrderBy?: OrderBy;
+      fields: ModelField[];
+
+      // temporary fields for the generation of migrations
+      deleted?: true;
+      oldName?: string;
+    }
+);
 
-export type Entity = Record<string, unknown> & { createdAt?: DateTime; deletedAt?: DateTime };
-
-export type Action = 'create' | 'update' | 'delete' | 'restore';
-
-export type MutationHook = (
-  model: Model,
-  action: Action,
-  when: 'before' | 'after',
-  data: { prev: Entity; input: Entity; normalizedInput: Entity; next: Entity },
-  ctx: Context
-) => Promise<void>;
-
-export type ObjectModel = BaseModel & {
-  type: 'object';
-  interfaces?: string[];
-  queriable?: boolean;
-  listQueriable?: boolean;
-  creatable?: boolean | { createdBy?: Partial<RelationField>; createdAt?: Partial<DateTimeField> };
-  updatable?: boolean | { updatedBy?: Partial<RelationField>; updatedAt?: Partial<DateTimeField> };
-  deletable?:
-    | boolean
-    | { deleted?: Partial<BooleanField>; deletedBy?: Partial<RelationField>; deletedAt?: Partial<DateTimeField> };
-  displayField?: string;
-  defaultOrderBy?: OrderBy;
-  fields: ModelField[];
-
-  // temporary fields for the generation of migrations
-  deleted?: true;
-  oldName?: string;
-};
+export type ScalarModel = Extract<RawModel, { kind: 'scalar' }>;
+export type EnumModel = Extract<RawModel, { kind: 'enum' }>;
+export type RawEnumModel = Extract<RawModel, { kind: 'raw-enum' }>;
+export type InterfaceModel = Extract<RawModel, { kind: 'interface' }>;
+export type RawObjectModel = Extract<RawModel, { kind: 'raw' }>;
+export type ObjectModel = Extract<RawModel, { kind: 'object' }>;
 
 type BaseNumberType = {
   unit?: 'million';
@@ -64,46 +50,48 @@ type BaseNumberType = {
   max?: number;
 };
 
-type BaseField = Omit<Field, 'type'>;
+type FieldBase = Omit<Field, 'type'>;
 
-type PrimitiveField =
-  | { type: 'ID' }
-  | { type: 'Boolean' }
-  | {
-      type: 'String';
-      stringType?: 'email' | 'url' | 'phone';
-      large?: true;
-      maxLength?: number;
-    }
-  | {
-      type: 'DateTime';
-      dateTimeType?: 'year' | 'date' | 'datetime' | 'year_and_month';
-      endOfDay?: boolean;
-    }
-  | ({
-      type: 'Int';
-      intType?: 'currency';
-    } & BaseNumberType)
-  | ({
-      type: 'Float';
-      floatType?: 'currency' | 'percentage';
-      double?: boolean;
-      precision?: number;
-      scale?: number;
-    } & BaseNumberType)
-  | { type: 'Upload' };
-
-type RawObjectField = BaseField & PrimitiveField;
-
-export type ModelField = BaseField &
+type FieldBase2 =
+  | ({ kind?: 'primitive' | undefined } & (
+      | { type: 'ID' }
+      | { type: 'Boolean' }
+      | {
+          type: 'String';
+          stringType?: 'email' | 'url' | 'phone';
+          large?: true;
+          maxLength?: number;
+        }
+      | {
+          type: 'DateTime';
+          dateTimeType?: 'year' | 'date' | 'datetime' | 'year_and_month';
+          endOfDay?: boolean;
+        }
+      | ({
+          type: 'Int';
+          intType?: 'currency';
+        } & BaseNumberType)
+      | ({
+          type: 'Float';
+          floatType?: 'currency' | 'percentage';
+          double?: boolean;
+          precision?: number;
+          scale?: number;
+        } & BaseNumberType)
+      | { type: 'Upload' }
+    ))
+  | { kind: 'enum'; type: string; possibleValues?: Value[] }
+  | { kind: 'raw'; type: string };
+
+export type RawObjectField = FieldBase & FieldBase2;
+
+export type ModelField = FieldBase &
   (
-    | PrimitiveField
-    | { type: 'json'; typeName: string }
-    | { type: 'enum'; typeName: string; possibleValues?: Value[] }
-    | { type: 'raw'; typeName: string }
+    | FieldBase2
+    | { kind: 'json'; type: string }
     | {
-        type: 'relation';
-        typeName: string;
+        kind: 'relation';
+        type: string;
         toOne?: boolean;
         reverse?: string;
         foreignKey?: string;
@@ -138,7 +126,6 @@ export type ModelField = BaseField &
     generated?: boolean;
     // The tooltip is "hidden" behind an icon in the admin forms
     tooltip?: string;
-    defaultValue?: string | number | ReadonlyArray<string> | undefined;
     // If true the field must be filled within forms but can be null in the database
     required?: boolean;
     indent?: boolean;
@@ -148,18 +135,22 @@ export type ModelField = BaseField &
     // temporary fields for the generation of migrations
     deleted?: true;
     oldName?: string;
+
+    meta?: Record<string, unknown>;
   };
 
-export type IDField = Extract<ModelField, { type: 'ID' }>;
-export type BooleanField = Extract<ModelField, { type: 'Boolean' }>;
-export type StringField = Extract<ModelField, { type: 'String' }>;
-export type DateTimeField = Extract<ModelField, { type: 'DateTime' }>;
-export type IntField = Extract<ModelField, { type: 'Int' }>;
-export type FloatField = Extract<ModelField, { type: 'Float' }>;
-export type JsonField = Extract<ModelField, { type: 'json' }>;
-export type EnumField = Extract<ModelField, { type: 'enum' }>;
-export type RawField = Extract<ModelField, { type: 'raw' }>;
-export type RelationField = Extract<ModelField, { type: 'relation' }>;
+export type PrimitiveField = Extract<ModelField, { kind?: 'primitive' | undefined }>;
+export type IDField = Extract<PrimitiveField, { type: 'ID' }>;
+export type BooleanField = Extract<PrimitiveField, { type: 'Boolean' }>;
+export type StringField = Extract<PrimitiveField, { type: 'String' }>;
+export type DateTimeField = Extract<PrimitiveField, { type: 'DateTime' }>;
+export type IntField = Extract<PrimitiveField, { type: 'Int' }>;
+export type FloatField = Extract<PrimitiveField, { type: 'Float' }>;
+export type UploadField = Extract<PrimitiveField, { type: 'Upload' }>;
+export type JsonField = Extract<ModelField, { kind: 'json' }>;
+export type EnumField = Extract<ModelField, { kind: 'enum' }>;
+export type RawField = Extract<ModelField, { kind: 'raw' }>;
+export type RelationField = Extract<ModelField, { kind: 'relation' }>;
 
 export type Models = Model[];
 

package/src/models/mutation-hook.ts

@@ -0,0 +1,17 @@
+import { DateTime } from 'luxon';
+import { Model } from '.';
+import { Context } from '..';
+
+export type Entity = Record<string, unknown> & { createdAt?: DateTime; deletedAt?: DateTime };
+
+export type FullEntity = Entity & { id: string };
+
+export type Action = 'create' | 'update' | 'delete' | 'restore';
+
+export type MutationHook = (
+  model: Model,
+  action: Action,
+  when: 'before' | 'after',
+  data: { prev: Entity; input: Entity; normalizedInput: Entity; next: FullEntity },
+  ctx: Context
+) => Promise<void>;

package/src/models/utils.ts

@@ -7,11 +7,13 @@ import startCase from 'lodash/startCase';
 import {
   BooleanField,
   DateTimeField,
+  EnumField,
   EnumModel,
   Model,
   ModelField,
   Models,
   ObjectModel,
+  PrimitiveField,
   RawEnumModel,
   RawField,
   RawModel,
@@ -43,18 +45,18 @@ export const getModelLabel = (model: Model) => getLabel(model.name);
 
 export const getLabel = (s: string) => startCase(camelCase(s));
 
-export const isObjectModel = (model: RawModel): model is ObjectModel => model.type === 'object';
+export const isObjectModel = (model: RawModel): model is ObjectModel => model.kind === 'object';
 
-export const isEnumModel = (model: RawModel): model is EnumModel => model.type === 'enum';
+export const isEnumModel = (model: RawModel): model is EnumModel => model.kind === 'enum';
 
-export const isRawEnumModel = (model: RawModel): model is RawEnumModel => model.type === 'raw-enum';
+export const isRawEnumModel = (model: RawModel): model is RawEnumModel => model.kind === 'raw-enum';
 
-export const isScalarModel = (model: RawModel): model is ScalarModel => model.type === 'scalar';
+export const isScalarModel = (model: RawModel): model is ScalarModel => model.kind === 'scalar';
 
-export const isRawObjectModel = (model: RawModel): model is RawObjectModel => model.type === 'raw';
+export const isRawObjectModel = (model: RawModel): model is RawObjectModel => model.kind === 'raw';
 
 export const isEnumList = (models: RawModels, field: ModelField) =>
-  field?.list === true && models.find(({ name }) => name === field.type)?.type === 'enum';
+  field?.list === true && models.find(({ name }) => name === field.kind)?.kind === 'enum';
 
 export const and =
   (...predicates: ((field: ModelField) => boolean)[]) =>
@@ -63,13 +65,18 @@ export const and =
 
 export const not = (predicate: (field: ModelField) => boolean) => (field: ModelField) => !predicate(field);
 
-export const isRelation = (field: ModelField): field is RelationField => field.type === 'relation';
+export const isPrimitive = (field: ModelField): field is PrimitiveField =>
+  field.kind === undefined || field.kind === 'primitive';
+
+export const isEnum = (field: ModelField): field is EnumField => field.kind === 'enum';
+
+export const isRelation = (field: ModelField): field is RelationField => field.kind === 'relation';
 
 export const isToOneRelation = (field: ModelField): field is RelationField => isRelation(field) && !!field.toOne;
 
 export const isQueriableField = ({ queriable }: ModelField) => queriable !== false;
 
-export const isRaw = (field: ModelField): field is RawField => field.type === 'raw';
+export const isRaw = (field: ModelField): field is RawField => field.kind === 'raw';
 
 export const isVisible = ({ hidden }: ModelField) => hidden !== true;
 
@@ -114,7 +121,6 @@ export const getModels = (rawModels: RawModels): Models => {
                 {
                   name: 'createdAt',
                   type: 'DateTime',
-
                   nonNull: true,
                   orderable: true,
                   generated: true,
@@ -122,8 +128,8 @@ export const getModels = (rawModels: RawModels): Models => {
                 } satisfies DateTimeField,
                 {
                   name: 'createdBy',
-                  type: 'relation',
-                  typeName: 'User',
+                  kind: 'relation',
+                  type: 'User',
                   nonNull: true,
                   reverse: `created${getModelPlural(model)}`,
                   generated: true,
@@ -143,8 +149,8 @@ export const getModels = (rawModels: RawModels): Models => {
                 } satisfies DateTimeField,
                 {
                   name: 'updatedBy',
-                  type: 'relation',
-                  typeName: 'User',
+                  kind: 'relation',
+                  type: 'User',
                   nonNull: true,
                   reverse: `updated${getModelPlural(model)}`,
                   generated: true,
@@ -158,7 +164,7 @@ export const getModels = (rawModels: RawModels): Models => {
                   name: 'deleted',
                   type: 'Boolean',
                   nonNull: true,
-                  default: false,
+                  defaultValue: false,
                   filterable: { default: false },
                   generated: true,
                   ...(typeof model.deletable === 'object' && model.deletable.deleted),
@@ -172,8 +178,8 @@ export const getModels = (rawModels: RawModels): Models => {
                 } satisfies DateTimeField,
                 {
                   name: 'deletedBy',
-                  type: 'relation',
-                  typeName: 'User',
+                  kind: 'relation',
+                  type: 'User',
                   reverse: `deleted${getModelPlural(model)}`,
                   generated: true,
                   ...(typeof model.deletable === 'object' && model.deletable.deletedBy),
@@ -183,7 +189,7 @@ export const getModels = (rawModels: RawModels): Models => {
         ] satisfies ModelField[]
       ).map((field: ModelField) => ({
         ...field,
-        ...(field.type === 'relation' && {
+        ...(field.kind === 'relation' && {
           foreignKey: field.foreignKey || `${field.name}Id`,
         }),
       })),
@@ -198,17 +204,17 @@ export const getModels = (rawModels: RawModels): Models => {
 
   for (const model of models) {
     for (const field of model.fields) {
-      if (field.type !== 'relation') {
+      if (field.kind !== 'relation') {
         continue;
       }
 
-      const fieldModel = summonByName(models, field.typeName);
+      const fieldModel = summonByName(models, field.type);
 
       const reverseRelation: ReverseRelation = {
-        type: 'relation',
+        kind: 'relation',
         name: field.reverse || (field.toOne ? typeToField(model.name) : getModelPluralField(model)),
         foreignKey: get(field, 'foreignKey'),
-        typeName: model.name,
+        type: model.name,
         toOne: !!field.toOne,
         fieldModel,
         field,

package/src/permissions/check.ts

@@ -147,8 +147,8 @@ export const checkCanWrite = async (
       continue;
     }
 
-    const fieldPermissions = field[action === 'CREATE' ? 'creatableBy' : 'updatableBy'];
-    if (fieldPermissions && !fieldPermissions.includes(ctx.user.role)) {
+    const fieldPermissions = field[action === 'CREATE' ? 'creatable' : 'updatable'];
+    if (fieldPermissions && typeof fieldPermissions === 'object' && !fieldPermissions.roles?.includes(ctx.user.role)) {
       throw new PermissionError(action, `this ${model.name}'s ${field.name}`, 'field permission not available');
     }
 

package/src/resolvers/filters.ts

@@ -85,7 +85,7 @@ const applyWhere = (node: WhereNode, where: Where, ops: Ops<Knex.QueryBuilder>,
     const field = summonByName(node.model.fields, key);
     const fullKey = `${node.shortTableAlias}.${key}`;
 
-    if (field.type === 'relation') {
+    if (field.kind === 'relation') {
       const relation = get(node.model.relationsByName, field.name);
       const tableAlias = `${node.model.name}__W__${key}`;
       const subNode: WhereNode = {