@smartive/graphql-magic 8.0.0 → 8.1.0

package/dist/cjs/index.cjs

@@ -30,10 +30,15 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   AliasGenerator: () => AliasGenerator,
+  CLIENT_CODEGEN: () => CLIENT_CODEGEN,
+  EMPTY_MODELS: () => EMPTY_MODELS,
   Enum: () => Enum,
   ForbiddenError: () => ForbiddenError,
+  GRAPHQL_CODEGEN: () => GRAPHQL_CODEGEN,
   GraphQLError: () => GraphQLError,
   ID_ALIAS: () => ID_ALIAS,
+  KNEXFILE: () => KNEXFILE,
+  KNEXFILE_PATH: () => KNEXFILE_PATH,
   MigrationGenerator: () => MigrationGenerator,
   NotFoundError: () => NotFoundError,
   PermissionError: () => PermissionError,
@@ -53,12 +58,16 @@ __export(src_exports, {
   displayField: () => displayField,
   document: () => document,
   enm: () => enm,
+  ensureFileExists: () => ensureFileExists,
   execute: () => execute,
   fieldType: () => fieldType,
   fields: () => fields,
+  findDeclarationInFile: () => findDeclarationInFile,
   generate: () => generate,
   generateDBModels: () => generateDBModels,
   generateDefinitions: () => generateDefinitions,
+  generateGraphqlApiTypes: () => generateGraphqlApiTypes,
+  generateGraphqlClientTypes: () => generateGraphqlClientTypes,
   generateKnexTables: () => generateKnexTables,
   generateMutations: () => generateMutations,
   generatePermissions: () => generatePermissions,
@@ -76,6 +85,7 @@ __export(src_exports, {
   getManyToManyRelation: () => getManyToManyRelation,
   getManyToManyRelations: () => getManyToManyRelations,
   getManyToManyRelationsQuery: () => getManyToManyRelationsQuery,
+  getMigrationDate: () => getMigrationDate,
   getModelLabel: () => getModelLabel,
   getModelLabelPlural: () => getModelLabelPlural,
   getModelPlural: () => getModelPlural,
@@ -88,6 +98,8 @@ __export(src_exports, {
   getResolverNode: () => getResolverNode,
   getResolvers: () => getResolvers,
   getRootFieldNode: () => getRootFieldNode,
+  getSetting: () => getSetting,
+  getSettings: () => getSettings,
   getSimpleFields: () => getSimpleFields,
   getString: () => getString,
   getType: () => getType,
@@ -110,6 +122,7 @@ __export(src_exports, {
   isFieldNode: () => isFieldNode,
   isFragmentSpreadNode: () => isFragmentSpreadNode,
   isInlineFragmentNode: () => isInlineFragmentNode,
+  isInputModel: () => isInputModel,
   isListType: () => isListType,
   isObjectModel: () => isObjectModel,
   isPrimitive: () => isPrimitive,
@@ -137,19 +150,25 @@ __export(src_exports, {
   not: () => not,
   object: () => object,
   ors: () => ors,
+  parseKnexfile: () => parseKnexfile,
+  parseModels: () => parseModels,
   printSchema: () => printSchema,
   printSchemaFromDocument: () => printSchemaFromDocument,
   printSchemaFromModels: () => printSchemaFromModels,
   queryRelations: () => queryRelations,
   queryResolver: () => queryResolver,
+  readLine: () => readLine,
   resolve: () => resolve,
   retry: () => retry,
   scalar: () => scalar,
+  staticEval: () => staticEval,
   summon: () => summon,
   summonByKey: () => summonByKey,
   summonByName: () => summonByName,
   typeToField: () => typeToField,
-  value: () => value
+  value: () => value,
+  visit: () => visit,
+  writeToFile: () => writeToFile
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -202,7 +221,7 @@ 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) {
+  for (const { name: name2, creatable, updatable, deletable } of models.filter(isEntityModel)) {
     if (creatable) {
       parts.push(
         `export const CREATE_${constantCase(
@@ -266,6 +285,7 @@ var isEnumModel = (model) => model.kind === "enum";
 var isRawEnumModel = (model) => model.kind === "raw-enum";
 var isScalarModel = (model) => model.kind === "scalar";
 var isObjectModel = (model) => model.kind === "object";
+var isInputModel = (model) => model.kind === "input";
 var isEnumList = (models, field) => field?.list === true && models.find(({ name: name2 }) => name2 === field.kind)?.kind === "enum";
 var and = (...predicates) => (field) => predicates.every((predicate) => predicate(field));
 var not = (predicate) => (field) => !predicate(field);
@@ -701,6 +721,491 @@ 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/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 config = staticEval(configDeclaration, {});
+  return config;
+};
+
+// 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");
@@ -1147,6 +1652,7 @@ var MigrationGenerator = class {
     };
     const kind = field.kind;
     switch (kind) {
+      case void 0:
       case "primitive":
         switch (field.type) {
           case "Boolean":
@@ -1209,6 +1715,16 @@ 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}`;
+};
 
 // src/errors.ts
 var import_graphql2 = require("graphql");
@@ -2528,7 +3044,8 @@ var generateDefinitions = (rawModels) => {
     ...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).map((model) => object(model.name, model.fields)),
+    ...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)),
@@ -2656,7 +3173,8 @@ var generateDefinitions = (rawModels) => {
           { 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)(
@@ -2727,7 +3245,8 @@ var generateDefinitions = (rawModels) => {
           }
           return mutations;
         })
-      )
+      ),
+      ...rawModels.filter(isObjectModel).filter((model) => model.name === "Mutation").flatMap((model) => model.fields)
     ])
   ];
 };
@@ -2742,10 +3261,15 @@ var printSchemaFromModels = (models) => printSchema((0, import_graphql5.buildAST
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AliasGenerator,
+  CLIENT_CODEGEN,
+  EMPTY_MODELS,
   Enum,
   ForbiddenError,
+  GRAPHQL_CODEGEN,
   GraphQLError,
   ID_ALIAS,
+  KNEXFILE,
+  KNEXFILE_PATH,
   MigrationGenerator,
   NotFoundError,
   PermissionError,
@@ -2765,12 +3289,16 @@ var printSchemaFromModels = (models) => printSchema((0, import_graphql5.buildAST
   displayField,
   document,
   enm,
+  ensureFileExists,
   execute,
   fieldType,
   fields,
+  findDeclarationInFile,
   generate,
   generateDBModels,
   generateDefinitions,
+  generateGraphqlApiTypes,
+  generateGraphqlClientTypes,
   generateKnexTables,
   generateMutations,
   generatePermissions,
@@ -2788,6 +3316,7 @@ var printSchemaFromModels = (models) => printSchema((0, import_graphql5.buildAST
   getManyToManyRelation,
   getManyToManyRelations,
   getManyToManyRelationsQuery,
+  getMigrationDate,
   getModelLabel,
   getModelLabelPlural,
   getModelPlural,
@@ -2800,6 +3329,8 @@ var printSchemaFromModels = (models) => printSchema((0, import_graphql5.buildAST
   getResolverNode,
   getResolvers,
   getRootFieldNode,
+  getSetting,
+  getSettings,
   getSimpleFields,
   getString,
   getType,
@@ -2822,6 +3353,7 @@ var printSchemaFromModels = (models) => printSchema((0, import_graphql5.buildAST
   isFieldNode,
   isFragmentSpreadNode,
   isInlineFragmentNode,
+  isInputModel,
   isListType,
   isObjectModel,
   isPrimitive,
@@ -2849,17 +3381,23 @@ var printSchemaFromModels = (models) => printSchema((0, import_graphql5.buildAST
   not,
   object,
   ors,
+  parseKnexfile,
+  parseModels,
   printSchema,
   printSchemaFromDocument,
   printSchemaFromModels,
   queryRelations,
   queryResolver,
+  readLine,
   resolve,
   retry,
   scalar,
+  staticEval,
   summon,
   summonByKey,
   summonByName,
   typeToField,
-  value
+  value,
+  visit,
+  writeToFile
 });