nuxt-graphql-middleware 4.3.1 → 5.0.0-alpha.0

package/dist/module.mjs

@@ -1,27 +1,23 @@
+import { loadSchema } from '@graphql-tools/load';
 import { fileURLToPath } from 'url';
-import { dirname, resolve, relative, parse as parse$1, join } from 'pathe';
+import { relative } from 'pathe';
 import { defu } from 'defu';
-import { useLogger, resolveAlias, resolveFiles, defineNuxtModule, createResolver, addImports, addServerImports, addTemplate, addServerHandler, addPlugin, updateTemplates } from '@nuxt/kit';
-import inquirer from 'inquirer';
+import { useLogger, resolveFiles, defineNuxtModule, resolveAlias, createResolver, addImports, addServerImports, addTemplate, addServerHandler, addPlugin } from '@nuxt/kit';
 import { onDevToolsInitialized, extendServerRpc } from '@nuxt/devtools-kit';
 import { existsSync } from 'fs';
 import { GraphqlMiddlewareTemplate } from '../dist/runtime/settings/index.js';
-import * as fs from 'node:fs';
 import { promises, existsSync as existsSync$1 } from 'node:fs';
-import { oldVisit } from '@graphql-codegen/plugin-helpers';
-import { validateGraphQlDocuments } from '@graphql-tools/utils';
-import { loadSchema } from '@graphql-tools/load';
-import { concatAST, parse, print, visit, Kind, Source } from 'graphql';
-import { falsy } from '../dist/runtime/helpers/index.js';
-import { generate as generate$1, executeCodegen } from '@graphql-codegen/cli';
-import * as PluginTypescript from '@graphql-codegen/typescript';
-import * as PluginTypescriptOperations from '@graphql-codegen/typescript-operations';
+import { generate } from '@graphql-codegen/cli';
 import * as PluginSchemaAst from '@graphql-codegen/schema-ast';
+import { basename } from 'node:path';
+import { Source, parse, printSourceLocation } from 'graphql';
+import { Generator } from 'graphql-typescript-deluxe';
 import { pascalCase } from 'change-case-all';
 import colors from 'picocolors';
+import { validateGraphQlDocuments } from '@graphql-tools/utils';
 
 const name = "nuxt-graphql-middleware";
-const version = "4.3.1";
+const version = "5.0.0-alpha.0";
 
 const DEVTOOLS_UI_ROUTE = "/__nuxt-graphql-middleware";
 const DEVTOOLS_UI_LOCAL_PORT = 3300;
@@ -64,236 +60,8 @@ function setupDevToolsUI(nuxt, clientPath) {
   });
 }
 
-const importSyntaxRE = /^#import (?:'([^']*)'|"([^"]*)")/;
-const matchImport = (value = "") => {
-  if (!value) {
-    return void 0;
-  }
-  if (value.indexOf("#import") !== 0) {
-    return void 0;
-  }
-  const matched = value.match(importSyntaxRE);
-  if (matched === null) {
-    return void 0;
-  }
-  const importIdentifierMatch = value.match(importSyntaxRE) || [];
-  const importIdentifier = importIdentifierMatch[1] ?? importIdentifierMatch[2];
-  if (importIdentifier === void 0) {
-    return void 0;
-  }
-  return { importIdentifier };
-};
-
-const lineEndingRE = /\r\n|\n/;
-function* linesWithInlinedImportsOf(fileContents, inlineImportsOptions, visited) {
-  const {
-    resolveOptions = {},
-    resolveImport,
-    fs: nodeFs = fs,
-    throwIfImportNotFound
-  } = inlineImportsOptions;
-  const { basedir } = resolveOptions;
-  if (typeof basedir !== "string") {
-    throw new TypeError(
-      "inlineImports requires options.resolverOptions.basedir be set"
-    );
-  }
-  if (!resolveImport) {
-    throw new TypeError("inlineImports requires options.resolveImport be set");
-  }
-  let lineNumber = 0;
-  for (const line of fileContents.split(lineEndingRE)) {
-    ++lineNumber;
-    const matched = matchImport(line);
-    if (matched) {
-      const importIdentifier = matched.importIdentifier;
-      let filename;
-      try {
-        filename = resolveImport(importIdentifier, resolveOptions);
-      } catch (err) {
-        if (throwIfImportNotFound === false) {
-          continue;
-        }
-        throw err;
-      }
-      if (visited.has(filename)) {
-        continue;
-      } else {
-        visited.add(filename);
-      }
-      const fragmentSource = nodeFs.readFileSync(filename, "utf8");
-      const line2 = inlineImportsWithLineToImports(
-        fragmentSource,
-        {
-          resolveImport,
-          resolveOptions: {
-            basedir: dirname(filename)
-          }
-        },
-        visited
-      );
-      yield { line: line2.inlineImports, match: true, lineNumber, filename };
-    } else {
-      yield { line, match: false, lineNumber };
-    }
-  }
-}
-function inlineImportsWithLineToImports(fileContents, options, visited = /* @__PURE__ */ new Set()) {
-  const inlineImportsResult = [];
-  const lineToImports = /* @__PURE__ */ new Map();
-  for (const { line, match, lineNumber, filename } of linesWithInlinedImportsOf(
-    fileContents,
-    options,
-    visited
-  )) {
-    inlineImportsResult.push(line);
-    if (match) {
-      lineToImports.set(lineNumber, { filename, line });
-    }
-  }
-  return {
-    inlineImports: inlineImportsResult.join("\n"),
-    lineToImports
-  };
-}
-
-function getCodeResult(operations, typeName, serverApiPrefix) {
-  const imports = [];
-  const resultTypes = [];
-  let code = "";
-  let nitroCode = "";
-  const names = Object.keys(operations);
-  if (names.length) {
-    const lines = [];
-    const nitroLines = [];
-    names.forEach((name) => {
-      const nameResult = pascalCase(name + typeName);
-      resultTypes.push(nameResult);
-      imports.push(nameResult);
-      const nameVariables = pascalCase(name + typeName + "Variables");
-      const { hasVariables, variablesOptional } = operations[name];
-      if (hasVariables) {
-        imports.push(nameVariables);
-      }
-      const variablesType = hasVariables ? nameVariables : "null";
-      lines.push(
-        `    ${name}: [${variablesType}, ${variablesOptional ? "true" : "false"}, ${nameResult}]`
-      );
-      nitroLines.push(
-        `    '${serverApiPrefix}/${typeName.toLowerCase()}/${name}': {
-      'default': GraphqlResponse<${nameResult}>
-    }`
-      );
-    });
-    code += `  export type GraphqlMiddleware${typeName} = {
-${lines.join(",\n")}
-  }
-`;
-    nitroCode += `${nitroLines.join("\n")}`;
-  }
-  return { code, imports, nitroCode, resultTypes };
-}
-const plugin$1 = (_schema, documents, config) => {
-  const allAst = concatAST(documents.map((v) => v.document).filter(falsy));
-  const operations = {
-    query: {},
-    mutation: {}
-  };
-  oldVisit(allAst, {
-    enter: {
-      OperationDefinition: (node) => {
-        if ("name" in node && node.name?.value && "operation" in node && (node.operation === "query" || node.operation === "mutation")) {
-          operations[node.operation][node.name.value] = {
-            hasVariables: !!node.variableDefinitions?.length,
-            variablesOptional: !!node.variableDefinitions?.every((v) => {
-              return v.defaultValue;
-            })
-          };
-        }
-      }
-    }
-  });
-  let code = "";
-  let nitroCode = "";
-  const imports = [];
-  const resultTypes = [];
-  const resultQuery = getCodeResult(
-    operations.query,
-    "Query",
-    config.serverApiPrefix
-  );
-  code += resultQuery.code;
-  nitroCode += resultQuery.nitroCode;
-  imports.push(...resultQuery.imports);
-  resultTypes.push(...resultQuery.resultTypes);
-  const resultMutation = getCodeResult(
-    operations.mutation,
-    "Mutation",
-    config.serverApiPrefix
-  );
-  code += "\n" + resultMutation.code;
-  nitroCode += "\n" + resultMutation.nitroCode;
-  imports.push(...resultMutation.imports);
-  resultTypes.push(...resultMutation.resultTypes);
-  return `
-import type { GraphqlResponse } from '#graphql-middleware-server-options-build'
-import type {
-  ${imports.join(",\n  ")}
-} from './../graphql-operations'
-
-
-declare module '#nuxt-graphql-middleware/generated-types' {
-  export type GraphqlMiddlewareResponseUnion = ${resultTypes.join(" | ")}
-${code}
-}
-
-declare module 'nitropack' {
-  interface InternalApi {
-${nitroCode}
-  }
-}
-`;
-};
-
-const PluginNuxtGraphqlMiddleware = {
-  __proto__: null,
-  plugin: plugin$1
-};
-
-const plugin = (_schema, documents, _config) => {
-  const allAst = concatAST(documents.map((v) => v.document).filter(falsy));
-  const operations = {
-    query: {},
-    mutation: {}
-  };
-  oldVisit(allAst, {
-    enter: {
-      OperationDefinition: (node) => {
-        if (node.name?.value && node.loc?.source && (node.operation === "query" || node.operation === "mutation")) {
-          operations[node.operation][node.name.value] = node.loc.source.body;
-        }
-      }
-    }
-  });
-  return `const documents = ${JSON.stringify(operations, null, 2)};
-export { documents };`;
-};
-
-const PluginNuxtGraphqlMiddlewareDocuments = {
-  __proto__: null,
-  plugin: plugin
-};
-
 function pluginLoader(name) {
   switch (name) {
-    case "@graphql-codegen/typescript":
-      return Promise.resolve(PluginTypescript);
-    case "@graphql-codegen/typescript-operations":
-      return Promise.resolve(PluginTypescriptOperations);
-    case "@graphql-codegen/typescript-nuxt-graphql-middleware":
-      return Promise.resolve(PluginNuxtGraphqlMiddleware);
-    case "@graphql-codegen/typescript-nuxt-graphql-middleware-documents":
-      return Promise.resolve(PluginNuxtGraphqlMiddlewareDocuments);
     case "@graphql-codegen/schema-ast":
       return Promise.resolve(PluginSchemaAst);
   }
@@ -317,88 +85,11 @@ function generateSchema(moduleOptions, dest, writeToDisk) {
       }
     }
   };
-  return generate$1(config, writeToDisk).then((v) => v[0]);
-}
-function generateTemplates(documents, schemaPath, options) {
-  return executeCodegen({
-    schema: schemaPath,
-    pluginLoader,
-    silent: true,
-    errorsOnly: true,
-    documents,
-    generates: {
-      [GraphqlMiddlewareTemplate.OperationTypes]: {
-        plugins: ["typescript", "typescript-operations"],
-        config: options.codegenConfig
-      },
-      [GraphqlMiddlewareTemplate.ComposableContext]: {
-        plugins: ["typescript-nuxt-graphql-middleware"],
-        config: {
-          serverApiPrefix: options.serverApiPrefix
-        }
-      },
-      [GraphqlMiddlewareTemplate.Documents]: {
-        plugins: ["typescript-nuxt-graphql-middleware-documents"]
-      }
-    }
-  });
-}
-
-function getMaxLengths(documents) {
-  let longestOperation = 0;
-  let longestName = 0;
-  let longestPath = 0;
-  for (const { operation, name, relativePath } of documents) {
-    if (operation && operation.length > longestOperation) {
-      longestOperation = operation.length;
-    }
-    if (name && name.length > longestName) {
-      longestName = name.length;
-    }
-    if (relativePath && relativePath.length > longestPath) {
-      longestPath = relativePath.length;
-    }
-  }
-  return { longestOperation, longestName, longestPath };
-}
-function logDocuments(logger, documents, logEverything) {
-  const { longestOperation, longestName, longestPath } = getMaxLengths(documents);
-  logger.log(colors.green("GraphQL Document Validation"));
-  for (const { operation, name, relativePath, isValid, errors } of documents) {
-    if (logEverything || !isValid) {
-      let log = "";
-      log += (operation || "").padEnd(longestOperation + 2);
-      log += colors.cyan((name || "").padEnd(longestName + 2));
-      log += colors.dim((relativePath || "").padEnd(longestPath + 2));
-      log += isValid ? colors.green("\u2713") : colors.red("x");
-      if (!isValid && errors) {
-        log += "\n" + errors.map((error) => colors.red(error)).join("\n");
-      }
-      logger.log(log);
-    }
-  }
-  process.stdout.write("\n");
-  logger.restoreStd();
-  if (documents.some((v) => !v.isValid)) {
-    logger.error("GraphQL document validation failed with errors.");
-  } else {
-    logger.success("GraphQL document validation completed successfully.");
-  }
+  return generate(config, writeToDisk).then((v) => v[0]);
 }
 
 const logger = useLogger(name);
 const defaultOptions = {
-  codegenConfig: {
-    exportFragmentSpreadSubTypes: true,
-    preResolveTypes: true,
-    skipTypeNameForRoot: true,
-    skipTypename: true,
-    useTypeImports: true,
-    onlyOperationTypes: true,
-    namingConvention: {
-      enumValues: "change-case-all#upperCaseFirst"
-    }
-  },
   downloadSchema: true,
   schemaPath: "~~/schema.graphql",
   serverApiPrefix: "/api/graphql_middleware",
@@ -408,16 +99,6 @@ const defaultOptions = {
   documents: [],
   devtools: true
 };
-function inlineFragments(source, resolver) {
-  return inlineImportsWithLineToImports(source, {
-    resolveImport(identifier) {
-      return resolver(identifier);
-    },
-    resolveOptions: {
-      basedir: "./"
-    }
-  }).inlineImports;
-}
 function validateOptions(options) {
   if (!options.graphqlEndpoint) {
     throw new Error("Missing graphqlEndpoint.");
@@ -433,321 +114,443 @@ async function getSchemaPath(schemaPath, options, resolver, writeToDisk = false)
       );
       throw new Error("Missing GraphQL schema.");
     }
-    return dest;
+    const schemaContent = await promises.readFile(dest).then((v) => v.toString());
+    return { schemaPath, schemaContent };
   }
   if (!options.graphqlEndpoint) {
     throw new Error("Missing graphqlEndpoint config.");
   }
-  await generateSchema(options, dest, writeToDisk);
-  return dest;
+  const result = await generateSchema(options, dest, writeToDisk);
+  return { schemaPath, schemaContent: result.content };
 }
-async function autoImportDocuments(patterns = [], srcResolver) {
-  if (!patterns.length) {
-    return Promise.resolve([]);
+const fileExists = (path, extensions = ["js", "ts", "mjs"]) => {
+  if (!path) {
+    return null;
+  } else if (existsSync$1(path)) {
+    return path;
   }
-  const files = (await resolveFiles(srcResolver(), patterns, {
-    followSymbolicLinks: false
-  })).filter((path) => {
-    return !path.includes("schema.gql") && !path.includes("schema.graphql");
-  });
-  return Promise.all(
-    files.map((filename) => {
-      return promises.readFile(filename).then((v) => {
-        const content = v.toString().trim();
-        return {
-          content,
-          filename
-        };
-      });
-    })
+  const extension = extensions.find(
+    (extension2) => existsSync$1(`${path}.${extension2}`)
+  );
+  return extension ? `${path}.${extension}` : null;
+};
+
+function groupOperationsByType(ops) {
+  const result = {
+    query: {},
+    mutation: {},
+    subscription: {}
+  };
+  for (const op of ops) {
+    result[op.operationType][op.graphqlName] = {
+      hasVariables: op.hasVariables,
+      variablesOptional: !op.needsVariables
+    };
+  }
+  return result;
+}
+function buildOperationTypeCode(operationMetadata, typeName, serverApiPrefix) {
+  const imports = [];
+  const resultTypes = [];
+  let code = "";
+  let nitroCode = "";
+  const operationNames = Object.keys(operationMetadata);
+  if (operationNames.length === 0) {
+    return { code, nitroCode, imports, resultTypes };
+  }
+  const lines = [];
+  const nitroLines = [];
+  for (const name of operationNames) {
+    const nameResult = pascalCase(`${name}${typeName}`);
+    const nameVariables = pascalCase(`${name}${typeName}Variables`);
+    resultTypes.push(nameResult);
+    imports.push(nameResult);
+    const { hasVariables, variablesOptional } = operationMetadata[name];
+    if (hasVariables) {
+      imports.push(nameVariables);
+    }
+    const variablesType = hasVariables ? nameVariables : "null";
+    lines.push(
+      `    ${name}: [${variablesType}, ${variablesOptional ? "true" : "false"}, ${nameResult}]`
+    );
+    nitroLines.push(`
+    '${serverApiPrefix}/${typeName.toLowerCase()}/${name}': {
+      'default': GraphqlResponse<${nameResult}>
+    }`);
+  }
+  code += `  export type GraphqlMiddleware${typeName} = {
+${lines.join(",\n")}
+  }
+`;
+  nitroCode += nitroLines.join("\n");
+  return { code, nitroCode, imports, resultTypes };
+}
+function generateContextTemplate(collectedOperations, serverApiPrefix) {
+  const grouped = groupOperationsByType(collectedOperations);
+  const queryResult = buildOperationTypeCode(
+    grouped.query,
+    "Query",
+    serverApiPrefix
   );
+  const mutationResult = buildOperationTypeCode(
+    grouped.mutation,
+    "Mutation",
+    serverApiPrefix
+  );
+  const subscriptionResult = buildOperationTypeCode(
+    grouped.subscription,
+    "Subscription",
+    serverApiPrefix
+  );
+  const allImports = [
+    ...queryResult.imports,
+    ...mutationResult.imports,
+    ...subscriptionResult.imports
+  ];
+  const allResultTypes = [
+    ...queryResult.resultTypes,
+    ...mutationResult.resultTypes,
+    ...subscriptionResult.resultTypes
+  ];
+  const combinedCode = [
+    queryResult.code,
+    mutationResult.code,
+    subscriptionResult.code
+  ].join("\n");
+  const combinedNitroCode = [
+    queryResult.nitroCode,
+    mutationResult.nitroCode,
+    subscriptionResult.nitroCode
+  ].join("\n");
+  return `
+import type { GraphqlResponse } from '#graphql-middleware-server-options-build'
+import type {
+  ${allImports.join(",\n  ")}
+} from './../graphql-operations'
+
+declare module '#nuxt-graphql-middleware/generated-types' {
+  export type GraphqlMiddlewareResponseUnion = ${allResultTypes.join(" | ")}
+${combinedCode}
 }
-function inlineNestedFragments(document, fragmentMap) {
-  const parsed = parse(document);
-  const fragmentsToInline = /* @__PURE__ */ new Set();
-  visit(parsed, {
-    FragmentSpread(node) {
-      fragmentsToInline.add(node.name.value);
+
+declare module 'nitropack' {
+  interface InternalApi {
+${combinedNitroCode}
+  }
+}
+`;
+}
+
+function getMaxLengths(entries) {
+  let name = 0;
+  let path = 0;
+  let type = 0;
+  for (const entry of entries) {
+    if (entry.type.length > type) {
+      type = entry.type.length;
     }
-  });
-  fragmentsToInline.forEach((fragmentName) => {
-    const fragment = fragmentMap[fragmentName];
-    if (fragment) {
-      document += "\n" + fragment;
-      const nestedFragmentNames = /* @__PURE__ */ new Set();
-      visit(parse(fragment), {
-        FragmentSpread(node) {
-          nestedFragmentNames.add(node.name.value);
-        }
-      });
-      nestedFragmentNames.forEach((nestedFragmentName) => {
-        if (!fragmentsToInline.has(nestedFragmentName)) {
-          fragmentsToInline.add(nestedFragmentName);
-          const nestedFragment = fragmentMap[nestedFragmentName];
-          if (nestedFragment) {
-            document += "\n" + nestedFragment;
+    if (entry.name.length > name) {
+      name = entry.name.length;
+    }
+    if (entry.path.length > path) {
+      path = entry.path.length;
+    }
+  }
+  return { name, path, type };
+}
+function logAllEntries(entries) {
+  const lengths = getMaxLengths(entries);
+  let prevHadError = false;
+  for (const entry of entries) {
+    const hasErrors = entry.errors.length > 0;
+    const icon = hasErrors ? colors.red(" x ") : colors.green(" \u2713 ");
+    const type = entry.type.padEnd(lengths.type);
+    const namePadded = colors.bold(entry.name.padEnd(lengths.name));
+    const name = hasErrors ? colors.red(namePadded) : colors.green(namePadded);
+    const path = colors.dim(entry.path.padEnd(lengths.path));
+    const parts = [icon, type, name, path];
+    if (hasErrors && !prevHadError) {
+      process.stdout.write("-".repeat(process.stdout.columns) + "\n");
+    }
+    logger.log(parts.join(" | "));
+    if (hasErrors) {
+      const errorLines = [];
+      entry.errors.forEach((error) => {
+        let output = colors.red(error.message);
+        if (error.source && error.locations) {
+          for (const location of error.locations) {
+            output += "\n\n" + colors.red(printSourceLocation(error.source, location));
           }
         }
+        errorLines.push(output);
       });
+      logger.log(
+        errorLines.join("\n").split("\n").map((v) => "    " + v).join("\n")
+      );
+      process.stdout.write("-".repeat(process.stdout.columns) + "\n");
     }
-  });
-  return document;
+    prevHadError = hasErrors;
+  }
+  logger.restoreStd();
 }
-async function buildDocuments(providedDocuments = [], autoImportPatterns, resolver, autoInlineFragments) {
-  const documents = await autoImportDocuments(autoImportPatterns, resolver).then((importedDocuments) => [
-    ...importedDocuments,
-    ...providedDocuments.map((content) => ({
-      content,
-      filename: "nuxt.config.ts"
-    }))
-  ]).then((documents2) => {
-    if (autoInlineFragments) {
-      return documents2;
-    }
-    return documents2.map((v) => {
-      if (!v.content.trim()) {
-        return null;
+class CollectedFile {
+  filePath;
+  fileContents;
+  isOnDisk;
+  parsed;
+  constructor(filePath, fileContents, isOnDisk = false) {
+    this.filePath = filePath;
+    this.fileContents = fileContents;
+    this.isOnDisk = isOnDisk;
+    this.parsed = parse(fileContents);
+  }
+  static async fromFilePath(filePath) {
+    const content = (await promises.readFile(filePath)).toString();
+    return new CollectedFile(filePath, content, true);
+  }
+  /**
+   * If isOnDisk, re-read file contents from disk, then parse it (syntax only).
+   */
+  async update() {
+    if (this.isOnDisk) {
+      const newContents = (await promises.readFile(this.filePath)).toString();
+      if (newContents === this.fileContents) {
+        return false;
       }
-      try {
-        return {
-          content: inlineFragments(v.content, resolveAlias),
-          filename: v.filename
-        };
-      } catch (e) {
-        logger.error(e);
-        logger.error(
-          "Failed to inline fragments for document: " + v.filename
-        );
-      }
-      return null;
-    }).filter(falsy);
-  }).then((docs) => {
-    return docs.filter((v) => v.content.trim());
-  });
-  if (!autoInlineFragments) {
-    return documents;
+      this.fileContents = newContents;
+      this.parsed = parse(newContents);
+      return true;
+    }
+    return false;
   }
-  const fragmentMap = {};
-  documents.forEach((doc) => {
-    const parsed = parse(doc.content);
-    visit(parsed, {
-      FragmentDefinition(node) {
-        fragmentMap[node.name.value] = print(node);
-      }
-    });
-  });
-  documents.forEach((doc) => {
-    doc.content = inlineNestedFragments(doc.content, fragmentMap);
-  });
-  return documents;
 }
-function parseDocument(document, rootDir) {
-  let name2 = document.filename ? document.filename.replace(rootDir, "") : "";
-  if (name2.charAt(0) === "/") {
-    name2 = name2.slice(1);
+class Collector {
+  constructor(schema, context, nuxtConfigDocuments = [], generatorOptions) {
+    this.schema = schema;
+    this.context = context;
+    this.nuxtConfigDocuments = nuxtConfigDocuments;
+    this.generator = new Generator(schema, generatorOptions);
+  }
+  /**
+   * All collected files.
+   */
+  files = /* @__PURE__ */ new Map();
+  /**
+   * The code generator.
+   */
+  generator;
+  /**
+   * A map of operation name and timestamp when the operation was last validated.
+   */
+  operationTimestamps = /* @__PURE__ */ new Map();
+  /**
+   * The generated TypeScript type template output.
+   */
+  outputTypes = "";
+  /**
+   * The generated oeprations file.
+   */
+  outputOperations = "";
+  /**
+   * The generated context template file.
+   */
+  outputContext = "";
+  /**
+   * Whether we need to rebuild the Generator state.
+   */
+  needsRebuild = false;
+  filePathToRelative(filePath) {
+    return filePath.replace(this.context.srcDir, "~");
+  }
+  operationToLogEntry(operation, errors) {
+    return {
+      name: operation.graphqlName,
+      type: operation.operationType,
+      path: this.filePathToRelative(operation.filePath),
+      errors
+    };
   }
-  const source = new Source(document.content, name2);
-  return parse(source);
-}
-function validateDocuments(schema, documents, rootDir) {
-  const validated = [];
-  for (let i = 0; i < documents.length; i++) {
-    const document = { ...documents[i] };
-    if (document.filename) {
-      document.relativePath = document.filename.replace(rootDir + "/", "");
+  /**
+   * Executes code gen and performs validation for operations.
+   */
+  buildState() {
+    const output = this.generator.build();
+    const operations = output.getCollectedOperations();
+    const generatedCode = output.getGeneratedCode();
+    this.outputOperations = output.getOperationsFile();
+    this.outputTypes = output.getEverything();
+    this.outputContext = generateContextTemplate(
+      operations,
+      this.context.serverApiPrefix
+    );
+    const fragmentMap = /* @__PURE__ */ new Map();
+    const operationSourceMap = /* @__PURE__ */ new Map();
+    for (const code of generatedCode) {
+      if (code.type === "fragment" && code.graphqlName && code.source) {
+        fragmentMap.set(code.graphqlName, code.source);
+      } else if (code.type === "operation" && code.graphqlName && code.source) {
+        operationSourceMap.set(code.graphqlName, code.source);
+      }
     }
-    try {
-      const node = parseDocument(document, rootDir);
-      document.content = print(node);
-      document.errors = validateGraphQlDocuments(schema, [
-        node
-      ]);
-      const operation = node.definitions.find(
-        (v) => v.kind === "OperationDefinition"
+    let hasErrors = false;
+    const logEntries = [];
+    for (const operation of operations) {
+      const previousTimestamp = this.operationTimestamps.get(
+        operation.graphqlName
       );
-      if (operation) {
-        document.name = operation.name?.value;
-        document.operation = operation.operation;
+      if (previousTimestamp === operation.timestamp) {
+        continue;
+      }
+      const fragments = operation.dependencies.map(
+        (v) => v.type === "fragment-name" ? fragmentMap.get(v.value) || "" : ""
+      ).join("\n");
+      const fullOperation = operationSourceMap.get(operation.graphqlName) + fragments;
+      const source = new Source(fullOperation, basename(operation.filePath));
+      const document = parse(source);
+      const errors = validateGraphQlDocuments(this.schema, [document]);
+      if (errors.length) {
+        hasErrors = true;
       } else {
-        document.name = document.relativePath;
+        this.operationTimestamps.set(operation.graphqlName, operation.timestamp);
       }
-      document.isValid = document.errors.length === 0;
-    } catch (e) {
-      document.errors = [e];
-      document.isValid = false;
+      logEntries.push(this.operationToLogEntry(operation, errors));
     }
-    document.id = [document.operation, document.name, document.filename].filter(Boolean).join("_");
-    validated.push(document);
-    if (!document.isValid) {
-      break;
+    logAllEntries(logEntries);
+    if (hasErrors) {
+      throw new Error("GraphQL errors");
     }
   }
-  return validated;
-}
-function cleanGraphqlDocument(graphqlContent, operationName) {
-  const document = parse(graphqlContent);
-  let selectedOperation = null;
-  const fragments = {};
-  const usedFragments = /* @__PURE__ */ new Set();
-  visit(document, {
-    OperationDefinition(node) {
-      if (node.name?.value === operationName) {
-        selectedOperation = node;
-      }
-    },
-    FragmentDefinition(node) {
-      fragments[node.name.value] = node;
+  /**
+   * Get all file paths that match the import patterns.
+   */
+  async getImportPatternFiles() {
+    if (this.context.patterns.length) {
+      return resolveFiles(this.context.srcDir, this.context.patterns, {
+        followSymbolicLinks: false
+      });
     }
-  });
-  if (!selectedOperation) {
-    throw new Error(`Operation named "${operationName}" not found`);
+    return [];
+  }
+  /**
+   * Initialise the collector.
+   */
+  async init() {
+    const files = await this.getImportPatternFiles();
+    for (const filePath of files) {
+      await this.addFile(filePath);
+    }
+    this.nuxtConfigDocuments.forEach((docString, i) => {
+      const pseudoPath = `nuxt.config.ts[${i}]`;
+      const file = new CollectedFile(pseudoPath, docString, false);
+      this.files.set(pseudoPath, file);
+      this.generator.add({
+        filePath: "~/nuxt.config.ts",
+        documentNode: file.parsed
+      });
+    });
+    this.buildState();
+  }
+  /**
+   * Add a file.
+   */
+  async addFile(filePath) {
+    const file = await CollectedFile.fromFilePath(filePath);
+    this.files.set(filePath, file);
+    this.generator.add({
+      filePath: this.filePathToRelative(filePath),
+      documentNode: file.parsed
+    });
+    return file;
   }
-  visit(selectedOperation, {
-    FragmentSpread(node) {
-      usedFragments.add(node.name.value);
+  async handleAdd(filePath) {
+    await this.addFile(filePath);
+    return true;
+  }
+  async handleChange(filePath) {
+    const file = this.files.get(filePath);
+    if (!file) {
+      return false;
     }
-  });
-  let hasNewFragments = true;
-  while (hasNewFragments) {
-    hasNewFragments = false;
-    for (const fragmentName of usedFragments) {
-      visit(fragments[fragmentName], {
-        FragmentSpread(node) {
-          if (!usedFragments.has(node.name.value)) {
-            usedFragments.add(node.name.value);
-            hasNewFragments = true;
-          }
+    const needsUpdate = await file.update();
+    if (!needsUpdate) {
+      return false;
+    }
+    this.generator.update({
+      filePath: this.filePathToRelative(filePath),
+      documentNode: file.parsed
+    });
+    return true;
+  }
+  handleUnlink(filePath) {
+    const file = this.files.get(filePath);
+    if (!file) {
+      return false;
+    }
+    this.files.delete(filePath);
+    this.generator.remove(this.filePathToRelative(filePath));
+    return true;
+  }
+  handleUnlinkDir(folderPath) {
+    let anyHasChanged = false;
+    for (const filePath of [...this.files.keys()]) {
+      if (filePath.startsWith(folderPath)) {
+        const hasChanged = this.handleUnlink(filePath);
+        if (hasChanged) {
+          anyHasChanged = true;
         }
-      });
+      }
     }
+    return anyHasChanged;
   }
-  return {
-    kind: Kind.DOCUMENT,
-    definitions: [
-      selectedOperation,
-      ...Array.from(usedFragments).map(
-        (fragmentName) => fragments[fragmentName]
-      )
-    ]
-  };
-}
-async function generate(options, schemaPath, resolver, rootDir, logEverything = false) {
-  const schemaContent = await promises.readFile(schemaPath).then((v) => v.toString());
-  const schema = await loadSchema(schemaContent, { loaders: [] });
-  const documents = await buildDocuments(
-    options.documents,
-    options.autoImportPatterns,
-    resolver,
-    !!options.autoInlineFragments
-  );
-  const validated = validateDocuments(schema, documents, rootDir);
-  const extracted = validated.filter(
-    (v) => !v.operation
-  );
-  for (let i = 0; i < validated.length; i++) {
-    const v = validated[i];
-    if (!v) {
-      continue;
-    }
-    if (v.isValid) {
-      try {
-        const node = parse(v.content);
-        oldVisit(node, {
-          enter: {
-            OperationDefinition: (node2) => {
-              if (node2.name?.value && node2.loc?.source && (node2.operation === "query" || node2.operation === "mutation")) {
-                const document = { ...v };
-                const cleaned = cleanGraphqlDocument(
-                  node2.loc.source.body,
-                  node2.name.value
-                );
-                const errors = validateGraphQlDocuments(schema, [cleaned]);
-                document.errors = document.errors || [];
-                document.errors.push(...errors);
-                document.isValid = !document.errors.length;
-                document.name = node2.name.value;
-                document.operation = node2.operation;
-                document.content = print(cleaned);
-                document.id = [
-                  document.operation,
-                  document.name,
-                  document.filename
-                ].filter(Boolean).join("_");
-                extracted.push(document);
-              }
-            }
-          }
-        });
-      } catch (e) {
-        logger.error(e);
-        extracted.push(v);
-        break;
+  /**
+   * Handle the watcher event for the given file path.
+   */
+  async handleWatchEvent(event, filePath) {
+    try {
+      let hasChanged = false;
+      if (event === "add") {
+        hasChanged = await this.handleAdd(filePath);
+      } else if (event === "change") {
+        hasChanged = await this.handleChange(filePath);
+      } else if (event === "unlink") {
+        hasChanged = this.handleUnlink(filePath);
+      } else if (event === "unlinkDir") {
+        hasChanged = this.handleUnlinkDir(filePath);
+      } else if (event === "addDir") {
+      }
+      if (hasChanged) {
+        this.buildState();
       }
-    } else {
-      extracted.push(v);
-      break;
+    } catch (e) {
+      this.generator.resetCaches();
+      console.log(e);
     }
   }
-  const templates = await generateTemplates(
-    extracted.filter((v) => v.isValid).map((v) => v.content),
-    schemaPath,
-    options
-  );
-  const hasErrors = extracted.some((v) => !v.isValid) || validated.some((v) => !v.isValid);
-  if (hasErrors || logEverything) {
-    logDocuments(logger, extracted, logEverything);
+  /**
+   * Get the TypeScript types template contents.
+   */
+  getTemplateTypes() {
+    return this.outputTypes;
   }
-  process.stdout.write("\n");
-  logger.restoreStd();
-  hasErrors ? logger.error("GraphQL code generation failed with errors.") : logger.success("Finished GraphQL code generation.");
-  return {
-    templates: templates.sort((a, b) => {
-      return a.filename.localeCompare(b.filename);
-    }),
-    hasErrors,
-    documents: extracted.sort((a, b) => {
-      const nameA = a.name || "";
-      const nameB = b.name || "";
-      return nameA.localeCompare(nameB);
-    })
-  };
-}
-const fileExists = (path, extensions = ["js", "ts", "mjs"]) => {
-  if (!path) {
-    return null;
-  } else if (existsSync$1(path)) {
-    return path;
+  /**
+   * Get the context template contents.
+   */
+  getTemplateContext() {
+    return this.outputContext;
   }
-  const extension = extensions.find(
-    (extension2) => existsSync$1(`${path}.${extension2}`)
-  );
-  return extension ? `${path}.${extension}` : null;
-};
-async function outputDocuments(outputPath, documents) {
-  await promises.mkdir(outputPath, { recursive: true });
-  documents.forEach((v) => {
-    if (v.operation && v.name) {
-      const fileName = [v.operation, v.name, "graphql"].join(".");
-      const filePath = resolve(outputPath, fileName);
-      promises.writeFile(filePath, v.content);
-    }
-  });
-}
-async function getOutputDocumentsPath(optionsOutputDocuments, nuxtBuildDir, resolvePath) {
-  if (!optionsOutputDocuments) {
-    return null;
+  /**
+   * Get the operations template contents.
+   */
+  getTemplateOperations() {
+    return this.outputOperations;
   }
-  if (typeof optionsOutputDocuments === "boolean") {
-    return resolve(nuxtBuildDir, `${name}/documents`);
-  } else {
-    return await resolvePath(optionsOutputDocuments);
+  /**
+   * Log results (including parse/validation errors).
+   */
+  logDocuments(logEverything) {
   }
 }
 
-function pathWithoutExtension(fullPath) {
-  const parsed = parse$1(fullPath);
-  return join(parsed.dir, parsed.name);
-}
 const RPC_NAMESPACE = "nuxt-graphql-middleware";
 const module = defineNuxtModule({
   meta: {
@@ -761,12 +564,14 @@ const module = defineNuxtModule({
   defaults: defaultOptions,
   async setup(passedOptions, nuxt) {
     const options = defu({}, passedOptions, defaultOptions);
+    function addAlias(name2, aliasPath) {
+      nuxt.options.alias[name2] = aliasPath;
+    }
     const isModuleBuild = process.env.MODULE_BUILD === "true" && nuxt.options._prepare;
     if (isModuleBuild) {
       options.graphqlEndpoint = "http://localhost";
       options.downloadSchema = false;
       options.schemaPath = "~~/schema.graphql";
-      options.autoInlineFragments = true;
       options.autoImportPatterns = [
         "~~/playground/**/*.{gql,graphql}",
         "!node_modules"
@@ -783,37 +588,47 @@ const module = defineNuxtModule({
     if (!nuxt.options._prepare) {
       validateOptions(options);
     }
-    const schemaPathReplaced = resolveAlias(options.schemaPath);
     const moduleResolver = createResolver(import.meta.url);
     const serverResolver = createResolver(nuxt.options.serverDir);
     const srcResolver = createResolver(nuxt.options.srcDir);
     const appResolver = createResolver(nuxt.options.dir.app);
     const rootDir = nuxt.options.rootDir;
     const rootResolver = createResolver(rootDir);
-    const schemaPath = await getSchemaPath(
-      schemaPathReplaced,
+    const { schemaPath, schemaContent } = await getSchemaPath(
+      resolveAlias(options.schemaPath),
       options,
       rootResolver.resolve,
       options.downloadSchema
     );
+    const schema = await loadSchema(schemaContent, {
+      loaders: []
+    });
     const runtimeDir = fileURLToPath(new URL("./runtime", import.meta.url));
     nuxt.options.build.transpile.push(runtimeDir);
-    const ctx = {
-      templates: [],
-      documents: []
+    const context = {
+      patterns: options.autoImportPatterns || [],
+      srcDir: nuxt.options.srcDir,
+      schemaPath,
+      serverApiPrefix: options.serverApiPrefix
     };
-    let rpc = null;
+    const collector = new Collector(
+      schema,
+      context,
+      options.documents,
+      options.codegenConfig
+    );
+    await collector.init();
     if (options.devtools) {
       const clientPath = moduleResolver.resolve("./client");
       setupDevToolsUI(nuxt, clientPath);
       const setupRpc = () => {
-        rpc = extendServerRpc(RPC_NAMESPACE, {
+        extendServerRpc(RPC_NAMESPACE, {
           // register server RPC functions
           getModuleOptions() {
             return options;
           },
           getDocuments() {
-            return ctx.documents;
+            return [];
           }
         });
       };
@@ -825,70 +640,6 @@ const module = defineNuxtModule({
         });
       }
     }
-    let prompt = null;
-    const generateHandler = async (isFirst = false) => {
-      if (prompt && prompt.ui) {
-        prompt.ui.close();
-        prompt = null;
-      }
-      try {
-        const { templates, hasErrors, documents } = await generate(
-          options,
-          schemaPath,
-          rootResolver.resolve,
-          rootDir,
-          isFirst
-        );
-        ctx.templates = templates;
-        ctx.documents = documents;
-        rpc?.broadcast.documentsUpdated(documents);
-        const outputDocumentsPath = await getOutputDocumentsPath(
-          options.outputDocuments,
-          nuxt.options.buildDir,
-          rootResolver.resolvePath
-        );
-        if (outputDocumentsPath) {
-          outputDocuments(outputDocumentsPath, documents);
-          if (isFirst) {
-            logger.info("Documents generated at " + outputDocumentsPath);
-          }
-        }
-        if (hasErrors) {
-          throw new Error("Documents has errors.");
-        }
-      } catch (e) {
-        console.log(e);
-        logger.error("Failed to generate GraphQL files.");
-        if (isFirst) {
-          process.exit(1);
-        }
-        if (!options.downloadSchema) {
-          return;
-        }
-        if (!nuxt.options.dev) {
-          return;
-        }
-        process.stdout.write("\n");
-        logger.restoreStd();
-        prompt = inquirer.prompt({
-          type: "confirm",
-          name: "accept",
-          message: "Do you want to reload the GraphQL schema?"
-        });
-        prompt.then(async ({ accept }) => {
-          if (accept) {
-            await getSchemaPath(
-              schemaPathReplaced,
-              options,
-              rootResolver.resolve,
-              true
-            );
-            await generateHandler();
-          }
-        });
-      }
-    };
-    await generateHandler(true);
     nuxt.options.runtimeConfig.public["nuxt-graphql-middleware"] = {
       serverApiPrefix: options.serverApiPrefix
     };
@@ -925,32 +676,27 @@ const module = defineNuxtModule({
       );
       addServerImports(serverUtils);
     }
-    Object.values(GraphqlMiddlewareTemplate).forEach((filename) => {
-      const result = addTemplate({
-        write: true,
-        filename,
-        options: {
-          nuxtGraphqlMiddleware: true
-        },
-        getContents: () => {
-          return ctx.templates.find((v) => v.filename === filename)?.content || "";
-        }
-      });
-      if (result.dst.includes(GraphqlMiddlewareTemplate.Documents)) {
-        nuxt.options.alias["#graphql-documents"] = pathWithoutExtension(
-          result.dst
-        );
-      } else if (result.dst.includes(GraphqlMiddlewareTemplate.OperationTypes)) {
-        nuxt.options.alias["#graphql-operations"] = pathWithoutExtension(
-          result.dst
-        );
-      } else if (result.dst.includes(GraphqlMiddlewareTemplate.ComposableContext)) {
-        nuxt.options.alias["#nuxt-graphql-middleware/generated-types"] = pathWithoutExtension(result.dst);
-      }
+    const templateTypescript = addTemplate({
+      filename: GraphqlMiddlewareTemplate.OperationTypes,
+      write: true,
+      getContents: () => collector.getTemplateTypes()
+    });
+    addAlias("#graphql-operations", templateTypescript.dst);
+    const templateDocuments = addTemplate({
+      filename: GraphqlMiddlewareTemplate.Documents,
+      write: true,
+      getContents: () => collector.getTemplateOperations()
+    });
+    addAlias("#graphql-documents", templateDocuments.dst);
+    const templateContext = addTemplate({
+      filename: GraphqlMiddlewareTemplate.ComposableContext,
+      write: true,
+      getContents: () => collector.getTemplateContext()
     });
+    addAlias("#nuxt-graphql-middleware/generated-types", templateContext.dst);
     addTemplate({
       write: true,
-      filename: "graphql-documents.d.ts",
+      filename: "nuxt-graphql-middleware/graphql-documents.d.ts",
       getContents: () => {
         return `
 import type {
@@ -959,12 +705,12 @@ import type {
 } from '#nuxt-graphql-middleware/generated-types'
 
 declare module '#graphql-documents' {
-  type Documents = {
+  type Operations = {
     query: GraphqlMiddlewareQuery
     mutation: GraphqlMiddlewareMutation
   }
-  const documents: Documents
-  export { documents, Documents }
+  const operations: Operations
+  export { operations, Operations }
 }
 `;
       }
@@ -1075,12 +821,14 @@ export type GraphqlClientContext = {}
 `;
       }
     });
-    nuxt.options.alias["#graphql-middleware-client-options"] = pathWithoutExtension(clientOptionsTemplate.dst);
+    addAlias("#graphql-middleware-client-options", clientOptionsTemplate.dst);
     nuxt.options.nitro.externals = nuxt.options.nitro.externals || {};
     nuxt.options.nitro.externals.inline = nuxt.options.nitro.externals.inline || [];
     nuxt.options.nitro.externals.inline.push(template.dst);
-    nuxt.options.alias["#graphql-middleware-server-options-build"] = pathWithoutExtension(template.dst);
-    nuxt.options.alias["#graphql-middleware/types"] = pathWithoutExtension(
+    nuxt.options.nitro.externals.inline.push(templateDocuments.dst);
+    addAlias("#graphql-middleware-server-options-build", template.dst);
+    addAlias(
+      "#graphql-middleware/types",
       moduleResolver.resolve("./runtime/types.ts")
     );
     addServerHandler({
@@ -1109,26 +857,14 @@ export type GraphqlClientContext = {}
         handler: moduleResolver.resolve("./runtime/serverHandler/debug"),
         route: options.serverApiPrefix + "/debug"
       });
-      nuxt.hook("nitro:build:before", (nitro) => {
-        nuxt.hook("builder:watch", async (_event, path) => {
-          path = relative(
-            nuxt.options.srcDir,
-            resolve(nuxt.options.srcDir, path)
-          );
-          if (!path.match(/\.(gql|graphql)$/)) {
-            return;
-          }
-          if (schemaPath.includes(path)) {
-            return;
-          }
-          await generateHandler();
-          await updateTemplates({
-            filter: (template2) => {
-              return template2.options && template2.options.nuxtGraphqlMiddleware;
-            }
-          });
-          await nitro.hooks.callHook("dev:reload");
-        });
+      nuxt.hook("builder:watch", async (event, pathAbsolute) => {
+        if (pathAbsolute === schemaPath) {
+          return;
+        }
+        if (!pathAbsolute.match(/\.(gql|graphql)$/)) {
+          return;
+        }
+        await collector.handleWatchEvent(event, pathAbsolute);
       });
     }
   }