@smartive/graphql-magic 9.1.2 → 10.0.0

package/dist/bin/gqm.cjs

@@ -36,9 +36,9 @@ var import_lodash = require("lodash");
 // 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(
@@ -69,11 +69,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")}`;
 };
@@ -82,77 +91,104 @@ ${parts.join("\n\n")}`;
 var import_upperFirst = __toESM(require("lodash/upperFirst"), 1);
 
 // src/models/utils.ts
-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 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 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 and = (...predicates) => (field) => predicates.every((predicate) => predicate(field));
-var not = (predicate) => (field) => !predicate(field);
-var isRelation = (field) => field.kind === "relation";
-var isQueriableField = ({ queriable }) => queriable !== false;
-var isCustomField = (field) => field.kind === "custom";
-var isSimpleField = and(not(isRelation), not(isCustomField));
-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",
@@ -160,65 +196,326 @@ 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"));
   }
-  return models;
 };
+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;
+  }
+};
+var isEntityModelDefinition = (definition) => definition.kind === "entity";
+var getModelPlural = (model) => model.plural || (0, import_inflection.pluralize)(model.name);
+
+// src/models/utils.ts
+var typeToField = (type) => type.substr(0, 1).toLowerCase() + type.substr(1);
+var getLabel = (s) => (0, import_lodash3.startCase)((0, import_lodash3.camelCase)(s));
+var and = (...predicates) => (field) => predicates.every((predicate) => predicate(field));
+var not = (predicate) => (field) => !predicate(field);
+var isRootModel = (model) => model.root;
+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 isRelation = (field) => field.kind === "relation";
+var isInherited = (field) => field.inherited;
+var isInTable = (field) => field.name === "id" || !field.inherited;
+var isQueriableField = ({ queriable }) => queriable !== false;
+var isCustomField = (field) => field.kind === "custom";
+var isSimpleField = and(not(isRelation), not(isCustomField));
 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) => {
@@ -243,8 +540,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;
 };
@@ -261,56 +559,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))) {
+      for (const field of fields2.filter(not(isCustomField)).filter(isInTable)) {
         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);
-        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) {
@@ -331,19 +632,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();
       }
     });
@@ -356,10 +656,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(knex2, rawModels) {
-    this.rawModels = rawModels;
+  constructor(knex2, models) {
+    this.models = models;
     this.schema = (0, import_knex_schema_inspector.SchemaInspector)(knex2);
-    this.models = getModels(rawModels);
   }
   writer = new import_code_block_writer2.default["default"]({
     useSingleQuote: true,
@@ -369,9 +668,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) {
@@ -380,11 +678,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);
@@ -396,7 +694,7 @@ var MigrationGenerator = class {
             }
           });
         });
-        if (model.updatable) {
+        if (isUpdatableModel(model)) {
           up.push(() => {
             this.dropTable(`${model.name}Revision`);
           });
@@ -415,7 +713,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`, () => {
@@ -433,92 +731,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,
@@ -526,10 +834,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
           );
@@ -537,7 +845,7 @@ var MigrationGenerator = class {
       }
     }
     this.createEnums(
-      rawModels.filter(isEnumModel).filter((enm2) => enm2.deleted),
+      this.models.enums.filter((enm2) => enm2.deleted),
       down,
       up
     );
@@ -645,8 +953,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;
       }
@@ -674,15 +982,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 });
       }
     });
@@ -730,7 +1038,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) {
@@ -810,7 +1118,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":
@@ -831,14 +1139,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,`);
@@ -876,6 +1186,8 @@ var import_graphql2 = require("graphql");
 
 // src/resolvers/utils.ts
 var import_graphql3 = require("graphql");
+var import_lodash4 = require("lodash");
+var getColumnName = (field) => field.kind === "relation" ? field.foreignKey || `${field.name}Id` : field.name;
 
 // src/resolvers/arguments.ts
 var import_graphql4 = require("graphql");
@@ -889,7 +1201,6 @@ var import_flatMap = __toESM(require("lodash/flatMap"), 1);
 
 // 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");
@@ -914,6 +1225,13 @@ var object = (nme, fds, interfaces, dvs) => ({
   interfaces: interfaces && interfaces.map((i) => namedType(i)),
   directives: directives(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(
   (field) => ({
     kind: "InputValueDefinition",
@@ -1019,84 +1337,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(
@@ -1126,15 +1446,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,
@@ -1146,8 +1466,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,
@@ -1159,12 +1479,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}`,
@@ -1228,14 +1548,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))
@@ -1267,9 +1587,9 @@ var readLine = (prompt) => {
 
 // src/bin/gqm/templates.ts
 var EMPTY_MODELS = `
-import { RawModels, getModels } from '@smartive/graphql-magic';
+import { RawModels, Models } from '@smartive/graphql-magic';
 
-export const rawModels: RawModels = [
+const rawModels: RawModels = [
   {
     kind: 'entity',
     name: 'User',
@@ -1277,9 +1597,22 @@ export const rawModels: RawModels = [
   },
 ]
 
-export const models = getModels(rawModels);
+export const models = new Models(rawModels);
 `;
 var KNEXFILE = `
+import { DateTime } from 'luxon';
+import { types } from 'pg';
+
+const dateOids = { date: 1082, timestamptz: 1184, timestamp: 1114 };
+for (const oid of Object.values(dateOids)) {
+  types.setTypeParser(oid, (val) => DateTime.fromSQL(val));
+}
+
+const numberOids = { int8: 20, float8: 701, numeric: 1700 };
+for (const oid of Object.values(numberOids)) {
+  types.setTypeParser(oid, Number);
+}
+
 const config = {
   client: 'postgresql',
   connection: {
@@ -1288,6 +1621,13 @@ const config = {
     user: process.env.DATABASE_USER,
     password: process.env.DATABASE_PASSWORD,
   },
+  migrations: {
+    tableName: 'knex_migrations',
+  },
+  pool: {
+    min: 0,
+    max: 30,
+  },
 } as const;
 
 export default config;
@@ -1319,6 +1659,9 @@ var DEFAULTS = {
     init: (path) => {
       ensureDirectoryExists(path);
     }
+  },
+  gqlModule: {
+    defaultValue: "@smartive/graphql-magic"
   }
 };
 var initSetting = async (name2) => {
@@ -1329,8 +1672,10 @@ var initSetting = async (name2) => {
 };
 var initSettings = async () => {
   const settings = {};
-  for (const name2 of Object.keys(DEFAULTS)) {
-    settings[name2] = await initSetting(name2);
+  for (const [name2, config2] of Object.entries(DEFAULTS)) {
+    if ("queston" in config2) {
+      settings[name2] = await initSetting(name2);
+    }
   }
   saveSettings(settings);
 };
@@ -1346,8 +1691,12 @@ var getSettings = async () => {
 var getSetting = async (name2) => {
   const settings = await getSettings();
   if (!(name2 in settings)) {
-    settings[name2] = await initSetting(name2);
-    saveSettings(settings);
+    if ("question" in DEFAULTS[name2]) {
+      settings[name2] = await initSetting(name2);
+      saveSettings(settings);
+    } else {
+      return DEFAULTS[name2].defaultValue;
+    }
   }
   return settings[name2];
 };
@@ -1512,6 +1861,8 @@ var VISITOR = {
         return process;
       case "Symbol":
         return Symbol;
+      case "Models":
+        return Models;
     }
     const definitionNodes = node.getDefinitionNodes();
     if (!definitionNodes.length) {
@@ -1652,7 +2003,8 @@ var VISITOR = {
     return target[argument];
   },
   [import_ts_morph2.SyntaxKind.NoSubstitutionTemplateLiteral]: (node) => node.getLiteralValue(),
-  [import_ts_morph2.SyntaxKind.NullKeyword]: () => null
+  [import_ts_morph2.SyntaxKind.NullKeyword]: () => null,
+  [import_ts_morph2.SyntaxKind.NewExpression]: (node, context) => new (staticEval(node.getExpression(), context))(...node.getArguments().map((arg) => staticEval(arg, context)))
 };
 
 // src/bin/gqm/utils.ts
@@ -1703,11 +2055,11 @@ var parseModels = async () => {
   });
   const modelsPath = await getSetting("modelsPath");
   const sourceFile = project.addSourceFileAtPath(modelsPath);
-  const modelsDeclaration = findDeclarationInFile(sourceFile, "rawModels");
-  const rawModels = staticEval(modelsDeclaration, {});
+  const modelsDeclaration = findDeclarationInFile(sourceFile, "models");
+  const models = staticEval(modelsDeclaration, {});
   const generatedFolderPath = await getSetting("generatedFolderPath");
-  writeToFile(`${generatedFolderPath}/models.json`, JSON.stringify(rawModels, null, 2));
-  return rawModels;
+  writeToFile(`${generatedFolderPath}/models.json`, JSON.stringify(models.definitions, null, 2));
+  return models;
 };
 
 // src/bin/gqm/gqm.ts
@@ -1723,39 +2075,39 @@ import_commander.program.command("setup").description("Set up the project").acti
   ensureFileExists(KNEXFILE_PATH, KNEXFILE);
 });
 import_commander.program.command("generate").description("Generate all the things").action(async () => {
-  const rawModels = await parseModels();
+  const models = await parseModels();
   const generatedFolderPath = await getSetting("generatedFolderPath");
-  writeToFile(`${generatedFolderPath}/schema.graphql`, printSchemaFromModels(rawModels));
-  writeToFile(`${generatedFolderPath}/client/mutations.ts`, generateMutations(rawModels));
-  writeToFile(`${generatedFolderPath}/db/index.ts`, generateDBModels(rawModels));
-  writeToFile(`${generatedFolderPath}/db/knex.ts`, generateKnexTables(rawModels));
+  const gqlModule = await getSetting("gqlModule");
+  writeToFile(`${generatedFolderPath}/schema.graphql`, printSchemaFromModels(models));
+  writeToFile(`${generatedFolderPath}/client/mutations.ts`, generateMutations(models, gqlModule));
+  writeToFile(`${generatedFolderPath}/db/index.ts`, generateDBModels(models));
+  writeToFile(`${generatedFolderPath}/db/knex.ts`, generateKnexTables(models));
   await generateGraphqlApiTypes();
   await generateGraphqlClientTypes();
 });
 import_commander.program.command("generate-models").description("Generate models.json").action(async () => {
-  const rawModels = await parseModels();
-  const generatedFolderPath = await getSetting("generatedFolderPath");
-  writeToFile(`${generatedFolderPath}/models.json`, JSON.stringify(rawModels, null, 2));
+  await parseModels();
 });
 import_commander.program.command("generate-schema").description("Generate schema").action(async () => {
-  const rawModels = await parseModels();
+  const models = await parseModels();
   const generatedFolderPath = await getSetting("generatedFolderPath");
-  writeToFile(`${generatedFolderPath}/schema.graphql`, printSchemaFromModels(rawModels));
+  writeToFile(`${generatedFolderPath}/schema.graphql`, printSchemaFromModels(models));
 });
 import_commander.program.command("generate-mutation-queries").description("Generate mutation-queries").action(async () => {
-  const rawModels = await parseModels();
+  const models = await parseModels();
   const generatedFolderPath = await getSetting("generatedFolderPath");
-  writeToFile(`${generatedFolderPath}/client/mutations.ts`, generateMutations(rawModels));
+  const gqlModule = await getSetting("gqlModule");
+  writeToFile(`${generatedFolderPath}/client/mutations.ts`, generateMutations(models, gqlModule));
 });
 import_commander.program.command("generate-db-types").description("Generate DB types").action(async () => {
-  const rawModels = await parseModels();
+  const models = await parseModels();
   const generatedFolderPath = await getSetting("generatedFolderPath");
-  writeToFile(`${generatedFolderPath}/db/index.ts`, generateMutations(rawModels));
+  writeToFile(`${generatedFolderPath}/db/index.ts`, generateDBModels(models));
 });
 import_commander.program.command("generate-knex-types").description("Generate Knex types").action(async () => {
-  const rawModels = await parseModels();
+  const models = await parseModels();
   const generatedFolderPath = await getSetting("generatedFolderPath");
-  writeToFile(`${generatedFolderPath}/db/knex.ts`, generateKnexTables(rawModels));
+  writeToFile(`${generatedFolderPath}/db/knex.ts`, generateKnexTables(models));
 });
 import_commander.program.command("generate-graphql-api-types").description("Generate Graphql API types").action(async () => {
   await generateGraphqlApiTypes();
@@ -1763,18 +2115,20 @@ import_commander.program.command("generate-graphql-api-types").description("Gene
 import_commander.program.command("generate-graphql-client-types").description("Generate Graphql client types").action(async () => {
   await generateGraphqlClientTypes();
 });
-import_commander.program.command("generate-migration").description("Generate Migration").action(async () => {
+import_commander.program.command("generate-migration [<name>] [<date>]").description("Generate Migration").action(async (name2, date) => {
   const git = (0, import_simple_git.simpleGit)();
-  let name2 = process.argv[process.argv.indexOf("gqm") + 1] || (await git.branch()).current.split("/").pop();
-  if (name2 && ["staging", "production"].includes(name2)) {
+  if (!name2) {
+    name2 = (await git.branch()).current.split("/").pop();
+  }
+  if (!name2 || ["main", "staging", "production"].includes(name2)) {
     name2 = await readLine("Migration name:");
   }
   const knexfile = await parseKnexfile();
   const db = (0, import_knex.default)(knexfile);
   try {
-    const rawModels = await parseModels();
-    const migrations = await new MigrationGenerator(db, rawModels).generate();
-    writeToFile(`migrations/${getMigrationDate()}_${name2}.ts`, migrations);
+    const models = await parseModels();
+    const migrations = await new MigrationGenerator(db, models).generate();
+    writeToFile(`migrations/${date || getMigrationDate()}_${name2}.ts`, migrations);
   } finally {
     await db.destroy();
   }