@smartive/graphql-magic 9.1.2 → 10.0.0

package/dist/cjs/index.cjs

@@ -30,13 +30,27 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   AliasGenerator: () => AliasGenerator,
+  EntityModel: () => EntityModel,
+  EnumModel: () => EnumModel,
   ForbiddenError: () => ForbiddenError,
   GraphQLError: () => GraphQLError,
   ID_ALIAS: () => ID_ALIAS,
+  InputModel: () => InputModel,
+  InterfaceModel: () => InterfaceModel,
+  ManyToManyRelation: () => ManyToManyRelation,
   MigrationGenerator: () => MigrationGenerator,
+  Model: () => Model,
+  Models: () => Models,
+  NormalRelation: () => NormalRelation,
   NotFoundError: () => NotFoundError,
+  ObjectModel: () => ObjectModel,
   PermissionError: () => PermissionError,
+  RawEnumModel: () => RawEnumModel,
+  Relation: () => Relation,
+  ReverseRelation: () => ReverseRelation,
   SPECIAL_FILTERS: () => SPECIAL_FILTERS,
+  ScalarModel: () => ScalarModel,
+  TYPE_ALIAS: () => TYPE_ALIAS,
   UserInputError: () => UserInputError,
   actionableRelations: () => actionableRelations,
   addJoin: () => addJoin,
@@ -45,6 +59,7 @@ __export(src_exports, {
   applyFilters: () => applyFilters,
   applyJoins: () => applyJoins,
   applyPermissions: () => applyPermissions,
+  applySelects: () => applySelects,
   args: () => args,
   checkCanWrite: () => checkCanWrite,
   directive: () => directive,
@@ -62,6 +77,8 @@ __export(src_exports, {
   generateMutations: () => generateMutations,
   generatePermissions: () => generatePermissions,
   get: () => get,
+  getColumn: () => getColumn,
+  getColumnName: () => getColumnName,
   getEditEntityRelationsQuery: () => getEditEntityRelationsQuery,
   getEntityListQuery: () => getEntityListQuery,
   getEntityQuery: () => getEntityQuery,
@@ -72,16 +89,8 @@ __export(src_exports, {
   getInlineFragments: () => getInlineFragments,
   getJoins: () => getJoins,
   getLabel: () => getLabel,
-  getManyToManyRelation: () => getManyToManyRelation,
-  getManyToManyRelations: () => getManyToManyRelations,
   getManyToManyRelationsQuery: () => getManyToManyRelationsQuery,
   getMigrationDate: () => getMigrationDate,
-  getModelLabel: () => getModelLabel,
-  getModelLabelPlural: () => getModelLabelPlural,
-  getModelPlural: () => getModelPlural,
-  getModelPluralField: () => getModelPluralField,
-  getModelSlug: () => getModelSlug,
-  getModels: () => getModels,
   getMutationQuery: () => getMutationQuery,
   getNameOrAlias: () => getNameOrAlias,
   getPermissionStack: () => getPermissionStack,
@@ -94,6 +103,7 @@ __export(src_exports, {
   getTypeName: () => getTypeName,
   getUpdateEntityQuery: () => getUpdateEntityQuery,
   gql: () => gql,
+  hasName: () => hasName,
   hash: () => hash,
   hydrate: () => hydrate,
   iface: () => iface,
@@ -105,12 +115,14 @@ __export(src_exports, {
   isCustomField: () => isCustomField,
   isEntityModel: () => isEntityModel,
   isEnum: () => isEnum,
-  isEnumList: () => isEnumList,
   isEnumModel: () => isEnumModel,
   isFieldNode: () => isFieldNode,
   isFragmentSpreadNode: () => isFragmentSpreadNode,
+  isInTable: () => isInTable,
+  isInherited: () => isInherited,
   isInlineFragmentNode: () => isInlineFragmentNode,
   isInputModel: () => isInputModel,
+  isInterfaceModel: () => isInterfaceModel,
   isListType: () => isListType,
   isObjectModel: () => isObjectModel,
   isPrimitive: () => isPrimitive,
@@ -118,16 +130,20 @@ __export(src_exports, {
   isQueriableField: () => isQueriableField,
   isRawEnumModel: () => isRawEnumModel,
   isRelation: () => isRelation,
+  isRootModel: () => isRootModel,
   isScalarModel: () => isScalarModel,
   isSimpleField: () => isSimpleField,
   isToOneRelation: () => isToOneRelation,
   isUpdatable: () => isUpdatable,
   isUpdatableBy: () => isUpdatableBy,
+  isUpdatableField: () => isUpdatableField,
+  isUpdatableModel: () => isUpdatableModel,
   isVisible: () => isVisible,
   isVisibleRelation: () => isVisibleRelation,
   it: () => it,
   list: () => list,
   merge: () => merge2,
+  modelNeedsTable: () => modelNeedsTable,
   mutationResolver: () => mutationResolver,
   name: () => name,
   namedType: () => namedType,
@@ -137,6 +153,7 @@ __export(src_exports, {
   normalizeValueByTypeDefinition: () => normalizeValueByTypeDefinition,
   not: () => not,
   object: () => object,
+  or: () => or,
   ors: () => ors,
   printSchema: () => printSchema,
   printSchemaFromDocument: () => printSchemaFromDocument,
@@ -163,7 +180,7 @@ var execute = async ({
   body,
   ...ctx
 }) => {
-  const document2 = generate(ctx.rawModels);
+  const document2 = generate(ctx.models);
   const generatedResolvers = getResolvers(ctx.models);
   const schema = (0, import_schema.makeExecutableSchema)({
     typeDefs: document2,
@@ -199,9 +216,9 @@ var gql = (chunks, ...variables) => {
 // src/client/mutations.ts
 var import_upperCase = __toESM(require("lodash/upperCase"), 1);
 var constantCase = (str) => (0, import_upperCase.default)(str).replace(/ /g, "_");
-var generateMutations = (models) => {
+var generateMutations = (models, gqmModule = "@smartive/graphql-magic") => {
   const parts = [];
-  for (const { name: name2, creatable, updatable, deletable } of models.filter(isEntityModel)) {
+  for (const { name: name2, creatable, updatable, deletable } of models.entities.filter(not(isRootModel))) {
     if (creatable) {
       parts.push(
         `export const CREATE_${constantCase(
@@ -232,11 +249,20 @@ var generateMutations = (models) => {
   mutation Delete${name2}Mutation($id: ID!) {
     delete${name2}(where: { id: $id })
   }
+\`;`
+      );
+      parts.push(
+        `export const RESTORE_${constantCase(
+          name2
+        )} = gql\`
+  mutation Restore${name2}Mutation($id: ID!) {
+    restore${name2}(where: { id: $id })
+  }
 \`;`
       );
     }
   }
-  return `import { gql } from "@smartive/graphql-magic";
+  return `import { gql } from "${gqmModule}";
 
 ${parts.join("\n\n")}`;
 };
@@ -246,96 +272,104 @@ var import_upperFirst = __toESM(require("lodash/upperFirst"), 1);
 
 // src/models/utils.ts
 var import_assert = __toESM(require("assert"), 1);
-var import_inflection = require("inflection");
-var import_camelCase = __toESM(require("lodash/camelCase"), 1);
+var import_lodash3 = require("lodash");
 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 merge2 = (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 isEntityModel = (model) => model.kind === "entity";
-var isEnumModel = (model) => model.kind === "enum";
-var isRawEnumModel = (model) => model.kind === "raw-enum";
-var isScalarModel = (model) => model.kind === "scalar";
-var isObjectModel = (model) => model.kind === "object";
-var isInputModel = (model) => model.kind === "input";
-var isEnumList = (models, field) => field?.list === true && models.find(({ name: name2 }) => name2 === field.kind)?.kind === "enum";
-var and = (...predicates) => (field) => predicates.every((predicate) => predicate(field));
-var not = (predicate) => (field) => !predicate(field);
-var isPrimitive = (field) => field.kind === void 0 || field.kind === "primitive";
-var isEnum = (field) => field.kind === "enum";
-var isRelation = (field) => field.kind === "relation";
-var isToOneRelation = (field) => isRelation(field) && !!field.toOne;
-var isQueriableField = ({ queriable }) => queriable !== false;
-var isCustomField = (field) => field.kind === "custom";
-var isVisible = ({ hidden }) => hidden !== true;
-var isSimpleField = and(not(isRelation), not(isCustomField));
-var isUpdatable = ({ updatable }) => !!updatable;
-var isCreatable = ({ creatable }) => !!creatable;
-var isQueriableBy = (role) => (field) => field.queriable !== false && (field.queriable === void 0 || field.queriable === true || !field.queriable.roles || field.queriable.roles.includes(role));
-var isUpdatableBy = (role) => (field) => field.updatable && (field.updatable === true || !field.updatable.roles || field.updatable.roles.includes(role));
-var isCreatableBy = (role) => (field) => field.creatable && (field.creatable === true || !field.creatable.roles || field.creatable.roles.includes(role));
-var actionableRelations = (model, action) => model.fields.filter(isRelation).filter(
-  (field) => field[`${action === "filter" ? action : action.slice(0, -1)}able`]
-);
-var getModels = (rawModels) => {
-  const models = rawModels.filter(isEntityModel).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 ? [
+
+// src/models/models.ts
+var import_inflection = require("inflection");
+var import_lodash2 = require("lodash");
+var Models = class {
+  models;
+  modelsByName = {};
+  scalars;
+  rawEnums;
+  enums;
+  inputs;
+  interfaces;
+  objects;
+  entities;
+  definitions;
+  constructor(definitions) {
+    this.definitions = (0, import_lodash2.cloneDeep)(definitions);
+    this.definitions.push(
+      {
+        kind: "scalar",
+        name: "DateTime"
+      },
+      { kind: "scalar", name: "Upload" },
+      {
+        kind: "raw-enum",
+        name: "Order",
+        values: ["ASC", "DESC"]
+      }
+    );
+    const entities = this.definitions.filter(isEntityModelDefinition);
+    for (const entity of entities) {
+      if (entity.root) {
+        this.definitions.push({
+          kind: "enum",
+          name: `${entity.name}Type`,
+          values: entities.filter((subModel) => subModel.parent === entity.name).map((subModel) => subModel.name)
+        });
+      }
+      entity.fields = [
+        {
+          name: "id",
+          type: "ID",
+          nonNull: true,
+          unique: true,
+          primary: true,
+          generated: true
+        },
+        ...entity.root ? [
+          {
+            name: "type",
+            kind: "enum",
+            type: `${entity.name}Type`,
+            nonNull: true,
+            generated: true
+          }
+        ] : [],
+        ...entity.fields,
+        ...entity.creatable ? [
           {
             name: "createdAt",
             type: "DateTime",
             nonNull: true,
             orderable: true,
             generated: true,
-            ...typeof model.creatable === "object" && model.creatable.createdAt
+            ...typeof entity.creatable === "object" && entity.creatable.createdAt
           },
           {
             name: "createdBy",
             kind: "relation",
             type: "User",
             nonNull: true,
-            reverse: `created${getModelPlural(model)}`,
+            reverse: `created${getModelPlural(entity)}`,
             generated: true,
-            ...typeof model.creatable === "object" && model.creatable.createdBy
+            ...typeof entity.creatable === "object" && entity.creatable.createdBy
           }
         ] : [],
-        ...model.updatable ? [
+        ...entity.updatable ? [
           {
             name: "updatedAt",
             type: "DateTime",
             nonNull: true,
             orderable: true,
             generated: true,
-            ...typeof model.updatable === "object" && model.updatable.updatedAt
+            ...typeof entity.updatable === "object" && entity.updatable.updatedAt
           },
           {
             name: "updatedBy",
             kind: "relation",
             type: "User",
             nonNull: true,
-            reverse: `updated${getModelPlural(model)}`,
+            reverse: `updated${getModelPlural(entity)}`,
             generated: true,
-            ...typeof model.updatable === "object" && model.updatable.updatedBy
+            ...typeof entity.updatable === "object" && entity.updatable.updatedBy
           }
         ] : [],
-        ...model.deletable ? [
+        ...entity.deletable ? [
           {
             name: "deleted",
             type: "Boolean",
@@ -343,65 +377,349 @@ var getModels = (rawModels) => {
             defaultValue: false,
             filterable: { default: false },
             generated: true,
-            ...typeof model.deletable === "object" && model.deletable.deleted
+            ...typeof entity.deletable === "object" && entity.deletable.deleted
           },
           {
             name: "deletedAt",
             type: "DateTime",
             orderable: true,
             generated: true,
-            ...typeof model.deletable === "object" && model.deletable.deletedAt
+            ...typeof entity.deletable === "object" && entity.deletable.deletedAt
           },
           {
             name: "deletedBy",
             kind: "relation",
             type: "User",
-            reverse: `deleted${getModelPlural(model)}`,
+            reverse: `deleted${getModelPlural(entity)}`,
             generated: true,
-            ...typeof model.deletable === "object" && model.deletable.deletedBy
+            ...typeof entity.deletable === "object" && entity.deletable.deletedBy
           }
         ] : []
-      ].map((field) => ({
-        ...field,
-        ...field.kind === "relation" && {
-          foreignKey: field.foreignKey || `${field.name}Id`
+      ];
+      for (const field of entity.fields) {
+        if (field.kind === "relation") {
+          field.foreignKey = field.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) {
-      if (field.kind !== "relation") {
-        continue;
+    for (const model of entities) {
+      if (model.parent) {
+        const parent = summonByName(entities, model.parent);
+        const INHERITED_FIELDS = ["queriable", "listQueriable", "creatable", "updatable", "deletable"];
+        Object.assign(model, (0, import_lodash2.pick)(parent, INHERITED_FIELDS), (0, import_lodash2.pick)(model, INHERITED_FIELDS));
+        model.fields = [
+          ...parent.fields.map((field) => ({
+            ...field,
+            ...field.kind === "relation" && field.reverse && { reverse: field.reverse.replace(getModelPlural(parent), getModelPlural(model)) },
+            ...model.fields.find((childField) => childField.name === field.name),
+            inherited: true
+          })),
+          ...model.fields.filter((field) => !parent.fields.some((parentField) => parentField.name === field.name))
+        ];
       }
-      const fieldModel = summonByName(models, field.type);
-      const reverseRelation = {
-        kind: "relation",
-        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;
     }
+    this.models = this.definitions.map(
+      (definition) => new MODEL_KIND_TO_CLASS_MAPPING[definition.kind](this, definition)
+    );
+    for (const model of this.models) {
+      this.modelsByName[model.name] = model;
+    }
+    this.entities = this.models.filter((model) => model instanceof EntityModel);
+    this.enums = this.models.filter((model) => model instanceof EnumModel);
+    this.inputs = this.models.filter((model) => model instanceof InputModel);
+    this.interfaces = this.models.filter((model) => model instanceof InterfaceModel);
+    this.objects = this.models.filter((model) => model instanceof ObjectModel);
+    this.rawEnums = this.models.filter((model) => model instanceof RawEnumModel);
+    this.scalars = this.models.filter((model) => model instanceof ScalarModel);
+  }
+  getModel(name2, kind) {
+    const model = get(this.modelsByName, name2);
+    if (!kind) {
+      return model;
+    }
+    const expectedType = MODEL_KIND_TO_CLASS_MAPPING[kind];
+    if (!(model instanceof expectedType)) {
+      throw new Error(`Model ${name2} is not of kind ${kind}.`);
+    }
+    return model;
+  }
+};
+var Model = class {
+  constructor(models, definition) {
+    this.models = models;
+    Object.assign(this, definition);
+    this.plural = definition.plural || (0, import_inflection.pluralize)(definition.name);
+  }
+  name;
+  plural;
+  description;
+};
+var ScalarModel = class extends Model {
+  kind;
+};
+var EnumModel = class extends Model {
+  kind;
+  values;
+  deleted;
+  constructor(models, definition) {
+    super(models, definition);
+    Object.assign(this, (0, import_lodash2.omit)(definition, "name", "plural", "description"));
+  }
+};
+var RawEnumModel = class extends Model {
+  kind;
+  values;
+  constructor(models, definition) {
+    super(models, definition);
+    Object.assign(this, (0, import_lodash2.omit)(definition, "name", "plural", "description"));
+  }
+};
+var InterfaceModel = class extends Model {
+  kind;
+  fields;
+  constructor(models, definition) {
+    super(models, definition);
+    Object.assign(this, (0, import_lodash2.omit)(definition, "name", "plural", "description"));
+  }
+};
+var InputModel = class extends Model {
+  kind;
+  fields;
+  constructor(models, definition) {
+    super(models, definition);
+    Object.assign(this, (0, import_lodash2.omit)(definition, "name", "plural", "description"));
+  }
+};
+var ObjectModel = class extends Model {
+  kind;
+  fields;
+  constructor(models, definition) {
+    super(models, definition);
+    Object.assign(this, (0, import_lodash2.omit)(definition, "name", "plural", "description"));
+  }
+};
+var EntityModel = class extends Model {
+  kind;
+  root;
+  parent;
+  interfaces;
+  queriable;
+  listQueriable;
+  creatable;
+  updatable;
+  deletable;
+  displayField;
+  defaultOrderBy;
+  fields;
+  // temporary fields for the generation of migrations
+  deleted;
+  oldName;
+  fieldsByName = {};
+  fieldsByColumnName = {};
+  _relations;
+  _relationsByName;
+  _reverseRelations;
+  _reverseRelationsByName;
+  _manyToManyRelations;
+  _manyToManyRelationsByName;
+  pluralField;
+  slug;
+  labelPlural;
+  label;
+  _parentModel;
+  constructor(models, definition) {
+    super(models, definition);
+    Object.assign(this, (0, import_lodash2.omit)(definition, "name", "plural", "description"));
+    this.pluralField = typeToField(this.plural);
+    this.slug = (0, import_lodash2.kebabCase)(this.plural);
+    this.labelPlural = getLabel(this.plural);
+    this.label = getLabel(definition.name);
+    for (const field of definition.fields) {
+      this.fieldsByName[field.name] = field;
+    }
+  }
+  getField(name2) {
+    return get(this.fieldsByName, name2);
+  }
+  get relations() {
+    if (!this._relations) {
+      this._relations = this.fields.filter(isRelation).map((relationField) => new NormalRelation(this, relationField, this.models.getModel(relationField.type, "entity")));
+    }
+    return this._relations;
+  }
+  get relationsByName() {
+    if (!this._relationsByName) {
+      this._relationsByName = {};
+      for (const relation of this.relations) {
+        this._relationsByName[relation.name] = relation;
+      }
+    }
+    return this._relationsByName;
+  }
+  getRelation(name2) {
+    return get(this.relationsByName, name2);
+  }
+  get reverseRelations() {
+    if (!this._reverseRelations) {
+      this._reverseRelations = this.models.entities.flatMap(
+        (model) => model.relations.filter((relation) => relation.targetModel.name === this.name || relation.targetModel.name === this.rootModel.name).map((relation) => relation.reverse)
+      );
+    }
+    return this._reverseRelations;
+  }
+  get reverseRelationsByName() {
+    if (!this._reverseRelationsByName) {
+      this._reverseRelationsByName = {};
+      for (const reverseRelation of this.reverseRelations) {
+        this._reverseRelationsByName[reverseRelation.name] = reverseRelation;
+      }
+    }
+    return this._reverseRelationsByName;
+  }
+  getReverseRelation(name2) {
+    return get(this.reverseRelationsByName, name2);
+  }
+  get manyToManyRelations() {
+    if (!this._manyToManyRelations) {
+      this._manyToManyRelations = [];
+      for (const relationFromSource of this.reverseRelations) {
+        const relationToTarget = relationFromSource.targetModel.relations.find(
+          (relation) => !relation.field.generated && relation.field.name !== relationFromSource.field.name
+        );
+        if (!relationToTarget) {
+          continue;
+        }
+        const inapplicableFields = relationFromSource.targetModel.fields.filter(
+          (otherField) => !otherField.generated && ![relationFromSource.field.name, relationToTarget.field.name].includes(otherField.name)
+        );
+        if (inapplicableFields.length) {
+          continue;
+        }
+        this._manyToManyRelations.push(new ManyToManyRelation(relationFromSource, relationToTarget));
+      }
+    }
+    return this._manyToManyRelations;
+  }
+  get manyToManyRelationsByName() {
+    if (!this._manyToManyRelationsByName) {
+      this._manyToManyRelationsByName = {};
+      for (const manyToManyRelation of this.manyToManyRelations) {
+        this._manyToManyRelationsByName[manyToManyRelation.name] = manyToManyRelation;
+      }
+    }
+    return this._manyToManyRelationsByName;
+  }
+  getManyToManyRelation(name2) {
+    return get(this.manyToManyRelationsByName, name2);
+  }
+  get parentModel() {
+    if (this.parent) {
+      if (!this._parentModel) {
+        this._parentModel = this.models.getModel(this.parent, "entity");
+      }
+      return this._parentModel;
+    }
+  }
+  get rootModel() {
+    return this.parentModel || this;
+  }
+};
+var MODEL_KIND_TO_CLASS_MAPPING = {
+  entity: EntityModel,
+  enum: EnumModel,
+  input: InputModel,
+  interface: InterfaceModel,
+  object: ObjectModel,
+  "raw-enum": RawEnumModel,
+  scalar: ScalarModel
+};
+var Relation = class {
+  constructor(name2, sourceModel, field, targetModel) {
+    this.name = name2;
+    this.sourceModel = sourceModel;
+    this.field = field;
+    this.targetModel = targetModel;
+  }
+};
+var NormalRelation = class extends Relation {
+  constructor(sourceModel, field, targetModel) {
+    super(field.name, sourceModel, field, targetModel);
+    this.field = field;
+    this.reverse = new ReverseRelation(this);
+  }
+  reverse;
+};
+var ReverseRelation = class extends Relation {
+  constructor(reverse) {
+    super(
+      reverse.field.reverse || (reverse.field.toOne ? typeToField(reverse.sourceModel.name) : reverse.sourceModel.pluralField),
+      reverse.targetModel,
+      reverse.field,
+      reverse.sourceModel
+    );
+    this.reverse = reverse;
+  }
+};
+var ManyToManyRelation = class {
+  name;
+  sourceModel;
+  relationFromSource;
+  relationModel;
+  relationToTarget;
+  targetModel;
+  constructor(relationFromSource, relationToTarget) {
+    this.name = relationFromSource.name;
+    this.sourceModel = relationFromSource.sourceModel;
+    this.relationFromSource = relationFromSource;
+    this.relationModel = relationFromSource.targetModel;
+    if (this.relationModel !== relationToTarget.sourceModel) {
+      throw new Error(`Relation model is ambiguous.`);
+    }
+    this.relationToTarget = relationToTarget;
+    this.targetModel = relationToTarget.targetModel;
   }
-  return models;
 };
+var isEntityModelDefinition = (definition) => definition.kind === "entity";
+var getModelPlural = (model) => model.plural || (0, import_inflection.pluralize)(model.name);
+
+// src/models/utils.ts
+var isNotFalsy = (v) => typeof v !== "undefined" && v !== null && v !== false;
+var merge2 = (objects) => (objects || []).filter(isNotFalsy).reduce((i, acc) => ({ ...acc, ...i }), {});
+var typeToField = (type) => type.substr(0, 1).toLowerCase() + type.substr(1);
+var getLabel = (s) => (0, import_lodash3.startCase)((0, import_lodash3.camelCase)(s));
+var or = (...predicates) => (field) => predicates.some((predicate) => predicate(field));
+var and = (...predicates) => (field) => predicates.every((predicate) => predicate(field));
+var not = (predicate) => (field) => !predicate(field);
+var isRootModel = (model) => model.root;
+var isEntityModel = (model) => model instanceof EntityModel;
+var isEnumModel = (model) => model instanceof EnumModel;
+var isRawEnumModel = (model) => model instanceof RawEnumModel;
+var isScalarModel = (model) => model instanceof ScalarModel;
+var isObjectModel = (model) => model instanceof ObjectModel;
+var isInputModel = (model) => model instanceof InputModel;
+var isInterfaceModel = (model) => model instanceof InterfaceModel;
+var isUpdatableModel = (model) => model.updatable && model.fields.some(isUpdatableField);
+var isUpdatableField = (field) => !field.inherited && !!field.updatable;
+var modelNeedsTable = (model) => model.fields.some((field) => !field.inherited);
+var hasName = (name2) => (field) => field.name == name2;
+var isPrimitive = (field) => field.kind === void 0 || field.kind === "primitive";
+var isEnum = (field) => field.kind === "enum";
+var isRelation = (field) => field.kind === "relation";
+var isInherited = (field) => field.inherited;
+var isInTable = (field) => field.name === "id" || !field.inherited;
+var isToOneRelation = (field) => isRelation(field) && !!field.toOne;
+var isQueriableField = ({ queriable }) => queriable !== false;
+var isCustomField = (field) => field.kind === "custom";
+var isVisible = ({ hidden }) => hidden !== true;
+var isSimpleField = and(not(isRelation), not(isCustomField));
+var isUpdatable = ({ updatable }) => !!updatable;
+var isCreatable = ({ creatable }) => !!creatable;
+var isQueriableBy = (role) => (field) => field.queriable !== false && (field.queriable === void 0 || field.queriable === true || !field.queriable.roles || field.queriable.roles.includes(role));
+var isUpdatableBy = (role) => (field) => field.updatable && (field.updatable === true || !field.updatable.roles || field.updatable.roles.includes(role));
+var isCreatableBy = (role) => (field) => field.creatable && (field.creatable === true || !field.creatable.roles || field.creatable.roles.includes(role));
+var actionableRelations = (model, action) => model.relations.filter(
+  (relation) => relation.field[`${action === "filter" ? action : action.slice(0, -1)}able`]
+);
 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) => {
@@ -426,8 +744,9 @@ var it = (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)}`);
+    const error = new Error(`Object doesn't have ${String(key)}`);
+    console.warn(error);
+    throw error;
   }
   return value2;
 };
@@ -456,73 +775,49 @@ var getUpdateEntityQuery = (model, role, fields2, additionalFields = "") => `que
     ${additionalFields}
   }
 }`;
-var getEditEntityRelationsQuery = (models, model, action, fields2, ignoreFields, additionalFields = {}) => {
+var getEditEntityRelationsQuery = (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);
+      ${relations.map((relation) => {
     let filters = "";
-    if (model2.displayField) {
-      const displayField2 = model2.fieldsByName[model2.displayField];
+    if (relation.targetModel.displayField) {
+      const displayField2 = relation.targetModel.fieldsByName[relation.targetModel.displayField];
       if (displayField2.orderable) {
-        filters = `(orderBy: [{ ${model2.displayField}: ASC }])`;
+        filters = `(orderBy: [{ ${relation.targetModel.displayField}: ASC }])`;
       }
     }
-    return `${name2}: ${getModelPluralField(model2)}${filters} {
+    return `${relation.name}: ${relation.targetModel.pluralField}${filters} {
             id
-            display: ${model2.displayField || "id"}
-            ${additionalFields[name2] || ""}
+            display: ${relation.targetModel.displayField || "id"}
+            ${additionalFields[relation.name] || ""}
           }`;
   }).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} {
+              ${manyToManyRelations.map((relation) => {
+  return `${relation.name} {
                     id
-                    ${field.name} {
+                    ${relation.relationToTarget.name} {
                       id
                     }
                   }`;
 }).join(" ")}
             }
-            ${manyToManyRelations.map(([reverseRelation, { model: model2 }]) => {
-  return `${reverseRelation.name}: ${getModelPluralField(model2)} {
+            ${manyToManyRelations.map((relation) => {
+  return `${relation.name}: ${relation.targetModel.pluralField} {
                   id
-                  ${model2.displayField || ""}
+                  ${relation.targetModel.displayField || ""}
                 }`;
 }).join(" ")}
           }` : `query Create${model.name}ManyToManyRelations {
-            ${manyToManyRelations.map(([reverseRelation, { model: model2 }]) => {
-  return `${reverseRelation.name}: ${getModelPluralField(model2)} {
+            ${manyToManyRelations.map((relation) => {
+  return `${relation.name}: ${relation.targetModel.pluralField} {
                   id
-                  ${model2.displayField || ""}
+                  ${relation.targetModel.displayField || ""}
                 }`;
 }).join(" ")}
           }`);
@@ -548,14 +843,14 @@ var getMutationQuery = (model, action) => action === "create" ? `
 var displayField = (model) => `
 ${model.displayField ? `display: ${model.displayField}` : ""}
 `;
-var getEntityListQuery = (model, role, additionalFields = "", root) => `query ${getModelPlural(model)}List(
+var getEntityListQuery = (model, role, additionalFields = "", root) => `query ${model.plural}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" : ""}) {
+    data: ${root ? root.reverseRelationName : model.pluralField}(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}
@@ -564,37 +859,38 @@ var getEntityListQuery = (model, role, additionalFields = "", root) => `query ${
 }`;
 var isVisibleRelation = (visibleRelationsByRole, modelName, role) => {
   const whitelist = visibleRelationsByRole[role]?.[modelName];
-  return ({ name: name2 }) => whitelist ? whitelist.includes(name2) : true;
+  return (relation) => whitelist ? whitelist.includes(relation.name) : true;
 };
-var getEntityQuery = (models, model, role, visibleRelationsByRole, typesWithSubRelations) => `query Admin${model.name} ($id: ID!) {
+var getEntityQuery = (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(isRelation).filter(isVisibleRelation(visibleRelationsByRole, model.name, role)),
+  model.models,
+  model.relations.filter(isVisibleRelation(visibleRelationsByRole, model.name, role)),
   role,
   typesWithSubRelations
 )}
     ${queryRelations(
-  models,
-  model.reverseRelations.filter(and(isToOneRelation, isVisibleRelation(visibleRelationsByRole, model.name, role))),
+  model.models,
+  model.reverseRelations.filter(
+    (reverseRelation) => isToOneRelation(reverseRelation.field) && isVisibleRelation(visibleRelationsByRole, model.name, role)(reverseRelation)
+  ),
   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) {
+  data: ${model.pluralField}(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} {
+var queryRelations = (models, relations, role, typesWithSubRelations) => relations.map((relation) => {
+  const subRelations = typesWithSubRelations.includes(relation.targetModel.name) ? relation.targetModel.relations : [];
+  return `${relation.name} {
           id
-          ${displayField(relatedModel)}
+          ${displayField(relation.targetModel)}
           ${subRelations.length > 0 ? queryRelations(models, subRelations, role, typesWithSubRelations) : ""}
         }`;
 }).join("\n");
@@ -611,56 +907,59 @@ var PRIMITIVE_TYPES = {
   DateTime: "DateTime | string"
 };
 var OPTIONAL_SEED_FIELDS = ["createdAt", "createdById", "updatedAt", "updatedById", "deletedAt", "deletedById"];
-var generateDBModels = (rawModels) => {
+var generateDBModels = (models) => {
   const writer = new import_code_block_writer.default["default"]({
     useSingleQuote: true,
     indentNumberOfSpaces: 2
   });
   writer.write(`import { DateTime } from 'luxon';`).blankLine();
-  for (const enm2 of rawModels.filter(isEnumModel)) {
+  for (const enm2 of models.enums) {
     writer.write(`export type ${enm2.name} = ${enm2.values.map((v) => `'${v}'`).join(" | ")};`).blankLine();
   }
-  const models = getModels(rawModels);
-  for (const model of models) {
-    const fields2 = model.fields.some((field) => field.kind === "relation" && field.foreignKey === "id") ? model.fields.filter((field) => field.name !== "id") : model.fields;
+  for (const model of models.entities) {
+    const fields2 = model.relations.some((relation) => relation.field.foreignKey === "id") ? model.fields.filter((field) => field.name !== "id") : model.fields;
     writer.write(`export type ${model.name} = `).inlineBlock(() => {
       for (const field of fields2.filter(not(isCustomField))) {
-        writer.write(`'${getFieldName(field)}': ${getFieldType(field)}${field.nonNull ? "" : " | null"},`).newLine();
+        writer.write(`'${getColumnName(field)}': ${getFieldType(field)}${field.nonNull ? "" : " | null"};`).newLine();
       }
     }).blankLine();
     writer.write(`export type ${model.name}Initializer = `).inlineBlock(() => {
-      for (const field of fields2.filter(not(isCustomField))) {
+      for (const field of fields2.filter(not(isCustomField)).filter(isInTable)) {
         writer.write(
-          `'${getFieldName(field)}'${field.nonNull && field.defaultValue === void 0 ? "" : "?"}: ${getFieldType(
+          `'${getColumnName(field)}'${field.nonNull && field.defaultValue === void 0 ? "" : "?"}: ${getFieldType(
             field
-          )}${field.list ? " | string" : ""}${field.nonNull ? "" : " | null"},`
+          )}${field.list ? " | string" : ""}${field.nonNull ? "" : " | null"};`
         ).newLine();
       }
     }).blankLine();
     writer.write(`export type ${model.name}Mutator = `).inlineBlock(() => {
-      for (const field of fields2.filter(not(isCustomField))) {
-        writer.write(
-          `'${getFieldName(field)}'?: ${getFieldType(field)}${field.list ? " | string" : ""}${field.nonNull ? "" : " | null"},`
-        ).newLine();
-      }
-    }).blankLine();
-    writer.write(`export type ${model.name}Seed = `).inlineBlock(() => {
-      for (const field of fields2.filter(not(isCustomField))) {
-        const fieldName = getFieldName(field);
+      for (const field of fields2.filter(not(isCustomField)).filter(isInTable)) {
         writer.write(
-          `'${getFieldName(field)}'${field.nonNull && field.defaultValue === void 0 && !OPTIONAL_SEED_FIELDS.includes(fieldName) ? "" : "?"}: ${field.kind === "enum" ? field.list ? "string[]" : "string" : getFieldType(field)}${field.list ? " | string" : ""}${field.nonNull ? "" : " | null"},`
+          `'${getColumnName(field)}'?: ${getFieldType(field)}${field.list ? " | string" : ""}${field.nonNull ? "" : " | null"};`
         ).newLine();
       }
     }).blankLine();
+    if (!isRootModel(model)) {
+      writer.write(`export type ${model.name}Seed = `).inlineBlock(() => {
+        for (const field of fields2.filter(not(isCustomField))) {
+          if (model.parent && field.name === "type") {
+            continue;
+          }
+          const fieldName = getColumnName(field);
+          writer.write(
+            `'${getColumnName(field)}'${field.nonNull && field.defaultValue === void 0 && !OPTIONAL_SEED_FIELDS.includes(fieldName) ? "" : "?"}: ${field.kind === "enum" ? field.list ? "string[]" : "string" : getFieldType(field)}${field.list ? " | string" : ""}${field.nonNull ? "" : " | null"};`
+          ).newLine();
+        }
+      }).blankLine();
+    }
   }
   writer.write(`export type SeedData = `).inlineBlock(() => {
-    for (const model of models) {
-      writer.write(`${model.name}: ${model.name}Seed[],`).newLine();
+    for (const model of models.entities.filter(not(isRootModel))) {
+      writer.write(`${model.name}: ${model.name}Seed[];`).newLine();
     }
   });
   return writer.toString();
 };
-var getFieldName = (field) => field.kind === "relation" ? field.foreignKey || `${field.name}Id` : field.name;
 var getFieldType = (field) => {
   const kind = field.kind;
   switch (kind) {
@@ -681,19 +980,18 @@ var getFieldType = (field) => {
     }
   }
 };
-var generateKnexTables = (rawModels) => {
+var generateKnexTables = (models) => {
   const writer = new import_code_block_writer.default["default"]({
     useSingleQuote: true,
     indentNumberOfSpaces: 2
   });
-  const models = getModels(rawModels);
   writer.write(`import { Knex } from 'knex';`).newLine();
   writer.write(
-    `import { ${models.map((model) => `${model.name}, ${model.name}Initializer, ${model.name}Mutator`).join(", ")} } from '.';`
+    `import { ${models.entities.map((model) => `${model.name}, ${model.name}Initializer, ${model.name}Mutator`).join(", ")} } from '.';`
   ).blankLine();
   writer.write(`declare module 'knex/types/tables' `).inlineBlock(() => {
     writer.write(`interface Tables `).inlineBlock(() => {
-      for (const model of models) {
+      for (const model of models.entities) {
         writer.write(`'${model.name}': Knex.CompositeTableType<${model.name}, ${model.name}Initializer, ${model.name}Mutator>,`).newLine();
       }
     });
@@ -706,10 +1004,9 @@ var import_code_block_writer2 = __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;
+  constructor(knex, models) {
+    this.models = models;
     this.schema = (0, import_knex_schema_inspector.SchemaInspector)(knex);
-    this.models = getModels(rawModels);
   }
   writer = new import_code_block_writer2.default["default"]({
     useSingleQuote: true,
@@ -719,9 +1016,8 @@ var MigrationGenerator = class {
   columns = {};
   uuidUsed;
   nowUsed;
-  models;
   async generate() {
-    const { writer, schema, rawModels, models } = this;
+    const { writer, schema, 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) {
@@ -730,11 +1026,11 @@ var MigrationGenerator = class {
     const up = [];
     const down = [];
     this.createEnums(
-      rawModels.filter(isEnumModel).filter((enm2) => !enums.includes((0, import_lowerFirst.default)(enm2.name))),
+      this.models.enums.filter((enm2) => !enums.includes((0, import_lowerFirst.default)(enm2.name))),
       up,
       down
     );
-    for (const model of models) {
+    for (const model of models.entities) {
       if (model.deleted) {
         up.push(() => {
           this.dropTable(model.name);
@@ -746,7 +1042,7 @@ var MigrationGenerator = class {
             }
           });
         });
-        if (model.updatable) {
+        if (isUpdatableModel(model)) {
           up.push(() => {
             this.dropTable(`${model.name}Revision`);
           });
@@ -765,7 +1061,7 @@ var MigrationGenerator = class {
         tables[tables.indexOf(model.oldName)] = model.name;
         this.columns[model.name] = this.columns[model.oldName];
         delete this.columns[model.oldName];
-        if (model.updatable) {
+        if (isUpdatableModel(model)) {
           up.push(() => {
             this.renameTable(`${model.oldName}Revision`, `${model.name}Revision`);
             this.alterTable(`${model.name}Revision`, () => {
@@ -783,92 +1079,102 @@ var MigrationGenerator = class {
           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, ...field }) => field.kind !== "custom" && !this.columns[model.name].some(
-              (col) => col.name === (field.kind === "relation" ? field.foreignKey || `${name2}Id` : name2)
-            )
-          ),
-          up,
-          down
-        );
-        const existingFields = model.fields.filter(({ name: name2, kind, nonNull: nonNull2 }) => {
-          const col = this.columns[model.name].find((col2) => col2.name === (kind === "relation" ? `${name2}Id` : name2));
-          if (!col) {
-            return false;
-          }
-          return !nonNull2 && !col.is_nullable;
-        });
-        this.updateFields(model, existingFields, up, down);
-      }
-      if (model.updatable) {
-        if (!tables.includes(`${model.name}Revision`)) {
+      if (modelNeedsTable(model)) {
+        if (!tables.includes(model.name)) {
           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, kind } of model.fields.filter(({ updatable }) => updatable)) {
-                      const col = kind === "relation" ? `${name2}Id` : name2;
-                      writer.writeLine(`${col}: row.${col},`);
-                    }
-                  }).write(")));").newLine();
+            this.createTable(model.name, () => {
+              if (model.parent) {
+                this.column({
+                  ...model.fieldsByName.id,
+                  kind: "relation",
+                  type: model.parent,
+                  foreignKey: "id"
                 });
-              }).blankLine();
+              }
+              for (const field of model.fields.filter(not(isInherited))) {
+                this.column(field);
+              }
             });
-          }
+          });
           down.push(() => {
-            this.dropTable(`${model.name}Revision`);
+            this.dropTable(model.name);
           });
         } else {
-          const revisionTable = `${model.name}Revision`;
-          const missingRevisionFields = model.fields.filter(
-            ({ name: name2, updatable, ...field }) => field.kind !== "custom" && updatable && !this.columns[revisionTable].some(
-              (col) => col.name === (field.kind === "relation" ? field.foreignKey || `${name2}Id` : name2)
-            )
+          this.renameFields(
+            model,
+            model.fields.filter(not(isInherited)).filter(({ oldName }) => oldName),
+            up,
+            down
           );
-          this.createRevisionFields(model, missingRevisionFields, up, down);
-          const revisionFieldsToRemove = model.fields.filter(
-            ({ name: name2, updatable, generated, ...field }) => !generated && field.kind !== "custom" && !updatable && !(field.kind === "relation" && field.foreignKey === "id") && this.columns[revisionTable].some(
-              (col) => col.name === (field.kind === "relation" ? field.foreignKey || `${name2}Id` : name2)
-            )
+          this.createFields(
+            model,
+            model.fields.filter(not(isInherited)).filter(
+              ({ name: name2, ...field }) => field.kind !== "custom" && !this.columns[model.name].some(
+                (col) => col.name === (field.kind === "relation" ? field.foreignKey || `${name2}Id` : name2)
+              )
+            ),
+            up,
+            down
           );
-          this.createRevisionFields(model, revisionFieldsToRemove, down, up);
+          const existingFields = model.fields.filter(({ name: name2, kind, nonNull: nonNull2 }) => {
+            const col = this.columns[model.name].find((col2) => col2.name === (kind === "relation" ? `${name2}Id` : name2));
+            if (!col) {
+              return false;
+            }
+            return !nonNull2 && !col.is_nullable;
+          });
+          this.updateFields(model, existingFields, up, down);
+        }
+        if (isUpdatableModel(model)) {
+          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, kind } of model.fields.filter(isUpdatableField)) {
+                        const col = kind === "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(isUpdatableField).filter(
+              ({ name: name2, ...field }) => field.kind !== "custom" && !this.columns[revisionTable].some(
+                (col) => col.name === (field.kind === "relation" ? field.foreignKey || `${name2}Id` : name2)
+              )
+            );
+            this.createRevisionFields(model, missingRevisionFields, up, down);
+            const revisionFieldsToRemove = model.fields.filter(
+              ({ name: name2, updatable, generated, ...field }) => !generated && field.kind !== "custom" && !updatable && !(field.kind === "relation" && field.foreignKey === "id") && this.columns[revisionTable].some(
+                (col) => col.name === (field.kind === "relation" ? field.foreignKey || `${name2}Id` : name2)
+              )
+            );
+            this.createRevisionFields(model, revisionFieldsToRemove, down, up);
+          }
         }
       }
     }
-    for (const model of getModels(rawModels)) {
+    for (const model of models.entities) {
       if (tables.includes(model.name)) {
         this.createFields(
           model,
@@ -876,10 +1182,10 @@ var MigrationGenerator = class {
           down,
           up
         );
-        if (model.updatable) {
+        if (isUpdatableModel(model)) {
           this.createRevisionFields(
             model,
-            model.fields.filter(({ deleted, updatable }) => updatable && deleted),
+            model.fields.filter(isUpdatableField).filter(({ deleted }) => deleted),
             down,
             up
           );
@@ -887,7 +1193,7 @@ var MigrationGenerator = class {
       }
     }
     this.createEnums(
-      rawModels.filter(isEnumModel).filter((enm2) => enm2.deleted),
+      this.models.enums.filter((enm2) => enm2.deleted),
       down,
       up
     );
@@ -995,8 +1301,8 @@ var MigrationGenerator = class {
         }
       });
     });
-    if (model.updatable) {
-      const updatableFields = fields2.filter(({ updatable }) => updatable);
+    if (isUpdatableModel(model)) {
+      const updatableFields = fields2.filter(isUpdatableField);
       if (!updatableFields.length) {
         return;
       }
@@ -1024,15 +1330,15 @@ var MigrationGenerator = class {
     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')`);
-      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();`);
+      if (!model.parent) {
+        writer.writeLine(`table.uuid('${typeToField(model.name)}Id').notNullable();`);
+        writer.writeLine(`table.uuid('createdById').notNullable();`);
+        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)) {
+      for (const field of model.fields.filter(and(isUpdatableField, not(isInherited)))) {
         this.column(field, { setUnique: false, setDefault: false });
       }
     });
@@ -1080,7 +1386,7 @@ var MigrationGenerator = class {
           `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}"')`));
+      down.push(() => this.writer.writeLine(`await knex.raw('DROP TYPE "${name2}"');`));
     }
   }
   migration(name2, cbs) {
@@ -1160,7 +1466,7 @@ var MigrationGenerator = class {
             if (field.double) {
               col(`table.double('${name2}')`);
             } else {
-              col(`table.decimal('${name2}', ${get(field, "precision")}, ${get(field, "scale")})`);
+              col(`table.decimal('${name2}', ${field.precision ?? "undefined"}, ${field.scale ?? "undefined"})`);
             }
             break;
           case "String":
@@ -1181,14 +1487,16 @@ var MigrationGenerator = class {
         }
         break;
       case "relation":
-        col(`table.uuid('${name2}Id')`);
+        col(`table.uuid('${field.foreignKey}')`);
         if (foreign && !alter) {
-          this.writer.writeLine(`table.foreign('${name2}Id').references('id').inTable('${field.type}');`);
+          this.writer.writeLine(
+            `table.foreign('${field.foreignKey}').references('id').inTable('${field.type}').onDelete('CASCADE');`
+          );
         }
         break;
       case "enum":
         if (list2) {
-          this.writer.write(`table.specificType('${name2}', '"${typeToField(field.type)}"[]');`);
+          this.writer.write(`table.specificType('${name2}', '"${typeToField(field.type)}"[]')`);
         } else {
           this.writer.write(`table.enum('${name2}', null as any, `).inlineBlock(() => {
             this.writer.writeLine(`useNative: true,`);
@@ -1252,7 +1560,9 @@ var PermissionError = class extends ForbiddenError {
 // src/resolvers/utils.ts
 var import_crypto = require("crypto");
 var import_graphql3 = require("graphql");
+var import_lodash4 = require("lodash");
 var ID_ALIAS = "ID";
+var TYPE_ALIAS = "TYPE";
 var getTypeName = (t) => {
   switch (t.kind) {
     case "ListType":
@@ -1278,18 +1588,16 @@ var isFragmentSpreadNode = (n) => n.kind === import_graphql3.Kind.FRAGMENT_SPREA
 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 resultAlias = node.resultAlias;
   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 [, columnWithoutField, fieldName] = column.match(/^(.*\w)__(\w+)$/);
         const longColumn = node.ctx.aliases.getLong(columnWithoutField);
-        const longColumnWithoutRoot = longColumn.replace(new RegExp(`^${tableAlias}(__)?`), "");
-        const allParts = [tableAlias, ...longColumnWithoutRoot ? longColumnWithoutRoot.split("__") : [], fieldName];
+        const longColumnWithoutRoot = longColumn.replace(new RegExp(`^${resultAlias}(__)?`), "");
+        const allParts = [resultAlias, ...longColumnWithoutRoot ? longColumnWithoutRoot.split("__") : [], fieldName];
         for (let i = 0; i < allParts.length - 1; i++) {
           const part = allParts[i];
           if (!current[part]) {
@@ -1303,7 +1611,7 @@ function hydrate(node, raw) {
         }
         current[it(fieldName)] = value2;
       }
-    return res2[tableAlias];
+    return res2[resultAlias];
   });
   return res;
 }
@@ -1312,12 +1620,12 @@ var ors = (query, [first, ...rest]) => {
     return query;
   }
   return query.where((subQuery) => {
-    subQuery.where((subSubQuery) => {
-      first(subSubQuery);
+    void subQuery.where((subSubQuery) => {
+      void first(subSubQuery);
     });
     for (const cb of rest) {
-      subQuery.orWhere((subSubQuery) => {
-        cb(subSubQuery);
+      void subQuery.orWhere((subSubQuery) => {
+        void cb(subSubQuery);
       });
     }
   });
@@ -1331,15 +1639,26 @@ var getNameOrAlias = (node) => {
 };
 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(":");
+  for (const { table1Alias, table2Name, table2Alias, column1, column2 } of joins) {
     const table1ShortAlias = aliases.getShort(table1Alias);
-    const table2ShortAlias = aliases.getShort(alias);
-    query.leftJoin(`${table} as ${table2ShortAlias}`, `${table1ShortAlias}.${column1}`, `${table2ShortAlias}.${column2}`);
+    const table2ShortAlias = aliases.getShort(table2Alias);
+    void query.leftJoin(
+      `${table2Name} as ${table2ShortAlias}`,
+      `${table1ShortAlias}.${column1}`,
+      `${table2ShortAlias}.${column2}`
+    );
   }
 };
-var addJoin = (joins, table1Alias, table2, alias2, column1, column2) => {
-  joins[`${table2}:${alias2}`] ||= { table1Alias, column1, column2 };
+var addJoin = (joins, table1Alias, table2Name, table2Alias, column1, column2) => {
+  const join = { table1Alias, table2Name, table2Alias, column1, column2 };
+  const existingJoin = joins.find((j) => j.table2Alias === join.table2Alias);
+  if (existingJoin) {
+    if (!(0, import_lodash4.isEqual)(existingJoin, join)) {
+      throw new Error(`Join collision: ${existingJoin}, ${join}`);
+    }
+  } else {
+    joins.push(join);
+  }
 };
 var AliasGenerator = class {
   reverse = {};
@@ -1362,6 +1681,11 @@ var AliasGenerator = class {
   }
 };
 var hash = (s) => (0, import_crypto.createHash)("md5").update(JSON.stringify(s)).digest("hex");
+var getColumnName = (field) => field.kind === "relation" ? field.foreignKey || `${field.name}Id` : field.name;
+var getColumn = (node, key) => {
+  const field = node.model.fields.find((field2) => getColumnName(field2) === key);
+  return `${node.ctx.aliases.getShort(field.inherited ? node.rootTableAlias : node.tableAlias)}.${key}`;
+};
 
 // src/permissions/check.ts
 var getPermissionStack = (ctx, type, action) => {
@@ -1406,7 +1730,7 @@ var applyPermissions = (ctx, type, tableAlias, query, action, verifiedPermission
   return permissionStack;
 };
 var getEntityToMutate = async (ctx, model, where, action) => {
-  const query = ctx.knex(model.name).where(where).first();
+  const query = ctx.knex(model.parent || model.name).where(where).first();
   let entity = await query.clone();
   if (!entity) {
     console.error(
@@ -1422,6 +1746,10 @@ var getEntityToMutate = async (ctx, model, where, action) => {
     );
     throw new PermissionError(action, `this ${model.name}`, "no available permissions applied");
   }
+  if (model.parent) {
+    const subEntity = await ctx.knex(model.name).where({ id: entity.id }).first();
+    Object.assign(entity, subEntity);
+  }
   return entity;
 };
 var checkCanWrite = async (ctx, model, data, action) => {
@@ -1430,7 +1758,7 @@ var checkCanWrite = async (ctx, model, data, action) => {
     return;
   }
   if (permissionStack === false) {
-    throw new PermissionError(action, getModelPlural(model), "no applicable permissions");
+    throw new PermissionError(action, model.plural, "no applicable permissions");
   }
   const query = ctx.knex.select(1).first();
   let linked = false;
@@ -1478,10 +1806,10 @@ var permissionLinkQuery = (ctx, subQuery, links, id) => {
     subQuery.where({ [`${alias}.id`]: ctx.user.id });
   }
   if (where) {
-    applyWhere(summonByName(ctx.models, type), subQuery, alias, where, aliases);
+    applyWhere(ctx.models.getModel(type, "entity"), subQuery, alias, where, aliases);
   }
   for (const { type: type2, foreignKey, reverse, where: where2 } of links) {
-    const model = summonByName(ctx.models, type2);
+    const model = ctx.models.getModel(type2, "entity");
     const subAlias = aliases.getShort();
     if (reverse) {
       subQuery.leftJoin(`${type2} as ${subAlias}`, `${alias}.${foreignKey || "id"}`, `${subAlias}.id`);
@@ -1502,11 +1830,11 @@ var applyWhere = (model, query, alias, where, aliases) => {
     if (relation) {
       const subAlias = aliases.getShort();
       query.leftJoin(
-        `${relation.model.name} as ${subAlias}`,
+        `${relation.targetModel.name} as ${subAlias}`,
         `${alias}.${relation.field.foreignKey || `${relation.field.name}Id`}`,
         `${subAlias}.id`
       );
-      applyWhere(relation.model, query, subAlias, value2, aliases);
+      applyWhere(relation.targetModel, query, subAlias, value2, aliases);
     } else if (Array.isArray(value2)) {
       query.whereIn(`${alias}.${key}`, value2);
     } else {
@@ -1554,7 +1882,7 @@ var generatePermissions = (models, config) => {
 };
 var addPermissions = (models, permissions, links, block) => {
   const { type } = links[links.length - 1];
-  const model = summonByName(models, type);
+  const model = models.getModel(type, "entity");
   for (const action of ACTIONS) {
     if (action === "READ" || action in block) {
       if (!permissions[type]) {
@@ -1579,13 +1907,13 @@ var addPermissions = (models, permissions, links, block) => {
           reverse: true
         };
       } else {
-        const field2 = model.reverseRelationsByName[relation];
-        if (!field2) {
+        const reverseRelation = model.reverseRelationsByName[relation];
+        if (!reverseRelation) {
           throw new Error(`Relation ${relation} in model ${model.name} does not exist.`);
         }
         link = {
-          type: field2.model.name,
-          foreignKey: field2.foreignKey
+          type: reverseRelation.targetModel.name,
+          foreignKey: reverseRelation.field.foreignKey
         };
       }
       if (subBlock.WHERE) {
@@ -1730,13 +2058,18 @@ var applyFilters = (node, query, joins) => {
   if (orderBy) {
     applyOrderBy(node, orderBy, query);
   }
+  if (node.model.parent) {
+    void query.where({
+      [getColumn(node, "type")]: node.model.name
+    });
+  }
   if (where) {
     const ops = [];
     applyWhere2(node, where, ops, joins);
-    apply(query, ops);
+    void apply(query, ops);
   }
   if (search) {
-    applySearch(node, search, query);
+    void applySearch(node, search, query);
   }
 };
 var applyWhere2 = (node, where, ops, joins) => {
@@ -1748,34 +2081,34 @@ var applyWhere2 = (node, where, ops, joins) => {
       if (!SPECIAL_FILTERS[filter]) {
         throw new Error(`Invalid filter ${key}.`);
       }
-      ops.push(
-        (query) => query.whereRaw(SPECIAL_FILTERS[filter], [`${node.shortTableAlias}.${actualKey}`, value2])
-      );
+      ops.push((query) => query.whereRaw(SPECIAL_FILTERS[filter], [getColumn(node, actualKey), value2]));
       continue;
     }
-    const field = summonByName(node.model.fields, key);
-    const fullKey = `${node.shortTableAlias}.${key}`;
+    const field = node.model.getField(key);
     if (field.kind === "relation") {
-      const relation = get(node.model.relationsByName, field.name);
-      const tableAlias = `${node.model.name}__W__${key}`;
+      const relation = node.model.getRelation(field.name);
+      const targetModel = relation.targetModel;
+      const rootModel = targetModel.parentModel || targetModel;
+      const rootTableAlias = `${node.model.name}__W__${key}`;
+      const tableAlias = targetModel === rootModel ? rootTableAlias : `${node.model.name}__WS__${key}`;
       const subNode = {
         ctx: node.ctx,
-        model: relation.model,
-        tableName: relation.model.name,
-        tableAlias,
-        shortTableAlias: node.ctx.aliases.getShort(tableAlias),
-        foreignKey: relation.field.foreignKey
+        rootModel,
+        rootTableAlias,
+        model: targetModel,
+        tableAlias
       };
-      addJoin(joins, node.tableAlias, subNode.tableName, subNode.tableAlias, get(subNode, "foreignKey"), "id");
+      addJoin(joins, node.tableAlias, subNode.model.name, subNode.tableAlias, relation.field.foreignKey, "id");
       applyWhere2(subNode, value2, ops, joins);
       continue;
     }
+    const column = getColumn(node, key);
     if (Array.isArray(value2)) {
       if (field && field.list) {
         ops.push(
           (query) => ors(
             query,
-            value2.map((v) => (subQuery) => subQuery.whereRaw("? = ANY(??)", [v, fullKey]))
+            value2.map((v) => (subQuery) => subQuery.whereRaw("? = ANY(??)", [v, column]))
           )
         );
         continue;
@@ -1784,25 +2117,25 @@ var applyWhere2 = (node, where, ops, joins) => {
         if (value2.some((v) => v !== null)) {
           ops.push(
             (query) => ors(query, [
-              (subQuery) => subQuery.whereIn(fullKey, value2.filter((v) => v !== null)),
-              (subQuery) => subQuery.whereNull(fullKey)
+              (subQuery) => subQuery.whereIn(column, value2.filter((v) => v !== null)),
+              (subQuery) => subQuery.whereNull(column)
             ])
           );
           continue;
         }
-        ops.push((query) => query.whereNull(fullKey));
+        ops.push((query) => query.whereNull(column));
         continue;
       }
-      ops.push((query) => query.whereIn(fullKey, value2));
+      ops.push((query) => query.whereIn(column, value2));
       continue;
     }
-    ops.push((query) => query.where({ [fullKey]: value2 }));
+    ops.push((query) => query.where({ [column]: value2 }));
   }
 };
 var applySearch = (node, search, query) => ors(
   query,
   node.model.fields.filter(({ searchable }) => searchable).map(
-    ({ name: name2 }) => (query2) => query2.whereILike(`${node.shortTableAlias}.${name2}`, `%${search}%`)
+    ({ name: name2 }) => (query2) => query2.whereILike(getColumn(node, name2), `%${search}%`)
   )
 );
 var applyOrderBy = (node, orderBy, query) => {
@@ -1813,7 +2146,7 @@ var applyOrderBy = (node, orderBy, query) => {
     }
     const key = keys[0];
     const value2 = vals[key];
-    query.orderBy(`${node.shortTableAlias}.${key}`, value2);
+    void query.orderBy(getColumn(node, key), value2);
   }
 };
 
@@ -1829,19 +2162,26 @@ var getResolverNode = ({
   ctx,
   node,
   tableAlias,
+  rootTableAlias,
+  resultAlias,
   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")
-});
+}) => {
+  const model = ctx.models.getModel(typeName, "entity");
+  const rootModel = model.parent ? ctx.models.getModel(model.parent, "entity") : model;
+  return {
+    ctx,
+    rootModel,
+    rootTableAlias,
+    model,
+    tableAlias,
+    resultAlias,
+    baseTypeDefinition,
+    baseModel: ctx.models.entities.find((model2) => model2.name === baseTypeDefinition.name.value),
+    typeDefinition: getType(ctx.info.schema, typeName),
+    selectionSet: get(node.selectionSet, "selections")
+  };
+};
 var getRootFieldNode = ({
   ctx,
   node,
@@ -1850,14 +2190,17 @@ var getRootFieldNode = ({
   const fieldName = node.name.value;
   const fieldDefinition = summonByKey(baseTypeDefinition.fields || [], "name.value", fieldName);
   const typeName = getTypeName(fieldDefinition.type);
+  const model = ctx.models.getModel(typeName, "entity");
+  const rootModel = model.parent ? ctx.models.getModel(model.parent, "entity") : model;
   return {
     ctx,
-    tableName: typeName,
-    tableAlias: typeName,
-    shortTableAlias: ctx.aliases.getShort(typeName),
+    rootModel,
+    rootTableAlias: rootModel.name,
+    model,
+    tableAlias: model.name,
+    resultAlias: rootModel.name,
     baseTypeDefinition,
     typeDefinition: getType(ctx.info.schema, typeName),
-    model: summonByName(ctx.models, typeName),
     selectionSet: get(node.selectionSet, "selections"),
     field: node,
     fieldDefinition,
@@ -1876,7 +2219,9 @@ var getInlineFragments = (node) => node.selectionSet.filter(isInlineFragmentNode
   (subNode) => getResolverNode({
     ctx: node.ctx,
     node: subNode,
+    rootTableAlias: node.rootTableAlias,
     tableAlias: node.tableAlias + "__" + getFragmentTypeName(subNode),
+    resultAlias: node.resultAlias,
     baseTypeDefinition: node.baseTypeDefinition,
     typeName: getFragmentTypeName(subNode)
   })
@@ -1885,7 +2230,9 @@ var getFragmentSpreads = (node) => node.selectionSet.filter(isFragmentSpreadNode
   (subNode) => getResolverNode({
     ctx: node.ctx,
     node: node.ctx.info.fragments[subNode.name.value],
+    rootTableAlias: node.rootTableAlias,
     tableAlias: node.tableAlias,
+    resultAlias: node.resultAlias,
     baseTypeDefinition: node.baseTypeDefinition,
     typeName: node.model.name
   })
@@ -1899,44 +2246,90 @@ var getJoins = (node, toMany) => {
     const fieldNameOrAlias = getNameOrAlias(subNode);
     const fieldDefinition = summonByKey(baseTypeDefinition.fields || [], "name.value", fieldName);
     const typeName = getTypeName(fieldDefinition.type);
-    if (isObjectModel(summonByName(ctx.rawModels, typeName))) {
+    if (isObjectModel(ctx.models.getModel(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?.kind !== "relation") {
-        continue;
-      }
-      foreignKey = modelField.foreignKey;
+    const baseModel = ctx.models.getModel(baseTypeDefinition.name.value, "entity");
+    const relation = (toMany ? baseModel.reverseRelationsByName : baseModel.relationsByName)[fieldName];
+    if (!relation) {
+      continue;
     }
     const tableAlias = node.tableAlias + "__" + fieldNameOrAlias;
+    const model = ctx.models.getModel(typeName, "entity");
+    const rootModel = model;
     nodes.push({
       ctx,
-      tableName: typeName,
+      rootModel,
+      rootTableAlias: tableAlias,
+      model,
       tableAlias,
-      shortTableAlias: ctx.aliases.getShort(tableAlias),
+      resultAlias: tableAlias,
       baseTypeDefinition,
       baseModel,
       typeDefinition: getType(ctx.info.schema, typeName),
-      model: summonByName(ctx.models, typeName),
       selectionSet: get(subNode.selectionSet, "selections"),
       field: subNode,
       fieldDefinition,
-      foreignKey,
+      relation,
+      foreignKey: relation.field.foreignKey,
       isList: isListType(fieldDefinition.type)
     });
   }
   return nodes;
 };
 
+// src/resolvers/selects.ts
+var applySelects = (node, query, joins) => {
+  void query.select(
+    ...[
+      { tableAlias: node.rootTableAlias, resultAlias: node.resultAlias, field: "id", fieldAlias: ID_ALIAS },
+      ...node.model.root ? [{ tableAlias: node.rootTableAlias, resultAlias: node.resultAlias, field: "type", fieldAlias: TYPE_ALIAS }] : [],
+      ...getSimpleFields(node).filter((fieldNode) => {
+        const field = node.model.fieldsByName[fieldNode.name.value];
+        if (!field || field.kind === "relation" || field.kind === "custom") {
+          return false;
+        }
+        if (typeof field.queriable === "object" && !field.queriable.roles?.includes(node.ctx.user.role)) {
+          throw new PermissionError(
+            "READ",
+            `${node.model.name}'s field "${field.name}"`,
+            "field permission not available"
+          );
+        }
+        return true;
+      }).map((fieldNode) => {
+        const field = node.model.getField(fieldNode.name.value);
+        if (node.model.parent && !field.inherited) {
+          addJoin(joins, node.rootTableAlias, node.model.name, node.tableAlias, "id", "id");
+        }
+        const fieldAlias = getNameOrAlias(fieldNode);
+        if ([ID_ALIAS, TYPE_ALIAS].includes(fieldAlias)) {
+          throw new UserInputError(`Keyword ${fieldAlias} is reserved by graphql-magic.`);
+        }
+        return {
+          fieldNode,
+          field: fieldNode.name.value,
+          tableAlias: field.inherited ? node.rootTableAlias : node.tableAlias,
+          resultAlias: node.resultAlias,
+          fieldAlias
+        };
+      })
+    ].map(
+      ({ tableAlias, resultAlias, field, fieldAlias }) => `${node.ctx.aliases.getShort(tableAlias)}.${field} as ${node.ctx.aliases.getShort(resultAlias)}__${fieldAlias}`
+    )
+  );
+  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.rootModel.name, subNode.rootTableAlias, subNode.foreignKey, "id");
+    applySelects(subNode, query, joins);
+  }
+};
+
 // src/resolvers/resolver.ts
 var queryResolver = (_parent, _args, ctx, info) => resolve({ ...ctx, info, aliases: new AliasGenerator() });
 var resolve = async (ctx, id) => {
@@ -1952,13 +2345,13 @@ var resolve = async (ctx, id) => {
   });
   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);
+    void query.where({ [getColumn(node, "id")]: node.ctx.user.id });
   }
   if (id) {
-    query.where({ id });
+    void query.where({ [getColumn(node, "id")]: id });
+  }
+  if (!node.isList) {
+    void query.limit(1);
   }
   const raw = await query;
   const res = hydrate(node, raw);
@@ -1973,20 +2366,19 @@ var resolve = async (ctx, id) => {
   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 = {};
+  const query = node.ctx.knex.fromRaw(`"${node.rootModel.name}" as "${node.ctx.aliases.getShort(node.resultAlias)}"`);
+  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(":"))
+    [node.rootModel.name, node.rootTableAlias],
+    ...joins.map(({ table2Name, table2Alias }) => [table2Name, table2Alias])
   ];
   const verifiedPermissionStacks = {};
   for (const [table, alias] of tables) {
     const verifiedPermissionStack = applyPermissions(
-      ctx,
+      node.ctx,
       table,
       node.ctx.aliases.getShort(alias),
       query,
@@ -1999,39 +2391,6 @@ var buildQuery = async (node, parentVerifiedPermissionStacks) => {
   }
   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.kind === "relation" || field.kind === "custom") {
-          return false;
-        }
-        if (typeof field.queriable === "object" && !field.queriable.roles?.includes(node.ctx.user.role)) {
-          throw new PermissionError(
-            "READ",
-            `${node.model.name}'s field "${field.name}"`,
-            "field permission not available"
-          );
-        }
-        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;
@@ -2048,10 +2407,12 @@ var applySubQueries = async (node, entries, parentVerifiedPermissionStacks) => {
     const fieldName = getNameOrAlias(subNode.field);
     const isList = isListType(subNode.fieldDefinition.type);
     entries.forEach((entry) => entry[fieldName] = isList ? [] : null);
-    const foreignKey = get(subNode, "foreignKey");
+    const foreignKey = subNode.foreignKey;
     const { query, verifiedPermissionStacks } = await buildQuery(subNode, parentVerifiedPermissionStacks);
+    const shortTableAlias = subNode.ctx.aliases.getShort(subNode.tableAlias);
+    const shortResultAlias = subNode.ctx.aliases.getShort(subNode.resultAlias);
     const queries = ids.map(
-      (id) => query.clone().select(`${subNode.shortTableAlias}.${foreignKey} as ${subNode.shortTableAlias}__${foreignKey}`).where({ [`${subNode.shortTableAlias}.${foreignKey}`]: id })
+      (id) => query.clone().select(`${shortTableAlias}.${foreignKey} as ${shortResultAlias}__${foreignKey}`).where({ [`${shortTableAlias}.${foreignKey}`]: id })
     );
     const rawChildren = (await Promise.all(queries)).flat();
     const children = hydrate(subNode, rawChildren);
@@ -2095,7 +2456,7 @@ 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);
+    const model = ctx.models.getModel(modelName, "entity");
     switch (mutation) {
       case "create":
         return await create(model, args2, ctx);
@@ -2113,12 +2474,32 @@ var create = async (model, { data: input2 }, ctx) => {
   normalizedInput.id = (0, import_uuid.v4)();
   normalizedInput.createdAt = ctx.now;
   normalizedInput.createdById = ctx.user.id;
+  if (model.parent) {
+    normalizedInput.type = model.name;
+  }
   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);
+  if (model.parent) {
+    const rootInput = {};
+    const childInput = { id: normalizedInput.id };
+    for (const field of model.fields) {
+      const columnName = field.kind === "relation" ? `${field.name}Id` : field.name;
+      if (columnName in normalizedInput) {
+        if (field.inherited) {
+          rootInput[columnName] = normalizedInput[columnName];
+        } else {
+          childInput[columnName] = normalizedInput[columnName];
+        }
+      }
+    }
+    await ctx.knex(model.parent).insert(rootInput);
+    await ctx.knex(model.name).insert(childInput);
+  } else {
+    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);
@@ -2141,7 +2522,28 @@ var update = async (model, { where, data: input2 }, ctx) => {
     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);
+    if (model.parent) {
+      const rootInput = {};
+      const childInput = {};
+      for (const field of model.fields) {
+        const columnName = field.kind === "relation" ? `${field.name}Id` : field.name;
+        if (columnName in normalizedInput) {
+          if (field.inherited) {
+            rootInput[columnName] = normalizedInput[columnName];
+          } else {
+            childInput[columnName] = normalizedInput[columnName];
+          }
+        }
+      }
+      if (Object.keys(rootInput).length) {
+        await ctx.knex(model.parent).where({ id: prev.id }).update(rootInput);
+      }
+      if (Object.keys(childInput).length) {
+        await ctx.knex(model.name).where({ id: prev.id }).update(childInput);
+      }
+    } else {
+      await ctx.knex(model.name).where({ id: prev.id }).update(normalizedInput);
+    }
     await createRevision(model, next, ctx);
     await ctx.mutationHook?.(model, "update", "after", data, ctx);
   }
@@ -2151,7 +2553,8 @@ 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");
+  const rootModel = model.rootModel;
+  const entity = await getEntityToMutate(ctx, rootModel, where, "DELETE");
   if (entity.deleted) {
     throw new ForbiddenError("Entity is already deleted.");
   }
@@ -2190,10 +2593,9 @@ var del = async (model, { where, dryRun }, ctx) => {
       }
     }
     for (const {
-      model: descendantModel,
-      foreignKey,
-      field: { name: name2, onDelete }
-    } of currentModel.reverseRelations) {
+      targetModel: descendantModel,
+      field: { name: name2, foreignKey, onDelete }
+    } of currentModel.reverseRelations.filter((reverseRelation) => !reverseRelation.field.inherited)) {
       const query = ctx.knex(descendantModel.name).where({ [foreignKey]: entity2.id });
       switch (onDelete) {
         case "set-null": {
@@ -2235,7 +2637,7 @@ var del = async (model, { where, dryRun }, ctx) => {
       }
     }
   };
-  await deleteCascade(model, entity);
+  await deleteCascade(rootModel, entity);
   for (const callback of [...beforeHooks, ...mutations, ...afterHooks]) {
     await callback();
   }
@@ -2252,7 +2654,8 @@ 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");
+  const rootModel = model.rootModel;
+  const entity = await getEntityToMutate(ctx, rootModel, where, "RESTORE");
   if (!entity.deleted) {
     throw new ForbiddenError("Entity is not deleted.");
   }
@@ -2279,9 +2682,10 @@ var restore = async (model, { where }, ctx) => {
         await ctx.mutationHook(model, "restore", "after", data, ctx);
       });
     }
-    for (const { model: descendantModel, foreignKey } of currentModel.reverseRelations.filter(
-      ({ model: { deletable } }) => deletable
-    )) {
+    for (const {
+      targetModel: descendantModel,
+      field: { foreignKey }
+    } of currentModel.reverseRelations.filter((reverseRelation) => !reverseRelation.field.inherited).filter(({ targetModel: { deletable } }) => deletable)) {
       const query = ctx.knex(descendantModel.name).where({ [foreignKey]: relatedEntity.id });
       applyPermissions(ctx, descendantModel.name, descendantModel.name, query, "RESTORE");
       const descendants = await query;
@@ -2290,7 +2694,7 @@ var restore = async (model, { where }, ctx) => {
       }
     }
   };
-  await restoreCascade(model, entity);
+  await restoreCascade(rootModel, entity);
   for (const callback of [...beforeHooks, ...mutations, ...afterHooks]) {
     await callback();
   }
@@ -2298,24 +2702,37 @@ var restore = async (model, { where }, ctx) => {
 };
 var createRevision = async (model, data, ctx) => {
   if (model.updatable) {
-    const revisionData = {
-      id: (0, import_uuid.v4)(),
-      [`${typeToField(model.name)}Id`]: data.id,
+    const revisionId = (0, import_uuid.v4)();
+    const rootRevisionData = {
+      id: revisionId,
+      [`${typeToField(model.parent || model.name)}Id`]: data.id,
       createdAt: ctx.now,
       createdById: ctx.user.id
     };
     if (model.deletable) {
-      revisionData.deleted = data.deleted || false;
-    }
-    for (const { kind: type, name: name2, nonNull: nonNull2, ...field } of model.fields.filter(({ updatable }) => updatable)) {
-      const col = type === "relation" ? `${name2}Id` : name2;
-      if (nonNull2 && (!(col in data) || col === void 0 || col === null)) {
-        revisionData[col] = get(field, "defaultValue");
+      rootRevisionData.deleted = data.deleted || false;
+    }
+    const childRevisionData = { id: revisionId };
+    for (const field of model.fields.filter(({ updatable }) => updatable)) {
+      const col = field.kind === "relation" ? `${field.name}Id` : field.name;
+      let value2;
+      if (field.nonNull && (!(col in data) || col === void 0 || col === null)) {
+        value2 = get(field, "defaultValue");
+      } else {
+        value2 = data[col];
+      }
+      if (!model.parent || field.inherited) {
+        rootRevisionData[col] = value2;
       } else {
-        revisionData[col] = data[col];
+        childRevisionData[col] = value2;
       }
     }
-    await ctx.knex(`${model.name}Revision`).insert(revisionData);
+    if (model.parent) {
+      await ctx.knex(`${model.parent}Revision`).insert(rootRevisionData);
+      await ctx.knex(`${model.name}Revision`).insert(childRevisionData);
+    } else {
+      await ctx.knex(`${model.name}Revision`).insert(rootRevisionData);
+    }
   }
 };
 var sanitize = (ctx, model, data) => {
@@ -2332,7 +2749,7 @@ var sanitize = (ctx, model, data) => {
       data[key] = data[key].endOf("day");
       continue;
     }
-    if (isEnumList(ctx.rawModels, field) && Array.isArray(data[key])) {
+    if (field.list && field.kind === "enum" && Array.isArray(data[key])) {
       data[key] = `{${data[key].join(",")}}`;
       continue;
     }
@@ -2346,30 +2763,37 @@ var getResolvers = (models) => ({
     {
       me: queryResolver
     },
-    ...models.filter(({ queriable }) => queriable).map((model) => ({
+    ...models.entities.filter(({ queriable }) => queriable).map((model) => ({
       [typeToField(model.name)]: queryResolver
     })),
-    ...models.filter(({ listQueriable }) => listQueriable).map((model) => ({
-      [getModelPluralField(model)]: queryResolver
+    ...models.entities.filter(({ listQueriable }) => listQueriable).map((model) => ({
+      [model.pluralField]: queryResolver
     }))
   ]),
   Mutation: merge2([
-    ...models.filter(({ creatable }) => creatable).map((model) => ({
+    ...models.entities.filter(not(isRootModel)).filter(({ creatable }) => creatable).map((model) => ({
       [`create${model.name}`]: mutationResolver
     })),
-    ...models.filter(({ updatable }) => updatable).map((model) => ({
+    ...models.entities.filter(not(isRootModel)).filter(({ updatable }) => updatable).map((model) => ({
       [`update${model.name}`]: mutationResolver
     })),
-    ...models.filter(({ deletable }) => deletable).map((model) => ({
+    ...models.entities.filter(not(isRootModel)).filter(({ deletable }) => deletable).map((model) => ({
       [`delete${model.name}`]: mutationResolver,
       [`restore${model.name}`]: mutationResolver
     }))
-  ])
+  ]),
+  ...Object.assign(
+    {},
+    ...models.entities.filter(isRootModel).map((model) => ({
+      [model.name]: {
+        __resolveType: ({ TYPE }) => TYPE
+      }
+    }))
+  )
 });
 
 // src/schema/generate.ts
 var import_graphql5 = require("graphql");
-var import_flatMap2 = __toESM(require("lodash/flatMap"), 1);
 
 // src/schema/utils.ts
 var import_luxon = require("luxon");
@@ -2401,10 +2825,11 @@ var object = (nme, fds, interfaces, dvs) => ({
   interfaces: interfaces && interfaces.map((i) => namedType(i)),
   directives: directives(dvs)
 });
-var iface = (nme, fds, dvs) => ({
+var iface = (nme, fds, interfaces, dvs) => ({
   name: name(nme),
   fields: fields(fds),
   kind: "InterfaceTypeDefinition",
+  interfaces: interfaces && interfaces.map((i) => namedType(i)),
   directives: directives(dvs)
 });
 var inputValues = (fields2) => fields2.map(
@@ -2520,84 +2945,86 @@ var value = (val = null) => val === null ? {
 };
 
 // src/schema/generate.ts
-var generateDefinitions = (rawModels) => {
-  const models = getModels(rawModels);
+var generateDefinitions = ({
+  scalars,
+  rawEnums,
+  enums,
+  inputs,
+  interfaces,
+  entities,
+  objects
+}) => {
   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(isObjectModel).filter(({ name: name2 }) => !["Query", "Mutation"].includes(name2)).map((model) => object(model.name, model.fields)),
-    ...rawModels.filter(isInputModel).map((model) => input(model.name, model.fields)),
-    ...rawModels.filter(isObjectModel).filter(
-      (model) => models.some((m) => m.creatable && m.fields.some((f) => f.creatable && f.kind === "json" && f.type === model.name))
+    ...rawEnums.map((model) => enm(model.name, model.values)),
+    ...enums.map((model) => enm(model.name, model.values)),
+    ...scalars.map((model) => scalar(model.name)),
+    ...objects.filter(({ name: name2 }) => !["Query", "Mutation"].includes(name2)).map((model) => object(model.name, model.fields)),
+    ...interfaces.map(({ name: name2, fields: fields2 }) => iface(name2, fields2)),
+    ...inputs.map((model) => input(model.name, model.fields)),
+    ...objects.filter(
+      (model) => entities.some((m) => m.creatable && m.fields.some((f) => f.creatable && f.kind === "json" && f.type === model.name))
     ).map((model) => input(`Create${model.name}`, model.fields)),
-    ...rawModels.filter(isObjectModel).filter(
-      (model) => models.some((m) => m.creatable && m.fields.some((f) => f.creatable && f.kind === "json" && f.type === model.name))
+    ...objects.filter(
+      (model) => entities.some((m) => m.updatable && m.fields.some((f) => f.updatable && f.kind === "json" && f.type === model.name))
     ).map((model) => input(`Update${model.name}`, model.fields)),
-    ...(0, import_flatMap2.default)(
-      models.map((model) => {
-        const types = [
-          object(
-            model.name,
-            [
-              ...model.fields.filter(isQueriableField).map((field) => ({
-                ...field,
-                type: field.type,
-                args: [...field.args || []],
-                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(({ kind, unique, filterable }) => (unique || filterable) && kind !== "relation").map((field) => ({
-              name: field.name,
+    ...entities.flatMap((model) => {
+      const types = [
+        (isRootModel(model) ? iface : object)(
+          model.name,
+          [
+            ...model.fields.filter(isQueriableField).map((field) => ({
+              ...field,
               type: field.type,
-              list: true,
-              default: typeof field.filterable === "object" ? field.filterable.default : void 0
+              args: [...field.args || []],
+              directives: field.directives
             })),
-            ...(0, import_flatMap2.default)(
-              model.fields.filter(({ comparable }) => comparable),
-              (field) => [
-                { name: `${field.name}_GT`, type: field.type },
-                { name: `${field.name}_GTE`, type: field.type },
-                { name: `${field.name}_LT`, type: field.type },
-                { name: `${field.name}_LTE`, type: field.type }
-              ]
-            ),
-            ...model.fields.filter(isRelation).filter(({ filterable }) => filterable).map(({ name: name2, type }) => ({
+            ...model.reverseRelations.map(({ name: name2, field, targetModel }) => ({
               name: name2,
-              type: `${type}Where`
+              type: targetModel.name,
+              list: !field.toOne,
+              nonNull: !field.toOne,
+              args: [
+                { name: "where", type: `${targetModel.name}Where` },
+                ...targetModel.fields.some(({ searchable }) => searchable) ? [{ name: "search", type: "String" }] : [],
+                ...targetModel.fields.some(({ orderable }) => orderable) ? [{ name: "orderBy", type: `${targetModel.name}OrderBy`, list: true }] : [],
+                { name: "limit", type: "Int" },
+                { name: "offset", type: "Int" }
+              ]
             }))
+          ],
+          [...model.parent ? [model.parent] : [], ...model.interfaces || []]
+        ),
+        input(`${model.name}Where`, [
+          ...model.fields.filter(({ kind, unique, filterable }) => (unique || filterable) && kind !== "relation").map((field) => ({
+            name: field.name,
+            type: field.type,
+            list: true,
+            default: typeof field.filterable === "object" ? field.filterable.default : void 0
+          })),
+          ...model.fields.filter(({ comparable }) => comparable).flatMap((field) => [
+            { name: `${field.name}_GT`, type: field.type },
+            { name: `${field.name}_GTE`, type: field.type },
+            { name: `${field.name}_LT`, type: field.type },
+            { name: `${field.name}_LTE`, type: field.type }
           ]),
+          ...model.fields.filter(isRelation).filter(({ filterable }) => filterable).map(({ name: name2, type }) => ({
+            name: name2,
+            type: `${type}Where`
+          }))
+        ]),
+        input(
+          `${model.name}WhereUnique`,
+          model.fields.filter(({ unique }) => unique).map((field) => ({ name: field.name, type: field.type }))
+        ),
+        ...model.fields.some(({ orderable }) => orderable) ? [
           input(
-            `${model.name}WhereUnique`,
-            model.fields.filter(({ unique }) => unique).map((field) => ({ name: field.name, type: field.type }))
-          ),
-          ...model.fields.some(({ orderable }) => orderable) ? [
-            input(
-              `${model.name}OrderBy`,
-              model.fields.filter(({ orderable }) => orderable).map(({ name: name2 }) => ({ name: name2, type: "Order" }))
-            )
-          ] : []
-        ];
+            `${model.name}OrderBy`,
+            model.fields.filter(({ orderable }) => orderable).map(({ name: name2 }) => ({ name: name2, type: "Order" }))
+          )
+        ] : []
+      ];
+      if (!isRootModel(model)) {
         if (model.creatable) {
           types.push(
             input(
@@ -2627,15 +3054,15 @@ var generateDefinitions = (rawModels) => {
             )
           );
         }
-        return types;
-      })
-    ),
+      }
+      return types;
+    }),
     object("Query", [
       {
         name: "me",
         type: "User"
       },
-      ...models.filter(({ queriable }) => queriable).map(({ name: name2 }) => ({
+      ...entities.filter(({ queriable }) => queriable).map(({ name: name2 }) => ({
         name: typeToField(name2),
         type: name2,
         nonNull: true,
@@ -2647,8 +3074,8 @@ var generateDefinitions = (rawModels) => {
           }
         ]
       })),
-      ...models.filter(({ listQueriable }) => listQueriable).map((model) => ({
-        name: getModelPluralField(model),
+      ...entities.filter(({ listQueriable }) => listQueriable).map((model) => ({
+        name: model.pluralField,
         type: model.name,
         list: true,
         nonNull: true,
@@ -2660,12 +3087,12 @@ var generateDefinitions = (rawModels) => {
           { name: "offset", type: "Int" }
         ]
       })),
-      ...rawModels.filter(isObjectModel).filter((model) => model.name === "Query").flatMap((model) => model.fields)
+      ...objects.filter((model) => model.name === "Query").flatMap((model) => model.fields)
     ]),
     object("Mutation", [
-      ...(0, import_flatMap2.default)(
-        models.map((model) => {
-          const mutations = [];
+      ...entities.flatMap((model) => {
+        const mutations = [];
+        if (!isRootModel(model)) {
           if (model.creatable) {
             mutations.push({
               name: `create${model.name}`,
@@ -2729,14 +3156,14 @@ var generateDefinitions = (rawModels) => {
               ]
             });
           }
-          return mutations;
-        })
-      ),
-      ...rawModels.filter(isObjectModel).filter((model) => model.name === "Mutation").flatMap((model) => model.fields)
+        }
+        return mutations;
+      }),
+      ...objects.filter((model) => model.name === "Mutation").flatMap((model) => model.fields)
     ])
   ];
 };
-var generate = (rawModels) => document(generateDefinitions(rawModels));
+var generate = (models) => document(generateDefinitions(models));
 var printSchema = (schema) => [
   ...schema.getDirectives().map((d) => d.astNode && (0, import_graphql5.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_graphql5.print)(t.astNode))
@@ -2747,13 +3174,27 @@ var printSchemaFromModels = (models) => printSchema((0, import_graphql5.buildAST
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AliasGenerator,
+  EntityModel,
+  EnumModel,
   ForbiddenError,
   GraphQLError,
   ID_ALIAS,
+  InputModel,
+  InterfaceModel,
+  ManyToManyRelation,
   MigrationGenerator,
+  Model,
+  Models,
+  NormalRelation,
   NotFoundError,
+  ObjectModel,
   PermissionError,
+  RawEnumModel,
+  Relation,
+  ReverseRelation,
   SPECIAL_FILTERS,
+  ScalarModel,
+  TYPE_ALIAS,
   UserInputError,
   actionableRelations,
   addJoin,
@@ -2762,6 +3203,7 @@ var printSchemaFromModels = (models) => printSchema((0, import_graphql5.buildAST
   applyFilters,
   applyJoins,
   applyPermissions,
+  applySelects,
   args,
   checkCanWrite,
   directive,
@@ -2779,6 +3221,8 @@ var printSchemaFromModels = (models) => printSchema((0, import_graphql5.buildAST
   generateMutations,
   generatePermissions,
   get,
+  getColumn,
+  getColumnName,
   getEditEntityRelationsQuery,
   getEntityListQuery,
   getEntityQuery,
@@ -2789,16 +3233,8 @@ var printSchemaFromModels = (models) => printSchema((0, import_graphql5.buildAST
   getInlineFragments,
   getJoins,
   getLabel,
-  getManyToManyRelation,
-  getManyToManyRelations,
   getManyToManyRelationsQuery,
   getMigrationDate,
-  getModelLabel,
-  getModelLabelPlural,
-  getModelPlural,
-  getModelPluralField,
-  getModelSlug,
-  getModels,
   getMutationQuery,
   getNameOrAlias,
   getPermissionStack,
@@ -2811,6 +3247,7 @@ var printSchemaFromModels = (models) => printSchema((0, import_graphql5.buildAST
   getTypeName,
   getUpdateEntityQuery,
   gql,
+  hasName,
   hash,
   hydrate,
   iface,
@@ -2822,12 +3259,14 @@ var printSchemaFromModels = (models) => printSchema((0, import_graphql5.buildAST
   isCustomField,
   isEntityModel,
   isEnum,
-  isEnumList,
   isEnumModel,
   isFieldNode,
   isFragmentSpreadNode,
+  isInTable,
+  isInherited,
   isInlineFragmentNode,
   isInputModel,
+  isInterfaceModel,
   isListType,
   isObjectModel,
   isPrimitive,
@@ -2835,16 +3274,20 @@ var printSchemaFromModels = (models) => printSchema((0, import_graphql5.buildAST
   isQueriableField,
   isRawEnumModel,
   isRelation,
+  isRootModel,
   isScalarModel,
   isSimpleField,
   isToOneRelation,
   isUpdatable,
   isUpdatableBy,
+  isUpdatableField,
+  isUpdatableModel,
   isVisible,
   isVisibleRelation,
   it,
   list,
   merge,
+  modelNeedsTable,
   mutationResolver,
   name,
   namedType,
@@ -2854,6 +3297,7 @@ var printSchemaFromModels = (models) => printSchema((0, import_graphql5.buildAST
   normalizeValueByTypeDefinition,
   not,
   object,
+  or,
   ors,
   printSchema,
   printSchemaFromDocument,