@smartive/graphql-magic 3.1.0 → 4.0.0

package/dist/cjs/index.cjs

@@ -106,7 +106,6 @@ __export(src_exports, {
   isFieldNode: () => isFieldNode,
   isFragmentSpreadNode: () => isFragmentSpreadNode,
   isInlineFragmentNode: () => isInlineFragmentNode,
-  isJsonObjectModel: () => isJsonObjectModel,
   isListType: () => isListType,
   isObjectModel: () => isObjectModel,
   isQueriableBy: () => isQueriableBy,
@@ -162,35 +161,6 @@ var gql = (chunks, ...variables) => {
 // src/client/queries.ts
 var import_upperFirst = __toESM(require("lodash/upperFirst"), 1);
 
-// src/models.ts
-var isObjectModel = (model) => model.type === "object";
-var isEnumModel = (model) => model.type === "enum";
-var isRawEnumModel = (model) => model.type === "raw-enum";
-var isScalarModel = (model) => model.type === "scalar";
-var isRawObjectModel = (model) => model.type === "raw-object";
-var isJsonObjectModel = (model) => model.type === "json-object";
-var isEnumList = (models, field) => field?.list === true && models.find(({ name: name2 }) => name2 === field.type)?.type === "enum";
-var and = (...predicates) => (field) => predicates.every((predicate) => predicate(field));
-var not = (predicate) => (field) => !predicate(field);
-var isRelation = ({ relation }) => !!relation;
-var isVisibleRelation = (visibleRelationsByRole, modelName, role) => {
-  const whitelist = visibleRelationsByRole[role]?.[modelName];
-  return ({ name: name2 }) => whitelist ? whitelist.includes(name2) : true;
-};
-var isToOneRelation = ({ toOne }) => !!toOne;
-var isQueriableField = ({ queriable }) => queriable !== false;
-var isRaw = ({ raw }) => !!raw;
-var isVisible = ({ hidden }) => hidden !== true;
-var isSimpleField = and(not(isRelation), not(isRaw));
-var isUpdatable = ({ updatable }) => !!updatable;
-var isCreatable = ({ creatable }) => !!creatable;
-var isQueriableBy = (role) => (field) => isQueriableField(field) && (!field.queriableBy || field.queriableBy.includes(role));
-var isUpdatableBy = (role) => (field) => isUpdatable(field) && (!field.updatableBy || field.updatableBy.includes(role));
-var isCreatableBy = (role) => (field) => isCreatable(field) && (!field.creatableBy || field.creatableBy.includes(role));
-var actionableRelations = (model, action) => model.fields.filter(
-  ({ relation, ...field }) => relation && field[`${action === "filter" ? action : action.slice(0, -1)}able`]
-);
-
 // src/utils.ts
 var import_assert = __toESM(require("assert"), 1);
 var import_inflection = require("inflection");
@@ -207,6 +177,28 @@ var getModelSlug = (model) => (0, import_kebabCase.default)(getModelPlural(model
 var getModelLabelPlural = (model) => getLabel(getModelPlural(model));
 var getModelLabel = (model) => getLabel(model.name);
 var getLabel = (s) => (0, import_startCase.default)((0, import_camelCase.default)(s));
+var isObjectModel = (model) => model.type === "object";
+var isEnumModel = (model) => model.type === "enum";
+var isRawEnumModel = (model) => model.type === "raw-enum";
+var isScalarModel = (model) => model.type === "scalar";
+var isRawObjectModel = (model) => model.type === "raw";
+var isEnumList = (models, field) => field?.list === true && models.find(({ name: name2 }) => name2 === field.type)?.type === "enum";
+var and = (...predicates) => (field) => predicates.every((predicate) => predicate(field));
+var not = (predicate) => (field) => !predicate(field);
+var isRelation = (field) => field.type === "relation";
+var isToOneRelation = (field) => isRelation(field) && !!field.toOne;
+var isQueriableField = ({ queriable }) => queriable !== false;
+var isRaw = (field) => field.type === "raw";
+var isVisible = ({ hidden }) => hidden !== true;
+var isSimpleField = and(not(isRelation), not(isRaw));
+var isUpdatable = ({ updatable }) => !!updatable;
+var isCreatable = ({ creatable }) => !!creatable;
+var isQueriableBy = (role) => (field) => field.queriable !== false && (field.queriable == true || !field.queriable.roles || field.queriable.roles.includes(role));
+var isUpdatableBy = (role) => (field) => field.updatable && (field.updatable === true || !field.updatable.roles || field.updatable.roles.includes(role));
+var isCreatableBy = (role) => (field) => field.creatable && (field.creatable === true || !field.creatable.roles || field.creatable.roles.includes(role));
+var actionableRelations = (model, action) => model.fields.filter(isRelation).filter(
+  (field) => field[`${action === "filter" ? action : action.slice(0, -1)}able`]
+);
 var getModels = (rawModels) => {
   const models = rawModels.filter(isObjectModel).map((model) => {
     const objectModel = {
@@ -220,25 +212,41 @@ var getModels = (rawModels) => {
         { name: "id", type: "ID", nonNull: true, unique: true, primary: true, generated: true },
         ...model.fields,
         ...model.creatable ? [
-          { name: "createdAt", type: "DateTime", nonNull: !model.nonStrict, orderable: true, generated: true },
+          {
+            name: "createdAt",
+            type: "DateTime",
+            nonNull: true,
+            orderable: true,
+            generated: true,
+            ...typeof model.creatable === "object" && model.creatable.createdAt
+          },
           {
             name: "createdBy",
-            type: "User",
-            relation: true,
-            nonNull: !model.nonStrict,
+            type: "relation",
+            typeName: "User",
+            nonNull: true,
             reverse: `created${getModelPlural(model)}`,
-            generated: true
+            generated: true,
+            ...typeof model.creatable === "object" && model.creatable.createdBy
           }
         ] : [],
         ...model.updatable ? [
-          { name: "updatedAt", type: "DateTime", nonNull: !model.nonStrict, orderable: true, generated: true },
+          {
+            name: "updatedAt",
+            type: "DateTime",
+            nonNull: true,
+            orderable: true,
+            generated: true,
+            ...typeof model.updatable === "object" && model.updatable.updatedAt
+          },
           {
             name: "updatedBy",
-            type: "User",
-            relation: true,
-            nonNull: !model.nonStrict,
+            type: "relation",
+            typeName: "User",
+            nonNull: true,
             reverse: `updated${getModelPlural(model)}`,
-            generated: true
+            generated: true,
+            ...typeof model.updatable === "object" && model.updatable.updatedBy
           }
         ] : [],
         ...model.deletable ? [
@@ -247,23 +255,30 @@ var getModels = (rawModels) => {
             type: "Boolean",
             nonNull: true,
             default: false,
-            filterable: true,
-            defaultFilter: false,
-            generated: true
+            filterable: { default: false },
+            generated: true,
+            ...typeof model.deletable === "object" && model.deletable.deleted
+          },
+          {
+            name: "deletedAt",
+            type: "DateTime",
+            orderable: true,
+            generated: true,
+            ...typeof model.deletable === "object" && model.deletable.deletedAt
           },
-          { name: "deletedAt", type: "DateTime", orderable: true, generated: true },
           {
             name: "deletedBy",
-            type: "User",
-            relation: true,
+            type: "relation",
+            typeName: "User",
             reverse: `deleted${getModelPlural(model)}`,
-            generated: true
+            generated: true,
+            ...typeof model.deletable === "object" && model.deletable.deletedBy
           }
         ] : []
-      ].map(({ foreignKey, ...field }) => ({
+      ].map((field) => ({
         ...field,
-        ...field.relation && {
-          foreignKey: foreignKey || `${field.name}Id`
+        ...field.type === "relation" && {
+          foreignKey: field.foreignKey || `${field.name}Id`
         }
       }))
     };
@@ -273,12 +288,16 @@ var getModels = (rawModels) => {
     return objectModel;
   });
   for (const model of models) {
-    for (const field of model.fields.filter(({ relation }) => relation)) {
-      const fieldModel = summonByName(models, field.type);
+    for (const field of model.fields) {
+      if (field.type !== "relation") {
+        continue;
+      }
+      const fieldModel = summonByName(models, field.typeName);
       const reverseRelation = {
+        type: "relation",
         name: field.reverse || (field.toOne ? typeToField(model.name) : getModelPluralField(model)),
         foreignKey: get(field, "foreignKey"),
-        type: model.name,
+        typeName: model.name,
         toOne: !!field.toOne,
         fieldModel,
         field,
@@ -356,8 +375,8 @@ var getEditEntityRelationsQuery = (models, model, action, fields2, ignoreFields,
     ({ name: name2 }) => (!fields2 || fields2.includes(name2)) && (!ignoreFields || !ignoreFields.includes(name2))
   );
   return !!relations.length && `query ${(0, import_upperFirst.default)(action)}${model.name}Relations {
-      ${relations.map(({ name: name2, type }) => {
-    const model2 = summonByName(models, type);
+      ${relations.map(({ name: name2, typeName }) => {
+    const model2 = summonByName(models, typeName);
     let filters = "";
     if (model2.displayField) {
       const displayField2 = model2.fieldsByName[model2.displayField];
@@ -457,6 +476,10 @@ var getEntityListQuery = (model, role, additionalFields = "", root) => `query ${
     }
   ${root ? "}" : ""}
 }`;
+var isVisibleRelation = (visibleRelationsByRole, modelName, role) => {
+  const whitelist = visibleRelationsByRole[role]?.[modelName];
+  return ({ name: name2 }) => whitelist ? whitelist.includes(name2) : true;
+};
 var getEntityQuery = (models, model, role, visibleRelationsByRole, typesWithSubRelations) => `query Admin${model.name} ($id: ID!) {
   data: ${typeToField(model.name)}(where: { id: $id }) {
     ${displayField(model)}
@@ -513,14 +536,14 @@ var generateDBModels = (rawModels) => {
   }
   const models = getModels(rawModels);
   for (const model of models) {
-    const fields2 = model.fields.some((field) => field.foreignKey === "id") ? model.fields.filter((field) => field.name !== "id") : model.fields;
+    const fields2 = model.fields.some((field) => field.type === "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(({ raw }) => !raw)) {
+      for (const field of fields2.filter(not(isRaw))) {
         writer.write(`'${getFieldName(field)}': ${getFieldOutputType(field)}${field.nonNull ? "" : " | null"},`).newLine();
       }
     }).blankLine();
     writer.write(`export type ${model.name}Initializer = `).inlineBlock(() => {
-      for (const field of fields2.filter(({ raw }) => !raw)) {
+      for (const field of fields2.filter(not(isRaw))) {
         writer.write(
           `'${getFieldName(field)}'${field.nonNull && field.default === void 0 ? "" : "?"}: ${getFieldInputType(
             field
@@ -529,12 +552,12 @@ var generateDBModels = (rawModels) => {
       }
     }).blankLine();
     writer.write(`export type ${model.name}Mutator = `).inlineBlock(() => {
-      for (const field of fields2.filter(({ raw }) => !raw)) {
+      for (const field of fields2.filter(not(isRaw))) {
         writer.write(`'${getFieldName(field)}'?: ${getFieldInputType(field)}${field.nonNull ? "" : " | null"},`).newLine();
       }
     }).blankLine();
     writer.write(`export type ${model.name}Seed = `).inlineBlock(() => {
-      for (const field of fields2.filter(({ raw }) => !raw)) {
+      for (const field of fields2.filter(not(isRaw))) {
         const fieldName = getFieldName(field);
         writer.write(
           `'${getFieldName(field)}'${field.nonNull && field.default === void 0 && !OPTIONAL_SEED_FIELDS.includes(fieldName) ? "" : "?"}: ${getFieldInputType(
@@ -552,14 +575,20 @@ var generateDBModels = (rawModels) => {
   });
   return writer.toString();
 };
-var getFieldName = ({ relation, name: name2, foreignKey }) => {
-  return foreignKey || `${name2}${relation ? "Id" : ""}`;
-};
-var getFieldOutputType = ({ relation, type, list: list2, json }) => {
-  if (json || relation) {
-    return "string";
+var getFieldName = (field) => field.type === "relation" ? field.foreignKey || `${field.name}Id` : field.name;
+var getFieldOutputType = (field) => {
+  switch (field.type) {
+    case "json":
+      return "string";
+    case "relation":
+      return "string";
+    case "enum":
+      return field.typeName + field.list ? "[]" : "";
+    case "raw":
+      throw new Error(`Raw fields are not in the db.`);
+    default:
+      return get(PRIMITIVE_TYPES, field.type) + (field.list ? "[]" : "");
   }
-  return (PRIMITIVE_TYPES[type] || type) + (list2 ? "[]" : "");
 };
 var getFieldInputType = (field, stringTypes = []) => {
   let outputType = getFieldOutputType(field);
@@ -764,14 +793,6 @@ var generateDefinitions = (rawModels) => {
     ...rawModels.filter(isRawEnumModel).map((model) => enm(model.name, model.values)),
     ...rawModels.filter(isScalarModel).map((model) => scalar(model.name)),
     ...rawModels.filter(isRawObjectModel).map((model) => object(model.name, model.fields)),
-    ...rawModels.filter(isJsonObjectModel).map((model) => object(model.name, model.fields)),
-    ...rawModels.filter(isRawObjectModel).filter(({ rawFilters }) => rawFilters).map(
-      (model) => input(
-        `${model.name}Where`,
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- array gets filtered above to only include models with rawFilters
-        model.rawFilters.map(({ name: name2, type, list: list2 = false, nonNull: nonNull2 = false }) => ({ name: name2, type, list: list2, nonNull: nonNull2 }))
-      )
-    ),
     ...(0, import_flatMap.default)(
       models.map((model) => {
         const types = [
@@ -780,10 +801,8 @@ var generateDefinitions = (rawModels) => {
             [
               ...model.fields.filter(isQueriableField).map((field) => ({
                 ...field,
-                args: [
-                  ...field.args || [],
-                  ...hasRawFilters(rawModels, field.type) ? [{ name: "where", type: `${field.type}Where` }] : []
-                ],
+                type: field.type === "relation" || field.type === "enum" || field.type === "raw" ? field.typeName : field.type,
+                args: [...field.args || []],
                 directives: field.directives
               })),
               ...model.reverseRelations.map(({ name: name2, field, model: model2 }) => ({
@@ -803,7 +822,12 @@ var generateDefinitions = (rawModels) => {
             model.interfaces
           ),
           input(`${model.name}Where`, [
-            ...model.fields.filter(({ unique, filterable, relation }) => (unique || filterable) && !relation).map(({ name: name2, type, defaultFilter }) => ({ name: name2, type, list: true, default: defaultFilter })),
+            ...model.fields.filter(({ type, unique, filterable }) => (unique || filterable) && type !== "relation").map(({ type, name: name2, filterable }) => ({
+              name: name2,
+              type,
+              list: true,
+              default: typeof filterable === "object" ? filterable.default : void 0
+            })),
             ...(0, import_flatMap.default)(
               model.fields.filter(({ comparable }) => comparable),
               ({ name: name2, type }) => [
@@ -813,9 +837,9 @@ var generateDefinitions = (rawModels) => {
                 { name: `${name2}_LTE`, type }
               ]
             ),
-            ...model.fields.filter(({ filterable, relation }) => filterable && relation).map(({ name: name2, type }) => ({
+            ...model.fields.filter(isRelation).filter(({ filterable }) => filterable).map(({ name: name2, typeName }) => ({
               name: name2,
-              type: `${type}Where`
+              type: `${typeName}Where`
             }))
           ]),
           input(
@@ -834,7 +858,7 @@ var generateDefinitions = (rawModels) => {
             input(
               `Create${model.name}`,
               model.fields.filter(({ creatable }) => creatable).map(
-                ({ name: name2, relation, type, nonNull: nonNull2, list: list2, default: defaultValue }) => relation ? { name: `${name2}Id`, type: "ID", nonNull: nonNull2 } : { name: name2, type, list: list2, nonNull: nonNull2 && defaultValue === void 0 }
+                ({ name: name2, nonNull: nonNull2, list: list2, default: defaultValue, ...field }) => field.type === "relation" ? { name: `${name2}Id`, type: "ID", nonNull: nonNull2 } : { name: name2, type: field.type, list: list2, nonNull: nonNull2 && defaultValue === void 0 }
               )
             )
           );
@@ -844,7 +868,7 @@ var generateDefinitions = (rawModels) => {
             input(
               `Update${model.name}`,
               model.fields.filter(({ updatable }) => updatable).map(
-                ({ name: name2, relation, type, list: list2 }) => relation ? { name: `${name2}Id`, type: "ID" } : { name: name2, type, list: list2 }
+                ({ name: name2, type, list: list2 }) => type === "relation" ? { name: `${name2}Id`, type: "ID" } : { name: name2, type, list: list2 }
               )
             )
           );
@@ -962,7 +986,6 @@ var printSchema = (schema) => [
   ...Object.values(schema.getTypeMap()).filter((t) => !t.name.match(/^__/)).sort((a, b) => a.name > b.name ? 1 : -1).map((t) => t.astNode && (0, import_graphql.print)(t.astNode))
 ].filter(Boolean).map((s) => `${s}
 `).join("\n");
-var hasRawFilters = (models, type) => models.filter(isRawObjectModel).some(({ name: name2, rawFilters }) => name2 === type && !!rawFilters);
 var printSchemaFromDocument = (document2) => printSchema((0, import_graphql.buildASTSchema)(document2));
 var printSchemaFromModels = (models) => printSchema((0, import_graphql.buildASTSchema)(generate(models)));
 
@@ -1114,17 +1137,19 @@ var MigrationGenerator = class {
         this.createFields(
           model,
           model.fields.filter(
-            ({ name: name2, relation, raw, foreignKey }) => !raw && !this.columns[model.name].some((col) => col.name === (foreignKey || (relation ? `${name2}Id` : name2)))
+            ({ name: name2, ...field }) => field.type !== "raw" && !this.columns[model.name].some(
+              (col) => col.name === (field.type === "relation" ? field.foreignKey || `${name2}Id` : name2)
+            )
           ),
           up,
           down
         );
-        const existingFields = model.fields.filter(({ name: name2, relation, nonNull: nonNull2 }) => {
-          const col = this.columns[model.name].find((col2) => col2.name === (relation ? `${name2}Id` : name2));
+        const existingFields = model.fields.filter(({ name: name2, type, nonNull: nonNull2 }) => {
+          const col = this.columns[model.name].find((col2) => col2.name === (type === "relation" ? `${name2}Id` : name2));
           if (!col) {
             return false;
           }
-          return !model.nonStrict && !nonNull2 && !col.is_nullable;
+          return !nonNull2 && !col.is_nullable;
         });
         this.updateFields(model, existingFields, up, down);
       }
@@ -1147,8 +1172,8 @@ var MigrationGenerator = class {
                     if (model.deletable) {
                       writer.writeLine(`deleted: row.deleted,`);
                     }
-                    for (const { name: name2, relation } of model.fields.filter(({ updatable }) => updatable)) {
-                      const col = relation ? `${name2}Id` : name2;
+                    for (const { name: name2, type } of model.fields.filter(({ updatable }) => updatable)) {
+                      const col = type === "relation" ? `${name2}Id` : name2;
                       writer.writeLine(`${col}: row.${col},`);
                     }
                   }).write(")));").newLine();
@@ -1162,11 +1187,15 @@ var MigrationGenerator = class {
         } else {
           const revisionTable = `${model.name}Revision`;
           const missingRevisionFields = model.fields.filter(
-            ({ name: name2, relation, raw, foreignKey, updatable }) => !raw && updatable && !this.columns[revisionTable].some((col) => col.name === (foreignKey || (relation ? `${name2}Id` : name2)))
+            ({ name: name2, updatable, ...field }) => field.type !== "raw" && updatable && !this.columns[revisionTable].some(
+              (col) => col.name === (field.type === "relation" ? field.foreignKey || `${name2}Id` : name2)
+            )
           );
           this.createRevisionFields(model, missingRevisionFields, up, down);
           const revisionFieldsToRemove = model.fields.filter(
-            ({ name: name2, updatable, foreignKey, relation, raw, generated }) => !generated && !raw && !updatable && foreignKey !== "id" && this.columns[revisionTable].some((col) => col.name === (foreignKey || (relation ? `${name2}Id` : name2)))
+            ({ name: name2, updatable, generated, ...field }) => !generated && field.type !== "raw" && !updatable && !(field.type === "relation" && field.foreignKey === "id") && this.columns[revisionTable].some(
+              (col) => col.name === (field.type === "relation" ? field.foreignKey || `${name2}Id` : name2)
+            )
           );
           this.createRevisionFields(model, revisionFieldsToRemove, down, up);
         }
@@ -1218,8 +1247,8 @@ var MigrationGenerator = class {
       for (const field of fields2) {
         this.alterTable(model.name, () => {
           this.renameColumn(
-            field.relation ? `${field.oldName}Id` : get(field, "oldName"),
-            field.relation ? `${field.name}Id` : field.name
+            field.type === "relation" ? `${field.oldName}Id` : get(field, "oldName"),
+            field.type === "relation" ? `${field.name}Id` : field.name
           );
         });
       }
@@ -1228,14 +1257,14 @@ var MigrationGenerator = class {
       for (const field of fields2) {
         this.alterTable(model.name, () => {
           this.renameColumn(
-            field.relation ? `${field.name}Id` : field.name,
-            field.relation ? `${field.oldName}Id` : get(field, "oldName")
+            field.type === "relation" ? `${field.name}Id` : field.name,
+            field.type === "relation" ? `${field.oldName}Id` : get(field, "oldName")
           );
         });
       }
     });
     for (const field of fields2) {
-      summonByName(this.columns[model.name], field.relation ? `${field.oldName}Id` : field.oldName).name = field.relation ? `${field.name}Id` : field.name;
+      summonByName(this.columns[model.name], field.type === "relation" ? `${field.oldName}Id` : field.oldName).name = field.type === "relation" ? `${field.name}Id` : field.name;
     }
   }
   createFields(model, fields2, up, down) {
@@ -1271,8 +1300,8 @@ var MigrationGenerator = class {
     });
     down.push(() => {
       this.alterTable(model.name, () => {
-        for (const { relation, name: name2 } of fields2) {
-          this.dropColumn(relation ? `${name2}Id` : name2);
+        for (const { type, name: name2 } of fields2) {
+          this.dropColumn(type === "relation" ? `${name2}Id` : name2);
         }
       });
     });
@@ -1294,7 +1323,7 @@ var MigrationGenerator = class {
           this.column(
             field,
             { alter: true },
-            summonByName(this.columns[model.name], field.relation ? `${field.name}Id` : field.name)
+            summonByName(this.columns[model.name], field.type === "relation" ? `${field.name}Id` : field.name)
           );
         }
       });
@@ -1317,7 +1346,7 @@ var MigrationGenerator = class {
             this.column(
               field,
               { alter: true },
-              summonByName(this.columns[model.name], field.relation ? `${field.name}Id` : field.name)
+              summonByName(this.columns[model.name], field.type === "relation" ? `${field.name}Id` : field.name)
             );
           }
         });
@@ -1330,9 +1359,7 @@ var MigrationGenerator = class {
       writer.writeLine(`table.uuid('id').notNullable().primary();`);
       writer.writeLine(`table.uuid('${typeToField(model.name)}Id').notNullable();`);
       writer.write(`table.uuid('createdById')`);
-      if (!model.nonStrict) {
-        writer.write(".notNullable()");
-      }
+      writer.write(".notNullable()");
       writer.write(";").newLine();
       writer.writeLine(`table.timestamp('createdAt').notNullable().defaultTo(knex.fn.now(0));`);
       if (model.deletable) {
@@ -1353,8 +1380,8 @@ var MigrationGenerator = class {
           }
         });
         this.writer.write(`await knex('${model.name}Revision').update(`).inlineBlock(() => {
-          for (const { name: name2, relation } of missingRevisionFields) {
-            const col = relation ? `${name2}Id` : name2;
+          for (const { name: name2, type } of missingRevisionFields) {
+            const col = type === "relation" ? `${name2}Id` : name2;
             this.writer.write(
               `${col}: knex.raw('(select "${col}" from "${model.name}" where "${model.name}".id = "${model.name}Revision"."${typeToField(model.name)}Id")'),`
             ).newLine();
@@ -1372,7 +1399,7 @@ var MigrationGenerator = class {
       down.push(() => {
         this.alterTable(revisionTable, () => {
           for (const field of missingRevisionFields) {
-            this.dropColumn(field.relation ? `${field.name}Id` : field.name);
+            this.dropColumn(field.type === "relation" ? `${field.name}Id` : field.name);
           }
         });
       });
@@ -1418,7 +1445,7 @@ var MigrationGenerator = class {
     }
     return value2;
   }
-  column({ name: name2, relation, type, primary, list: list2, ...field }, { setUnique = true, setNonNull = true, alter = false, foreign = true, setDefault = true } = {}, toColumn) {
+  column({ name: name2, primary, list: list2, ...field }, { setUnique = true, setNonNull = true, alter = false, foreign = true, setDefault = true } = {}, toColumn) {
     const col = (what) => {
       if (what) {
         this.writer.write(what);
@@ -1451,55 +1478,55 @@ var MigrationGenerator = class {
       }
       this.writer.write(";").newLine();
     };
-    if (relation) {
-      col(`table.uuid('${name2}Id')`);
-      if (foreign && !alter) {
-        this.writer.writeLine(`table.foreign('${name2}Id').references('id').inTable('${type}');`);
-      }
-    } else if (this.rawModels.some((m) => m.name === type && m.type === "enum")) {
-      list2 ? this.writer.write(`table.specificType('${name2}', '"${typeToField(type)}"[]');`) : this.writer.write(`table.enum('${name2}', null as any, `).inlineBlock(() => {
-        this.writer.writeLine(`useNative: true,`);
-        this.writer.writeLine(`existingType: true,`);
-        this.writer.writeLine(`enumName: '${typeToField(type)}',`);
-      }).write(")");
-      col();
-    } else {
-      switch (type) {
-        case "Boolean":
-          col(`table.boolean('${name2}')`);
-          break;
-        case "Int":
-          col(`table.integer('${name2}')`);
-          break;
-        case "Float":
-          if (field.double) {
-            col(`table.double('${name2}')`);
-          } else {
-            col(`table.decimal('${name2}', ${get(field, "precision")}, ${get(field, "scale")})`);
-          }
-          break;
-        case "String":
-          if (field.large) {
-            col(`table.text('${name2}')`);
-          } else {
-            col(`table.string('${name2}', ${field.maxLength})`);
-          }
-          break;
-        case "DateTime":
-          col(`table.timestamp('${name2}')`);
-          break;
-        case "ID":
-          if (field.maxLength) {
-            col(`table.string('${name2}', ${get(field, "maxLength")})`);
-          } else {
-            col(`table.uuid('${name2}')`);
-          }
-          break;
-        case "Upload":
-          break;
-        default:
-          throw new Error(`Unknown field type ${type}`);
-      }
+    switch (field.type) {
+      case "Boolean":
+        col(`table.boolean('${name2}')`);
+        break;
+      case "Int":
+        col(`table.integer('${name2}')`);
+        break;
+      case "Float":
+        if (field.double) {
+          col(`table.double('${name2}')`);
+        } else {
+          col(`table.decimal('${name2}', ${get(field, "precision")}, ${get(field, "scale")})`);
+        }
+        break;
+      case "String":
+        if (field.large) {
+          col(`table.text('${name2}')`);
+        } else {
+          col(`table.string('${name2}', ${field.maxLength})`);
+        }
+        break;
+      case "DateTime":
+        col(`table.timestamp('${name2}')`);
+        break;
+      case "ID":
+        col(`table.uuid('${name2}')`);
+        break;
+      case "Upload":
+        break;
+      case "relation":
+        col(`table.uuid('${name2}Id')`);
+        if (foreign && !alter) {
+          this.writer.writeLine(`table.foreign('${name2}Id').references('id').inTable('${field.typeName}');`);
+        }
+        break;
+      case "enum":
+        if (list2) {
+          this.writer.write(`table.specificType('${name2}', '"${typeToField(field.type)}"[]');`);
+        } else {
+          this.writer.write(`table.enum('${name2}', null as any, `).inlineBlock(() => {
+            this.writer.writeLine(`useNative: true,`);
+            this.writer.writeLine(`existingType: true,`);
+            this.writer.writeLine(`enumName: '${typeToField(field.type)}',`);
+          }).write(")");
+        }
+        col();
+        break;
+      default:
+        throw new Error(`Unknown field type ${field.type}`);
     }
   }
 };
@@ -1717,7 +1744,7 @@ var checkCanWrite = async (ctx, model, data, action) => {
   }
   const query = ctx.knex.select(1).first();
   let linked = false;
-  for (const field of model.fields.filter(({ relation }) => relation).filter((field2) => field2.generated || (action === "CREATE" ? field2.creatable : field2.updatable))) {
+  for (const field of model.fields.filter(isRelation).filter((field2) => field2.generated || (action === "CREATE" ? field2.creatable : field2.updatable))) {
     const foreignKey = field.foreignKey || `${field.name}Id`;
     const foreignId = data[foreignKey];
     if (!foreignId) {
@@ -1853,7 +1880,7 @@ var addPermissions = (models, permissions, links, block) => {
   }
   if (block.RELATIONS) {
     for (const [relation, subBlock] of Object.entries(block.RELATIONS)) {
-      const field = model.fields.find((field2) => field2.relation && field2.name === relation);
+      const field = model.fields.filter(isRelation).find((field2) => field2.name === relation);
       let link;
       if (field) {
         link = {
@@ -2038,7 +2065,7 @@ var applyWhere2 = (node, where, ops, joins) => {
     }
     const field = summonByName(node.model.fields, key);
     const fullKey = `${node.shortTableAlias}.${key}`;
-    if (field.relation) {
+    if (field.type === "relation") {
       const relation = get(node.model.relationsByName, field.name);
       const tableAlias = `${node.model.name}__W__${key}`;
       const subNode = {
@@ -2152,7 +2179,7 @@ var getSimpleFields = (node) => {
     if (!selection.selectionSet) {
       return true;
     }
-    return node.model.fields.some(({ json, name: name2 }) => json && name2 === selection.name.value);
+    return node.model.fields.some(({ type, name: name2 }) => type === "json" && name2 === selection.name.value);
   });
 };
 var getInlineFragments = (node) => node.selectionSet.filter(isInlineFragmentNode).map(
@@ -2182,7 +2209,7 @@ var getJoins = (node, toMany) => {
     const fieldNameOrAlias = getNameOrAlias(subNode);
     const fieldDefinition = summonByKey(baseTypeDefinition.fields || [], "name.value", fieldName);
     const typeName = getTypeName(fieldDefinition.type);
-    if (isJsonObjectModel(summonByName(ctx.rawModels, typeName))) {
+    if (isRawObjectModel(summonByName(ctx.rawModels, typeName))) {
       continue;
     }
     const baseModel = summonByName(ctx.models, baseTypeDefinition.name.value);
@@ -2195,7 +2222,7 @@ var getJoins = (node, toMany) => {
       foreignKey = reverseRelation.foreignKey;
     } else {
       const modelField = baseModel.fieldsByName[fieldName];
-      if (!modelField || modelField.raw) {
+      if (modelField?.type !== "relation") {
         continue;
       }
       foreignKey = modelField.foreignKey;
@@ -2288,10 +2315,10 @@ var applySelects = (node, query, joins) => {
       { field: "id", alias: ID_ALIAS },
       ...getSimpleFields(node).filter((n) => {
         const field = node.model.fields.find(({ name: name2 }) => name2 === n.name.value);
-        if (!field || field.relation || field.raw) {
+        if (!field || field.type === "relation" || field.type === "raw") {
           return false;
         }
-        if (field.queriableBy && !field.queriableBy.includes(node.ctx.user.role)) {
+        if (typeof field.queriable === "object" && !field.queriable.roles?.includes(node.ctx.user.role)) {
           throw new PermissionError(
             "READ",
             `${node.model.name}'s field "${field.name}"`,
@@ -2590,8 +2617,8 @@ var createRevision = async (model, data, ctx) => {
     if (model.deletable) {
       revisionData.deleted = data.deleted || false;
     }
-    for (const { name: name2, relation, nonNull: nonNull2, ...field } of model.fields.filter(({ updatable }) => updatable)) {
-      const col = relation ? `${name2}Id` : name2;
+    for (const { type, name: name2, nonNull: nonNull2, ...field } of model.fields.filter(({ updatable }) => updatable)) {
+      const col = type === "relation" ? `${name2}Id` : name2;
       if (nonNull2 && (!(col in data) || col === void 0 || col === null)) {
         revisionData[col] = get(field, "default");
       } else {
@@ -2621,7 +2648,7 @@ var sanitize = (ctx, model, data) => {
     }
   }
 };
-var isEndOfDay = (field) => field?.endOfDay === true && field?.dateTimeType === "date" && field?.type === "DateTime";
+var isEndOfDay = (field) => field.type === "DateTime" && field?.endOfDay === true && field?.dateTimeType === "date" && field?.type === "DateTime";
 
 // src/resolvers/resolvers.ts
 var getResolvers = (models) => ({
@@ -2728,7 +2755,6 @@ var getResolvers = (models) => ({
   isFieldNode,
   isFragmentSpreadNode,
   isInlineFragmentNode,
-  isJsonObjectModel,
   isListType,
   isObjectModel,
   isQueriableBy,