@smartive/graphql-magic 8.1.0 → 8.1.2

package/dist/bin/gqm.cjs

@@ -22,7 +22,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// src/bin/gqm.ts
+// src/bin/gqm/gqm.ts
 var import_commander = require("commander");
 var import_dotenv = require("dotenv");
 var import_knex = __toESM(require("knex"), 1);
@@ -350,742 +350,257 @@ var generateKnexTables = (rawModels) => {
   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/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);
   }
-};
-
-// 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"
-      }
-    }
+  writer = new import_code_block_writer2.default["default"]({
+    useSingleQuote: true,
+    indentNumberOfSpaces: 2
   });
-};
-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"
-      }
+  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);
     }
-  });
-};
-
-// 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));
+    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);
+          });
+        }
       }
-    }
-    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);
+      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`];
         }
-      } else if (typeof target === "string") {
-        const name2 = node.getName();
-        switch (name2) {
-          case "slice":
-          case "toUpperCase":
-          case "toLowerCase":
-            return target[name2].bind(target);
+      }
+      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);
         }
       }
-      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++;
+    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
+          );
+        }
       }
-      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()}`);
+    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';`);
     }
-  },
-  [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.`);
+    if (this.nowUsed) {
+      writer.writeLine(`import { date } from '../src/utils/dates';`);
     }
-  },
-  [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;
-      }
+    writer.blankLine();
+    if (this.nowUsed) {
+      writer.writeLine(`const now = date();`).blankLine();
     }
+    this.migration("up", up);
+    this.migration("down", down.reverse());
+    return writer.toString();
   }
-};
-
-// 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
+  renameFields(model, fields2, up, down) {
+    if (!fields2.length) {
+      return;
     }
-  });
-  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
+    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;
     }
-  });
-  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);
+  createFields(model, fields2, up, down) {
+    if (!fields2.length) {
+      return;
     }
-    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);
-          });
+    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 (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 (alter.length) {
+        this.alterTable(model.name, () => {
+          alter.map((cb) => cb());
         });
       }
       if (updates.length) {
@@ -1344,399 +859,884 @@ var MigrationGenerator = class {
     }
   }
 };
-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}`;
+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/codegen.ts
+var import_cli = require("@graphql-codegen/cli");
+
+// src/bin/gqm/settings.ts
+var import_fs = require("fs");
+var import_path = require("path");
+
+// src/bin/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/bin/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/bin/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;
 };
-
-// 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;
+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/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));
+// src/bin/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/bin/gqm/parse-knexfile.ts
+var import_ts_morph4 = require("ts-morph");
+
+// src/bin/gqm/static-eval.ts
+var import_ts_morph2 = require("ts-morph");
+
+// src/bin/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 (field.nonNull) {
-    type = nonNull(type);
+  if ("unknown" in visitor2) {
+    return visitor2.unknown(node);
   }
-  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])
-    })
-  )
+  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/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
-                }
-              ]
-            });
+// src/bin/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);
           }
-          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
-                }
-              ]
-            });
+          const caseValue = staticEval(caseClause.getExpression(), context);
+          if (value2 === caseValue) {
+            active = true;
+            if (caseClause.getStatements().length) {
+              return staticEval(clause, context);
+            }
           }
-          return mutations;
-        })
-      ),
-      ...rawModels.filter(isObjectModel).filter((model) => model.name === "Mutation").flatMap((model) => model.fields)
-    ])
-  ];
+        }
+      }
+    }
+  },
+  [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/bin/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/bin/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/bin/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;
 };
-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
+// src/bin/gqm/gqm.ts
 (0, import_dotenv.config)({
   path: ".env"
 });
@@ -1791,7 +1791,7 @@ import_commander.program.command("generate-graphql-client-types").description("G
 });
 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();
+  let name2 = process.argv[process.argv.indexOf("gqm") + 1] || (await git.branch()).current.split("/").pop();
   if (name2 && ["staging", "production"].includes(name2)) {
     name2 = await readLine("Migration name:");
   }