@smartive/graphql-magic 3.1.0 → 5.0.0

package/dist/cjs/index.cjs

@@ -53,6 +53,7 @@ __export(src_exports, {
   displayField: () => displayField,
   document: () => document,
   enm: () => enm,
+  execute: () => execute,
   fieldType: () => fieldType,
   fields: () => fields,
   generate: () => generate,
@@ -106,7 +107,6 @@ __export(src_exports, {
   isFieldNode: () => isFieldNode,
   isFragmentSpreadNode: () => isFragmentSpreadNode,
   isInlineFragmentNode: () => isInlineFragmentNode,
-  isJsonObjectModel: () => isJsonObjectModel,
   isListType: () => isListType,
   isObjectModel: () => isObjectModel,
   isQueriableBy: () => isQueriableBy,
@@ -151,6 +151,42 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
+// src/api/execute.ts
+var import_schema = require("@graphql-tools/schema");
+var import_graphql = require("graphql");
+var execute = async ({
+  additionalResolvers,
+  body,
+  ...ctx
+}) => {
+  const document2 = generate(ctx.rawModels);
+  const generatedResolvers = getResolvers(ctx.models);
+  const schema = (0, import_schema.makeExecutableSchema)({
+    typeDefs: document2,
+    resolvers: {
+      ...generatedResolvers,
+      ...additionalResolvers
+    }
+  });
+  const contextValue = {
+    document: document2,
+    ...ctx
+  };
+  const result = await (0, import_graphql.execute)({
+    schema,
+    document: (0, import_graphql.parse)(new import_graphql.Source(body.query, "GraphQL request")),
+    contextValue,
+    variableValues: body.variables,
+    operationName: body.operationName,
+    fieldResolver: (parent, _args, _ctx, info) => {
+      const node = get(info.fieldNodes, 0);
+      const alias = node.alias;
+      return parent[alias ? alias.value : node.name.value];
+    }
+  });
+  return result;
+};
+
 // src/client/gql.ts
 var gql = (chunks, ...variables) => {
   return chunks.reduce(
@@ -162,36 +198,7 @@ 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
+// src/models/utils.ts
 var import_assert = __toESM(require("assert"), 1);
 var import_inflection = require("inflection");
 var import_camelCase = __toESM(require("lodash/camelCase"), 1);
@@ -207,6 +214,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 +249,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 +292,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 +325,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 +412,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 +513,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 +573,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 +589,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 +612,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);
@@ -592,7 +658,7 @@ var generateKnexTables = (rawModels) => {
 };
 
 // src/generate/generate.ts
-var import_graphql = require("graphql");
+var import_graphql2 = require("graphql");
 var import_flatMap = __toESM(require("lodash/flatMap"), 1);
 
 // src/generate/utils.ts
@@ -764,14 +830,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 +838,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 +859,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 +874,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 +895,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 +905,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 }
               )
             )
           );
@@ -958,13 +1019,12 @@ var generateDefinitions = (rawModels) => {
 };
 var generate = (rawModels) => document(generateDefinitions(rawModels));
 var printSchema = (schema) => [
-  ...schema.getDirectives().map((d) => d.astNode && (0, import_graphql.print)(d.astNode)),
-  ...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))
+  ...schema.getDirectives().map((d) => d.astNode && (0, import_graphql2.print)(d.astNode)),
+  ...Object.values(schema.getTypeMap()).filter((t) => !t.name.match(/^__/)).sort((a, b) => a.name > b.name ? 1 : -1).map((t) => t.astNode && (0, import_graphql2.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)));
+var printSchemaFromDocument = (document2) => printSchema((0, import_graphql2.buildASTSchema)(document2));
+var printSchemaFromModels = (models) => printSchema((0, import_graphql2.buildASTSchema)(generate(models)));
 
 // src/generate/mutations.ts
 var import_upperCase = __toESM(require("lodash/upperCase"), 1);
@@ -1114,17 +1174,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 +1209,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 +1224,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 +1284,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 +1294,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 +1337,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 +1360,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 +1383,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 +1396,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 +1417,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 +1436,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 +1482,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,62 +1515,62 @@ 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}`);
     }
   }
 };
 
 // src/errors.ts
-var import_graphql2 = require("graphql");
-var GraphQLError = class extends import_graphql2.GraphQLError {
+var import_graphql3 = require("graphql");
+var GraphQLError = class extends import_graphql3.GraphQLError {
   constructor(message, extensions) {
     super(message, void 0, void 0, void 0, void 0, void 0, extensions);
   }
@@ -1534,7 +1598,7 @@ var PermissionError = class extends ForbiddenError {
 
 // src/resolvers/utils.ts
 var import_crypto = require("crypto");
-var import_graphql3 = require("graphql");
+var import_graphql4 = require("graphql");
 var ID_ALIAS = "ID";
 var getTypeName = (t) => {
   switch (t.kind) {
@@ -1555,9 +1619,9 @@ var isListType = (type) => {
       return false;
   }
 };
-var isFieldNode = (n) => n.kind === import_graphql3.Kind.FIELD;
-var isInlineFragmentNode = (n) => n.kind === import_graphql3.Kind.INLINE_FRAGMENT;
-var isFragmentSpreadNode = (n) => n.kind === import_graphql3.Kind.FRAGMENT_SPREAD;
+var isFieldNode = (n) => n.kind === import_graphql4.Kind.FIELD;
+var isInlineFragmentNode = (n) => n.kind === import_graphql4.Kind.INLINE_FRAGMENT;
+var isFragmentSpreadNode = (n) => n.kind === import_graphql4.Kind.FRAGMENT_SPREAD;
 var getType = (schema, name2) => get(schema.getType(name2), "astNode");
 var getFragmentTypeName = (node) => get(get(node.typeCondition, "name"), "value");
 function hydrate(node, raw) {
@@ -1717,7 +1781,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 +1917,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 = {
@@ -1880,27 +1944,27 @@ var addPermissions = (models, permissions, links, block) => {
 };
 
 // src/resolvers/arguments.ts
-var import_graphql4 = require("graphql");
+var import_graphql5 = require("graphql");
 function getRawValue(value2, values) {
   switch (value2.kind) {
-    case import_graphql4.Kind.LIST:
+    case import_graphql5.Kind.LIST:
       if (!values) {
         return;
       }
       return value2.values.map((value3) => getRawValue(value3, values));
-    case import_graphql4.Kind.VARIABLE:
+    case import_graphql5.Kind.VARIABLE:
       return values?.[value2.name.value];
-    case import_graphql4.Kind.INT:
+    case import_graphql5.Kind.INT:
       return parseInt(value2.value, 10);
-    case import_graphql4.Kind.NULL:
+    case import_graphql5.Kind.NULL:
       return null;
-    case import_graphql4.Kind.FLOAT:
+    case import_graphql5.Kind.FLOAT:
       return parseFloat(value2.value);
-    case import_graphql4.Kind.STRING:
-    case import_graphql4.Kind.BOOLEAN:
-    case import_graphql4.Kind.ENUM:
+    case import_graphql5.Kind.STRING:
+    case import_graphql5.Kind.BOOLEAN:
+    case import_graphql5.Kind.ENUM:
       return value2.value;
-    case import_graphql4.Kind.OBJECT: {
+    case import_graphql5.Kind.OBJECT: {
       if (!value2.fields.length) {
         return;
       }
@@ -1932,7 +1996,7 @@ var normalizeArguments = (node) => {
 };
 function normalizeValue(value2, type, schema) {
   switch (type.kind) {
-    case import_graphql4.Kind.LIST_TYPE: {
+    case import_graphql5.Kind.LIST_TYPE: {
       if (Array.isArray(value2)) {
         const res = [];
         for (const v of value2) {
@@ -1946,9 +2010,9 @@ function normalizeValue(value2, type, schema) {
       }
       return [normalizedValue];
     }
-    case import_graphql4.Kind.NON_NULL_TYPE:
+    case import_graphql5.Kind.NON_NULL_TYPE:
       return normalizeValue(value2, type.type, schema);
-    case import_graphql4.Kind.NAMED_TYPE:
+    case import_graphql5.Kind.NAMED_TYPE:
       return normalizeValueByTypeDefinition(
         value2,
         schema.getType(type.name.value)?.astNode,
@@ -1957,7 +2021,7 @@ function normalizeValue(value2, type, schema) {
   }
 }
 var normalizeValueByTypeDefinition = (value2, type, schema) => {
-  if (!type || type.kind !== import_graphql4.Kind.INPUT_OBJECT_TYPE_DEFINITION) {
+  if (!type || type.kind !== import_graphql5.Kind.INPUT_OBJECT_TYPE_DEFINITION) {
     return value2;
   }
   if (!value2) {
@@ -2038,7 +2102,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 +2216,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 +2246,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 +2259,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 +2352,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 +2654,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 +2685,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) => ({
@@ -2675,6 +2739,7 @@ var getResolvers = (models) => ({
   displayField,
   document,
   enm,
+  execute,
   fieldType,
   fields,
   generate,
@@ -2728,7 +2793,6 @@ var getResolvers = (models) => ({
   isFieldNode,
   isFragmentSpreadNode,
   isInlineFragmentNode,
-  isJsonObjectModel,
   isListType,
   isObjectModel,
   isQueriableBy,