@smartive/graphql-magic 7.0.1 → 8.1.0

package/dist/bin/gqm.cjs

@@ -0,0 +1,1812 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/bin/gqm.ts
+var import_commander = require("commander");
+var import_dotenv = require("dotenv");
+var import_knex = __toESM(require("knex"), 1);
+var import_simple_git = require("simple-git");
+
+// src/api/execute.ts
+var import_schema = require("@graphql-tools/schema");
+var import_graphql = require("graphql");
+
+// 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) => {
+  const parts = [];
+  for (const { name: name2, creatable, updatable, deletable } of models.filter(isEntityModel)) {
+    if (creatable) {
+      parts.push(
+        `export const CREATE_${constantCase(
+          name2
+        )} = gql\`
+  mutation Create${name2}Mutation($data: Create${name2}!) {
+    create${name2}(data: $data) { id }
+  }
+\`;`
+      );
+    }
+    if (updatable) {
+      parts.push(
+        `export const UPDATE_${constantCase(
+          name2
+        )} = gql\`
+  mutation Update${name2}Mutation($id: ID!, $data: Update${name2}!) {
+    update${name2}(where: { id: $id }, data: $data) { id }
+  }
+\`;`
+      );
+    }
+    if (deletable) {
+      parts.push(
+        `export const DELETE_${constantCase(
+          name2
+        )} = gql\`
+  mutation Delete${name2}Mutation($id: ID!) {
+    delete${name2}(where: { id: $id })
+  }
+\`;`
+      );
+    }
+  }
+  return `import { gql } from "@smartive/graphql-magic";
+
+${parts.join("\n\n")}`;
+};
+
+// src/client/queries.ts
+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_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 ? [
+          {
+            name: "createdAt",
+            type: "DateTime",
+            nonNull: true,
+            orderable: true,
+            generated: true,
+            ...typeof model.creatable === "object" && model.creatable.createdAt
+          },
+          {
+            name: "createdBy",
+            kind: "relation",
+            type: "User",
+            nonNull: true,
+            reverse: `created${getModelPlural(model)}`,
+            generated: true,
+            ...typeof model.creatable === "object" && model.creatable.createdBy
+          }
+        ] : [],
+        ...model.updatable ? [
+          {
+            name: "updatedAt",
+            type: "DateTime",
+            nonNull: true,
+            orderable: true,
+            generated: true,
+            ...typeof model.updatable === "object" && model.updatable.updatedAt
+          },
+          {
+            name: "updatedBy",
+            kind: "relation",
+            type: "User",
+            nonNull: true,
+            reverse: `updated${getModelPlural(model)}`,
+            generated: true,
+            ...typeof model.updatable === "object" && model.updatable.updatedBy
+          }
+        ] : [],
+        ...model.deletable ? [
+          {
+            name: "deleted",
+            type: "Boolean",
+            nonNull: true,
+            defaultValue: false,
+            filterable: { default: false },
+            generated: true,
+            ...typeof model.deletable === "object" && model.deletable.deleted
+          },
+          {
+            name: "deletedAt",
+            type: "DateTime",
+            orderable: true,
+            generated: true,
+            ...typeof model.deletable === "object" && model.deletable.deletedAt
+          },
+          {
+            name: "deletedBy",
+            kind: "relation",
+            type: "User",
+            reverse: `deleted${getModelPlural(model)}`,
+            generated: true,
+            ...typeof model.deletable === "object" && model.deletable.deletedBy
+          }
+        ] : []
+      ].map((field) => ({
+        ...field,
+        ...field.kind === "relation" && {
+          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;
+      }
+      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;
+    }
+  }
+  return models;
+};
+var summonByName = (array, value2) => summonByKey(array, "name", value2);
+var summonByKey = (array, key, value2) => summon(array, (element) => (0, import_get.default)(element, key) === value2, `No element found with ${key} ${value2}`);
+var summon = (array, cb, errorMessage) => {
+  if (array === void 0) {
+    console.trace();
+    throw new Error("Base array is not defined.");
+  }
+  const result = array.find(cb);
+  if (result === void 0) {
+    console.trace();
+    throw new Error(errorMessage || "Element not found.");
+  }
+  return result;
+};
+var it = (object2) => {
+  if (object2 === void 0 || object2 === null) {
+    console.trace();
+    throw new Error("Base object is not defined.");
+  }
+  return object2;
+};
+var get = (object2, key) => {
+  const value2 = it(object2)[key];
+  if (value2 === void 0 || value2 === null) {
+    console.trace();
+    throw new Error(`Object doesn't have ${String(key)}`);
+  }
+  return value2;
+};
+
+// src/db/generate.ts
+var import_code_block_writer = __toESM(require("code-block-writer"), 1);
+var PRIMITIVE_TYPES = {
+  ID: "string",
+  Boolean: "boolean",
+  Upload: "string",
+  Int: "number",
+  Float: "number",
+  String: "string",
+  DateTime: "DateTime | string"
+};
+var OPTIONAL_SEED_FIELDS = ["createdAt", "createdById", "updatedAt", "updatedById", "deletedAt", "deletedById"];
+var generateDBModels = (rawModels) => {
+  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)) {
+    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;
+    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();
+      }
+    }).blankLine();
+    writer.write(`export type ${model.name}Initializer = `).inlineBlock(() => {
+      for (const field of fields2.filter(not(isCustomField))) {
+        writer.write(
+          `'${getFieldName(field)}'${field.nonNull && field.defaultValue === void 0 ? "" : "?"}: ${getFieldType(
+            field
+          )}${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);
+        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"},`
+        ).newLine();
+      }
+    }).blankLine();
+  }
+  writer.write(`export type SeedData = `).inlineBlock(() => {
+    for (const model of models) {
+      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) {
+    case "json":
+      return "string";
+    case "relation":
+      return "string";
+    case "enum":
+      return field.type + (field.list ? "[]" : "");
+    case "custom":
+      throw new Error(`Custom fields are not in the db.`);
+    case "primitive":
+    case void 0:
+      return get(PRIMITIVE_TYPES, field.type) + (field.list ? "[]" : "");
+    default: {
+      const exhaustiveCheck = kind;
+      throw new Error(exhaustiveCheck);
+    }
+  }
+};
+var generateKnexTables = (rawModels) => {
+  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 '.';`
+  ).blankLine();
+  writer.write(`declare module 'knex/types/tables' `).inlineBlock(() => {
+    writer.write(`interface Tables `).inlineBlock(() => {
+      for (const model of models) {
+        writer.write(`'${model.name}': Knex.CompositeTableType<${model.name}, ${model.name}Initializer, ${model.name}Mutator>,`).newLine();
+      }
+    });
+  });
+  return writer.toString();
+};
+
+// src/gqm/codegen.ts
+var import_cli = require("@graphql-codegen/cli");
+
+// src/gqm/settings.ts
+var import_fs = require("fs");
+var import_path = require("path");
+
+// src/gqm/readline.ts
+var import_readline = __toESM(require("readline"), 1);
+var readLine = (prompt) => {
+  const rl = import_readline.default.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve2) => {
+    rl.question(prompt, (answer) => {
+      rl.close();
+      resolve2(answer);
+    });
+  });
+};
+
+// src/gqm/templates.ts
+var EMPTY_MODELS = `
+import { RawModels, getModels } from '@smartive/graphql-magic';
+
+export const rawModels: RawModels = [
+  {
+    kind: 'entity',
+    name: 'User',
+    fields: []
+  },
+]
+
+export const models = getModels(rawModels);
+`;
+var GRAPHQL_CODEGEN = (path) => `
+overwrite: true
+schema: '${path}/schema.graphql'
+documents: null
+generates:
+  ${path}/api/index.ts:
+    plugins:
+      - 'typescript'
+      - 'typescript-resolvers'
+      - add:
+          content: "import { DateTime } from 'luxon'"
+config:
+  scalars:
+    DateTime: DateTime
+`;
+var CLIENT_CODEGEN = (path) => `
+schema: ${path}/schema.graphql
+documents: [ './src/**/*.ts', './src/**/*.tsx' ]
+generates:
+  ${path}/client/index.ts:
+    plugins:
+      - typescript
+      - typescript-operations
+      - typescript-compatibility
+
+config:
+  preResolveTypes: true # Simplifies the generated types
+  namingConvention: keep # Keeps naming as-is
+  nonOptionalTypename: true # Forces \`__typename\` on all selection sets
+  skipTypeNameForRoot: true # Don't generate __typename for root types
+  avoidOptionals: # Avoids optionals on the level of the field
+    field: true
+  scalars:
+    DateTime: string
+`;
+var KNEXFILE = `
+const config = {
+  client: 'postgresql',
+  connection: {
+    host: process.env.DATABASE_HOST,
+    database: process.env.DATABASE_NAME,
+    user: process.env.DATABASE_USER,
+    password: process.env.DATABASE_PASSWORD,
+  },
+} as const;
+
+export default config;
+`;
+
+// src/gqm/settings.ts
+var SETTINGS_PATH = ".gqmrc.json";
+var DEFAULTS = {
+  modelsPath: {
+    question: "What is the models path?",
+    defaultValue: "src/config/models.ts",
+    init: (path) => {
+      ensureFileExists(path, EMPTY_MODELS);
+    }
+  },
+  generatedFolderPath: {
+    question: "What is the path for generated stuff?",
+    defaultValue: "src/generated",
+    init: (path) => {
+      ensureFileExists(`${path}/.gitkeep`, "");
+      ensureFileExists(`${path}/db/.gitkeep`, "");
+      ensureFileExists(`${path}/api/.gitkeep`, "");
+      ensureFileExists(`${path}/client/.gitkeep`, "");
+      ensureFileExists(`graphql-codegen.yml`, GRAPHQL_CODEGEN(path));
+      ensureFileExists(`client-codegen.yml`, CLIENT_CODEGEN(path));
+    }
+  }
+};
+var initSetting = async (name2) => {
+  const { question, defaultValue, init } = DEFAULTS[name2];
+  const value2 = await readLine(`${question} (${defaultValue})`) || defaultValue;
+  init(value2);
+  return value2;
+};
+var initSettings = async () => {
+  const settings = {};
+  for (const name2 of Object.keys(DEFAULTS)) {
+    settings[name2] = await initSetting(name2);
+  }
+  saveSettings(settings);
+};
+var saveSettings = (settings) => {
+  writeToFile(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+};
+var getSettings = async () => {
+  if (!(0, import_fs.existsSync)(SETTINGS_PATH)) {
+    await initSettings();
+  }
+  return JSON.parse((0, import_fs.readFileSync)(SETTINGS_PATH, "utf8"));
+};
+var getSetting = async (name2) => {
+  const settings = await getSettings();
+  if (!(name2 in settings)) {
+    settings[name2] = await initSetting(name2);
+    saveSettings(settings);
+  }
+  return settings[name2];
+};
+var ensureDirectoryExists = (filePath) => {
+  const dir = (0, import_path.dirname)(filePath);
+  if ((0, import_fs.existsSync)(dir)) {
+    return true;
+  }
+  ensureDirectoryExists(dir);
+  try {
+    (0, import_fs.mkdirSync)(dir);
+    return true;
+  } catch (err) {
+    if (err.code === "EEXIST") {
+      return true;
+    }
+    throw err;
+  }
+};
+var ensureFileExists = (filePath, content) => {
+  if (!(0, import_fs.existsSync)(filePath)) {
+    console.info(`Creating ${filePath}`);
+    ensureDirectoryExists(filePath);
+    (0, import_fs.writeFileSync)(filePath, content);
+  }
+};
+var writeToFile = (filePath, content) => {
+  ensureDirectoryExists(filePath);
+  if ((0, import_fs.existsSync)(filePath)) {
+    const currentContent = (0, import_fs.readFileSync)(filePath, "utf-8");
+    if (content === currentContent) {
+    } else {
+      (0, import_fs.writeFileSync)(filePath, content);
+      console.info(`${filePath} updated`);
+    }
+  } else {
+    (0, import_fs.writeFileSync)(filePath, content);
+    console.info(`Created ${filePath}`);
+  }
+};
+
+// src/gqm/codegen.ts
+var generateGraphqlApiTypes = async () => {
+  const generatedFolderPath = await getSetting("generatedFolderPath");
+  await (0, import_cli.generate)({
+    overwrite: true,
+    schema: `${generatedFolderPath}/schema.graphql`,
+    documents: null,
+    generates: {
+      [`${generatedFolderPath}/api/index.ts`]: {
+        plugins: ["typescript", "typescript-resolvers", { add: { content: `import { DateTime } from 'luxon';` } }]
+      }
+    },
+    config: {
+      scalars: {
+        DateTime: "DateTime"
+      }
+    }
+  });
+};
+var generateGraphqlClientTypes = async () => {
+  const generatedFolderPath = await getSetting("generatedFolderPath");
+  await (0, import_cli.generate)({
+    schema: `${generatedFolderPath}/schema.graphql`,
+    documents: ["./src/**/*.ts", "./src/**/*.tsx"],
+    generates: {
+      [`${generatedFolderPath}/client/index.ts`]: {
+        plugins: ["typescript", "typescript-operations", "typescript-compatibility"]
+      }
+    },
+    config: {
+      preResolveTypes: true,
+      // Simplifies the generated types
+      namingConvention: "keep",
+      // Keeps naming as-is
+      nonOptionalTypename: true,
+      // Forces `__typename` on all selection sets
+      skipTypeNameForRoot: true,
+      // Don't generate __typename for root types
+      avoidOptionals: {
+        // Avoids optionals on the level of the field
+        field: true
+      },
+      scalars: {
+        DateTime: "string"
+      }
+    }
+  });
+};
+
+// src/gqm/parse-knexfile.ts
+var import_ts_morph4 = require("ts-morph");
+
+// src/gqm/static-eval.ts
+var import_ts_morph2 = require("ts-morph");
+
+// src/gqm/visitor.ts
+var import_ts_morph = require("ts-morph");
+var visit = (node, context, visitor2) => {
+  const kind = node?.getKind();
+  if (kind in visitor2) {
+    return visitor2[kind](node.asKindOrThrow(kind), context);
+  }
+  if ("unknown" in visitor2) {
+    return visitor2.unknown(node);
+  }
+  console.error(node.getText());
+  console.error(node.getParent().getText());
+  throw new Error(
+    `Cannot handle kind ${get(
+      Object.entries(import_ts_morph.SyntaxKind).find(([, val]) => val === kind),
+      0
+    )}`
+  );
+};
+
+// src/gqm/static-eval.ts
+var staticEval = (node, context) => visit(node, context, visitor);
+var visitor = {
+  undefined: () => void 0,
+  [import_ts_morph2.SyntaxKind.VariableDeclaration]: (node, context) => staticEval(node.getInitializer(), context),
+  [import_ts_morph2.SyntaxKind.ArrayLiteralExpression]: (node, context) => {
+    const values = [];
+    for (const value2 of node.getElements()) {
+      if (value2.isKind(import_ts_morph2.SyntaxKind.SpreadElement)) {
+        values.push(...staticEval(value2, context));
+      } else {
+        values.push(staticEval(value2, context));
+      }
+    }
+    return values;
+  },
+  [import_ts_morph2.SyntaxKind.ObjectLiteralExpression]: (node, context) => {
+    const result = {};
+    for (const property of node.getProperties()) {
+      Object.assign(result, staticEval(property, context));
+    }
+    return result;
+  },
+  [import_ts_morph2.SyntaxKind.StringLiteral]: (node) => node.getLiteralValue(),
+  [import_ts_morph2.SyntaxKind.PropertyAssignment]: (node, context) => ({
+    [node.getName()]: staticEval(node.getInitializer(), context)
+  }),
+  [import_ts_morph2.SyntaxKind.ShorthandPropertyAssignment]: (node, context) => ({
+    [node.getName()]: staticEval(node.getNameNode(), context)
+  }),
+  [import_ts_morph2.SyntaxKind.SpreadElement]: (node, context) => staticEval(node.getExpression(), context),
+  [import_ts_morph2.SyntaxKind.SpreadAssignment]: (node, context) => staticEval(node.getExpression(), context),
+  [import_ts_morph2.SyntaxKind.Identifier]: (node, context) => {
+    switch (node.getText()) {
+      case "undefined":
+        return void 0;
+      case "process":
+        return process;
+    }
+    const definitionNodes = node.getDefinitionNodes();
+    if (!definitionNodes.length) {
+      throw new Error(`No definition node found for identifier ${node.getText()}.`);
+    }
+    return staticEval(definitionNodes[0], context);
+  },
+  [import_ts_morph2.SyntaxKind.ParenthesizedExpression]: (node, context) => staticEval(node.getExpression(), context),
+  [import_ts_morph2.SyntaxKind.AsExpression]: (node, context) => staticEval(node.getExpression(), context),
+  [import_ts_morph2.SyntaxKind.ConditionalExpression]: (node, context) => staticEval(node.getCondition(), context) ? staticEval(node.getWhenTrue(), context) : staticEval(node.getWhenFalse(), context),
+  [import_ts_morph2.SyntaxKind.TrueKeyword]: () => true,
+  [import_ts_morph2.SyntaxKind.FalseKeyword]: () => false,
+  [import_ts_morph2.SyntaxKind.NumericLiteral]: (node) => node.getLiteralValue(),
+  [import_ts_morph2.SyntaxKind.CallExpression]: (node, context) => {
+    const method = staticEval(node.getExpression(), context);
+    const args2 = node.getArguments().map((arg) => staticEval(arg, context));
+    return method(...args2);
+  },
+  [import_ts_morph2.SyntaxKind.PropertyAccessExpression]: (node, context) => {
+    const target = staticEval(node.getExpression(), context);
+    const property = target[node.getName()];
+    if (typeof property === "function") {
+      if (Array.isArray(target)) {
+        switch (node.getName()) {
+          case "map":
+          case "flatMap":
+          case "includes":
+          case "some":
+          case "find":
+          case "filter":
+            return target[node.getName()].bind(target);
+        }
+      } else if (typeof target === "string") {
+        const name2 = node.getName();
+        switch (name2) {
+          case "slice":
+          case "toUpperCase":
+          case "toLowerCase":
+            return target[name2].bind(target);
+        }
+      }
+      throw new Error(`Cannot handle method ${node.getName()} on type ${typeof target}`);
+    }
+    return property;
+  },
+  [import_ts_morph2.SyntaxKind.ArrowFunction]: (node, context) => {
+    return (...args2) => {
+      const parameters = {};
+      let i = 0;
+      for (const parameter of node.getParameters()) {
+        parameters[parameter.getName()] = args2[i];
+        i++;
+      }
+      return staticEval(node.getBody(), { ...context, ...parameters });
+    };
+  },
+  [import_ts_morph2.SyntaxKind.Block]: (node, context) => {
+    for (const statement of node.getStatements()) {
+      return staticEval(statement, context);
+    }
+  },
+  [import_ts_morph2.SyntaxKind.CaseClause]: (node, context) => {
+    const statements = node.getStatements();
+    if (statements.length !== 1) {
+      console.error(node.getText());
+      throw new Error(`Can only handle code blocks with 1 statement.`);
+    }
+    return staticEval(statements[0], context);
+  },
+  [import_ts_morph2.SyntaxKind.DefaultClause]: (node, context) => {
+    const statements = node.getStatements();
+    if (statements.length !== 1) {
+      console.error(node.getText());
+      throw new Error(`Can only handle code blocks with exactly 1 statement.`);
+    }
+    return staticEval(statements[0], context);
+  },
+  [import_ts_morph2.SyntaxKind.ReturnStatement]: (node, context) => {
+    return staticEval(node.getExpression(), context);
+  },
+  [import_ts_morph2.SyntaxKind.SwitchStatement]: (node, context) => {
+    const value2 = staticEval(node.getExpression(), context);
+    let active = false;
+    for (const clause of node.getCaseBlock().getClauses()) {
+      switch (clause.getKind()) {
+        case import_ts_morph2.SyntaxKind.DefaultClause:
+          return staticEval(clause, context);
+        case import_ts_morph2.SyntaxKind.CaseClause: {
+          const caseClause = clause.asKindOrThrow(import_ts_morph2.SyntaxKind.CaseClause);
+          if (caseClause.getStatements().length && active) {
+            return staticEval(clause, context);
+          }
+          const caseValue = staticEval(caseClause.getExpression(), context);
+          if (value2 === caseValue) {
+            active = true;
+            if (caseClause.getStatements().length) {
+              return staticEval(clause, context);
+            }
+          }
+        }
+      }
+    }
+  },
+  [import_ts_morph2.SyntaxKind.Parameter]: (node, context) => context[node.getName()],
+  [import_ts_morph2.SyntaxKind.BinaryExpression]: (node, context) => {
+    switch (node.getOperatorToken().getKind()) {
+      case import_ts_morph2.SyntaxKind.EqualsEqualsEqualsToken:
+        return staticEval(node.getLeft(), context) === staticEval(node.getRight(), context);
+      case import_ts_morph2.SyntaxKind.BarBarToken:
+        return staticEval(node.getLeft(), context) || staticEval(node.getRight(), context);
+      default:
+        throw new Error(`Cannot handle operator of kind ${node.getOperatorToken().getKindName()}`);
+    }
+  },
+  [import_ts_morph2.SyntaxKind.SatisfiesExpression]: (node, context) => staticEval(node.getExpression(), context),
+  [import_ts_morph2.SyntaxKind.TemplateExpression]: (node, context) => node.getHead().getLiteralText() + node.getTemplateSpans().map((span) => staticEval(span.getExpression(), context) + staticEval(span.getLiteral(), context)).join(""),
+  [import_ts_morph2.SyntaxKind.TemplateTail]: (node) => node.getLiteralText(),
+  [import_ts_morph2.SyntaxKind.TemplateMiddle]: (node) => node.getLiteralText(),
+  [import_ts_morph2.SyntaxKind.PrefixUnaryExpression]: (node, context) => {
+    switch (node.getOperatorToken()) {
+      case import_ts_morph2.SyntaxKind.PlusToken:
+        return +staticEval(node.getOperand(), context);
+      case import_ts_morph2.SyntaxKind.MinusToken:
+        return -staticEval(node.getOperand(), context);
+      case import_ts_morph2.SyntaxKind.TildeToken:
+        return ~staticEval(node.getOperand(), context);
+      case import_ts_morph2.SyntaxKind.ExclamationToken:
+        return !staticEval(node.getOperand(), context);
+      case import_ts_morph2.SyntaxKind.PlusPlusToken:
+      case import_ts_morph2.SyntaxKind.MinusMinusToken:
+        throw new Error(`Cannot handle assignments.`);
+    }
+  },
+  [import_ts_morph2.SyntaxKind.ElementAccessExpression]: (node, context) => {
+    const target = staticEval(node.getExpression(), context);
+    const argument = staticEval(node.getArgumentExpression(), context);
+    return target[argument];
+  },
+  [import_ts_morph2.SyntaxKind.NoSubstitutionTemplateLiteral]: (node) => node.getLiteralValue()
+};
+
+// src/gqm/utils.ts
+var import_ts_morph3 = require("ts-morph");
+var findDeclarationInFile = (sourceFile, name2) => {
+  const syntaxList = sourceFile.getChildrenOfKind(import_ts_morph3.SyntaxKind.SyntaxList)[0];
+  if (!syntaxList) {
+    throw new Error("No SyntaxList");
+  }
+  const declaration = findDeclaration(syntaxList, name2);
+  if (!declaration) {
+    throw new Error(`No ${name2} declaration`);
+  }
+  return declaration;
+};
+var findDeclaration = (syntaxList, name2) => {
+  for (const variableStatement of syntaxList.getChildrenOfKind(import_ts_morph3.SyntaxKind.VariableStatement)) {
+    for (const declaration of variableStatement.getDeclarationList().getDeclarations()) {
+      if (declaration.getName() === name2) {
+        return declaration;
+      }
+    }
+  }
+};
+
+// src/gqm/parse-knexfile.ts
+var KNEXFILE_PATH = `knexfile.ts`;
+var parseKnexfile = async () => {
+  const project = new import_ts_morph4.Project({
+    manipulationSettings: {
+      indentationText: import_ts_morph4.IndentationText.TwoSpaces
+    }
+  });
+  ensureFileExists(KNEXFILE_PATH, KNEXFILE);
+  const sourceFile = project.addSourceFileAtPath(KNEXFILE_PATH);
+  const configDeclaration = findDeclarationInFile(sourceFile, "config");
+  const config2 = staticEval(configDeclaration, {});
+  return config2;
+};
+
+// src/gqm/parse-models.ts
+var import_ts_morph5 = require("ts-morph");
+var parseModels = async () => {
+  const project = new import_ts_morph5.Project({
+    manipulationSettings: {
+      indentationText: import_ts_morph5.IndentationText.TwoSpaces
+    }
+  });
+  const modelsPath = await getSetting("modelsPath");
+  const sourceFile = project.addSourceFileAtPath(modelsPath);
+  const modelsDeclaration = findDeclarationInFile(sourceFile, "rawModels");
+  const rawModels = staticEval(modelsDeclaration, {});
+  const generatedFolderPath = await getSetting("generatedFolderPath");
+  writeToFile(`${generatedFolderPath}/models.json`, JSON.stringify(rawModels, null, 2));
+  return rawModels;
+};
+
+// src/migrations/generate.ts
+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;
+    this.schema = (0, import_knex_schema_inspector.SchemaInspector)(knex2);
+    this.models = getModels(rawModels);
+  }
+  writer = new import_code_block_writer2.default["default"]({
+    useSingleQuote: true,
+    indentNumberOfSpaces: 2
+  });
+  schema;
+  columns = {};
+  uuidUsed;
+  nowUsed;
+  models;
+  async generate() {
+    const { writer, schema, rawModels, models } = this;
+    const enums = (await schema.knex("pg_type").where({ typtype: "e" }).select("typname")).map(({ typname }) => typname);
+    const tables = await schema.tables();
+    for (const table of tables) {
+      this.columns[table] = await schema.columnInfo(table);
+    }
+    const up = [];
+    const down = [];
+    this.createEnums(
+      rawModels.filter(isEnumModel).filter((enm2) => !enums.includes((0, import_lowerFirst.default)(enm2.name))),
+      up,
+      down
+    );
+    for (const model of models) {
+      if (model.deleted) {
+        up.push(() => {
+          this.dropTable(model.name);
+        });
+        down.push(() => {
+          this.createTable(model.name, () => {
+            for (const field of model.fields) {
+              this.column(field);
+            }
+          });
+        });
+        if (model.updatable) {
+          up.push(() => {
+            this.dropTable(`${model.name}Revision`);
+          });
+          down.push(() => {
+            this.createRevisionTable(model);
+          });
+        }
+      }
+      if (model.oldName) {
+        up.push(() => {
+          this.renameTable(model.oldName, model.name);
+        });
+        down.push(() => {
+          this.renameTable(model.name, model.oldName);
+        });
+        tables[tables.indexOf(model.oldName)] = model.name;
+        this.columns[model.name] = this.columns[model.oldName];
+        delete this.columns[model.oldName];
+        if (model.updatable) {
+          up.push(() => {
+            this.renameTable(`${model.oldName}Revision`, `${model.name}Revision`);
+            this.alterTable(`${model.name}Revision`, () => {
+              this.renameColumn(`${typeToField(get(model, "oldName"))}Id`, `${typeToField(model.name)}Id`);
+            });
+          });
+          down.push(() => {
+            this.renameTable(`${model.name}Revision`, `${model.oldName}Revision`);
+            this.alterTable(`${model.oldName}Revision`, () => {
+              this.renameColumn(`${typeToField(model.name)}Id`, `${typeToField(get(model, "oldName"))}Id`);
+            });
+          });
+          tables[tables.indexOf(`${model.oldName}Revision`)] = `${model.name}Revision`;
+          this.columns[`${model.name}Revision`] = this.columns[`${model.oldName}Revision`];
+          delete this.columns[`${model.oldName}Revision`];
+        }
+      }
+      if (!tables.includes(model.name)) {
+        up.push(() => {
+          this.createTable(model.name, () => {
+            for (const field of model.fields) {
+              this.column(field);
+            }
+          });
+        });
+        down.push(() => {
+          this.dropTable(model.name);
+        });
+      } else {
+        this.renameFields(
+          model,
+          model.fields.filter(({ oldName }) => oldName),
+          up,
+          down
+        );
+        this.createFields(
+          model,
+          model.fields.filter(
+            ({ name: name2, ...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`)) {
+          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();
+                });
+              }).blankLine();
+            });
+          }
+          down.push(() => {
+            this.dropTable(`${model.name}Revision`);
+          });
+        } 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.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)) {
+      if (tables.includes(model.name)) {
+        this.createFields(
+          model,
+          model.fields.filter(({ name: name2, deleted }) => deleted && this.columns[model.name].some((col) => col.name === name2)),
+          down,
+          up
+        );
+        if (model.updatable) {
+          this.createRevisionFields(
+            model,
+            model.fields.filter(({ deleted, updatable }) => updatable && deleted),
+            down,
+            up
+          );
+        }
+      }
+    }
+    this.createEnums(
+      rawModels.filter(isEnumModel).filter((enm2) => enm2.deleted),
+      down,
+      up
+    );
+    writer.writeLine(`import { Knex } from 'knex';`);
+    if (this.uuidUsed) {
+      writer.writeLine(`import { v4 as uuid } from 'uuid';`);
+    }
+    if (this.nowUsed) {
+      writer.writeLine(`import { date } from '../src/utils/dates';`);
+    }
+    writer.blankLine();
+    if (this.nowUsed) {
+      writer.writeLine(`const now = date();`).blankLine();
+    }
+    this.migration("up", up);
+    this.migration("down", down.reverse());
+    return writer.toString();
+  }
+  renameFields(model, fields2, up, down) {
+    if (!fields2.length) {
+      return;
+    }
+    up.push(() => {
+      for (const field of fields2) {
+        this.alterTable(model.name, () => {
+          this.renameColumn(
+            field.kind === "relation" ? `${field.oldName}Id` : get(field, "oldName"),
+            field.kind === "relation" ? `${field.name}Id` : field.name
+          );
+        });
+      }
+    });
+    down.push(() => {
+      for (const field of fields2) {
+        this.alterTable(model.name, () => {
+          this.renameColumn(
+            field.kind === "relation" ? `${field.name}Id` : field.name,
+            field.kind === "relation" ? `${field.oldName}Id` : get(field, "oldName")
+          );
+        });
+      }
+    });
+    for (const field of fields2) {
+      summonByName(this.columns[model.name], field.kind === "relation" ? `${field.oldName}Id` : field.oldName).name = field.kind === "relation" ? `${field.name}Id` : field.name;
+    }
+  }
+  createFields(model, fields2, up, down) {
+    if (!fields2.length) {
+      return;
+    }
+    up.push(() => {
+      const alter = [];
+      const updates = [];
+      const postAlter = [];
+      for (const field of fields2) {
+        alter.push(() => this.column(field, { setNonNull: field.defaultValue !== void 0 }));
+        if (field.nonNull && field.defaultValue === void 0) {
+          updates.push(() => this.writer.write(`${field.name}: 'TODO',`).newLine());
+          postAlter.push(() => this.column(field, { alter: true, foreign: false }));
+        }
+      }
+      if (alter.length) {
+        this.alterTable(model.name, () => {
+          alter.map((cb) => cb());
+        });
+      }
+      if (updates.length) {
+        this.writer.write(`await knex('${model.name}').update(`).inlineBlock(() => {
+          updates.map((cb) => cb());
+        }).write(");").newLine().blankLine();
+      }
+      if (postAlter.length) {
+        this.alterTable(model.name, () => {
+          postAlter.map((cb) => cb());
+        });
+      }
+    });
+    down.push(() => {
+      this.alterTable(model.name, () => {
+        for (const { kind, name: name2 } of fields2) {
+          this.dropColumn(kind === "relation" ? `${name2}Id` : name2);
+        }
+      });
+    });
+  }
+  updateFields(model, fields2, up, down) {
+    if (!fields2.length) {
+      return;
+    }
+    up.push(() => {
+      this.alterTable(model.name, () => {
+        for (const field of fields2) {
+          this.column(field, { alter: true });
+        }
+      });
+    });
+    down.push(() => {
+      this.alterTable(model.name, () => {
+        for (const field of fields2) {
+          this.column(
+            field,
+            { alter: true },
+            summonByName(this.columns[model.name], field.kind === "relation" ? `${field.name}Id` : field.name)
+          );
+        }
+      });
+    });
+    if (model.updatable) {
+      const updatableFields = fields2.filter(({ updatable }) => updatable);
+      if (!updatableFields.length) {
+        return;
+      }
+      up.push(() => {
+        this.alterTable(`${model.name}Revision`, () => {
+          for (const field of updatableFields) {
+            this.column(field, { alter: true });
+          }
+        });
+      });
+      down.push(() => {
+        this.alterTable(`${model.name}Revision`, () => {
+          for (const field of updatableFields) {
+            this.column(
+              field,
+              { alter: true },
+              summonByName(this.columns[model.name], field.kind === "relation" ? `${field.name}Id` : field.name)
+            );
+          }
+        });
+      });
+    }
+  }
+  createRevisionTable(model) {
+    const writer = this.writer;
+    this.createTable(`${model.name}Revision`, () => {
+      writer.writeLine(`table.uuid('id').notNullable().primary();`);
+      writer.writeLine(`table.uuid('${typeToField(model.name)}Id').notNullable();`);
+      writer.write(`table.uuid('createdById')`);
+      writer.write(".notNullable()");
+      writer.write(";").newLine();
+      writer.writeLine(`table.timestamp('createdAt').notNullable().defaultTo(knex.fn.now(0));`);
+      if (model.deletable) {
+        writer.writeLine(`table.boolean('deleted').notNullable();`);
+      }
+      for (const field of model.fields.filter((field2) => field2.updatable)) {
+        this.column(field, { setUnique: false, setDefault: false });
+      }
+    });
+  }
+  createRevisionFields(model, missingRevisionFields, up, down) {
+    const revisionTable = `${model.name}Revision`;
+    if (missingRevisionFields.length) {
+      up.push(() => {
+        this.alterTable(revisionTable, () => {
+          for (const field of missingRevisionFields) {
+            this.column(field, { setUnique: false, setNonNull: false, setDefault: false });
+          }
+        });
+        this.writer.write(`await knex('${model.name}Revision').update(`).inlineBlock(() => {
+          for (const { name: name2, kind: type } of missingRevisionFields) {
+            const col = type === "relation" ? `${name2}Id` : name2;
+            this.writer.write(
+              `${col}: knex.raw('(select "${col}" from "${model.name}" where "${model.name}".id = "${model.name}Revision"."${typeToField(model.name)}Id")'),`
+            ).newLine();
+          }
+        }).write(");").newLine().blankLine();
+        const nonNullableMissingRevisionFields = missingRevisionFields.filter(({ nonNull: nonNull2 }) => nonNull2);
+        if (nonNullableMissingRevisionFields.length) {
+          this.alterTable(revisionTable, () => {
+            for (const field of nonNullableMissingRevisionFields) {
+              this.column(field, { setUnique: false, setDefault: false, alter: true });
+            }
+          });
+        }
+      });
+      down.push(() => {
+        this.alterTable(revisionTable, () => {
+          for (const field of missingRevisionFields) {
+            this.dropColumn(field.kind === "relation" ? `${field.name}Id` : field.name);
+          }
+        });
+      });
+    }
+  }
+  createEnums(enums, up, down) {
+    for (const enm2 of enums) {
+      const name2 = (0, import_lowerFirst.default)(enm2.name);
+      up.push(
+        () => this.writer.writeLine(
+          `await knex.raw(\`CREATE TYPE "${name2}" AS ENUM (${enm2.values.map((value2) => `'${value2}'`).join(",")})\`);`
+        ).newLine()
+      );
+      down.push(() => this.writer.writeLine(`await knex.raw('DROP TYPE "${name2}"')`));
+    }
+  }
+  migration(name2, cbs) {
+    return this.writer.write(`export const ${name2} = async (knex: Knex) => `).inlineBlock(() => {
+      cbs.map((cb) => cb());
+    }).write(";").newLine().blankLine();
+  }
+  createTable(table, block) {
+    return this.writer.write(`await knex.schema.createTable('${table}', (table) => `).inlineBlock(block).write(");").newLine().blankLine();
+  }
+  alterTable(table, block) {
+    return this.writer.write(`await knex.schema.alterTable('${table}', (table) => `).inlineBlock(block).write(");").newLine().blankLine();
+  }
+  dropColumn(col) {
+    return this.writer.writeLine(`table.dropColumn('${col}');`);
+  }
+  dropTable(table) {
+    return this.writer.writeLine(`await knex.schema.dropTable('${table}');`).blankLine();
+  }
+  renameTable(from, to) {
+    return this.writer.writeLine(`await knex.schema.renameTable('${from}', '${to}');`).blankLine();
+  }
+  renameColumn(from, to) {
+    this.writer.writeLine(`table.renameColumn('${from}', '${to}')`);
+  }
+  value(value2) {
+    if (typeof value2 === "string") {
+      return `'${value2}'`;
+    }
+    return value2;
+  }
+  column({ name: name2, primary, list: list2, ...field }, { setUnique = true, setNonNull = true, alter = false, foreign = true, setDefault = true } = {}, toColumn) {
+    const col = (what) => {
+      if (what) {
+        this.writer.write(what);
+      }
+      if (setNonNull) {
+        if (toColumn) {
+          if (toColumn.is_nullable) {
+            this.writer.write(`.nullable()`);
+          } else {
+            this.writer.write(".notNullable()");
+          }
+        } else {
+          if (field.nonNull) {
+            this.writer.write(`.notNullable()`);
+          } else {
+            this.writer.write(".nullable()");
+          }
+        }
+      }
+      if (setDefault && field.defaultValue !== void 0) {
+        this.writer.write(`.defaultTo(${this.value(field.defaultValue)})`);
+      }
+      if (primary) {
+        this.writer.write(".primary()");
+      } else if (setUnique && field.unique) {
+        this.writer.write(".unique()");
+      }
+      if (alter) {
+        this.writer.write(".alter()");
+      }
+      this.writer.write(";").newLine();
+    };
+    const kind = field.kind;
+    switch (kind) {
+      case void 0:
+      case "primitive":
+        switch (field.type) {
+          case "Boolean":
+            col(`table.boolean('${name2}')`);
+            break;
+          case "Int":
+            col(`table.integer('${name2}')`);
+            break;
+          case "Float":
+            if (field.double) {
+              col(`table.double('${name2}')`);
+            } else {
+              col(`table.decimal('${name2}', ${get(field, "precision")}, ${get(field, "scale")})`);
+            }
+            break;
+          case "String":
+            if (field.large) {
+              col(`table.text('${name2}')`);
+            } else {
+              col(`table.string('${name2}', ${field.maxLength})`);
+            }
+            break;
+          case "DateTime":
+            col(`table.timestamp('${name2}')`);
+            break;
+          case "ID":
+            col(`table.uuid('${name2}')`);
+            break;
+          case "Upload":
+            break;
+        }
+        break;
+      case "relation":
+        col(`table.uuid('${name2}Id')`);
+        if (foreign && !alter) {
+          this.writer.writeLine(`table.foreign('${name2}Id').references('id').inTable('${field.type}');`);
+        }
+        break;
+      case "enum":
+        if (list2) {
+          this.writer.write(`table.specificType('${name2}', '"${typeToField(field.type)}"[]');`);
+        } else {
+          this.writer.write(`table.enum('${name2}', null as any, `).inlineBlock(() => {
+            this.writer.writeLine(`useNative: true,`);
+            this.writer.writeLine(`existingType: true,`);
+            this.writer.writeLine(`enumName: '${typeToField(field.type)}',`);
+          }).write(")");
+        }
+        col();
+        break;
+      case "json":
+        this.writer.write(`table.json('${typeToField(field.type)}')`);
+        break;
+      case "custom":
+        throw new Error("Custom fields aren't stored in the database");
+      default: {
+        const exhaustiveCheck = kind;
+        throw new Error(exhaustiveCheck);
+      }
+    }
+  }
+};
+var getMigrationDate = () => {
+  const date = /* @__PURE__ */ new Date();
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  const hours = String(date.getHours()).padStart(2, "0");
+  const minutes = String(date.getMinutes()).padStart(2, "0");
+  const seconds = String(date.getSeconds()).padStart(2, "0");
+  return `${year}${month}${day}${hours}${minutes}${seconds}`;
+};
+
+// src/errors.ts
+var import_graphql2 = require("graphql");
+
+// src/resolvers/utils.ts
+var import_graphql3 = require("graphql");
+
+// src/resolvers/arguments.ts
+var import_graphql4 = require("graphql");
+
+// src/resolvers/mutations.ts
+var import_uuid = require("uuid");
+
+// src/resolvers/resolver.ts
+var import_cloneDeep = __toESM(require("lodash/cloneDeep"), 1);
+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");
+
+// src/values.ts
+var Enum = class {
+  constructor(value2) {
+    this.value = value2;
+  }
+};
+
+// src/schema/utils.ts
+var document = (definitions) => ({
+  kind: "Document",
+  definitions
+});
+var scalar = (nme) => ({
+  name: name(nme),
+  kind: "ScalarTypeDefinition"
+});
+var input = (nme, fields2, dvs) => ({
+  name: name(nme),
+  fields: inputValues(fields2),
+  kind: "InputObjectTypeDefinition",
+  directives: directives(dvs)
+});
+var object = (nme, fds, interfaces, dvs) => ({
+  name: name(nme),
+  fields: fields(fds),
+  kind: "ObjectTypeDefinition",
+  interfaces: interfaces && interfaces.map((i) => namedType(i)),
+  directives: directives(dvs)
+});
+var inputValues = (fields2) => fields2.map(
+  (field) => ({
+    kind: "InputValueDefinition",
+    name: name(field.name),
+    type: fieldType(field),
+    defaultValue: field.defaultValue === void 0 ? void 0 : value(field.defaultValue),
+    directives: directives(field.directives)
+  })
+);
+var fields = (fields2) => fields2.map(
+  (field) => ({
+    kind: "FieldDefinition",
+    name: name(field.name),
+    type: fieldType(field),
+    arguments: field.args?.map((arg) => ({
+      kind: "InputValueDefinition",
+      name: name(arg.name),
+      type: fieldType(arg),
+      defaultValue: arg.defaultValue === void 0 ? void 0 : value(arg.defaultValue)
+    })),
+    directives: directives(field.directives)
+  })
+);
+var directives = (directives2) => directives2?.map(
+  (directive) => ({
+    kind: "Directive",
+    name: name(directive.name),
+    arguments: args(directive.values)
+  })
+);
+var args = (ags) => ags?.map(
+  (argument) => ({
+    kind: "Argument",
+    name: name(argument.name),
+    value: value(argument.values)
+  })
+);
+var enm = (nme, values) => ({
+  name: name(nme),
+  kind: "EnumTypeDefinition",
+  values: values.map(
+    (v) => ({
+      kind: "EnumValueDefinition",
+      name: name(v)
+    })
+  )
+});
+var nonNull = (type) => ({
+  type,
+  kind: "NonNullType"
+});
+var namedType = (nme) => ({
+  kind: "NamedType",
+  name: name(nme)
+});
+var list = (type) => ({
+  type,
+  kind: "ListType"
+});
+var name = (name2) => ({
+  kind: "Name",
+  value: name2
+});
+var fieldType = (field) => {
+  let type = namedType(field.type);
+  if (field.list) {
+    type = list(nonNull(type));
+  }
+  if (field.nonNull) {
+    type = nonNull(type);
+  }
+  return type;
+};
+var value = (val = null) => val === null ? {
+  kind: "NullValue"
+} : typeof val === "boolean" ? {
+  kind: "BooleanValue",
+  value: val
+} : typeof val === "number" ? {
+  kind: "IntValue",
+  value: `${val}`
+} : typeof val === "string" ? {
+  kind: "StringValue",
+  value: val
+} : val instanceof Enum ? {
+  kind: "EnumValue",
+  value: val.value
+} : Array.isArray(val) ? {
+  kind: "ListValue",
+  values: val.map(value)
+} : val instanceof import_luxon.DateTime ? {
+  kind: "StringValue",
+  value: val.toString()
+} : {
+  kind: "ObjectValue",
+  fields: Object.keys(val).map(
+    (nme) => ({
+      kind: "ObjectField",
+      name: name(nme),
+      value: value(val[nme])
+    })
+  )
+};
+
+// src/schema/generate.ts
+var generateDefinitions = (rawModels) => {
+  const models = getModels(rawModels);
+  return [
+    // Predefined types
+    enm("Order", ["ASC", "DESC"]),
+    scalar("DateTime"),
+    scalar("Upload"),
+    ...rawModels.filter(isEnumModel).map((model) => enm(model.name, model.values)),
+    ...rawModels.filter(isRawEnumModel).map((model) => enm(model.name, model.values)),
+    ...rawModels.filter(isScalarModel).map((model) => scalar(model.name)),
+    ...rawModels.filter(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))
+    ).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))
+    ).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,
+              type: field.type,
+              list: true,
+              default: typeof field.filterable === "object" ? field.filterable.default : void 0
+            })),
+            ...(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 }) => ({
+              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}OrderBy`,
+              model.fields.filter(({ orderable }) => orderable).map(({ name: name2 }) => ({ name: name2, type: "Order" }))
+            )
+          ] : []
+        ];
+        if (model.creatable) {
+          types.push(
+            input(
+              `Create${model.name}`,
+              model.fields.filter(({ creatable }) => creatable).map(
+                (field) => field.kind === "relation" ? { name: `${field.name}Id`, type: "ID", nonNull: field.nonNull } : {
+                  name: field.name,
+                  type: field.kind === "json" ? `Create${field.type}` : field.type,
+                  list: field.list,
+                  nonNull: field.nonNull && field.defaultValue === void 0
+                }
+              )
+            )
+          );
+        }
+        if (model.updatable) {
+          types.push(
+            input(
+              `Update${model.name}`,
+              model.fields.filter(({ updatable }) => updatable).map(
+                (field) => field.kind === "relation" ? { name: `${field.name}Id`, type: "ID" } : {
+                  name: field.name,
+                  type: field.kind === "json" ? `Update${field.type}` : field.type,
+                  list: field.list
+                }
+              )
+            )
+          );
+        }
+        return types;
+      })
+    ),
+    object("Query", [
+      {
+        name: "me",
+        type: "User"
+      },
+      ...models.filter(({ queriable }) => queriable).map(({ name: name2 }) => ({
+        name: typeToField(name2),
+        type: name2,
+        nonNull: true,
+        args: [
+          {
+            name: "where",
+            type: `${name2}WhereUnique`,
+            nonNull: true
+          }
+        ]
+      })),
+      ...models.filter(({ listQueriable }) => listQueriable).map((model) => ({
+        name: getModelPluralField(model),
+        type: model.name,
+        list: true,
+        nonNull: true,
+        args: [
+          { name: "where", type: `${model.name}Where` },
+          ...model.fields.some(({ searchable }) => searchable) ? [{ name: "search", type: "String" }] : [],
+          ...model.fields.some(({ orderable }) => orderable) ? [{ name: "orderBy", type: `${model.name}OrderBy`, list: true }] : [],
+          { name: "limit", type: "Int" },
+          { name: "offset", type: "Int" }
+        ]
+      })),
+      ...rawModels.filter(isObjectModel).filter((model) => model.name === "Query").flatMap((model) => model.fields)
+    ]),
+    object("Mutation", [
+      ...(0, import_flatMap2.default)(
+        models.map((model) => {
+          const mutations = [];
+          if (model.creatable) {
+            mutations.push({
+              name: `create${model.name}`,
+              type: model.name,
+              nonNull: true,
+              args: [
+                {
+                  name: "data",
+                  type: `Create${model.name}`,
+                  nonNull: true
+                }
+              ]
+            });
+          }
+          if (model.updatable) {
+            mutations.push({
+              name: `update${model.name}`,
+              type: model.name,
+              nonNull: true,
+              args: [
+                {
+                  name: "where",
+                  type: `${model.name}WhereUnique`,
+                  nonNull: true
+                },
+                {
+                  name: "data",
+                  type: `Update${model.name}`,
+                  nonNull: true
+                }
+              ]
+            });
+          }
+          if (model.deletable) {
+            mutations.push({
+              name: `delete${model.name}`,
+              type: "ID",
+              nonNull: true,
+              args: [
+                {
+                  name: "where",
+                  type: `${model.name}WhereUnique`,
+                  nonNull: true
+                },
+                {
+                  name: "dryRun",
+                  type: "Boolean"
+                }
+              ]
+            });
+            mutations.push({
+              name: `restore${model.name}`,
+              type: "ID",
+              nonNull: true,
+              args: [
+                {
+                  name: "where",
+                  type: `${model.name}WhereUnique`,
+                  nonNull: true
+                }
+              ]
+            });
+          }
+          return mutations;
+        })
+      ),
+      ...rawModels.filter(isObjectModel).filter((model) => model.name === "Mutation").flatMap((model) => model.fields)
+    ])
+  ];
+};
+var generate = (rawModels) => document(generateDefinitions(rawModels));
+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))
+].filter(Boolean).map((s) => `${s}
+`).join("\n");
+var printSchemaFromModels = (models) => printSchema((0, import_graphql5.buildASTSchema)(generate(models)));
+
+// src/bin/gqm.ts
+(0, import_dotenv.config)({
+  path: ".env"
+});
+(0, import_dotenv.config)({
+  path: ".env.local"
+});
+import_commander.program.description("The graphql-magic cli.");
+import_commander.program.command("setup").description("Set up the project").action(async () => {
+  await getSettings();
+  ensureFileExists(KNEXFILE_PATH, KNEXFILE);
+});
+import_commander.program.command("generate").description("Generate all the things").action(async () => {
+  const rawModels = 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));
+  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));
+});
+import_commander.program.command("generate-schema").description("Generate schema").action(async () => {
+  const rawModels = await parseModels();
+  const generatedFolderPath = await getSetting("generatedFolderPath");
+  writeToFile(`${generatedFolderPath}/schema.graphql`, printSchemaFromModels(rawModels));
+});
+import_commander.program.command("generate-mutation-queries").description("Generate mutation-queries").action(async () => {
+  const rawModels = await parseModels();
+  const generatedFolderPath = await getSetting("generatedFolderPath");
+  writeToFile(`${generatedFolderPath}/client/mutations.ts`, generateMutations(rawModels));
+});
+import_commander.program.command("generate-db-types").description("Generate DB types").action(async () => {
+  const rawModels = await parseModels();
+  const generatedFolderPath = await getSetting("generatedFolderPath");
+  writeToFile(`${generatedFolderPath}/db/index.ts`, generateMutations(rawModels));
+});
+import_commander.program.command("generate-knex-types").description("Generate Knex types").action(async () => {
+  const rawModels = await parseModels();
+  const generatedFolderPath = await getSetting("generatedFolderPath");
+  writeToFile(`${generatedFolderPath}/db/knex.ts`, generateKnexTables(rawModels));
+});
+import_commander.program.command("generate-graphql-api-types").description("Generate Graphql API types").action(async () => {
+  await generateGraphqlApiTypes();
+});
+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 () => {
+  const git = (0, import_simple_git.simpleGit)();
+  let name2 = process.argv[2] || (await git.branch()).current.split("/").pop();
+  if (name2 && ["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);
+  } finally {
+    await db.destroy();
+  }
+});
+import_commander.program.command("*", { noHelp: true }).description("Invalid command").action(() => {
+  console.error("Invalid command: %s\nSee --help for a list of available commands.", import_commander.program.args.join(" "));
+  process.exit(1);
+});
+import_commander.program.parse(process.argv);