@smartive/graphql-magic 1.0.1

package/dist/cjs/index.cjs

@@ -0,0 +1,2646 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AliasGenerator: () => AliasGenerator,
+  Enum: () => Enum,
+  ForbiddenError: () => ForbiddenError,
+  GraphQLError: () => GraphQLError,
+  ID_ALIAS: () => ID_ALIAS,
+  MigrationGenerator: () => MigrationGenerator,
+  NotFoundError: () => NotFoundError,
+  PermissionError: () => PermissionError,
+  SPECIAL_FILTERS: () => SPECIAL_FILTERS,
+  UserInputError: () => UserInputError,
+  actionableRelations: () => actionableRelations,
+  addJoin: () => addJoin,
+  and: () => and,
+  apply: () => apply,
+  applyFilters: () => applyFilters,
+  applyJoins: () => applyJoins,
+  applyPermissions: () => applyPermissions,
+  args: () => args,
+  checkCanWrite: () => checkCanWrite,
+  directive: () => directive,
+  directives: () => directives,
+  displayField: () => displayField,
+  document: () => document,
+  enm: () => enm,
+  fieldType: () => fieldType,
+  fields: () => fields,
+  generate: () => generate,
+  generateDefinitions: () => generateDefinitions,
+  generateMutations: () => generateMutations,
+  generatePermissions: () => generatePermissions,
+  get: () => get,
+  getEditEntityRelationsQuery: () => getEditEntityRelationsQuery,
+  getEntityListQuery: () => getEntityListQuery,
+  getEntityQuery: () => getEntityQuery,
+  getEntityToMutate: () => getEntityToMutate,
+  getFindEntityQuery: () => getFindEntityQuery,
+  getFragmentSpreads: () => getFragmentSpreads,
+  getFragmentTypeName: () => getFragmentTypeName,
+  getInlineFragments: () => getInlineFragments,
+  getJoins: () => getJoins,
+  getLabel: () => getLabel,
+  getManyToManyRelation: () => getManyToManyRelation,
+  getManyToManyRelations: () => getManyToManyRelations,
+  getManyToManyRelationsQuery: () => getManyToManyRelationsQuery,
+  getModelLabel: () => getModelLabel,
+  getModelLabelPlural: () => getModelLabelPlural,
+  getModelPlural: () => getModelPlural,
+  getModelPluralField: () => getModelPluralField,
+  getModelSlug: () => getModelSlug,
+  getModels: () => getModels,
+  getMutationQuery: () => getMutationQuery,
+  getNameOrAlias: () => getNameOrAlias,
+  getPermissionStack: () => getPermissionStack,
+  getResolverNode: () => getResolverNode,
+  getResolvers: () => getResolvers,
+  getRootFieldNode: () => getRootFieldNode,
+  getSimpleFields: () => getSimpleFields,
+  getString: () => getString,
+  getType: () => getType,
+  getTypeName: () => getTypeName,
+  getUpdateEntityQuery: () => getUpdateEntityQuery,
+  gql: () => gql,
+  hash: () => hash,
+  hydrate: () => hydrate,
+  iface: () => iface,
+  input: () => input,
+  inputValue: () => inputValue,
+  inputValues: () => inputValues,
+  isCreatable: () => isCreatable,
+  isCreatableBy: () => isCreatableBy,
+  isEnumList: () => isEnumList,
+  isEnumModel: () => isEnumModel,
+  isFieldNode: () => isFieldNode,
+  isFragmentSpreadNode: () => isFragmentSpreadNode,
+  isInlineFragmentNode: () => isInlineFragmentNode,
+  isJsonObjectModel: () => isJsonObjectModel,
+  isListType: () => isListType,
+  isObjectModel: () => isObjectModel,
+  isQueriableBy: () => isQueriableBy,
+  isQueriableField: () => isQueriableField,
+  isRaw: () => isRaw,
+  isRawEnumModel: () => isRawEnumModel,
+  isRawObjectModel: () => isRawObjectModel,
+  isRelation: () => isRelation,
+  isScalarModel: () => isScalarModel,
+  isSimpleField: () => isSimpleField,
+  isToOneRelation: () => isToOneRelation,
+  isUpdatable: () => isUpdatable,
+  isUpdatableBy: () => isUpdatableBy,
+  isVisible: () => isVisible,
+  isVisibleRelation: () => isVisibleRelation,
+  it: () => it,
+  list: () => list,
+  merge: () => merge,
+  mutationResolver: () => mutationResolver,
+  name: () => name,
+  namedType: () => namedType,
+  nonNull: () => nonNull,
+  normalizeArguments: () => normalizeArguments,
+  normalizeValue: () => normalizeValue,
+  normalizeValueByTypeDefinition: () => normalizeValueByTypeDefinition,
+  not: () => not,
+  object: () => object,
+  ors: () => ors,
+  printSchema: () => printSchema,
+  printSchemaFromDocument: () => printSchemaFromDocument,
+  printSchemaFromModels: () => printSchemaFromModels,
+  queryRelations: () => queryRelations,
+  queryResolver: () => queryResolver,
+  resolve: () => resolve,
+  retry: () => retry,
+  scalar: () => scalar,
+  summon: () => summon,
+  summonByKey: () => summonByKey,
+  summonByName: () => summonByName,
+  typeToField: () => typeToField,
+  value: () => value
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/client/gql.ts
+var gql = (chunks, ...variables) => {
+  return chunks.reduce(
+    (accumulator, chunk, index) => `${accumulator}${chunk}${index in variables ? variables[index] : ""}`,
+    ""
+  );
+};
+
+// 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");
+var import_camelCase = __toESM(require("lodash/camelCase"), 1);
+var import_get = __toESM(require("lodash/get"), 1);
+var import_kebabCase = __toESM(require("lodash/kebabCase"), 1);
+var import_startCase = __toESM(require("lodash/startCase"), 1);
+var isNotFalsy = (v) => typeof v !== "undefined" && v !== null && v !== false;
+var merge = (objects) => (objects || []).filter(isNotFalsy).reduce((i, acc) => ({ ...acc, ...i }), {});
+var typeToField = (type) => type.substr(0, 1).toLowerCase() + type.substr(1);
+var getModelPlural = (model) => model.plural || (0, import_inflection.pluralize)(model.name);
+var getModelPluralField = (model) => typeToField(getModelPlural(model));
+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 getModels = (rawModels) => {
+  const models = rawModels.filter(isObjectModel).map((model) => {
+    const objectModel = {
+      ...model,
+      fieldsByName: {},
+      relations: [],
+      relationsByName: {},
+      reverseRelations: [],
+      reverseRelationsByName: {},
+      fields: [
+        { 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: "createdBy",
+            type: "User",
+            relation: true,
+            nonNull: !model.nonStrict,
+            reverse: `created${getModelPlural(model)}`,
+            generated: true
+          }
+        ] : [],
+        ...model.updatable ? [
+          { name: "updatedAt", type: "DateTime", nonNull: !model.nonStrict, orderable: true, generated: true },
+          {
+            name: "updatedBy",
+            type: "User",
+            relation: true,
+            nonNull: !model.nonStrict,
+            reverse: `updated${getModelPlural(model)}`,
+            generated: true
+          }
+        ] : [],
+        ...model.deletable ? [
+          {
+            name: "deleted",
+            type: "Boolean",
+            nonNull: true,
+            default: false,
+            filterable: true,
+            defaultFilter: false,
+            generated: true
+          },
+          { name: "deletedAt", type: "DateTime", orderable: true, generated: true },
+          {
+            name: "deletedBy",
+            type: "User",
+            relation: true,
+            reverse: `deleted${getModelPlural(model)}`,
+            generated: true
+          }
+        ] : []
+      ].map(({ foreignKey, ...field }) => ({
+        ...field,
+        ...field.relation && {
+          foreignKey: foreignKey || `${field.name}Id`
+        }
+      }))
+    };
+    for (const field of objectModel.fields) {
+      objectModel.fieldsByName[field.name] = field;
+    }
+    return objectModel;
+  });
+  for (const model of models) {
+    for (const field of model.fields.filter(({ relation }) => relation)) {
+      const fieldModel = summonByName(models, field.type);
+      const reverseRelation = {
+        name: field.reverse || (field.toOne ? typeToField(model.name) : getModelPluralField(model)),
+        foreignKey: get(field, "foreignKey"),
+        type: model.name,
+        toOne: !!field.toOne,
+        fieldModel,
+        field,
+        model
+      };
+      const relation = {
+        field,
+        model: fieldModel,
+        reverseRelation
+      };
+      model.relations.push(relation);
+      model.relationsByName[relation.field.name] = relation;
+      fieldModel.reverseRelations.push(reverseRelation);
+      fieldModel.reverseRelationsByName[reverseRelation.name] = reverseRelation;
+    }
+  }
+  return models;
+};
+var summonByName = (array, value2) => summonByKey(array, "name", value2);
+var summonByKey = (array, key, value2) => summon(array, (element) => (0, import_get.default)(element, key) === value2, `No element found with ${key} ${value2}`);
+var summon = (array, cb, errorMessage) => {
+  if (array === void 0) {
+    throw new Error("Base array is not defined.");
+  }
+  const result = array.find(cb);
+  if (result === void 0) {
+    console.trace();
+    throw new Error(errorMessage || "Element not found.");
+  }
+  return result;
+};
+var it = (object2) => {
+  if (object2 === void 0 || object2 === null) {
+    console.trace();
+    throw new Error("Base object is not defined.");
+  }
+  return object2;
+};
+var get = (object2, key) => {
+  const value2 = it(object2)[key];
+  if (value2 === void 0 || value2 === null) {
+    console.trace();
+    throw new Error(`Object doesn't have ${String(key)}`);
+  }
+  return value2;
+};
+var getString = (v) => {
+  (0, import_assert.default)(typeof v === "string");
+  return v;
+};
+var retry = async (cb, condition) => {
+  try {
+    return await cb();
+  } catch (e) {
+    if (condition(e)) {
+      return await cb();
+    } else {
+      throw e;
+    }
+  }
+};
+
+// src/client/queries.ts
+var getUpdateEntityQuery = (model, role, fields2, additionalFields = "") => `query Update${model.name}Fields ($id: ID!) {
+  data: ${typeToField(model.name)}(where: { id: $id }) {
+    id
+    ${model.fields.filter(({ name: name2 }) => !fields2 || fields2.includes(name2)).filter(not(isRelation)).filter(isUpdatableBy(role)).map(({ name: name2 }) => name2).join(" ")}
+    ${actionableRelations(model, "update").filter(({ name: name2 }) => !fields2 || fields2.includes(name2)).map(({ name: name2 }) => `${name2} { id }`)}
+    ${additionalFields}
+  }
+}`;
+var getEditEntityRelationsQuery = (models, model, action, fields2, ignoreFields, additionalFields = {}) => {
+  const relations = actionableRelations(model, action).filter(
+    ({ 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);
+    return `${name2}: ${getModelPluralField(model2)} {
+            id
+            display: ${model2.displayField || ""}
+            ${additionalFields[name2] || ""}
+          }`;
+  }).join(" ")}
+    }`;
+};
+var getManyToManyRelations = (model, fields2, ignoreFields) => {
+  const manyToManyRelations = [];
+  for (const field of model.reverseRelations) {
+    if (fields2 && !fields2.includes(field.name) || ignoreFields && ignoreFields.includes(field.name)) {
+      continue;
+    }
+    const relation = field.model.relations.find(
+      (relation2) => !relation2.field.generated && relation2.field.name !== field.field.name
+    );
+    if (!relation) {
+      continue;
+    }
+    const inapplicableFields = field.model.fields.filter(
+      (otherField) => !otherField.generated && ![field.field.name, relation.field.name].includes(otherField.name)
+    );
+    if (inapplicableFields.length) {
+      continue;
+    }
+    manyToManyRelations.push([field, relation]);
+  }
+  return manyToManyRelations;
+};
+var getManyToManyRelation = (model, name2) => getManyToManyRelations(model, [name2])[0];
+var getManyToManyRelationsQuery = (model, action, manyToManyRelations) => !!manyToManyRelations.length && (action === "update" ? `query Update${model.name}ManyToManyRelations($id: ID!) {
+            ${typeToField(model.name)}(where: { id: $id }) {
+              ${manyToManyRelations.map(([reverseRelation, { field }]) => {
+  return `${reverseRelation.name} {
+                    id
+                    ${field.name} {
+                      id
+                    }
+                  }`;
+}).join(" ")}
+            }
+            ${manyToManyRelations.map(([reverseRelation, { model: model2 }]) => {
+  return `${reverseRelation.name}: ${getModelPluralField(model2)} {
+                  id
+                  ${model2.displayField || ""}
+                }`;
+}).join(" ")}
+          }` : `query Create${model.name}ManyToManyRelations {
+            ${manyToManyRelations.map(([reverseRelation, { model: model2 }]) => {
+  return `${reverseRelation.name}: ${getModelPluralField(model2)} {
+                  id
+                  ${model2.displayField || ""}
+                }`;
+}).join(" ")}
+          }`);
+var getMutationQuery = (model, action) => action === "create" ? `
+        mutation Create${model.name} ($data: Create${model.name}!) {
+          mutated: create${model.name}(data: $data) {
+            id
+          }
+        }
+        ` : action === "update" ? `
+        mutation Update${model.name} ($id: ID!, $data: Update${model.name}!) {
+          mutated: update${model.name}(where: { id: $id } data: $data) {
+            id
+          }
+        }
+        ` : `
+        mutation Delete${model.name} ($id: ID!) {
+          mutated: delete${model.name}(where: { id: $id }) {
+            id
+          }
+        }
+        `;
+var displayField = (model) => `
+${model.displayField ? `display: ${model.displayField}` : ""}
+`;
+var getEntityListQuery = (model, role, additionalFields = "", root) => `query ${getModelPlural(model)}List(
+  ${root ? "$id: ID!," : ""}
+  $limit: Int!,
+  $where: ${model.name}Where!,
+  ${model.fields.some(({ searchable }) => searchable) ? "$search: String," : ""}
+) {
+  ${root ? `root: ${typeToField(root.model.name)}(where: { id: $id }) {` : ""}
+    data: ${root ? root.reverseRelationName : getModelPluralField(model)}(limit: $limit, where: $where, ${model.fields.some(({ searchable }) => searchable) ? ", search: $search" : ""}) {
+      ${displayField(model)}
+      ${model.fields.filter(and(isSimpleField, isQueriableBy(role))).map(({ name: name2 }) => name2)}
+      ${additionalFields}
+    }
+  ${root ? "}" : ""}
+}`;
+var getEntityQuery = (models, model, role, visibleRelationsByRole, typesWithSubRelations) => `query Admin${model.name} ($id: ID!) {
+  data: ${typeToField(model.name)}(where: { id: $id }) {
+    ${displayField(model)}
+    ${model.fields.filter(and(isSimpleField, isQueriableBy(role))).map(({ name: name2 }) => name2)}
+    ${queryRelations(
+  models,
+  model.fields.filter(and(isRelation, isVisibleRelation(visibleRelationsByRole, model.name, role))),
+  role,
+  typesWithSubRelations
+)}
+    ${queryRelations(
+  models,
+  model.reverseRelations.filter(and(isToOneRelation, isVisibleRelation(visibleRelationsByRole, model.name, role))),
+  role,
+  typesWithSubRelations
+)}
+  }
+}`;
+var getFindEntityQuery = (model, role) => `query Find${model.name}($where: ${model.name}Where!, $orderBy: [${model.name}OrderBy!]) {
+  data: ${getModelPluralField(model)}(limit: 1, where: $where, orderBy: $orderBy) {
+    ${model.fields.filter(and(isSimpleField, isQueriableBy(role))).map(({ name: name2 }) => name2)}
+  }
+}`;
+var queryRelations = (models, relations, role, typesWithSubRelations) => relations.map(({ name: name2, type }) => {
+  const relatedModel = summonByName(models, type);
+  const subRelations = typesWithSubRelations.includes(type) ? relatedModel.fields.filter(isRelation) : [];
+  return `${name2} {
+          id
+          ${displayField(relatedModel)}
+          ${subRelations.length > 0 ? queryRelations(models, subRelations, role, typesWithSubRelations) : ""}
+        }`;
+}).join("\n");
+
+// src/generate/generate.ts
+var import_graphql = require("graphql");
+var import_flatMap = __toESM(require("lodash/flatMap"), 1);
+
+// src/generate/utils.ts
+var import_luxon = require("luxon");
+
+// src/values.ts
+var Enum = class {
+  constructor(value2) {
+    this.value = value2;
+  }
+};
+
+// src/generate/utils.ts
+var document = (definitions) => ({
+  kind: "Document",
+  definitions
+});
+var directive = (nme, locations, fields2) => ({
+  name: name(nme),
+  repeatable: false,
+  kind: "DirectiveDefinition",
+  arguments: fields2 && inputValues(fields2),
+  locations: locations.map(name)
+});
+var scalar = (nme) => ({
+  name: name(nme),
+  kind: "ScalarTypeDefinition"
+});
+var input = (nme, fields2, dvs) => ({
+  name: name(nme),
+  fields: inputValues(fields2),
+  kind: "InputObjectTypeDefinition",
+  directives: directives(dvs)
+});
+var object = (nme, fds, interfaces, dvs) => ({
+  name: name(nme),
+  fields: fields(fds),
+  kind: "ObjectTypeDefinition",
+  interfaces: interfaces && interfaces.map((i) => namedType(i)),
+  directives: directives(dvs)
+});
+var iface = (nme, fds, dvs) => ({
+  name: name(nme),
+  fields: fields(fds),
+  kind: "InterfaceTypeDefinition",
+  directives: directives(dvs)
+});
+var inputValues = (fields2) => fields2.map(
+  (field) => ({
+    kind: "InputValueDefinition",
+    name: name(field.name),
+    type: fieldType(field),
+    defaultValue: field.default === void 0 ? void 0 : value(field.default),
+    directives: directives(field.directives)
+  })
+);
+var fields = (fields2) => fields2.map(
+  (field) => ({
+    kind: "FieldDefinition",
+    name: name(field.name),
+    type: fieldType(field),
+    arguments: field.args?.map((arg) => ({
+      kind: "InputValueDefinition",
+      name: name(arg.name),
+      type: fieldType(arg),
+      defaultValue: arg.default === void 0 ? void 0 : value(arg.default)
+    })),
+    directives: directives(field.directives)
+  })
+);
+var inputValue = (nme, type, dvs, description, defaultValue) => ({
+  name: name(nme),
+  type,
+  kind: "InputValueDefinition",
+  directives: directives(dvs),
+  defaultValue: defaultValue ? value(defaultValue) : void 0,
+  description: description ? value(description) : void 0
+});
+var directives = (directives2) => directives2?.map(
+  (directive2) => ({
+    kind: "Directive",
+    name: name(directive2.name),
+    arguments: args(directive2.values)
+  })
+);
+var args = (ags) => ags?.map(
+  (argument) => ({
+    kind: "Argument",
+    name: name(argument.name),
+    value: value(argument.values)
+  })
+);
+var enm = (nme, values) => ({
+  name: name(nme),
+  kind: "EnumTypeDefinition",
+  values: values.map(
+    (v) => ({
+      kind: "EnumValueDefinition",
+      name: name(v)
+    })
+  )
+});
+var nonNull = (type) => ({
+  type,
+  kind: "NonNullType"
+});
+var namedType = (nme) => ({
+  kind: "NamedType",
+  name: name(nme)
+});
+var list = (type) => ({
+  type,
+  kind: "ListType"
+});
+var name = (name2) => ({
+  kind: "Name",
+  value: name2
+});
+var fieldType = (field) => {
+  let type = namedType(field.type);
+  if (field.list) {
+    type = list(nonNull(type));
+  }
+  if (field.nonNull) {
+    type = nonNull(type);
+  }
+  return type;
+};
+var value = (val = null) => val === null ? {
+  kind: "NullValue"
+} : typeof val === "boolean" ? {
+  kind: "BooleanValue",
+  value: val
+} : typeof val === "number" ? {
+  kind: "IntValue",
+  value: `${val}`
+} : typeof val === "string" ? {
+  kind: "StringValue",
+  value: val
+} : val instanceof Enum ? {
+  kind: "EnumValue",
+  value: val.value
+} : Array.isArray(val) ? {
+  kind: "ListValue",
+  values: val.map(value)
+} : val instanceof import_luxon.DateTime ? {
+  kind: "StringValue",
+  value: val.toString()
+} : {
+  kind: "ObjectValue",
+  fields: Object.keys(val).map(
+    (nme) => ({
+      kind: "ObjectField",
+      name: name(nme),
+      value: value(val[nme])
+    })
+  )
+};
+
+// src/generate/generate.ts
+var generateDefinitions = (rawModels) => {
+  const models = getModels(rawModels);
+  return [
+    // Predefined types
+    enm("Order", ["ASC", "DESC"]),
+    scalar("DateTime"),
+    scalar("Upload"),
+    ...rawModels.filter(isEnumModel).map((model) => enm(model.name, model.values)),
+    ...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 = [
+          object(
+            model.name,
+            [
+              ...model.fields.filter(isQueriableField).map((field) => ({
+                ...field,
+                args: [
+                  ...field.args || [],
+                  ...hasRawFilters(rawModels, field.type) ? [{ name: "where", type: `${field.type}Where` }] : []
+                ],
+                directives: field.directives
+              })),
+              ...model.reverseRelations.map(({ name: name2, field, model: model2 }) => ({
+                name: name2,
+                type: model2.name,
+                list: !field.toOne,
+                nonNull: !field.toOne,
+                args: [
+                  { name: "where", type: `${model2.name}Where` },
+                  ...model2.fields.some(({ searchable }) => searchable) ? [{ name: "search", type: "String" }] : [],
+                  ...model2.fields.some(({ orderable }) => orderable) ? [{ name: "orderBy", type: `${model2.name}OrderBy`, list: true }] : [],
+                  { name: "limit", type: "Int" },
+                  { name: "offset", type: "Int" }
+                ]
+              }))
+            ],
+            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 })),
+            ...(0, import_flatMap.default)(
+              model.fields.filter(({ comparable }) => comparable),
+              ({ name: name2, type }) => [
+                { name: `${name2}_GT`, type },
+                { name: `${name2}_GTE`, type },
+                { name: `${name2}_LT`, type },
+                { name: `${name2}_LTE`, type }
+              ]
+            ),
+            ...model.fields.filter(({ filterable, relation }) => filterable && relation).map(({ name: name2, type }) => ({
+              name: name2,
+              type: `${type}Where`
+            }))
+          ]),
+          input(
+            `${model.name}WhereUnique`,
+            model.fields.filter(({ unique }) => unique).map(({ name: name2, type }) => ({ name: name2, type }))
+          ),
+          ...model.fields.some(({ orderable }) => orderable) ? [
+            input(
+              `${model.name}OrderBy`,
+              model.fields.filter(({ orderable }) => orderable).map(({ name: name2 }) => ({ name: name2, type: "Order" }))
+            )
+          ] : []
+        ];
+        if (model.creatable) {
+          types.push(
+            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 }
+              )
+            )
+          );
+        }
+        if (model.updatable) {
+          types.push(
+            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 }
+              )
+            )
+          );
+        }
+        return types;
+      })
+    ),
+    object("Query", [
+      {
+        name: "me",
+        type: "User"
+      },
+      ...models.filter(({ queriable }) => queriable).map(({ name: name2 }) => ({
+        name: typeToField(name2),
+        type: name2,
+        nonNull: true,
+        args: [
+          {
+            name: "where",
+            type: `${name2}WhereUnique`,
+            nonNull: true
+          }
+        ]
+      })),
+      ...models.filter(({ listQueriable }) => listQueriable).map((model) => ({
+        name: getModelPluralField(model),
+        type: model.name,
+        list: true,
+        nonNull: true,
+        args: [
+          { name: "where", type: `${model.name}Where` },
+          ...model.fields.some(({ searchable }) => searchable) ? [{ name: "search", type: "String" }] : [],
+          ...model.fields.some(({ orderable }) => orderable) ? [{ name: "orderBy", type: `${model.name}OrderBy`, list: true }] : [],
+          { name: "limit", type: "Int" },
+          { name: "offset", type: "Int" }
+        ]
+      }))
+    ]),
+    object("Mutation", [
+      ...(0, import_flatMap.default)(
+        models.map((model) => {
+          const mutations = [];
+          if (model.creatable) {
+            mutations.push({
+              name: `create${model.name}`,
+              type: model.name,
+              nonNull: true,
+              args: [
+                {
+                  name: "data",
+                  type: `Create${model.name}`,
+                  nonNull: true
+                }
+              ]
+            });
+          }
+          if (model.updatable) {
+            mutations.push({
+              name: `update${model.name}`,
+              type: model.name,
+              nonNull: true,
+              args: [
+                {
+                  name: "where",
+                  type: `${model.name}WhereUnique`,
+                  nonNull: true
+                },
+                {
+                  name: "data",
+                  type: `Update${model.name}`,
+                  nonNull: true
+                }
+              ]
+            });
+          }
+          if (model.deletable) {
+            mutations.push({
+              name: `delete${model.name}`,
+              type: "ID",
+              nonNull: true,
+              args: [
+                {
+                  name: "where",
+                  type: `${model.name}WhereUnique`,
+                  nonNull: true
+                },
+                {
+                  name: "dryRun",
+                  type: "Boolean"
+                }
+              ]
+            });
+            mutations.push({
+              name: `restore${model.name}`,
+              type: "ID",
+              nonNull: true,
+              args: [
+                {
+                  name: "where",
+                  type: `${model.name}WhereUnique`,
+                  nonNull: true
+                }
+              ]
+            });
+          }
+          return mutations;
+        })
+      )
+    ])
+  ];
+};
+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))
+].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)));
+
+// src/generate/mutations.ts
+var import_upperCase = __toESM(require("lodash/upperCase"), 1);
+var constantCase = (str) => (0, import_upperCase.default)(str).replace(/ /g, "_");
+var generateMutations = (models) => {
+  const parts = [];
+  for (const { name: name2, creatable, updatable, deletable } of models) {
+    if (creatable) {
+      parts.push(
+        `export const CREATE_${constantCase(
+          name2
+        )} = gql\`
+  mutation Create${name2}Mutation($data: Create${name2}!) {
+    create${name2}(data: $data) { id }
+  }
+\`;`
+      );
+    }
+    if (updatable) {
+      parts.push(
+        `export const UPDATE_${constantCase(
+          name2
+        )} = gql\`
+  mutation Update${name2}Mutation($id: ID!, $data: Update${name2}!) {
+    update${name2}(where: { id: $id }, data: $data) { id }
+  }
+\`;`
+      );
+    }
+    if (deletable) {
+      parts.push(
+        `export const DELETE_${constantCase(
+          name2
+        )} = gql\`
+  mutation Delete${name2}Mutation($id: ID!) {
+    delete${name2}(where: { id: $id })
+  }
+\`;`
+      );
+    }
+  }
+  return `import { gql } from "@smartive-private/graphql-magic";
+
+${parts.join("\n\n")}`;
+};
+
+// src/migrations/generate.ts
+var import_code_block_writer = __toESM(require("code-block-writer"), 1);
+var import_knex_schema_inspector = require("knex-schema-inspector");
+var import_lowerFirst = __toESM(require("lodash/lowerFirst"), 1);
+var MigrationGenerator = class {
+  constructor(knex, rawModels) {
+    this.rawModels = rawModels;
+    this.schema = (0, import_knex_schema_inspector.SchemaInspector)(knex);
+    this.models = getModels(rawModels);
+  }
+  writer = new (import_code_block_writer.default["default"] || import_code_block_writer.default)({
+    useSingleQuote: true,
+    indentNumberOfSpaces: 2
+  });
+  schema;
+  columns = {};
+  uuidUsed;
+  nowUsed;
+  models;
+  async generate() {
+    const { writer, schema, rawModels, models } = this;
+    const enums = (await schema.knex("pg_type").where({ typtype: "e" }).select("typname")).map(({ typname }) => typname);
+    const tables = await schema.tables();
+    for (const table of tables) {
+      this.columns[table] = await schema.columnInfo(table);
+    }
+    const up = [];
+    const down = [];
+    this.createEnums(
+      rawModels.filter(isEnumModel).filter((enm2) => !enums.includes((0, import_lowerFirst.default)(enm2.name))),
+      up,
+      down
+    );
+    for (const model of models) {
+      if (model.deleted) {
+        up.push(() => {
+          this.dropTable(model.name);
+        });
+        down.push(() => {
+          this.createTable(model.name, () => {
+            for (const field of model.fields) {
+              this.column(field);
+            }
+          });
+        });
+        if (model.updatable) {
+          up.push(() => {
+            this.dropTable(`${model.name}Revision`);
+          });
+          down.push(() => {
+            this.createRevisionTable(model);
+          });
+        }
+      }
+      if (model.oldName) {
+        up.push(() => {
+          this.renameTable(model.oldName, model.name);
+        });
+        down.push(() => {
+          this.renameTable(model.name, model.oldName);
+        });
+        tables[tables.indexOf(model.oldName)] = model.name;
+        this.columns[model.name] = this.columns[model.oldName];
+        delete this.columns[model.oldName];
+        if (model.updatable) {
+          up.push(() => {
+            this.renameTable(`${model.oldName}Revision`, `${model.name}Revision`);
+            this.alterTable(`${model.name}Revision`, () => {
+              this.renameColumn(`${typeToField(get(model, "oldName"))}Id`, `${typeToField(model.name)}Id`);
+            });
+          });
+          down.push(() => {
+            this.renameTable(`${model.name}Revision`, `${model.oldName}Revision`);
+            this.alterTable(`${model.oldName}Revision`, () => {
+              this.renameColumn(`${typeToField(model.name)}Id`, `${typeToField(get(model, "oldName"))}Id`);
+            });
+          });
+          tables[tables.indexOf(`${model.oldName}Revision`)] = `${model.name}Revision`;
+          this.columns[`${model.name}Revision`] = this.columns[`${model.oldName}Revision`];
+          delete this.columns[`${model.oldName}Revision`];
+        }
+      }
+      if (!tables.includes(model.name)) {
+        up.push(() => {
+          this.createTable(model.name, () => {
+            for (const field of model.fields) {
+              this.column(field);
+            }
+          });
+        });
+        down.push(() => {
+          this.dropTable(model.name);
+        });
+      } else {
+        this.renameFields(
+          model,
+          model.fields.filter(({ oldName }) => oldName),
+          up,
+          down
+        );
+        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)))
+          ),
+          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));
+          if (!col) {
+            return false;
+          }
+          return !model.nonStrict && !nonNull2 && !col.is_nullable;
+        });
+        this.updateFields(model, existingFields, up, down);
+      }
+      if (model.updatable) {
+        if (!tables.includes(`${model.name}Revision`)) {
+          up.push(() => {
+            this.createRevisionTable(model);
+          });
+          if (tables.includes(model.name)) {
+            up.push(() => {
+              writer.block(() => {
+                writer.writeLine(`const data = await knex('${model.name}');`);
+                writer.write(`if (data.length)`).block(() => {
+                  writer.write(`await knex.batchInsert('${model.name}Revision', data.map((row) => (`).inlineBlock(() => {
+                    writer.writeLine(`id: uuid(),`);
+                    writer.writeLine(`${typeToField(model.name)}Id: row.id,`);
+                    this.nowUsed = true;
+                    writer.writeLine(`createdAt: row.updatedAt || row.createdAt || now,`);
+                    writer.writeLine(`createdById: row.updatedById || row.createdById,`);
+                    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;
+                      writer.writeLine(`${col}: row.${col},`);
+                    }
+                  }).write(")));").newLine();
+                });
+              }).blankLine();
+            });
+          }
+          down.push(() => {
+            this.dropTable(`${model.name}Revision`);
+          });
+        } 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)))
+          );
+          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)))
+          );
+          this.createRevisionFields(model, revisionFieldsToRemove, down, up);
+        }
+      }
+    }
+    for (const model of getModels(rawModels)) {
+      if (tables.includes(model.name)) {
+        this.createFields(
+          model,
+          model.fields.filter(({ name: name2, deleted }) => deleted && this.columns[model.name].some((col) => col.name === name2)),
+          down,
+          up
+        );
+        if (model.updatable) {
+          this.createRevisionFields(
+            model,
+            model.fields.filter(({ deleted, updatable }) => updatable && deleted),
+            down,
+            up
+          );
+        }
+      }
+    }
+    this.createEnums(
+      rawModels.filter(isEnumModel).filter((enm2) => enm2.deleted),
+      down,
+      up
+    );
+    writer.writeLine(`import { Knex } from 'knex';`);
+    if (this.uuidUsed) {
+      writer.writeLine(`import { v4 as uuid } from 'uuid';`);
+    }
+    if (this.nowUsed) {
+      writer.writeLine(`import { date } from '../src/utils/dates';`);
+    }
+    writer.blankLine();
+    if (this.nowUsed) {
+      writer.writeLine(`const now = date();`).blankLine();
+    }
+    this.migration("up", up);
+    this.migration("down", down.reverse());
+    return writer.toString();
+  }
+  renameFields(model, fields2, up, down) {
+    if (!fields2.length) {
+      return;
+    }
+    up.push(() => {
+      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
+          );
+        });
+      }
+    });
+    down.push(() => {
+      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")
+          );
+        });
+      }
+    });
+    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;
+    }
+  }
+  createFields(model, fields2, up, down) {
+    if (!fields2.length) {
+      return;
+    }
+    up.push(() => {
+      const alter = [];
+      const updates = [];
+      const postAlter = [];
+      for (const field of fields2) {
+        alter.push(() => this.column(field, { setNonNull: field.default !== void 0 }));
+        if (field.nonNull && field.default === void 0) {
+          updates.push(() => this.writer.write(`${field.name}: 'TODO',`).newLine());
+          postAlter.push(() => this.column(field, { alter: true, foreign: false }));
+        }
+      }
+      if (alter.length) {
+        this.alterTable(model.name, () => {
+          alter.map((cb) => cb());
+        });
+      }
+      if (updates.length) {
+        this.writer.write(`await knex('${model.name}').update(`).inlineBlock(() => {
+          updates.map((cb) => cb());
+        }).write(");").newLine().blankLine();
+      }
+      if (postAlter.length) {
+        this.alterTable(model.name, () => {
+          postAlter.map((cb) => cb());
+        });
+      }
+    });
+    down.push(() => {
+      this.alterTable(model.name, () => {
+        for (const { relation, name: name2 } of fields2) {
+          this.dropColumn(relation ? `${name2}Id` : name2);
+        }
+      });
+    });
+  }
+  updateFields(model, fields2, up, down) {
+    if (!fields2.length) {
+      return;
+    }
+    up.push(() => {
+      this.alterTable(model.name, () => {
+        for (const field of fields2) {
+          this.column(field, { alter: true });
+        }
+      });
+    });
+    down.push(() => {
+      this.alterTable(model.name, () => {
+        for (const field of fields2) {
+          this.column(
+            field,
+            { alter: true },
+            summonByName(this.columns[model.name], field.relation ? `${field.name}Id` : field.name)
+          );
+        }
+      });
+    });
+    if (model.updatable) {
+      const updatableFields = fields2.filter(({ updatable }) => updatable);
+      if (!updatableFields.length) {
+        return;
+      }
+      up.push(() => {
+        this.alterTable(`${model.name}Revision`, () => {
+          for (const field of updatableFields) {
+            this.column(field, { alter: true });
+          }
+        });
+      });
+      down.push(() => {
+        this.alterTable(`${model.name}Revision`, () => {
+          for (const field of updatableFields) {
+            this.column(
+              field,
+              { alter: true },
+              summonByName(this.columns[model.name], field.relation ? `${field.name}Id` : field.name)
+            );
+          }
+        });
+      });
+    }
+  }
+  createRevisionTable(model) {
+    const writer = this.writer;
+    this.createTable(`${model.name}Revision`, () => {
+      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(";").newLine();
+      writer.writeLine(`table.timestamp('createdAt').notNullable().defaultTo(knex.fn.now(0));`);
+      if (model.deletable) {
+        writer.writeLine(`table.boolean('deleted').notNullable();`);
+      }
+      for (const field of model.fields.filter((field2) => field2.updatable)) {
+        this.column(field, { setUnique: false, setDefault: false });
+      }
+    });
+  }
+  createRevisionFields(model, missingRevisionFields, up, down) {
+    const revisionTable = `${model.name}Revision`;
+    if (missingRevisionFields.length) {
+      up.push(() => {
+        this.alterTable(revisionTable, () => {
+          for (const field of missingRevisionFields) {
+            this.column(field, { setUnique: false, setNonNull: false, setDefault: false });
+          }
+        });
+        this.writer.write(`await knex('${model.name}Revision').update(`).inlineBlock(() => {
+          for (const { name: name2, relation } of missingRevisionFields) {
+            const col = 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();
+          }
+        }).write(");").newLine().blankLine();
+        const nonNullableMissingRevisionFields = missingRevisionFields.filter(({ nonNull: nonNull2 }) => nonNull2);
+        if (nonNullableMissingRevisionFields.length) {
+          this.alterTable(revisionTable, () => {
+            for (const field of nonNullableMissingRevisionFields) {
+              this.column(field, { setUnique: false, setDefault: false, alter: true });
+            }
+          });
+        }
+      });
+      down.push(() => {
+        this.alterTable(revisionTable, () => {
+          for (const field of missingRevisionFields) {
+            this.dropColumn(field.relation ? `${field.name}Id` : field.name);
+          }
+        });
+      });
+    }
+  }
+  createEnums(enums, up, down) {
+    for (const enm2 of enums) {
+      const name2 = (0, import_lowerFirst.default)(enm2.name);
+      up.push(
+        () => this.writer.writeLine(
+          `await knex.raw(\`CREATE TYPE "${name2}" AS ENUM (${enm2.values.map((value2) => `'${value2}'`).join(",")})\`);`
+        ).newLine()
+      );
+      down.push(() => this.writer.writeLine(`await knex.raw('DROP TYPE "${name2}"')`));
+    }
+  }
+  migration(name2, cbs) {
+    return this.writer.write(`export const ${name2} = async (knex: Knex) => `).inlineBlock(() => {
+      cbs.map((cb) => cb());
+    }).write(";").newLine().blankLine();
+  }
+  createTable(table, block) {
+    return this.writer.write(`await knex.schema.createTable('${table}', (table) => `).inlineBlock(block).write(");").newLine().blankLine();
+  }
+  alterTable(table, block) {
+    return this.writer.write(`await knex.schema.alterTable('${table}', (table) => `).inlineBlock(block).write(");").newLine().blankLine();
+  }
+  dropColumn(col) {
+    return this.writer.writeLine(`table.dropColumn('${col}');`);
+  }
+  dropTable(table) {
+    return this.writer.writeLine(`await knex.schema.dropTable('${table}');`).blankLine();
+  }
+  renameTable(from, to) {
+    return this.writer.writeLine(`await knex.schema.renameTable('${from}', '${to}');`).blankLine();
+  }
+  renameColumn(from, to) {
+    this.writer.writeLine(`table.renameColumn('${from}', '${to}')`);
+  }
+  value(value2) {
+    if (typeof value2 === "string") {
+      return `'${value2}'`;
+    }
+    return value2;
+  }
+  column({ name: name2, relation, type, primary, list: list2, ...field }, { setUnique = true, setNonNull = true, alter = false, foreign = true, setDefault = true } = {}, toColumn) {
+    const col = (what) => {
+      if (what) {
+        this.writer.write(what);
+      }
+      if (setNonNull) {
+        if (toColumn) {
+          if (toColumn.is_nullable) {
+            this.writer.write(`.nullable()`);
+          } else {
+            this.writer.write(".notNullable()");
+          }
+        } else {
+          if (field.nonNull) {
+            this.writer.write(`.notNullable()`);
+          } else {
+            this.writer.write(".nullable()");
+          }
+        }
+      }
+      if (setDefault && field.default !== void 0) {
+        this.writer.write(`.defaultTo(${this.value(field.default)})`);
+      }
+      if (primary) {
+        this.writer.write(".primary()");
+      } else if (setUnique && field.unique) {
+        this.writer.write(".unique()");
+      }
+      if (alter) {
+        this.writer.write(".alter()");
+      }
+      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}`);
+      }
+    }
+  }
+};
+
+// src/errors.ts
+var import_graphql2 = require("graphql");
+var GraphQLError = class extends import_graphql2.GraphQLError {
+  constructor(message, extensions) {
+    super(message, void 0, void 0, void 0, void 0, void 0, extensions);
+  }
+};
+var ForbiddenError = class extends GraphQLError {
+  constructor(what) {
+    super(what, { code: "FORBIDDEN" });
+  }
+};
+var NotFoundError = class extends GraphQLError {
+  constructor(what) {
+    super(what, { code: "NOT_FOUND" });
+  }
+};
+var UserInputError = class extends GraphQLError {
+  constructor(what) {
+    super(what, { code: "BAD_USER_INPUT" });
+  }
+};
+var PermissionError = class extends ForbiddenError {
+  constructor(action, what) {
+    super(`You do not have sufficient permissions to ${action.toLowerCase()} ${what}.`);
+  }
+};
+
+// src/resolvers/utils.ts
+var import_crypto = require("crypto");
+var import_graphql3 = require("graphql");
+var ID_ALIAS = "ID";
+var getTypeName = (t) => {
+  switch (t.kind) {
+    case "ListType":
+    case "NonNullType":
+      return getTypeName(t.type);
+    default:
+      return t.name.value;
+  }
+};
+var isListType = (type) => {
+  switch (type.kind) {
+    case "ListType":
+      return true;
+    case "NonNullType":
+      return isListType(type.type);
+    default:
+      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 getType = (schema, name2) => get(schema.getType(name2), "astNode");
+var getFragmentTypeName = (node) => get(get(node.typeCondition, "name"), "value");
+function hydrate(node, raw) {
+  const tableAlias = node.tableAlias;
+  const res = raw.map((entry) => {
+    const res2 = {};
+    outer:
+      for (const [column, value2] of Object.entries(entry)) {
+        let current = res2;
+        const shortParts = column.split("__");
+        const fieldName = shortParts.pop();
+        const columnWithoutField = shortParts.join("__");
+        const longColumn = node.ctx.aliases.getLong(columnWithoutField);
+        const longColumnWithoutRoot = longColumn.replace(new RegExp(`^${tableAlias}(__)?`), "");
+        const allParts = [tableAlias, ...longColumnWithoutRoot ? longColumnWithoutRoot.split("__") : [], fieldName];
+        for (let i = 0; i < allParts.length - 1; i++) {
+          const part = allParts[i];
+          if (!current[part]) {
+            const idField = [node.ctx.aliases.getShort(allParts.slice(0, i + 1).join("__")), ID_ALIAS].join("__");
+            if (!entry[idField]) {
+              continue outer;
+            }
+            current[part] = {};
+          }
+          current = current[part];
+        }
+        current[it(fieldName)] = value2;
+      }
+    return res2[tableAlias];
+  });
+  return res;
+}
+var ors = (query, [first, ...rest]) => {
+  if (!first) {
+    return query;
+  }
+  return query.where((subQuery) => {
+    subQuery.where((subSubQuery) => {
+      first(subSubQuery);
+    });
+    for (const cb of rest) {
+      subQuery.orWhere((subSubQuery) => {
+        cb(subSubQuery);
+      });
+    }
+  });
+};
+var getNameOrAlias = (node) => {
+  const name2 = node.alias ? node.alias.value : node.name.value;
+  if ([ID_ALIAS].indexOf(name2) >= 0) {
+    throw new UserInputError(`"${name2}" can not be used as alias since it's a reserved word`);
+  }
+  return name2;
+};
+var apply = (target, ops) => ops.reduce((target2, op) => op(target2), target);
+var applyJoins = (aliases, query, joins) => {
+  for (const [tableName, { table1Alias, column1, column2 }] of Object.entries(joins)) {
+    const [table, alias] = tableName.split(":");
+    const table1ShortAlias = aliases.getShort(table1Alias);
+    const table2ShortAlias = aliases.getShort(alias);
+    query.leftJoin(`${table} as ${table2ShortAlias}`, `${table1ShortAlias}.${column1}`, `${table2ShortAlias}.${column2}`);
+  }
+};
+var addJoin = (joins, table1Alias, table2, alias2, column1, column2) => {
+  joins[`${table2}:${alias2}`] ||= { table1Alias, column1, column2 };
+};
+var AliasGenerator = class {
+  reverse = {};
+  getShort(long) {
+    if (!long) {
+      const short2 = `a${Object.keys(this.reverse).length}`;
+      return this.reverse[short2] = short2;
+    }
+    const shortPrefix = long.split("__").map((part) => part[0] + part.slice(1).replaceAll(/[a-z]+/g, "")).join("__");
+    let postfix = 0;
+    let short = shortPrefix + (postfix || "");
+    while (short in this.reverse && this.reverse[short] !== long) {
+      short = shortPrefix + ++postfix;
+    }
+    this.reverse[short] = long;
+    return short;
+  }
+  getLong(short) {
+    return get(this.reverse, short);
+  }
+};
+var hash = (s) => (0, import_crypto.createHash)("md5").update(JSON.stringify(s)).digest("hex");
+
+// src/permissions/check.ts
+var getPermissionStack = (ctx, type, action) => {
+  const rolePermissions = ctx.permissions[ctx.user.role];
+  if (typeof rolePermissions === "boolean" || rolePermissions === void 0) {
+    return !!rolePermissions;
+  }
+  const typePermissions = rolePermissions[type];
+  if (typeof typePermissions === "boolean" || typePermissions === void 0) {
+    return !!typePermissions;
+  }
+  const actionPermission = typePermissions[action];
+  if (typeof actionPermission === "boolean" || actionPermission === void 0) {
+    return !!actionPermission;
+  }
+  return actionPermission;
+};
+var applyPermissions = (ctx, type, tableAlias, query, action, verifiedPermissionStack) => {
+  const permissionStack = getPermissionStack(ctx, type, action);
+  if (permissionStack === true) {
+    return permissionStack;
+  }
+  if (permissionStack === false) {
+    query.where(false);
+    return permissionStack;
+  }
+  if (verifiedPermissionStack?.every(
+    (prefixChain) => permissionStack.some(
+      (chain) => hash(prefixChain) === hash(chain.slice(0, -1)) && // TODO: this is stricter than it could be if we add these checks to the query
+      !("where" in get(chain, chain.length - 1)) && !("me" in get(chain, chain.length - 1))
+    )
+  )) {
+    return permissionStack;
+  }
+  ors(
+    query,
+    permissionStack.map(
+      (links) => (query2) => query2.whereNull(`${tableAlias}.id`).orWhereExists((subQuery) => permissionLinkQuery(ctx, subQuery, links, ctx.knex.raw(`"${tableAlias}".id`)))
+    )
+  );
+  return permissionStack;
+};
+var getEntityToMutate = async (ctx, model, where, action) => {
+  const query = ctx.knex(model.name).where(where).first();
+  let entity = await query.clone();
+  if (!entity) {
+    throw new NotFoundError("Entity to mutate");
+  }
+  applyPermissions(ctx, model.name, model.name, query, action);
+  entity = await query;
+  if (!entity) {
+    throw new PermissionError(action, `this ${model.name}`);
+  }
+  return entity;
+};
+var checkCanWrite = async (ctx, model, data, action) => {
+  const permissionStack = getPermissionStack(ctx, model.name, action);
+  if (permissionStack === true) {
+    return;
+  }
+  if (permissionStack === false) {
+    throw new PermissionError(action, getModelPlural(model));
+  }
+  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))) {
+    const foreignKey = field.foreignKey || `${field.name}Id`;
+    const foreignId = data[foreignKey];
+    if (!foreignId) {
+      continue;
+    }
+    const fieldPermissions = field[action === "CREATE" ? "creatableBy" : "updatableBy"];
+    if (fieldPermissions && !fieldPermissions.includes(ctx.user.role)) {
+      throw new PermissionError(action, `this ${model.name}'s ${field.name}`);
+    }
+    linked = true;
+    const fieldPermissionStack = getPermissionStack(ctx, field.type, "LINK");
+    if (fieldPermissionStack === true) {
+      query.whereExists((subQuery) => subQuery.from(`${field.type} as a`).whereRaw(`a.id = ?`, foreignId));
+      continue;
+    }
+    if (fieldPermissionStack === false || !fieldPermissionStack.length) {
+      throw new PermissionError(action, `this ${model.name}'s ${field.name}`);
+    }
+    ors(
+      query,
+      fieldPermissionStack.map(
+        (links) => (query2) => query2.whereExists((subQuery) => permissionLinkQuery(ctx, subQuery, links, foreignId))
+      )
+    );
+  }
+  if (linked) {
+    const canMutate = await query;
+    if (!canMutate) {
+      throw new PermissionError(action, `this ${model.name} because there are no entities you can link it to`);
+    }
+  } else if (action === "CREATE") {
+    throw new PermissionError(action, `this ${model.name} because there are no entity types you can link it to`);
+  }
+};
+var permissionLinkQuery = (ctx, subQuery, links, id) => {
+  const aliases = new AliasGenerator();
+  let alias = aliases.getShort();
+  const { type, me, where } = links[0];
+  subQuery.from(`${type} as ${alias}`);
+  if (me) {
+    subQuery.where({ [`${alias}.id`]: ctx.user.id });
+  }
+  if (where) {
+    applyWhere(summonByName(ctx.models, type), subQuery, alias, where, aliases);
+  }
+  for (const { type: type2, foreignKey, reverse, where: where2 } of links) {
+    const model = summonByName(ctx.models, type2);
+    const subAlias = aliases.getShort();
+    if (reverse) {
+      subQuery.leftJoin(`${type2} as ${subAlias}`, `${alias}.${foreignKey || "id"}`, `${subAlias}.id`);
+    } else {
+      subQuery.rightJoin(`${type2} as ${subAlias}`, `${alias}.id`, `${subAlias}.${foreignKey || "id"}`);
+    }
+    subQuery.where({ [`${subAlias}.deleted`]: false });
+    if (where2) {
+      applyWhere(model, subQuery, subAlias, where2, aliases);
+    }
+    alias = subAlias;
+  }
+  subQuery.whereRaw(`"${alias}".id = ?`, id);
+};
+var applyWhere = (model, query, alias, where, aliases) => {
+  for (const [key, value2] of Object.entries(where)) {
+    const relation = model.relationsByName[key];
+    if (relation) {
+      const subAlias = aliases.getShort();
+      query.leftJoin(
+        `${relation.model.name} as ${subAlias}`,
+        `${alias}.${relation.field.foreignKey || `${relation.field.name}Id`}`,
+        `${subAlias}.id`
+      );
+      applyWhere(relation.model, query, subAlias, value2, aliases);
+    } else if (Array.isArray(value2)) {
+      query.whereIn(`${alias}.${key}`, value2);
+    } else {
+      query.where({ [`${alias}.${key}`]: value2 });
+    }
+  }
+};
+
+// src/permissions/generate.ts
+var ACTIONS = ["READ", "CREATE", "UPDATE", "DELETE", "RESTORE", "LINK"];
+var generatePermissions = (models, config) => {
+  const permissions = {};
+  for (const [role, roleConfig] of Object.entries(config)) {
+    if (roleConfig === true) {
+      permissions[role] = true;
+      continue;
+    }
+    const rolePermissions = {};
+    for (const [key, block] of Object.entries(roleConfig)) {
+      const type = key === "me" ? "User" : key;
+      if (key !== "me" && !("WHERE" in block)) {
+        rolePermissions[type] = {};
+        for (const action of ACTIONS) {
+          if (action === "READ" || action in block) {
+            rolePermissions[type][action] = true;
+          }
+        }
+      }
+      addPermissions(
+        models,
+        rolePermissions,
+        [
+          {
+            type,
+            ...key === "me" && { me: true },
+            ..."WHERE" in block && { where: block.WHERE }
+          }
+        ],
+        block
+      );
+    }
+    permissions[role] = rolePermissions;
+  }
+  return permissions;
+};
+var addPermissions = (models, permissions, links, block) => {
+  const { type } = links[links.length - 1];
+  const model = summonByName(models, type);
+  for (const action of ACTIONS) {
+    if (action === "READ" || action in block) {
+      if (!permissions[type]) {
+        permissions[type] = {};
+      }
+      if (!permissions[type][action]) {
+        permissions[type][action] = [];
+      }
+      if (permissions[type][action] !== true) {
+        permissions[type][action].push(links);
+      }
+    }
+  }
+  if (block.RELATIONS) {
+    for (const [relation, subBlock] of Object.entries(block.RELATIONS)) {
+      const field = model.fields.find((field2) => field2.relation && field2.name === relation);
+      let link;
+      if (field) {
+        link = {
+          type: field.type,
+          foreignKey: field.foreignKey || `${field.name}Id`,
+          reverse: true
+        };
+      } else {
+        const field2 = model.reverseRelationsByName[relation];
+        if (!field2) {
+          throw new Error(`Relation ${relation} in model ${model.name} does not exist.`);
+        }
+        link = {
+          type: field2.model.name,
+          foreignKey: field2.foreignKey
+        };
+      }
+      if (subBlock.WHERE) {
+        link.where = subBlock.WHERE;
+      }
+      addPermissions(models, permissions, [...links, link], subBlock);
+    }
+  }
+};
+
+// src/resolvers/arguments.ts
+var import_graphql4 = require("graphql");
+function getRawValue(value2, values) {
+  switch (value2.kind) {
+    case import_graphql4.Kind.LIST:
+      if (!values) {
+        return;
+      }
+      return value2.values.map((value3) => getRawValue(value3, values));
+    case import_graphql4.Kind.VARIABLE:
+      return values?.[value2.name.value];
+    case import_graphql4.Kind.INT:
+      return parseInt(value2.value, 10);
+    case import_graphql4.Kind.NULL:
+      return null;
+    case import_graphql4.Kind.FLOAT:
+      return parseFloat(value2.value);
+    case import_graphql4.Kind.STRING:
+    case import_graphql4.Kind.BOOLEAN:
+    case import_graphql4.Kind.ENUM:
+      return value2.value;
+    case import_graphql4.Kind.OBJECT: {
+      if (!value2.fields.length) {
+        return;
+      }
+      const res = {};
+      for (const field of value2.fields) {
+        res[field.name.value] = getRawValue(field.value, values);
+      }
+      return res;
+    }
+  }
+}
+var normalizeArguments = (node) => {
+  const normalizedArguments = {};
+  if (node.field.arguments) {
+    for (const argument of node.field.arguments) {
+      const rawValue = getRawValue(argument.value, node.ctx.info.variableValues);
+      const normalizedValue = normalizeValue(
+        rawValue,
+        summonByKey(node.fieldDefinition.arguments || [], "name.value", argument.name.value).type,
+        node.ctx.info.schema
+      );
+      if (normalizedValue === void 0) {
+        continue;
+      }
+      normalizedArguments[argument.name.value] = normalizedValue;
+    }
+  }
+  return normalizedArguments;
+};
+function normalizeValue(value2, type, schema) {
+  switch (type.kind) {
+    case import_graphql4.Kind.LIST_TYPE: {
+      if (Array.isArray(value2)) {
+        const res = [];
+        for (const v of value2) {
+          res.push(normalizeValue(v, type.type, schema));
+        }
+        return res;
+      }
+      const normalizedValue = normalizeValue(value2, type.type, schema);
+      if (normalizedValue === void 0) {
+        return;
+      }
+      return [normalizedValue];
+    }
+    case import_graphql4.Kind.NON_NULL_TYPE:
+      return normalizeValue(value2, type.type, schema);
+    case import_graphql4.Kind.NAMED_TYPE:
+      return normalizeValueByTypeDefinition(
+        value2,
+        schema.getType(type.name.value)?.astNode,
+        schema
+      );
+  }
+}
+var normalizeValueByTypeDefinition = (value2, type, schema) => {
+  if (!type || type.kind !== import_graphql4.Kind.INPUT_OBJECT_TYPE_DEFINITION) {
+    return value2;
+  }
+  if (!value2) {
+    return;
+  }
+  const res = {};
+  for (const key of Object.keys(value2)) {
+    const field = summonByKey(type.fields, "name.value", key);
+    const normalizedValue = normalizeValue(value2[key], field.type, schema);
+    if (normalizedValue === void 0) {
+      continue;
+    }
+    res[key] = normalizedValue;
+  }
+  return res;
+};
+
+// src/resolvers/filters.ts
+var SPECIAL_FILTERS = {
+  GT: "?? > ?",
+  GTE: "?? >= ?",
+  LT: "?? < ?",
+  LTE: "?? <= ?"
+};
+var applyFilters = (node, query, joins) => {
+  const normalizedArguments = normalizeArguments(node);
+  if (!normalizedArguments.orderBy) {
+    if (node.model.defaultOrderBy) {
+      normalizedArguments.orderBy = node.model.defaultOrderBy;
+    } else if (node.model.creatable) {
+      normalizedArguments.orderBy = [{ createdAt: "DESC" }];
+    }
+  }
+  if (node.model.deletable) {
+    if (!normalizedArguments.where) {
+      normalizedArguments.where = {};
+    }
+    if (normalizedArguments.where.deleted && (!Array.isArray(normalizedArguments.where.deleted) || normalizedArguments.where.deleted.some((v) => v))) {
+      if (node.ctx.user.role !== "ADMIN") {
+        throw new ForbiddenError("You cannot access deleted entries.");
+      }
+    } else {
+      normalizedArguments.where.deleted = false;
+    }
+  }
+  const { limit, offset, orderBy, where, search } = normalizedArguments;
+  if (limit) {
+    query.limit(limit);
+  }
+  if (offset) {
+    query.offset(offset);
+  }
+  if (orderBy) {
+    applyOrderBy(node, orderBy, query);
+  }
+  if (where) {
+    const ops = [];
+    applyWhere2(node, where, ops, joins);
+    apply(query, ops);
+  }
+  if (search) {
+    applySearch(node, search, query);
+  }
+};
+var applyWhere2 = (node, where, ops, joins) => {
+  for (const key of Object.keys(where)) {
+    const value2 = where[key];
+    const specialFilter = key.match(/^(\w+)_(\w+)$/);
+    if (specialFilter) {
+      const [, actualKey, filter] = specialFilter;
+      if (!SPECIAL_FILTERS[filter]) {
+        throw new Error(`Invalid filter ${key}.`);
+      }
+      ops.push(
+        (query) => query.whereRaw(SPECIAL_FILTERS[filter], [`${node.shortTableAlias}.${actualKey}`, value2])
+      );
+      continue;
+    }
+    const field = summonByName(node.model.fields, key);
+    const fullKey = `${node.shortTableAlias}.${key}`;
+    if (field.relation) {
+      const relation = get(node.model.relationsByName, field.name);
+      const tableAlias = `${node.model.name}__W__${key}`;
+      const subNode = {
+        ctx: node.ctx,
+        model: relation.model,
+        tableName: relation.model.name,
+        tableAlias,
+        shortTableAlias: node.ctx.aliases.getShort(tableAlias),
+        foreignKey: relation.field.foreignKey
+      };
+      addJoin(joins, node.tableAlias, subNode.tableName, subNode.tableAlias, get(subNode, "foreignKey"), "id");
+      applyWhere2(subNode, value2, ops, joins);
+      continue;
+    }
+    if (Array.isArray(value2)) {
+      if (field && field.list) {
+        ops.push(
+          (query) => ors(
+            query,
+            value2.map((v) => (subQuery) => subQuery.whereRaw("? = ANY(??)", [v, fullKey]))
+          )
+        );
+        continue;
+      }
+      if (value2.some((v) => v === null)) {
+        if (value2.some((v) => v !== null)) {
+          ops.push(
+            (query) => ors(query, [
+              (subQuery) => subQuery.whereIn(fullKey, value2.filter((v) => v !== null)),
+              (subQuery) => subQuery.whereNull(fullKey)
+            ])
+          );
+          continue;
+        }
+        ops.push((query) => query.whereNull(fullKey));
+        continue;
+      }
+      ops.push((query) => query.whereIn(fullKey, value2));
+      continue;
+    }
+    ops.push((query) => query.where({ [fullKey]: value2 }));
+  }
+};
+var applySearch = (node, search, query) => ors(
+  query,
+  node.model.fields.filter(({ searchable }) => searchable).map(
+    ({ name: name2 }) => (query2) => query2.whereILike(`${node.shortTableAlias}.${name2}`, `%${search}%`)
+  )
+);
+var applyOrderBy = (node, orderBy, query) => {
+  for (const vals of orderBy) {
+    const keys = Object.keys(vals);
+    if (keys.length !== 1) {
+      throw new UserInputError(`You need to specify exactly 1 value to order by for each orderBy entry.`);
+    }
+    const key = keys[0];
+    const value2 = vals[key];
+    query.orderBy(`${node.shortTableAlias}.${key}`, value2);
+  }
+};
+
+// src/resolvers/mutations.ts
+var import_uuid = require("uuid");
+
+// src/resolvers/resolver.ts
+var import_cloneDeep = __toESM(require("lodash/cloneDeep"), 1);
+var import_flatMap2 = __toESM(require("lodash/flatMap"), 1);
+
+// src/resolvers/node.ts
+var getResolverNode = ({
+  ctx,
+  node,
+  tableAlias,
+  baseTypeDefinition,
+  typeName
+}) => ({
+  ctx,
+  tableName: typeName,
+  tableAlias,
+  shortTableAlias: ctx.aliases.getShort(tableAlias),
+  baseTypeDefinition,
+  baseModel: ctx.models.find((model) => model.name === baseTypeDefinition.name.value),
+  typeDefinition: getType(ctx.info.schema, typeName),
+  model: summonByName(ctx.models, typeName),
+  selectionSet: get(node.selectionSet, "selections")
+});
+var getRootFieldNode = ({
+  ctx,
+  node,
+  baseTypeDefinition
+}) => {
+  const fieldName = node.name.value;
+  const fieldDefinition = summonByKey(baseTypeDefinition.fields || [], "name.value", fieldName);
+  const typeName = getTypeName(fieldDefinition.type);
+  return {
+    ctx,
+    tableName: typeName,
+    tableAlias: typeName,
+    shortTableAlias: ctx.aliases.getShort(typeName),
+    baseTypeDefinition,
+    typeDefinition: getType(ctx.info.schema, typeName),
+    model: summonByName(ctx.models, typeName),
+    selectionSet: get(node.selectionSet, "selections"),
+    field: node,
+    fieldDefinition,
+    isList: isListType(fieldDefinition.type)
+  };
+};
+var getSimpleFields = (node) => {
+  return node.selectionSet.filter(isFieldNode).filter((selection) => {
+    if (!selection.selectionSet) {
+      return true;
+    }
+    return node.model.fields.some(({ json, name: name2 }) => json && name2 === selection.name.value);
+  });
+};
+var getInlineFragments = (node) => node.selectionSet.filter(isInlineFragmentNode).map(
+  (subNode) => getResolverNode({
+    ctx: node.ctx,
+    node: subNode,
+    tableAlias: node.tableAlias + "__" + getFragmentTypeName(subNode),
+    baseTypeDefinition: node.baseTypeDefinition,
+    typeName: getFragmentTypeName(subNode)
+  })
+);
+var getFragmentSpreads = (node) => node.selectionSet.filter(isFragmentSpreadNode).map(
+  (subNode) => getResolverNode({
+    ctx: node.ctx,
+    node: node.ctx.info.fragments[subNode.name.value],
+    tableAlias: node.tableAlias,
+    baseTypeDefinition: node.baseTypeDefinition,
+    typeName: node.model.name
+  })
+);
+var getJoins = (node, toMany) => {
+  const nodes = [];
+  for (const subNode of node.selectionSet.filter(isFieldNode).filter(({ selectionSet }) => selectionSet)) {
+    const ctx = node.ctx;
+    const baseTypeDefinition = node.typeDefinition;
+    const fieldName = subNode.name.value;
+    const fieldNameOrAlias = getNameOrAlias(subNode);
+    const fieldDefinition = summonByKey(baseTypeDefinition.fields || [], "name.value", fieldName);
+    const typeName = getTypeName(fieldDefinition.type);
+    if (isJsonObjectModel(summonByName(ctx.rawModels, typeName))) {
+      continue;
+    }
+    const baseModel = summonByName(ctx.models, baseTypeDefinition.name.value);
+    let foreignKey;
+    if (toMany) {
+      const reverseRelation = baseModel.reverseRelationsByName[fieldName];
+      if (!reverseRelation) {
+        continue;
+      }
+      foreignKey = reverseRelation.foreignKey;
+    } else {
+      const modelField = baseModel.fieldsByName[fieldName];
+      if (!modelField || modelField.raw) {
+        continue;
+      }
+      foreignKey = modelField.foreignKey;
+    }
+    const tableAlias = node.tableAlias + "__" + fieldNameOrAlias;
+    nodes.push({
+      ctx,
+      tableName: typeName,
+      tableAlias,
+      shortTableAlias: ctx.aliases.getShort(tableAlias),
+      baseTypeDefinition,
+      baseModel,
+      typeDefinition: getType(ctx.info.schema, typeName),
+      model: summonByName(ctx.models, typeName),
+      selectionSet: get(subNode.selectionSet, "selections"),
+      field: subNode,
+      fieldDefinition,
+      foreignKey,
+      isList: isListType(fieldDefinition.type)
+    });
+  }
+  return nodes;
+};
+
+// src/resolvers/resolver.ts
+var queryResolver = (_parent, _args, ctx, info) => resolve({ ...ctx, info, aliases: new AliasGenerator() });
+var resolve = async (ctx, id) => {
+  const fieldNode = summonByKey(ctx.info.fieldNodes, "name.value", ctx.info.fieldName);
+  const baseTypeDefinition = get(
+    ctx.info.operation.operation === "query" ? ctx.info.schema.getQueryType() : ctx.info.schema.getMutationType(),
+    "astNode"
+  );
+  const node = getRootFieldNode({
+    ctx,
+    node: fieldNode,
+    baseTypeDefinition
+  });
+  const { query, verifiedPermissionStacks } = await buildQuery(node);
+  if (ctx.info.fieldName === "me") {
+    query.where({ [`${node.shortTableAlias}.id`]: node.ctx.user.id });
+  }
+  if (!node.isList) {
+    query.limit(1);
+  }
+  if (id) {
+    query.where({ id });
+  }
+  const raw = await query;
+  const res = hydrate(node, raw);
+  await applySubQueries(node, res, verifiedPermissionStacks);
+  if (node.isList) {
+    return res;
+  }
+  if (!res[0]) {
+    throw new NotFoundError("Entity not found");
+  }
+  return res[0];
+};
+var buildQuery = async (node, parentVerifiedPermissionStacks) => {
+  const { tableAlias, shortTableAlias, tableName, model, ctx } = node;
+  const query = ctx.knex.fromRaw(`"${tableName}" as "${shortTableAlias}"`);
+  const joins = {};
+  applyFilters(node, query, joins);
+  applySelects(node, query, joins);
+  applyJoins(node.ctx.aliases, query, joins);
+  const tables = [
+    [model.name, tableAlias],
+    ...Object.keys(joins).map((tableName2) => tableName2.split(":"))
+  ];
+  const verifiedPermissionStacks = {};
+  for (const [table, alias] of tables) {
+    const verifiedPermissionStack = applyPermissions(
+      ctx,
+      table,
+      node.ctx.aliases.getShort(alias),
+      query,
+      "READ",
+      parentVerifiedPermissionStacks?.[alias.split("__").slice(0, -1).join("__")]
+    );
+    if (typeof verifiedPermissionStack !== "boolean") {
+      verifiedPermissionStacks[alias] = verifiedPermissionStack;
+    }
+  }
+  return { query, verifiedPermissionStacks };
+};
+var applySelects = (node, query, joins) => {
+  query.select(
+    ...[
+      { 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) {
+          return false;
+        }
+        if (field.queriableBy && !field.queriableBy.includes(node.ctx.user.role)) {
+          throw new PermissionError("READ", `${node.model.name}'s field "${field.name}"`);
+        }
+        return true;
+      }).map((n) => ({ field: n.name.value, alias: getNameOrAlias(n) }))
+    ].map(
+      ({ field, alias }) => `${node.shortTableAlias}.${field} as ${node.shortTableAlias}__${alias}`
+    )
+  );
+  for (const subNode of getInlineFragments(node)) {
+    applySelects(subNode, query, joins);
+  }
+  for (const subNode of getFragmentSpreads(node)) {
+    applySelects(subNode, query, joins);
+  }
+  for (const subNode of getJoins(node, false)) {
+    addJoin(joins, node.tableAlias, subNode.tableName, subNode.tableAlias, get(subNode, "foreignKey"), "id");
+    applySelects(subNode, query, joins);
+  }
+};
+var applySubQueries = async (node, entries, parentVerifiedPermissionStacks) => {
+  if (!entries.length) {
+    return;
+  }
+  const entriesById = {};
+  for (const entry of entries) {
+    if (!entriesById[entry[ID_ALIAS]]) {
+      entriesById[entry[ID_ALIAS]] = [];
+    }
+    entriesById[entry[ID_ALIAS]].push(entry);
+  }
+  const ids = Object.keys(entriesById);
+  for (const subNode of getJoins(node, true)) {
+    const fieldName = getNameOrAlias(subNode.field);
+    const isList = isListType(subNode.fieldDefinition.type);
+    entries.forEach((entry) => entry[fieldName] = isList ? [] : null);
+    const foreignKey = get(subNode, "foreignKey");
+    const { query, verifiedPermissionStacks } = await buildQuery(subNode, parentVerifiedPermissionStacks);
+    const queries = ids.map(
+      (id) => query.clone().select(`${subNode.shortTableAlias}.${foreignKey} as ${subNode.shortTableAlias}__${foreignKey}`).where({ [`${subNode.shortTableAlias}.${foreignKey}`]: id })
+    );
+    const rawChildren = (await Promise.all(queries)).flat();
+    const children = hydrate(subNode, rawChildren);
+    for (const child of children) {
+      for (const entry of entriesById[child[foreignKey]]) {
+        if (isList) {
+          entry[fieldName].push((0, import_cloneDeep.default)(child));
+        } else {
+          entry[fieldName] = (0, import_cloneDeep.default)(child);
+        }
+      }
+    }
+    await applySubQueries(
+      subNode,
+      (0, import_flatMap2.default)(
+        entries.map((entry) => {
+          const children2 = entry[fieldName];
+          return isList ? children2 : children2 ? [children2] : [];
+        })
+      ),
+      verifiedPermissionStacks
+    );
+  }
+  for (const subNode of getInlineFragments(node)) {
+    await applySubQueries(subNode, entries, parentVerifiedPermissionStacks);
+  }
+  for (const subNode of getFragmentSpreads(node)) {
+    await applySubQueries(subNode, entries, parentVerifiedPermissionStacks);
+  }
+  for (const subNode of getJoins(node, false)) {
+    await applySubQueries(
+      subNode,
+      entries.map((item) => item[getNameOrAlias(subNode.field)]).filter(Boolean),
+      parentVerifiedPermissionStacks
+    );
+  }
+};
+
+// src/resolvers/mutations.ts
+var mutationResolver = async (_parent, args2, partialCtx, info) => {
+  return await partialCtx.knex.transaction(async (knex) => {
+    const [, mutation, modelName] = it(info.fieldName.match(/^(create|update|delete|restore)(.+)$/));
+    const ctx = { ...partialCtx, knex, info, aliases: new AliasGenerator() };
+    const model = summonByName(ctx.models, modelName);
+    switch (mutation) {
+      case "create":
+        return await create(model, args2, ctx);
+      case "update":
+        return await update(model, args2, ctx);
+      case "delete":
+        return await del(model, args2, ctx);
+      case "restore":
+        return await restore(model, args2, ctx);
+    }
+  });
+};
+var create = async (model, { data: input2 }, ctx) => {
+  const normalizedInput = { ...input2 };
+  normalizedInput.id = (0, import_uuid.v4)();
+  normalizedInput.createdAt = ctx.now;
+  normalizedInput.createdById = ctx.user.id;
+  sanitize(ctx, model, normalizedInput);
+  await checkCanWrite(ctx, model, normalizedInput, "CREATE");
+  await ctx.handleUploads?.(normalizedInput);
+  const data = { prev: {}, input: input2, normalizedInput, next: normalizedInput };
+  await ctx.mutationHook?.(model, "create", "before", data, ctx);
+  await ctx.knex(model.name).insert(normalizedInput);
+  await createRevision(model, normalizedInput, ctx);
+  await ctx.mutationHook?.(model, "create", "after", data, ctx);
+  return await resolve(ctx, normalizedInput.id);
+};
+var update = async (model, { where, data: input2 }, ctx) => {
+  if (Object.keys(where).length === 0) {
+    throw new Error(`No ${model.name} specified.`);
+  }
+  const normalizedInput = { ...input2 };
+  sanitize(ctx, model, normalizedInput);
+  const prev = await getEntityToMutate(ctx, model, where, "UPDATE");
+  for (const key of Object.keys(normalizedInput)) {
+    if (normalizedInput[key] === prev[key]) {
+      delete normalizedInput[key];
+    }
+  }
+  if (Object.keys(normalizedInput).length > 0) {
+    await checkCanWrite(ctx, model, normalizedInput, "UPDATE");
+    await ctx.handleUploads?.(normalizedInput);
+    const next = { ...prev, ...normalizedInput };
+    const data = { prev, input: input2, normalizedInput, next };
+    await ctx.mutationHook?.(model, "update", "before", data, ctx);
+    await ctx.knex(model.name).where(where).update(normalizedInput);
+    await createRevision(model, next, ctx);
+    await ctx.mutationHook?.(model, "update", "after", data, ctx);
+  }
+  return await resolve(ctx);
+};
+var del = async (model, { where, dryRun }, ctx) => {
+  if (Object.keys(where).length === 0) {
+    throw new Error(`No ${model.name} specified.`);
+  }
+  const entity = await getEntityToMutate(ctx, model, where, "DELETE");
+  if (entity.deleted) {
+    throw new ForbiddenError("Entity is already deleted.");
+  }
+  const toDelete = {};
+  const toUnlink = {};
+  const beforeHooks = [];
+  const mutations = [];
+  const afterHooks = [];
+  const deleteCascade = async (currentModel, entity2) => {
+    if (entity2.deleted) {
+      return;
+    }
+    if (dryRun) {
+      if (!(currentModel.name in toDelete)) {
+        toDelete[currentModel.name] = {};
+      }
+      toDelete[currentModel.name][entity2.id] = entity2[currentModel.displayField || "id"] || entity2.id;
+    } else {
+      const normalizedInput = { deleted: true, deletedAt: ctx.now, deletedById: ctx.user.id };
+      const data = { prev: entity2, input: {}, normalizedInput, next: { ...entity2, ...normalizedInput } };
+      if (ctx.mutationHook) {
+        beforeHooks.push(async () => {
+          await ctx.mutationHook(currentModel, "delete", "before", data, ctx);
+        });
+      }
+      mutations.push(async () => {
+        await ctx.knex(currentModel.name).where({ id: entity2.id }).update(normalizedInput);
+        await createRevision(currentModel, { ...entity2, deleted: true }, ctx);
+      });
+      if (ctx.mutationHook) {
+        afterHooks.push(async () => {
+          await ctx.mutationHook(currentModel, "delete", "after", data, ctx);
+        });
+      }
+    }
+    for (const {
+      model: descendantModel,
+      foreignKey,
+      field: { name: name2, onDelete }
+    } of currentModel.reverseRelations) {
+      const query = ctx.knex(descendantModel.name).where({ [foreignKey]: entity2.id });
+      switch (onDelete) {
+        case "set-null": {
+          const descendants = await query;
+          for (const descendant of descendants) {
+            if (dryRun) {
+              if (!toUnlink[descendantModel.name]) {
+                toUnlink[descendantModel.name] = {};
+              }
+              if (!toUnlink[descendantModel.name][descendant.id]) {
+                toUnlink[descendantModel.name][descendant.id] = {
+                  display: descendant[descendantModel.displayField || "id"] || entity2.id,
+                  fields: []
+                };
+              }
+              toUnlink[descendantModel.name][descendant.id].fields.push(name2);
+            } else {
+              mutations.push(async () => {
+                await ctx.knex(descendantModel.name).where({ id: descendant.id }).update({
+                  [`${name2}Id`]: null
+                });
+              });
+            }
+          }
+          break;
+        }
+        case "cascade":
+        default: {
+          applyPermissions(ctx, descendantModel.name, descendantModel.name, query, "DELETE");
+          const descendants = await query;
+          if (descendants.length && !descendantModel.deletable) {
+            throw new ForbiddenError(`This ${model.name} depends on a ${descendantModel.name} which cannot be deleted.`);
+          }
+          for (const descendant of descendants) {
+            await deleteCascade(descendantModel, descendant);
+          }
+          break;
+        }
+      }
+    }
+  };
+  await deleteCascade(model, entity);
+  for (const callback of [...beforeHooks, ...mutations, ...afterHooks]) {
+    await callback();
+  }
+  if (dryRun) {
+    throw new GraphQLError(`Delete dry run:`, {
+      code: "DELETE_DRY_RUN",
+      toDelete,
+      toUnlink
+    });
+  }
+  return entity.id;
+};
+var restore = async (model, { where }, ctx) => {
+  if (Object.keys(where).length === 0) {
+    throw new Error(`No ${model.name} specified.`);
+  }
+  const entity = await getEntityToMutate(ctx, model, where, "RESTORE");
+  if (!entity.deleted) {
+    throw new ForbiddenError("Entity is not deleted.");
+  }
+  const beforeHooks = [];
+  const mutations = [];
+  const afterHooks = [];
+  const restoreCascade = async (currentModel, relatedEntity) => {
+    if (!relatedEntity.deleted || !relatedEntity.deletedAt || !relatedEntity.deletedAt.equals(entity.deletedAt)) {
+      return;
+    }
+    const normalizedInput = { deleted: false, deletedAt: null, deletedById: null };
+    const data = { prev: relatedEntity, input: {}, normalizedInput, next: { ...relatedEntity, ...normalizedInput } };
+    if (ctx.mutationHook) {
+      beforeHooks.push(async () => {
+        await ctx.mutationHook(model, "restore", "before", data, ctx);
+      });
+    }
+    mutations.push(async () => {
+      await ctx.knex(currentModel.name).where({ id: relatedEntity.id }).update(normalizedInput);
+      await createRevision(currentModel, { ...relatedEntity, deleted: false }, ctx);
+    });
+    if (ctx.mutationHook) {
+      afterHooks.push(async () => {
+        await ctx.mutationHook(model, "restore", "after", data, ctx);
+      });
+    }
+    for (const { model: descendantModel, foreignKey } of currentModel.reverseRelations.filter(
+      ({ model: { deletable } }) => deletable
+    )) {
+      const query = ctx.knex(descendantModel.name).where({ [foreignKey]: relatedEntity.id });
+      applyPermissions(ctx, descendantModel.name, descendantModel.name, query, "RESTORE");
+      const descendants = await query;
+      for (const descendant of descendants) {
+        await restoreCascade(descendantModel, descendant);
+      }
+    }
+  };
+  await restoreCascade(model, entity);
+  for (const callback of [...beforeHooks, ...mutations, ...afterHooks]) {
+    await callback();
+  }
+  return entity.id;
+};
+var createRevision = async (model, data, ctx) => {
+  if (model.updatable) {
+    const revisionData = {
+      id: (0, import_uuid.v4)(),
+      [`${typeToField(model.name)}Id`]: data.id,
+      createdAt: ctx.now,
+      createdById: ctx.user.id
+    };
+    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;
+      if (nonNull2 && (!(col in data) || col === void 0 || col === null)) {
+        revisionData[col] = get(field, "default");
+      } else {
+        revisionData[col] = data[col];
+      }
+    }
+    await ctx.knex(`${model.name}Revision`).insert(revisionData);
+  }
+};
+var sanitize = (ctx, model, data) => {
+  if (model.updatable) {
+    data.updatedAt = ctx.now;
+    data.updatedById = ctx.user.id;
+  }
+  for (const key of Object.keys(data)) {
+    const field = model.fields.find(({ name: name2 }) => name2 === key);
+    if (!field) {
+      continue;
+    }
+    if (isEndOfDay(field) && data[key]) {
+      data[key] = data[key].endOf("day");
+      continue;
+    }
+    if (isEnumList(ctx.rawModels, field) && Array.isArray(data[key])) {
+      data[key] = `{${data[key].join(",")}}`;
+      continue;
+    }
+  }
+};
+var isEndOfDay = (field) => field?.endOfDay === true && field?.dateTimeType === "date" && field?.type === "DateTime";
+
+// src/resolvers/resolvers.ts
+var getResolvers = (models) => ({
+  Query: merge([
+    {
+      me: queryResolver
+    },
+    ...models.filter(({ queriable }) => queriable).map((model) => ({
+      [typeToField(model.name)]: queryResolver
+    })),
+    ...models.filter(({ listQueriable }) => listQueriable).map((model) => ({
+      [getModelPluralField(model)]: queryResolver
+    }))
+  ]),
+  Mutation: merge([
+    ...models.filter(({ creatable }) => creatable).map((model) => ({
+      [`create${model.name}`]: mutationResolver
+    })),
+    ...models.filter(({ updatable }) => updatable).map((model) => ({
+      [`update${model.name}`]: mutationResolver
+    })),
+    ...models.filter(({ deletable }) => deletable).map((model) => ({
+      [`delete${model.name}`]: mutationResolver,
+      [`restore${model.name}`]: mutationResolver
+    }))
+  ])
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AliasGenerator,
+  Enum,
+  ForbiddenError,
+  GraphQLError,
+  ID_ALIAS,
+  MigrationGenerator,
+  NotFoundError,
+  PermissionError,
+  SPECIAL_FILTERS,
+  UserInputError,
+  actionableRelations,
+  addJoin,
+  and,
+  apply,
+  applyFilters,
+  applyJoins,
+  applyPermissions,
+  args,
+  checkCanWrite,
+  directive,
+  directives,
+  displayField,
+  document,
+  enm,
+  fieldType,
+  fields,
+  generate,
+  generateDefinitions,
+  generateMutations,
+  generatePermissions,
+  get,
+  getEditEntityRelationsQuery,
+  getEntityListQuery,
+  getEntityQuery,
+  getEntityToMutate,
+  getFindEntityQuery,
+  getFragmentSpreads,
+  getFragmentTypeName,
+  getInlineFragments,
+  getJoins,
+  getLabel,
+  getManyToManyRelation,
+  getManyToManyRelations,
+  getManyToManyRelationsQuery,
+  getModelLabel,
+  getModelLabelPlural,
+  getModelPlural,
+  getModelPluralField,
+  getModelSlug,
+  getModels,
+  getMutationQuery,
+  getNameOrAlias,
+  getPermissionStack,
+  getResolverNode,
+  getResolvers,
+  getRootFieldNode,
+  getSimpleFields,
+  getString,
+  getType,
+  getTypeName,
+  getUpdateEntityQuery,
+  gql,
+  hash,
+  hydrate,
+  iface,
+  input,
+  inputValue,
+  inputValues,
+  isCreatable,
+  isCreatableBy,
+  isEnumList,
+  isEnumModel,
+  isFieldNode,
+  isFragmentSpreadNode,
+  isInlineFragmentNode,
+  isJsonObjectModel,
+  isListType,
+  isObjectModel,
+  isQueriableBy,
+  isQueriableField,
+  isRaw,
+  isRawEnumModel,
+  isRawObjectModel,
+  isRelation,
+  isScalarModel,
+  isSimpleField,
+  isToOneRelation,
+  isUpdatable,
+  isUpdatableBy,
+  isVisible,
+  isVisibleRelation,
+  it,
+  list,
+  merge,
+  mutationResolver,
+  name,
+  namedType,
+  nonNull,
+  normalizeArguments,
+  normalizeValue,
+  normalizeValueByTypeDefinition,
+  not,
+  object,
+  ors,
+  printSchema,
+  printSchemaFromDocument,
+  printSchemaFromModels,
+  queryRelations,
+  queryResolver,
+  resolve,
+  retry,
+  scalar,
+  summon,
+  summonByKey,
+  summonByName,
+  typeToField,
+  value
+});