nuxt-graphql-middleware 5.0.0-alpha.5 → 5.0.0-alpha.7

package/dist/module.mjs

@@ -1,92 +1,25 @@
-import { loadSchema } from '@graphql-tools/load';
 import { fileURLToPath } from 'url';
-import { relative } from 'pathe';
-import { defu } from 'defu';
-import { useLogger, resolveFiles, defineNuxtModule, resolveAlias, createResolver, addImports, addServerImports, addTypeTemplate, 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 { useLogger, addTemplate, addServerTemplate, addTypeTemplate, resolveAlias, createResolver, resolveFiles, addPlugin, addServerHandler, addImports, addServerImports, useNitro, defineNuxtModule } from '@nuxt/kit';
 import fs from 'node:fs/promises';
-import { existsSync as existsSync$1, promises } from 'node:fs';
-import { generate } from '@graphql-codegen/cli';
-import * as PluginSchemaAst from '@graphql-codegen/schema-ast';
+import { existsSync, promises } from 'node:fs';
+import { relative } from 'pathe';
 import { basename } from 'node:path';
-import { printSourceLocation, parse, OperationTypeNode, Source } from 'graphql';
+import { printSourceLocation, parse, Source, OperationTypeNode } from 'graphql';
 import { Generator, FieldNotFoundError, TypeNotFoundError, FragmentNotFoundError } from 'graphql-typescript-deluxe';
-import colors from 'picocolors';
+import color from 'picocolors';
 import { validateGraphQlDocuments } from '@graphql-tools/utils';
+import { generate } from '@graphql-codegen/cli';
+import * as PluginSchemaAst from '@graphql-codegen/schema-ast';
+import { loadSchema } from '@graphql-tools/load';
+import { defu } from 'defu';
+import * as micromatch from 'micromatch';
+import { ConfirmPrompt } from '@clack/core';
+import isUnicodeSupported from 'is-unicode-supported';
+import { existsSync as existsSync$1 } from 'fs';
+import { onDevToolsInitialized, extendServerRpc } from '@nuxt/devtools-kit';
 
 const name = "nuxt-graphql-middleware";
-const version = "5.0.0-alpha.5";
-
-const DEVTOOLS_UI_ROUTE = "/__nuxt-graphql-middleware";
-const DEVTOOLS_UI_LOCAL_PORT = 3300;
-function setupDevToolsUI(nuxt, clientPath) {
-  const isProductionBuild = existsSync(clientPath);
-  if (isProductionBuild) {
-    nuxt.hook("vite:serverCreated", async (server) => {
-      const sirv = await import('sirv').then((r) => r.default || r);
-      server.middlewares.use(
-        DEVTOOLS_UI_ROUTE,
-        sirv(clientPath, { dev: true, single: true })
-      );
-    });
-  } else {
-    nuxt.hook("vite:extendConfig", (config) => {
-      config.server = config.server || {};
-      config.server.proxy = config.server.proxy || {};
-      config.server.proxy[DEVTOOLS_UI_ROUTE] = {
-        target: "http://localhost:" + DEVTOOLS_UI_LOCAL_PORT + DEVTOOLS_UI_ROUTE,
-        changeOrigin: true,
-        followRedirects: true,
-        rewrite: (path) => path.replace(DEVTOOLS_UI_ROUTE, "")
-      };
-    });
-  }
-  nuxt.hook("devtools:customTabs", (tabs) => {
-    tabs.push({
-      // unique identifier
-      name: "nuxt-graphql-middleware",
-      // title to display in the tab
-      title: "GraphQL Middleware",
-      // any icon from Iconify, or a URL to an image
-      icon: "akar-icons:graphql-fill",
-      // iframe view
-      view: {
-        type: "iframe",
-        src: DEVTOOLS_UI_ROUTE
-      }
-    });
-  });
-}
-
-function pluginLoader(name) {
-  switch (name) {
-    case "@graphql-codegen/schema-ast":
-      return Promise.resolve(PluginSchemaAst);
-  }
-  throw new Error(`graphql-codegen plugin not found: ${name}`);
-}
-function generateSchema(moduleOptions, dest, writeToDisk) {
-  const pluginConfig = moduleOptions.codegenSchemaConfig?.urlSchemaOptions;
-  const schemaAstConfig = moduleOptions.codegenSchemaConfig?.schemaAstConfig || {
-    sort: true
-  };
-  const config = {
-    schema: moduleOptions.graphqlEndpoint,
-    pluginLoader,
-    silent: true,
-    errorsOnly: true,
-    config: pluginConfig,
-    generates: {
-      [dest]: {
-        plugins: ["schema-ast"],
-        config: schemaAstConfig
-      }
-    }
-  };
-  return generate(config, writeToDisk).then((v) => v[0]);
-}
+const version = "5.0.0-alpha.7";
 
 const logger = useLogger(name);
 const defaultOptions = {
@@ -98,59 +31,26 @@ const defaultOptions = {
   includeComposables: true,
   documents: [],
   devtools: true,
-  errorOverlay: true
+  errorOverlay: true,
+  graphqlConfigFilePath: "./graphql.config.ts"
 };
 function validateOptions(options) {
   if (!options.graphqlEndpoint) {
     throw new Error("Missing graphqlEndpoint.");
   }
 }
-async function getSchemaPath(schemaPath, options, resolver, writeToDisk = false) {
-  const dest = resolver(schemaPath);
-  if (!options.downloadSchema) {
-    const fileExists2 = await fs.access(dest).then(() => true).catch(() => false);
-    if (!fileExists2) {
-      logger.error(
-        '"downloadSchema" is set to false but no schema exists at ' + dest
-      );
-      throw new Error("Missing GraphQL schema.");
-    }
-    const schemaContent = await fs.readFile(dest).then((v) => v.toString());
-    return { schemaPath, schemaContent };
-  }
-  if (!options.graphqlEndpoint) {
-    throw new Error("Missing graphqlEndpoint config.");
-  }
-  const result = await generateSchema(options, dest, writeToDisk);
-  return { schemaPath, schemaContent: result.content };
-}
 const fileExists = (path, extensions = ["js", "ts", "mjs"]) => {
   if (!path) {
     return null;
-  } else if (existsSync$1(path)) {
+  } else if (existsSync(path)) {
     return path;
   }
   const extension = extensions.find(
-    (extension2) => existsSync$1(`${path}.${extension2}`)
+    (extension2) => existsSync(`${path}.${extension2}`)
   );
   return extension ? `${path}.${extension}` : null;
 };
 
-function generateResponseTypeTemplate(operations, context) {
-  const allTypes = operations.map((v) => v.typeName).sort();
-  return `import type {
-  ${allTypes.join(",\n  ")}
-} from './../graphql-operations'
-import type { GraphqlResponseAdditions } from './server-options'
-import type { GraphqlServerResponse } from '${context.runtimeTypesPath}'
-
-export type GraphqlMiddlewareResponseUnion =
-  | ${allTypes.join("\n  | ") || "never"}
-
-export type GraphqlResponse<T> = GraphqlServerResponse<T> & GraphqlResponseAdditions
-export type GraphqlResponseTyped = GraphqlResponse<GraphqlMiddlewareResponseUnion>`;
-}
-
 const SYMBOL_CROSS = "x";
 const SYMBOL_CHECK = "\u2714";
 function getMaxLengths(entries) {
@@ -175,11 +75,11 @@ function logAllEntries(entries) {
   let prevHadError = false;
   for (const entry of entries) {
     const hasErrors = entry.errors.length > 0;
-    const icon = hasErrors ? colors.red(SYMBOL_CROSS) : colors.green(SYMBOL_CHECK);
+    const icon = hasErrors ? color.red(SYMBOL_CROSS) : color.green(SYMBOL_CHECK);
     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);
+    const namePadded = color.bold(entry.name.padEnd(lengths.name));
+    const name = hasErrors ? color.red(namePadded) : color.green(namePadded);
+    const path = color.dim(entry.path);
     const parts = [icon, type, name, path];
     if (hasErrors && !prevHadError) {
       process.stdout.write("-".repeat(process.stdout.columns) + "\n");
@@ -188,10 +88,10 @@ function logAllEntries(entries) {
     if (hasErrors) {
       const errorLines = [];
       entry.errors.forEach((error) => {
-        let output = colors.red(error.message);
+        let output = color.red(error.message);
         if (error.source && error.locations) {
           for (const location of error.locations) {
-            output += "\n\n" + colors.red(printSourceLocation(error.source, location));
+            output += "\n\n" + color.red(printSourceLocation(error.source, location));
           }
         }
         errorLines.push(output);
@@ -238,51 +138,11 @@ class CollectedFile {
   }
 }
 
-function generateNitroTypes(operations, serverApiPrefix) {
-  const endpoints = [];
-  const imports = [];
-  for (const operation of operations) {
-    imports.push(operation.typeName);
-    const method = operation.operationType === OperationTypeNode.QUERY ? "get" : "post";
-    endpoints.push(
-      `    '${serverApiPrefix}/${operation.operationType}/${operation.graphqlName}': {
-      '${method}': GraphqlResponse<${operation.typeName}>
-    }`
-    );
-  }
-  return `import type { GraphqlResponse } from './response'
-import type {
-  ${imports.sort().join(",\n  ")}
-} from './../graphql-operations'
-
-declare module 'nitropack/types' {
-  interface InternalApi {
-${endpoints.sort().join("\n")}
-  }
-}`;
-}
-
-function generateSourcesTemplate(operations, srcDir) {
-  const lines = [];
-  for (const operation of operations) {
-    const filePath = relative(srcDir, operation.filePath);
-    lines.push(
-      `${operation.operationType}_${operation.graphqlName}: '${filePath}',`
-    );
-  }
-  return `
-export const operationSources = {
-  ${lines.join("\n  ")}
-}
-`;
-}
-
 class Collector {
-  constructor(schema, context, nuxtConfigDocuments = [], generatorOptions = {}) {
+  constructor(schema, helper) {
     this.schema = schema;
-    this.context = context;
-    this.nuxtConfigDocuments = nuxtConfigDocuments;
-    const mappedOptions = { ...generatorOptions };
+    this.helper = helper;
+    const mappedOptions = { ...helper.options.codegenConfig };
     if (!mappedOptions.output) {
       mappedOptions.output = {};
     }
@@ -310,35 +170,27 @@ class Collector {
    */
   rpcItems = /* @__PURE__ */ new Map();
   /**
-   * The generated TypeScript type template output.
-   */
-  outputTypes = "";
-  /**
-   * The generated TypeScript enum template output.
-   */
-  outputEnums = "";
-  /**
-   * The generated oeprations file.
-   */
-  outputOperations = "";
-  /**
-   * The generated oepration types file.
+   * The registered templates.
    */
-  outputOperationTypes = "";
+  templates = [];
   /**
-   * The generated context template file.
+   * The generated template contents.
    */
-  outputResponseTypes = "";
-  /**
-   * The generated nitro template file.
-   */
-  outputNitroTypes = "";
-  /**
-   * The generated nitro template file.
-   */
-  outputSources = "";
+  templateResult = /* @__PURE__ */ new Map();
+  async reset() {
+    this.files.clear();
+    this.generator.reset();
+    this.operationTimestamps.clear();
+    this.rpcItems.clear();
+  }
+  async updateSchema(schema) {
+    this.schema = schema;
+    this.generator.updateSchema(schema);
+    await this.reset();
+    await this.initDocuments();
+  }
   filePathToBuildRelative(filePath) {
-    return "./" + relative(this.context.buildDir, filePath);
+    return "./" + this.helper.toBuildRelative(filePath);
   }
   filePathToSourceRelative(filePath) {
     return "./" + relative(process.cwd(), filePath);
@@ -351,16 +203,12 @@ class Collector {
       errors
     };
   }
-  buildOutputTypes(file) {
-    let output = "";
-    const enumImports = file.getTypeScriptEnumDependencies();
-    if (enumImports.length) {
-      output += `import type { ${enumImports.join(", ")} } from './enums'
-
-`;
+  getTemplate(template) {
+    const content = this.templateResult.get(template);
+    if (content === void 0) {
+      throw new Error(`Missing template content: ${template}`);
     }
-    output += file.getSource();
-    return output;
+    return content;
   }
   /**
    * Executes code gen and performs validation for operations.
@@ -369,27 +217,22 @@ class Collector {
     const output = this.generator.build();
     const operations = output.getCollectedOperations();
     const generatedCode = output.getGeneratedCode();
-    this.outputOperations = output.getOperationsFile({
-      exportName: "documents",
-      minify: !this.context.isDev
-    }).getSource();
-    this.outputOperationTypes = output.getOperationTypesFile({
-      importFrom: "./../graphql-operations"
-    }).getSource();
-    this.outputEnums = output.buildFile(["enum"]).getSource();
-    this.outputTypes = this.buildOutputTypes(output.getTypes());
-    this.outputResponseTypes = generateResponseTypeTemplate(
-      operations,
-      this.context
-    );
-    this.outputNitroTypes = generateNitroTypes(
-      operations,
-      this.context.serverApiPrefix
-    );
-    this.outputSources = generateSourcesTemplate(
-      operations,
-      this.context.rootDir
-    );
+    this.templates.forEach((template) => {
+      if (template.build) {
+        const filename = template.options.path + ".js";
+        this.templateResult.set(
+          filename,
+          template.build(output, this.helper).trim()
+        );
+      }
+      if (template.buildTypes) {
+        const filename = template.options.path + ".d.ts";
+        this.templateResult.set(
+          filename,
+          template.buildTypes(output, this.helper).trim()
+        );
+      }
+    });
     const fragmentMap = /* @__PURE__ */ new Map();
     const operationSourceMap = /* @__PURE__ */ new Map();
     for (const code of generatedCode) {
@@ -418,7 +261,7 @@ class Collector {
       } else {
         this.operationTimestamps.set(operation.graphqlName, operation.timestamp);
       }
-      const shouldLog = errors.length || !this.context.logOnlyErrors;
+      const shouldLog = errors.length || !this.helper.options.logOnlyErrors;
       if (shouldLog) {
         logEntries.push(this.operationToLogEntry(operation, errors));
       }
@@ -427,21 +270,23 @@ class Collector {
     if (hasErrors) {
       throw new Error("GraphQL errors");
     }
-    for (const code of generatedCode) {
-      const id = `${code.identifier}_${code.graphqlName}`;
-      if (code.identifier === "fragment" || code.identifier === "mutation" || code.identifier === "query") {
-        if (this.rpcItems.get(id)?.timestamp === code.timestamp) {
-          continue;
+    if (this.helper.isDev) {
+      for (const code of generatedCode) {
+        const id = `${code.identifier}_${code.graphqlName}`;
+        if (code.identifier === "fragment" || code.identifier === "mutation" || code.identifier === "query") {
+          if (this.rpcItems.get(id)?.timestamp === code.timestamp) {
+            continue;
+          }
+          const fragmentDepdendencies = code.getGraphQLFragmentDependencies().map((name) => fragmentMap.get(name) || "").join("\n\n");
+          this.rpcItems.set(id, {
+            id,
+            timestamp: code.timestamp,
+            source: code.source + "\n\n" + fragmentDepdendencies,
+            name: code.graphqlName,
+            filePath: code.filePath,
+            identifier: code.identifier
+          });
         }
-        const fragmentDepdendencies = code.getGraphQLFragmentDependencies().map((name) => fragmentMap.get(name) || "").join("\n\n");
-        this.rpcItems.set(id, {
-          id,
-          timestamp: code.timestamp,
-          source: code.source + "\n\n" + fragmentDepdendencies,
-          name: code.graphqlName,
-          filePath: code.filePath,
-          identifier: code.identifier
-        });
       }
     }
   }
@@ -466,31 +311,45 @@ class Collector {
   logError(error) {
     let output = `${SYMBOL_CROSS}`;
     output += this.buildErrorMessage(error);
-    logger.error(colors.red(output));
+    logger.error(color.red(output));
   }
   /**
-   * Get all file paths that match the import patterns.
+   * Initialise the collector.
+   *
+   * In dev mode, the method will call itself recursively until all documents
+   * are valid.
+   *
+   * If not in dev mode the method will throw an error when documents are not
+   * valid.
    */
-  async getImportPatternFiles() {
-    if (this.context.patterns.length) {
-      return resolveFiles(this.context.srcDir, this.context.patterns, {
-        followSymbolicLinks: false
-      });
+  async init() {
+    try {
+      await this.initDocuments();
+    } catch (e) {
+      if (this.helper.isDev) {
+        const shouldRevalidate = await this.helper.prompt.confirm(
+          "Do you want to revalidate the GraphQL documents?"
+        );
+        if (shouldRevalidate === "yes") {
+          await this.reset();
+          return this.init();
+        }
+      }
+      throw new Error("Graphql document validation failed.");
     }
-    return [];
   }
   /**
    * Initialise the collector.
    */
-  async init() {
+  async initDocuments() {
     try {
-      const files = await this.getImportPatternFiles();
+      const files = await this.helper.getImportPatternFiles();
       for (const filePath of files) {
         await this.addFile(filePath);
       }
-      const nuxtConfigDocuments = this.nuxtConfigDocuments.join("\n\n");
+      const nuxtConfigDocuments = this.helper.options.documents.join("\n\n");
       if (nuxtConfigDocuments.length) {
-        const filePath = this.context.nuxtConfigPath;
+        const filePath = this.helper.paths.nuxtConfig;
         const file = new CollectedFile(filePath, nuxtConfigDocuments, false);
         this.files.set(filePath, file);
         this.generator.add({
@@ -510,6 +369,9 @@ class Collector {
    */
   async addFile(filePath) {
     const file = await CollectedFile.fromFilePath(filePath);
+    if (!file.fileContents) {
+      return null;
+    }
     this.files.set(filePath, file);
     this.generator.add({
       filePath,
@@ -518,26 +380,32 @@ class Collector {
     return file;
   }
   async handleAdd(filePath) {
-    const matching = await this.getImportPatternFiles();
-    if (!matching.includes(filePath)) {
+    if (!this.helper.matchesImportPattern(filePath)) {
       return false;
     }
-    await this.addFile(filePath);
-    return true;
+    const result = await this.addFile(filePath);
+    return !!result;
   }
   async handleChange(filePath) {
+    if (!this.helper.matchesImportPattern(filePath)) {
+      return false;
+    }
     const file = this.files.get(filePath);
     if (!file) {
-      return false;
+      return this.handleAdd(filePath);
     }
-    const needsUpdate = await file.update();
-    if (!needsUpdate) {
-      return false;
+    try {
+      const needsUpdate = await file.update();
+      if (!needsUpdate) {
+        return false;
+      }
+      this.generator.update({
+        filePath,
+        documentNode: file.parsed
+      });
+    } catch {
+      return this.handleUnlink(filePath);
     }
-    this.generator.update({
-      filePath,
-      documentNode: file.parsed
-    });
     return true;
   }
   handleUnlink(filePath) {
@@ -566,6 +434,7 @@ class Collector {
    */
   async handleWatchEvent(event, filePath) {
     let hasChanged = false;
+    const oldOperationTimestamps = new Map(this.operationTimestamps);
     try {
       if (event === "add") {
         hasChanged = await this.handleAdd(filePath);
@@ -575,7 +444,6 @@ class Collector {
         hasChanged = this.handleUnlink(filePath);
       } else if (event === "unlinkDir") {
         hasChanged = this.handleUnlinkDir(filePath);
-      } else if (event === "addDir") {
       }
       if (hasChanged) {
         this.buildState();
@@ -586,327 +454,700 @@ class Collector {
       this.logError(e);
       return {
         hasChanged: false,
+        affectedOperations: [],
         error: { message: this.buildErrorMessage(e) }
       };
     }
+    const affectedOperations = [];
     if (hasChanged) {
       logger.success("Finished GraphQL code update successfully.");
+      for (const [name, newTimestamp] of this.operationTimestamps) {
+        const oldTimestamp = oldOperationTimestamps.get(name);
+        if (!oldTimestamp || oldTimestamp !== newTimestamp) {
+          affectedOperations.push(name);
+        }
+      }
     }
-    return { hasChanged };
+    return { hasChanged, affectedOperations };
+  }
+  /**
+   * Adds a virtual template (not written to disk) for both Nuxt and Nitro.
+   *
+   * For some reason a template written to disk works for both Nuxt and Nitro,
+   * but a virtual template requires adding two templates.
+   */
+  addVirtualTemplate(template) {
+    const filename = template.options.path + ".js";
+    const getContents = () => this.getTemplate(filename);
+    addTemplate({
+      filename,
+      getContents
+    });
+    addServerTemplate({
+      // Since this is a virtual template, the name must match the final
+      // alias, example:
+      // - nuxt-graphql-middleware/foobar.mjs => #nuxt-graphql-middleware/foobar
+      //
+      // That way we can reference the same template using the alias in both
+      // Nuxt and Nitro environments.
+      filename: "#" + template.options.path,
+      getContents
+    });
   }
   /**
-   * Get the TypeScript types template contents.
+   * Adds a template that dependes on Collector state.
    */
-  getTemplateTypes() {
-    return this.outputTypes;
+  addTemplate(template) {
+    this.templates.push(template);
+    if (template.build) {
+      if (template.options.virtual) {
+        this.addVirtualTemplate(template);
+      } else {
+        const filename = template.options.path + ".js";
+        addTemplate({
+          filename,
+          write: true,
+          getContents: () => this.getTemplate(filename)
+        });
+      }
+    }
+    if (template.buildTypes) {
+      const filename = template.options.path + ".d.ts";
+      addTypeTemplate(
+        {
+          filename,
+          write: true,
+          getContents: () => this.getTemplate(filename)
+        },
+        {
+          nuxt: true,
+          nitro: true
+        }
+      );
+    }
+  }
+}
+
+class SchemaProvider {
+  constructor(helper) {
+    this.helper = helper;
   }
   /**
-   * Get the TypeScript Enums template contents.
+   * The raw schema content.
    */
-  getTemplateEnums() {
-    return this.outputEnums;
+  schemaContent = "";
+  /**
+   * The parsed schema object.
+   */
+  schema = null;
+  async init() {
+    try {
+      await this.loadSchema();
+    } catch (error) {
+      logger.error(error);
+      const hasLoaded = await this.loadFromDiskFallback();
+      if (!hasLoaded) {
+        throw new Error("Failed to load GraphQL schema.");
+      }
+    }
+  }
+  async loadFromDiskFallback() {
+    const hasSchemaOnDisk = await this.hasSchemaOnDisk();
+    if (this.helper.isDev && hasSchemaOnDisk && this.helper.options.downloadSchema) {
+      const shouldUseFromDisk = await this.helper.prompt.confirm(
+        "Do you want to continue with the previously downloaded schema from disk?"
+      );
+      if (shouldUseFromDisk === "yes") {
+        await this.loadSchema({ forceDisk: true });
+        return true;
+      }
+    }
+    return false;
   }
   /**
-   * Get the context template contents.
+   * Loads the schema from disk.
+   *
+   * @returns The schema contents from disk.
    */
-  getTemplateResponseTypes() {
-    return this.outputResponseTypes;
+  async loadSchemaFromDisk() {
+    const fileExists = await this.hasSchemaOnDisk();
+    if (!fileExists) {
+      logger.error(
+        '"downloadSchema" is set to false but no schema exists at ' + this.helper.paths.schema
+      );
+      throw new Error("Missing GraphQL schema.");
+    }
+    logger.info(`Loading GraphQL schema from disk: ${this.helper.paths.schema}`);
+    return await fs.readFile(this.helper.paths.schema).then((v) => v.toString());
   }
   /**
-   * Get the operations template contents.
+   * Downloads the schema and saves it to disk.
+   *
+   * @returns The schema contents.
    */
-  getTemplateOperations() {
-    return this.outputOperations;
+  downloadSchema() {
+    const endpoint = this.helper.options.graphqlEndpoint;
+    if (!endpoint) {
+      throw new Error("Missing graphqlEndpoint config.");
+    }
+    const pluginConfig = this.helper.options.codegenSchemaConfig?.urlSchemaOptions;
+    const schemaAstConfig = this.helper.options.codegenSchemaConfig?.schemaAstConfig || {
+      sort: true
+    };
+    const config = {
+      schema: endpoint,
+      pluginLoader: (name) => {
+        switch (name) {
+          case "@graphql-codegen/schema-ast":
+            return Promise.resolve(PluginSchemaAst);
+        }
+        throw new Error(`graphql-codegen plugin not found: ${name}`);
+      },
+      silent: true,
+      errorsOnly: true,
+      config: pluginConfig,
+      generates: {
+        [this.helper.paths.schema]: {
+          plugins: ["schema-ast"],
+          config: schemaAstConfig
+        }
+      }
+    };
+    logger.info(`Downloading GraphQL schema from "${endpoint}".`);
+    return generate(config, true).then((v) => v[0]?.content);
   }
   /**
-   * Get the operation types template contents.
+   * Determine if the schema exists on disk.
+   *
+   * @returns True if the schema file exists on disk.
    */
-  getTemplateOperationTypes() {
-    return this.outputOperationTypes;
+  hasSchemaOnDisk() {
+    return fs.access(this.helper.paths.schema).then(() => true).catch(() => false);
   }
   /**
-   * Get the nitro types template contents.
+   * Load the schema either from disk or by downloading it.
+   *
+   * @param forceDownload - Forces downloading the schema.
    */
-  getTemplateNitroTypes() {
-    return this.outputNitroTypes;
+  async loadSchema(opts) {
+    if (opts?.forceDisk) {
+      this.schemaContent = await this.loadSchemaFromDisk();
+    } else if (this.helper.options.downloadSchema || opts?.forceDownload) {
+      this.schemaContent = await this.downloadSchema();
+    } else {
+      this.schemaContent = await this.loadSchemaFromDisk();
+    }
+    this.schema = await loadSchema(this.schemaContent, {
+      loaders: []
+    });
   }
   /**
-   * Get the nitro types template contents.
+   * Get the schema.
+   *
+   * @returns The parsed GraphQL schema object.
    */
-  getTemplateSources() {
-    return this.outputSources;
+  getSchema() {
+    if (!this.schema) {
+      throw new Error("Failed to load schema.");
+    }
+    return this.schema;
   }
 }
 
-function generateDocumentTypesTemplate() {
-  return `
-import type { Query, Mutation } from './operations'
-
-declare module '#nuxt-graphql-middleware/documents' {
-  export type Documents = {
-    query: Record<keyof Query, string>
-    mutation: Record<keyof Mutation, string>
+const unicode = isUnicodeSupported();
+const s = (c, fallback) => unicode ? c : fallback;
+const S_BAR = s("\u2502", "|");
+const S_STEP_ACTIVE = s("\u25C6", "*");
+const S_STEP_CANCEL = s("\u25A0", "x");
+const S_STEP_ERROR = s("\u25B2", "x");
+const S_STEP_SUBMIT = s("\u25C7", "o");
+const S_RADIO_ACTIVE = s("\u25CF", ">");
+const S_RADIO_INACTIVE = s("\u25CB", " ");
+const S_BAR_END = s("\u2514", "\u2014");
+const symbol = (state) => {
+  switch (state) {
+    case "initial":
+    case "active":
+      return color.cyan(S_STEP_ACTIVE);
+    case "cancel":
+      return color.red(S_STEP_CANCEL);
+    case "error":
+      return color.yellow(S_STEP_ERROR);
+    case "submit":
+      return color.green(S_STEP_SUBMIT);
   }
-  export const documents: Documents
-}`;
-}
-
-function useViteWebSocket(nuxt) {
-  return new Promise((resolve) => {
-    nuxt.hooks.hook("vite:serverCreated", (viteServer) => {
-      resolve(viteServer.ws);
+};
+class ConsolePrompt {
+  abortController = null;
+  confirm(message) {
+    this.abort();
+    this.abortController = new AbortController();
+    const active = "Yes";
+    const inactive = "No";
+    return new ConfirmPrompt({
+      active,
+      inactive,
+      initialValue: true,
+      signal: this.abortController.signal,
+      render() {
+        const title = `${color.gray(S_BAR)}
+${symbol(this.state)}  ${message}
+`;
+        const value = this.value ? active : inactive;
+        switch (this.state) {
+          case "submit":
+            return `${title}${color.gray(S_BAR)}  ${color.dim(value)}`;
+          case "cancel":
+            return `${title}${color.gray(S_BAR)}  ${color.strikethrough(
+              color.dim(value)
+            )}
+${color.gray(S_BAR)}`;
+          default: {
+            return `${title}${color.cyan(S_BAR)}  ${this.value ? `${color.green(S_RADIO_ACTIVE)} ${active}` : `${color.dim(S_RADIO_INACTIVE)} ${color.dim(active)}`} ${color.dim("/")} ${!this.value ? `${color.green(S_RADIO_ACTIVE)} ${inactive}` : `${color.dim(S_RADIO_INACTIVE)} ${color.dim(inactive)}`}
+${color.cyan(S_BAR_END)}
+`;
+          }
+        }
+      }
+    }).prompt().then((v) => {
+      const result = v;
+      if (result === true) {
+        return "yes";
+      } else if (result === false) {
+        return "no";
+      }
+      return "cancel";
     });
-  });
-}
-const RPC_NAMESPACE = "nuxt-graphql-middleware";
-const module = defineNuxtModule({
-  meta: {
-    name,
-    configKey: "graphqlMiddleware",
-    version,
-    compatibility: {
-      nuxt: ">=3.15.0"
-    }
-  },
-  defaults: defaultOptions,
-  async setup(passedOptions, nuxt) {
-    const options = defu({}, passedOptions, defaultOptions);
-    function addAlias(name2, path) {
-      nuxt.options.alias[name2] = path;
-    }
-    function inlineNitroExternals(path) {
-      nuxt.options.nitro.externals = nuxt.options.nitro.externals || {};
-      nuxt.options.nitro.externals.inline = nuxt.options.nitro.externals.inline || [];
-      nuxt.options.nitro.externals.inline.push(path);
+  }
+  abort() {
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = null;
     }
+  }
+}
+
+class ModuleHelper {
+  constructor(nuxt, moduleUrl, options) {
+    this.nuxt = nuxt;
     const isModuleBuild = process.env.MODULE_BUILD === "true" && nuxt.options._prepare;
+    const mergedOptions = defu({}, options, defaultOptions);
+    if (!mergedOptions.autoImportPatterns) {
+      mergedOptions.autoImportPatterns = [
+        "~~/**/*.{gql,graphql}",
+        "!node_modules"
+      ];
+    }
     if (isModuleBuild) {
-      options.graphqlEndpoint = "http://localhost";
-      options.downloadSchema = false;
-      options.schemaPath = "~~/schema.graphql";
-      options.autoImportPatterns = [
+      mergedOptions.graphqlEndpoint = "http://localhost";
+      mergedOptions.downloadSchema = false;
+      mergedOptions.schemaPath = "~~/schema.graphql";
+      mergedOptions.autoImportPatterns = [
         "~~/playground/**/*.{gql,graphql}",
         "!node_modules"
       ];
     }
-    if (!passedOptions.autoImportPatterns) {
-      options.autoImportPatterns = ["~~/**/*.{gql,graphql}", "!node_modules"];
-    }
-    options.autoImportPatterns = (options.autoImportPatterns || []).map(
-      (pattern) => {
-        return resolveAlias(pattern);
-      }
-    );
+    mergedOptions.autoImportPatterns = (mergedOptions.autoImportPatterns || []).map((pattern) => {
+      return resolveAlias(pattern);
+    });
+    this.options = mergedOptions;
     if (!nuxt.options._prepare) {
-      validateOptions(options);
+      validateOptions(this.options);
     }
-    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, 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 nuxtGraphqlMiddlewareBuildDir = nuxt.options.buildDir + "/nuxt-graphql-middleware";
-    const operationTypesBuildDir = nuxt.options.buildDir + "/graphql-operations";
-    const toBuildRelative = (path) => {
-      return relative(nuxtGraphqlMiddlewareBuildDir, path);
+    this.isDev = nuxt.options.dev;
+    this.resolvers = {
+      module: createResolver(moduleUrl),
+      server: createResolver(nuxt.options.serverDir),
+      src: createResolver(nuxt.options.srcDir),
+      app: createResolver(nuxt.options.dir.app),
+      root: createResolver(nuxt.options.rootDir)
     };
-    addAlias("#nuxt-graphql-middleware", nuxtGraphqlMiddlewareBuildDir);
-    addAlias("#graphql-operations", operationTypesBuildDir);
-    const context = {
-      isDev: nuxt.options.dev,
-      patterns: options.autoImportPatterns || [],
-      srcDir: nuxt.options.srcDir,
-      rootDir: nuxt.options.rootDir,
-      buildDir: srcResolver.resolve(nuxt.options.buildDir),
-      nuxtConfigPath: rootResolver.resolve("nuxt.config.ts"),
-      schemaPath,
-      serverApiPrefix: options.serverApiPrefix,
-      logOnlyErrors: !!options.logOnlyErrors,
-      runtimeTypesPath: toBuildRelative(
-        moduleResolver.resolve("./runtime/types.ts")
-      )
+    this.paths = {
+      runtimeTypes: "",
+      root: nuxt.options.rootDir,
+      nuxtConfig: this.resolvers.root.resolve("nuxt.config.ts"),
+      serverDir: nuxt.options.serverDir,
+      schema: this.resolvers.root.resolve(
+        resolveAlias(this.options.schemaPath)
+      ),
+      serverOptions: this.findServerOptions(),
+      clientOptions: this.findClientOptions(),
+      moduleBuildDir: nuxt.options.buildDir + "/nuxt-graphql-middleware",
+      moduleTypesDir: nuxt.options.buildDir + "/graphql-operations"
     };
-    const collector = new Collector(
-      schema,
-      context,
-      options.documents,
-      options.codegenConfig
+    this.paths.runtimeTypes = this.toModuleBuildRelative(
+      this.resolvers.module.resolve("./runtime/types.ts")
     );
-    await collector.init();
-    const isDevToolsEnabled = nuxt.options.dev && options.devtools;
-    let rpc;
-    if (isDevToolsEnabled) {
-      const clientPath = moduleResolver.resolve("./client");
-      setupDevToolsUI(nuxt, clientPath);
-      onDevToolsInitialized(() => {
-        rpc = extendServerRpc(RPC_NAMESPACE, {
-          // register server RPC functions
-          getModuleOptions() {
-            return options;
-          },
-          getDocuments() {
-            return [...collector.rpcItems.values()];
-          }
-        });
-      });
+  }
+  resolvers;
+  paths;
+  isDev;
+  options;
+  prompt = new ConsolePrompt();
+  nitroExternals = [];
+  /**
+   * Find the path to the graphqlMiddleware.serverOptions.ts file.
+   */
+  findServerOptions() {
+    const newPath = this.resolvers.server.resolve(
+      "graphqlMiddleware.serverOptions"
+    );
+    const serverPath = fileExists(newPath);
+    if (serverPath) {
+      return serverPath;
     }
-    nuxt.options.appConfig.graphqlMiddleware = {
-      clientCacheEnabled: !!options.clientCache?.enabled,
-      clientCacheMaxSize: options.clientCache?.maxSize || 100
-    };
-    nuxt.options.runtimeConfig.graphqlMiddleware = {
-      graphqlEndpoint: options.graphqlEndpoint || ""
-    };
-    if (options.includeComposables) {
-      const nuxtComposables = [
-        "useGraphqlQuery",
-        "useGraphqlMutation",
-        "useGraphqlState",
-        "useAsyncGraphqlQuery"
-      ];
-      if (options.enableFileUploads) {
-        nuxtComposables.push("useGraphqlUploadMutation");
+    const candidates = [
+      this.resolvers.root.resolve("graphqlMiddleware.serverOptions"),
+      this.resolvers.root.resolve("app/graphqlMiddleware.serverOptions"),
+      this.resolvers.src.resolve("graphqlMiddleware.serverOptions")
+    ];
+    for (let i = 0; i < candidates.length; i++) {
+      const path = candidates[i];
+      const filePath = fileExists(path);
+      if (filePath) {
+        throw new Error(
+          `The graphqlMiddleware.serverOptions file should be placed in Nuxt's <serverDir> ("${this.paths.serverDir}/graphqlMiddleware.serverOptions.ts").`
+        );
       }
-      nuxtComposables.forEach((name2) => {
-        addImports({
-          from: moduleResolver.resolve("./runtime/composables/" + name2),
-          name: name2
-        });
+    }
+    logger.info("No graphqlMiddleware.serverOptions file found.");
+    return null;
+  }
+  findClientOptions() {
+    const clientOptionsPath = this.resolvers.app.resolve(
+      "graphqlMiddleware.clientOptions"
+    );
+    if (fileExists(clientOptionsPath)) {
+      return clientOptionsPath;
+    }
+    return null;
+  }
+  /**
+   * Transform the path relative to the module's build directory.
+   *
+   * @param path - The absolute path.
+   *
+   * @returns The path relative to the module's build directory.
+   */
+  toModuleBuildRelative(path) {
+    return relative(this.paths.moduleBuildDir, path);
+  }
+  /**
+   * Transform the path relative to the Nuxt build directory.
+   *
+   * @param path - The absolute path.
+   *
+   * @returns The path relative to the module's build directory.
+   */
+  toBuildRelative(path) {
+    return relative(this.nuxt.options.buildDir, path);
+  }
+  /**
+   * Get all file paths that match the import patterns.
+   */
+  async getImportPatternFiles() {
+    return resolveFiles(
+      this.nuxt.options.srcDir,
+      this.options.autoImportPatterns,
+      {
+        followSymbolicLinks: false
+      }
+    );
+  }
+  matchesImportPattern(filePath) {
+    return micromatch.isMatch(filePath, this.options.autoImportPatterns);
+  }
+  addAlias(name, path) {
+    this.nuxt.options.alias[name] = path;
+    const pathFromName = `./${name.substring(1)}`;
+    this.nuxt.options.nitro.typescript ||= {};
+    this.nuxt.options.nitro.typescript.tsConfig ||= {};
+    this.nuxt.options.nitro.typescript.tsConfig.compilerOptions ||= {};
+    this.nuxt.options.nitro.typescript.tsConfig.compilerOptions.paths ||= {};
+    this.nuxt.options.nitro.typescript.tsConfig.compilerOptions.paths[name] = [
+      pathFromName
+    ];
+    this.nuxt.options.nitro.typescript.tsConfig.compilerOptions.paths[name + "/*"] = [pathFromName + "/*"];
+    this.inlineNitroExternals(name);
+  }
+  inlineNitroExternals(arg) {
+    const path = typeof arg === "string" ? arg : arg.dst;
+    this.nitroExternals.push(path);
+    this.transpile(path);
+  }
+  transpile(path) {
+    this.nuxt.options.build.transpile.push(path);
+  }
+  applyBuildConfig() {
+    this.nuxt.options.nitro.externals ||= {};
+    this.nuxt.options.nitro.externals.inline ||= [];
+    this.nuxt.options.nitro.externals.inline.push(...this.nitroExternals);
+  }
+  addTemplate(template) {
+    if (template.build) {
+      const content = template.build(this).trim();
+      addTemplate({
+        filename: template.options.path + ".js",
+        write: true,
+        getContents: () => content
+      });
+    }
+    if (template.buildTypes) {
+      const content = template.buildTypes(this).trim();
+      const filename = template.options.path + ".d.ts";
+      addTypeTemplate({
+        filename,
+        write: true,
+        getContents: () => content
       });
-      const serverUtils = ["useGraphqlQuery", "useGraphqlMutation"].map(
-        (name2) => {
-          return {
-            from: moduleResolver.resolve("./runtime/server/utils/" + name2),
-            name: name2
-          };
-        }
-      );
-      addServerImports(serverUtils);
     }
-    addTypeTemplate({
-      filename: GraphqlMiddlewareTemplate.OperationTypes,
-      write: true,
-      getContents: () => collector.getTemplateTypes()
+  }
+  addPlugin(path) {
+    addPlugin(this.resolvers.module.resolve(path), {
+      append: false
     });
-    addTypeTemplate({
-      filename: GraphqlMiddlewareTemplate.Types,
-      write: true,
-      getContents: () => {
-        return `
-declare module '#nuxt-graphql-middleware/sources' {
-  export const operationSources: Record<string, string>
-}
-`;
-      }
+  }
+  addServerHandler(name, path, method) {
+    addServerHandler({
+      handler: this.resolvers.module.resolve("./runtime/server/api/" + name),
+      route: this.options.serverApiPrefix + path,
+      method
     });
-    addTemplate({
-      filename: GraphqlMiddlewareTemplate.Enums,
-      write: true,
-      getContents: () => collector.getTemplateEnums()
+  }
+  addComposable(name) {
+    addImports({
+      from: this.resolvers.module.resolve("./runtime/composables/" + name),
+      name
     });
-    addTemplate({
-      filename: GraphqlMiddlewareTemplate.OperationSources,
-      write: true,
-      getContents: () => collector.getTemplateSources()
+  }
+  addServerUtil(name) {
+    addServerImports([
+      {
+        from: this.resolvers.module.resolve("./runtime/server/utils/" + name),
+        name
+      }
+    ]);
+  }
+}
+
+function defineGeneratorTemplate(options, build, buildTypes) {
+  return {
+    type: "generator",
+    options,
+    build,
+    buildTypes
+  };
+}
+function defineStaticTemplate(options, build, buildTypes) {
+  return {
+    type: "static",
+    options,
+    build,
+    buildTypes
+  };
+}
+
+const ClientOptions = defineStaticTemplate(
+  { path: "nuxt-graphql-middleware/client-options" },
+  (helper) => {
+    if (helper.paths.clientOptions) {
+      const pathRelative = helper.toModuleBuildRelative(
+        helper.paths.clientOptions
+      );
+      return `import clientOptions from '${pathRelative}'
+export { clientOptions }
+`;
+    }
+    return `export const clientOptions = {}`;
+  },
+  (helper) => {
+    if (helper.paths.clientOptions) {
+      const pathRelative = helper.toModuleBuildRelative(
+        helper.paths.clientOptions
+      );
+      return `import type { GraphqlClientOptions } from '${helper.paths.runtimeTypes}'
+import { clientOptions } from '${pathRelative}'
+
+export type GraphqlClientContext = typeof clientOptions extends GraphqlClientOptions<infer R> ? R : {}
+
+export { clientOptions }`;
+    }
+    return `
+import type { GraphqlClientOptions } from '${helper.paths.runtimeTypes}'
+export const clientOptions: GraphqlClientOptions
+
+export type GraphqlClientContext = {}
+`;
+  }
+);
+
+const Documents = defineGeneratorTemplate(
+  { path: "nuxt-graphql-middleware/documents", virtual: true },
+  (output, helper) => {
+    return output.getOperationsFile({
+      exportName: "documents",
+      minify: !helper.isDev
+    }).getSource();
+  },
+  () => {
+    return `
+import type { Query, Mutation } from './operation-types'
+
+declare module '#nuxt-graphql-middleware/documents' {
+  export type Documents = {
+    query: Record<keyof Query, string>
+    mutation: Record<keyof Mutation, string>
+  }
+  export const documents: Documents
+}`;
+  }
+);
+
+const GraphqlConfig = defineStaticTemplate(
+  { path: "nuxt-graphql-middleware/graphql.config" },
+  (helper) => {
+    const patterns = helper.options.autoImportPatterns || [];
+    const configPath = helper.resolvers.root.resolve(
+      (helper.options.graphqlConfigFilePath || "").replace(
+        "/graphql.config.ts",
+        ""
+      )
+    );
+    const schemaPath = "./" + relative(configPath, helper.paths.schema);
+    const documents = patterns.filter((v) => !v.includes("!")).map((pattern) => {
+      return "./" + relative(configPath, helper.resolvers.root.resolve(pattern));
     });
-    addTemplate({
-      filename: GraphqlMiddlewareTemplate.Helpers,
-      write: true,
-      getContents: () => `export const serverApiPrefix = '${context.serverApiPrefix}'
+    return `const schema = ${JSON.stringify(schemaPath)}
+
+const documents = ${JSON.stringify(documents, null, 2)};
+
+const config = {
+  schema,
+  documents,
+}
+
+export default config
+`;
+  },
+  () => {
+    return `
+import type { IGraphQLProject } from 'graphql-config'
+
+type WithRequired<T, K extends keyof T> = T & { [P in K]-?: T[P] };
+
+const config: WithRequired<IGraphQLProject, 'schema' | 'documents'>;
+
+export default config;
+`;
+  }
+);
+
+const Helpers = defineStaticTemplate(
+  { path: "nuxt-graphql-middleware/helpers" },
+  (helper) => {
+    return `export const serverApiPrefix = '${helper.options.serverApiPrefix}'
 export function getEndpoint(operation, operationName) {
-  return '${context.serverApiPrefix}' + '/' + operation + '/' + operationName
+  return serverApiPrefix + '/' + operation + '/' + operationName
 }
-`
-    });
-    addTypeTemplate({
-      filename: GraphqlMiddlewareTemplate.HelpersTypes,
-      write: true,
-      getContents: () => `export const serverApiPrefix: string;
-export function getEndpoint(operation: string, operationName: string): string
-`
-    });
-    addTypeTemplate({
-      filename: GraphqlMiddlewareTemplate.NitroTypes,
-      write: true,
-      getContents: () => collector.getTemplateNitroTypes()
-    });
-    addTypeTemplate({
-      filename: GraphqlMiddlewareTemplate.OperationTypesAll,
-      write: true,
-      getContents: () => collector.getTemplateOperationTypes()
-    });
-    const templateDocuments = addTemplate({
-      filename: GraphqlMiddlewareTemplate.Documents,
-      write: true,
-      getContents: () => collector.getTemplateOperations()
-    });
-    inlineNitroExternals(templateDocuments.dst);
-    addTypeTemplate({
-      filename: GraphqlMiddlewareTemplate.ResponseTypes,
-      write: true,
-      getContents: () => collector.getTemplateResponseTypes()
-    });
-    addTypeTemplate({
-      write: true,
-      filename: "nuxt-graphql-middleware/documents.d.ts",
-      getContents: () => generateDocumentTypesTemplate()
-    });
-    const findServerOptions = () => {
-      const newPath = serverResolver.resolve("graphqlMiddleware.serverOptions");
-      const serverPath = fileExists(newPath);
-      if (serverPath) {
-        return serverPath;
-      }
-      const candidates = [
-        rootResolver.resolve("graphqlMiddleware.serverOptions"),
-        rootResolver.resolve("app/graphqlMiddleware.serverOptions"),
-        srcResolver.resolve("graphqlMiddleware.serverOptions")
-      ];
-      for (let i = 0; i < candidates.length; i++) {
-        const path = candidates[i];
-        const filePath = fileExists(path);
-        if (filePath) {
-          logger.warn(
-            `The graphqlMiddleware.serverOptions file should be placed in Nuxt's <serverDir> ("${nuxt.options.serverDir}/graphqlMiddleware.serverOptions.ts"). The new path will be enforced in the next major release.`
-          );
-          return filePath;
-        }
-      }
-      logger.info("No graphqlMiddleware.serverOptions file found.");
-    };
-    const resolvedServerOptionsPath = findServerOptions();
-    const moduleTypesPath = toBuildRelative(moduleResolver.resolve("./types"));
-    const resolvedPathRelative = resolvedServerOptionsPath ? toBuildRelative(resolvedServerOptionsPath) : null;
-    const template = addTemplate({
-      filename: "nuxt-graphql-middleware/server-options.mjs",
-      write: true,
-      getContents: () => {
-        const serverOptionsLine = resolvedPathRelative ? `import serverOptions from '${resolvedPathRelative}'` : `const serverOptions = {}`;
-        return `
+`;
+  },
+  () => {
+    return `export const serverApiPrefix: string;
+export function getEndpoint(operation: string, operationName: string): string`;
+  }
+);
+
+const NitroTypes = defineGeneratorTemplate(
+  { path: "nuxt-graphql-middleware/nitro" },
+  null,
+  (output, helper) => {
+    const operations = output.getCollectedOperations();
+    const serverApiPrefix = helper.options.serverApiPrefix;
+    const endpoints = [];
+    const imports = [];
+    for (const operation of operations) {
+      imports.push(operation.typeName);
+      const method = operation.operationType === OperationTypeNode.QUERY ? "get" : "post";
+      endpoints.push(
+        `    '${serverApiPrefix}/${operation.operationType}/${operation.graphqlName}': {
+      '${method}': GraphqlResponse<${operation.typeName}>
+    }`
+      );
+    }
+    return `import type { GraphqlResponse } from './response'
+import type {
+  ${imports.sort().join(",\n  ")}
+} from './../graphql-operations'
+
+declare module 'nitropack/types' {
+  interface InternalApi {
+${endpoints.sort().join("\n")}
+  }
+}`;
+  }
+);
+
+const OperationTypesAll = defineGeneratorTemplate(
+  { path: "nuxt-graphql-middleware/operation-types" },
+  () => `export {}`,
+  (output) => {
+    return output.getOperationTypesFile({
+      importFrom: "./../graphql-operations"
+    }).getSource();
+  }
+);
+
+const Operations = defineGeneratorTemplate(
+  { path: "graphql-operations/index" },
+  (output) => {
+    const typesFile = output.getOperations("js");
+    return typesFile.getSource();
+  },
+  (output) => {
+    const typesFile = output.getOperations("d.ts");
+    return typesFile.getSource();
+  }
+);
+
+const Response = defineGeneratorTemplate(
+  { path: "nuxt-graphql-middleware/response" },
+  null,
+  (output, helper) => {
+    const operations = output.getCollectedOperations();
+    const allTypes = operations.map((v) => v.typeName).sort();
+    return `import type {
+  ${allTypes.join(",\n  ")}
+} from './../graphql-operations'
+import type { GraphqlResponseAdditions } from './server-options'
+import type { GraphqlServerResponse } from '${helper.paths.runtimeTypes}'
+
+declare module '#nuxt-graphql-middleware/response' {
+  export type GraphqlMiddlewareResponseUnion =
+    | ${allTypes.join("\n  | ") || "never"}
+
+  export type GraphqlResponse<T> = GraphqlServerResponse<T> & GraphqlResponseAdditions
+  export type GraphqlResponseTyped = GraphqlResponse<GraphqlMiddlewareResponseUnion>
+}`;
+  }
+);
+
+const ServerOptions = defineStaticTemplate(
+  { path: "nuxt-graphql-middleware/server-options" },
+  (helper) => {
+    const resolvedPathRelative = helper.paths.serverOptions ? helper.toModuleBuildRelative(helper.paths.serverOptions) : null;
+    const serverOptionsLine = resolvedPathRelative ? `import serverOptions from '${resolvedPathRelative}'` : `const serverOptions = {}`;
+    return `
 ${serverOptionsLine}
 export { serverOptions }
 `;
-      }
-    });
-    inlineNitroExternals(template.dst);
-    addTemplate({
-      filename: "nuxt-graphql-middleware/server-options.d.ts",
-      write: true,
-      getContents: () => {
-        const serverOptionsLineTypes = resolvedPathRelative ? `import serverOptions from '${resolvedPathRelative}'` : `const serverOptions: GraphqlMiddlewareServerOptions = {}`;
-        return `
+  },
+  (helper) => {
+    const resolvedPathRelative = helper.paths.serverOptions ? helper.toModuleBuildRelative(helper.paths.serverOptions) : null;
+    const serverOptionsLineTypes = resolvedPathRelative ? `import serverOptions from '${resolvedPathRelative}'` : `const serverOptions: GraphqlMiddlewareServerOptions = {}`;
+    const moduleTypesPath = helper.toModuleBuildRelative(
+      helper.resolvers.module.resolve("./types")
+    );
+    return `
 import type { GraphqlMiddlewareServerOptions } from '${moduleTypesPath}'
 ${serverOptionsLineTypes}
 
@@ -914,112 +1155,278 @@ export type GraphqlResponseAdditions =
   typeof serverOptions extends GraphqlMiddlewareServerOptions<infer R, any, any> ? R : {}
 
 export { serverOptions }`;
-      }
-    });
-    const getClientOptionsImport = () => {
-      const clientOptionsPath = appResolver.resolve(
-        "graphqlMiddleware.clientOptions"
-      );
-      if (fileExists(clientOptionsPath)) {
-        const pathRelative = toBuildRelative(clientOptionsPath);
-        return `import clientOptions from '${pathRelative}'`;
-      }
-    };
-    const clientOptionsImport = getClientOptionsImport();
-    addTemplate({
-      filename: "nuxt-graphql-middleware/client-options.mjs",
-      write: true,
-      getContents: () => {
-        if (clientOptionsImport) {
-          return `${clientOptionsImport}
-export { clientOptions }`;
-        }
-        return `export const clientOptions = {}`;
-      }
-    });
-    addTemplate({
-      filename: "nuxt-graphql-middleware/client-options.d.ts",
-      write: true,
-      getContents: () => {
-        if (clientOptionsImport) {
-          return `import type { GraphqlClientOptions } from '${context.runtimeTypesPath}'
-${clientOptionsImport}
+  }
+);
 
-export type GraphqlClientContext = typeof clientOptions extends GraphqlClientOptions<infer R> ? R : {}
+const Sources = defineGeneratorTemplate(
+  { path: "nuxt-graphql-middleware/sources" },
+  (output, helper) => {
+    const operations = output.getCollectedOperations();
+    const srcDir = helper.paths.root;
+    const lines = [];
+    for (const operation of operations) {
+      const filePath = relative(srcDir, operation.filePath);
+      lines.push(
+        `${operation.operationType}_${operation.graphqlName}: '${filePath}',`
+      );
+    }
+    return `
+export const operationSources = {
+  ${lines.join("\n  ")}
+}
+`;
+  },
+  () => {
+    return `export const operationSources: Record<string, string>`;
+  }
+);
 
-export { clientOptions }`;
-        }
-        return `import type { GraphqlClientOptions } from '${context.runtimeTypesPath}'
-export const clientOptions: GraphqlClientOptions
+const TEMPLATES = [
+  ClientOptions,
+  Documents,
+  GraphqlConfig,
+  Helpers,
+  NitroTypes,
+  OperationTypesAll,
+  Operations,
+  Response,
+  ServerOptions,
+  Sources
+];
 
-export type GraphqlClientContext = {}
-`;
-      }
-    });
-    addServerHandler({
-      handler: moduleResolver.resolve("./runtime/serverHandler/index"),
-      route: options.serverApiPrefix + "/:operation/:name"
+const DEVTOOLS_UI_ROUTE = "/__nuxt-graphql-middleware";
+const DEVTOOLS_UI_LOCAL_PORT = 3300;
+function setupDevToolsUI(nuxt, clientPath) {
+  const isProductionBuild = existsSync$1(clientPath);
+  if (isProductionBuild) {
+    nuxt.hook("vite:serverCreated", async (server) => {
+      const sirv = await import('sirv').then((r) => r.default || r);
+      server.middlewares.use(
+        DEVTOOLS_UI_ROUTE,
+        sirv(clientPath, { dev: true, single: true })
+      );
     });
-    if (options.enableFileUploads) {
-      addServerHandler({
-        handler: moduleResolver.resolve("./runtime/serverHandler/upload"),
-        route: options.serverApiPrefix + "/upload/:name"
-      });
-    }
-    addPlugin(moduleResolver.resolve("./runtime/plugins/provideState"), {
-      append: false
+  } else {
+    nuxt.hook("vite:extendConfig", (config) => {
+      config.server = config.server || {};
+      config.server.proxy = config.server.proxy || {};
+      config.server.proxy[DEVTOOLS_UI_ROUTE] = {
+        target: "http://localhost:" + DEVTOOLS_UI_LOCAL_PORT + DEVTOOLS_UI_ROUTE,
+        changeOrigin: true,
+        followRedirects: true,
+        rewrite: (path) => path.replace(DEVTOOLS_UI_ROUTE, "")
+      };
     });
-    if (context.isDev && options.errorOverlay) {
-      addPlugin(moduleResolver.resolve("./runtime/plugins/devMode"), {
-        append: false
-      });
-    }
-    nuxt.hook("nitro:config", (nitroConfig) => {
-      nitroConfig.externals = defu(
-        typeof nitroConfig.externals === "object" ? nitroConfig.externals : {},
-        {
-          inline: [moduleResolver.resolve("./runtime")]
-        }
-      );
+  }
+  nuxt.hook("devtools:customTabs", (tabs) => {
+    tabs.push({
+      // unique identifier
+      name: "nuxt-graphql-middleware",
+      // title to display in the tab
+      title: "GraphQL Middleware",
+      // any icon from Iconify, or a URL to an image
+      icon: "akar-icons:graphql-fill",
+      // iframe view
+      view: {
+        type: "iframe",
+        src: DEVTOOLS_UI_ROUTE
+      }
     });
-    if (nuxt.options.dev || nuxt.options._prepare) {
-      let sendError = function(error) {
-        wsPromise.then((ws) => {
-          ws.send({
-            type: "error",
-            err: {
-              message: error.message,
-              stack: ""
+  });
+}
+
+const RPC_NAMESPACE = "nuxt-graphql-middleware";
+class DevModeHandler {
+  constructor(nuxt, schemaProvider, collector, helper) {
+    this.nuxt = nuxt;
+    this.schemaProvider = schemaProvider;
+    this.collector = collector;
+    this.helper = helper;
+  }
+  devToolsRpc = null;
+  nitro = null;
+  viteWebSocket = null;
+  operationsToReload = /* @__PURE__ */ new Set();
+  init() {
+    this.nuxt.hooks.hookOnce("ready", this.onReady.bind(this));
+    this.nuxt.hooks.hookOnce(
+      "vite:serverCreated",
+      this.onViteServerCreated.bind(this)
+    );
+    this.nuxt.hook("builder:watch", this.onBuilderWatch.bind(this));
+    if (this.helper.options.devtools) {
+      const clientPath = this.helper.resolvers.module.resolve("./client");
+      setupDevToolsUI(this.nuxt, clientPath);
+      onDevToolsInitialized(() => {
+        this.devToolsRpc = extendServerRpc(
+          RPC_NAMESPACE,
+          {
+            // register server RPC functions
+            getModuleOptions: () => {
+              return this.helper.options;
+            },
+            getDocuments: () => {
+              return [...this.collector.rpcItems.values()];
             }
-          });
-        });
-      };
-      addServerHandler({
-        handler: moduleResolver.resolve("./runtime/serverHandler/debug"),
-        route: options.serverApiPrefix + "/debug"
+          }
+        );
       });
-      const wsPromise = useViteWebSocket(nuxt);
-      nuxt.hook("builder:watch", async (event, pathAbsolute) => {
-        if (pathAbsolute === schemaPath) {
-          return;
-        }
-        if (!pathAbsolute.match(/\.(gql|graphql)$/)) {
+    }
+  }
+  onReady() {
+    this.nitro = useNitro();
+    this.nitro.hooks.hook("compiled", this.onNitroCompiled.bind(this));
+  }
+  async onBuilderWatch(event, pathAbsolute) {
+    if (pathAbsolute === this.helper.paths.schema) {
+      return;
+    }
+    if (!pathAbsolute.match(/\.(gql|graphql)$/)) {
+      return;
+    }
+    this.helper.prompt.abort();
+    const { hasChanged, affectedOperations, error } = await this.collector.handleWatchEvent(event, pathAbsolute);
+    if (error) {
+      this.sendError(error);
+      await this.helper.prompt.confirm("Do you want to download and update the GraphQL schema?").then(async (shouldReload) => {
+        if (shouldReload !== "yes") {
           return;
         }
-        const { hasChanged, error } = await collector.handleWatchEvent(
-          event,
-          pathAbsolute
-        );
-        if (error) {
-          sendError(error);
-        }
-        if (hasChanged) {
-          if (rpc) {
-            rpc.broadcast.documentsUpdated([...collector.rpcItems.values()]);
-          }
+        try {
+          await this.schemaProvider.loadSchema({ forceDownload: true });
+          await this.collector.updateSchema(this.schemaProvider.getSchema());
+        } catch (e) {
+          logger.error(e);
         }
       });
+      return;
+    }
+    if (!hasChanged) {
+      return;
+    }
+    if (this.nitro) {
+      await this.nitro.hooks.callHook("rollup:reload");
+    }
+    if (affectedOperations.length) {
+      affectedOperations.forEach(
+        (operation) => this.operationsToReload.add(operation)
+      );
+    }
+    if (this.devToolsRpc) {
+      try {
+        this.devToolsRpc.broadcast.documentsUpdated([
+          ...this.collector.rpcItems.values()
+        ]);
+      } catch {
+        logger.info(
+          "Failed to update GraphQL documents in dev tools. The documents might be stale."
+        );
+      }
+    }
+  }
+  onViteServerCreated(server) {
+    this.viteWebSocket = server.ws;
+  }
+  sendError(error) {
+    if (!this.viteWebSocket) {
+      return;
+    }
+    this.viteWebSocket.send({
+      type: "error",
+      err: {
+        message: error.message,
+        stack: ""
+      }
+    });
+  }
+  onNitroCompiled() {
+    if (!this.operationsToReload.size) {
+      return;
+    }
+    const operations = [...this.operationsToReload.values()];
+    this.operationsToReload.clear();
+    if (!this.viteWebSocket) {
+      return;
+    }
+    this.viteWebSocket.send({
+      type: "custom",
+      event: "nuxt-graphql-middleware:reload",
+      data: { operations }
+    });
+  }
+}
+
+const module = defineNuxtModule({
+  meta: {
+    name,
+    configKey: "graphqlMiddleware",
+    version,
+    compatibility: {
+      nuxt: ">=3.15.0"
     }
+  },
+  defaults: defaultOptions,
+  async setup(passedOptions, nuxt) {
+    const helper = new ModuleHelper(nuxt, import.meta.url, passedOptions);
+    const schemaProvider = new SchemaProvider(helper);
+    await schemaProvider.init();
+    const collector = new Collector(schemaProvider.getSchema(), helper);
+    nuxt.options.appConfig.graphqlMiddleware = {
+      clientCacheEnabled: !!helper.options.clientCache?.enabled,
+      clientCacheMaxSize: helper.options.clientCache?.maxSize ?? 100
+    };
+    nuxt.options.runtimeConfig.graphqlMiddleware = {
+      graphqlEndpoint: helper.options.graphqlEndpoint || ""
+    };
+    helper.transpile(fileURLToPath(new URL("./runtime", import.meta.url)));
+    helper.inlineNitroExternals(helper.resolvers.module.resolve("./runtime"));
+    helper.inlineNitroExternals(helper.paths.moduleBuildDir);
+    helper.inlineNitroExternals(helper.paths.moduleTypesDir);
+    helper.addAlias("#nuxt-graphql-middleware", helper.paths.moduleBuildDir);
+    helper.addAlias("#graphql-operations", helper.paths.moduleTypesDir);
+    helper.addPlugin("./runtime/plugins/provideState");
+    if (helper.isDev && helper.options.errorOverlay) {
+      helper.addPlugin("./runtime/plugins/devMode");
+    }
+    helper.addServerHandler("query", "/query/:name", "get");
+    helper.addServerHandler("mutation", "/mutation/:name", "post");
+    if (helper.options.enableFileUploads) {
+      helper.addServerHandler("upload", "/upload/:name", "post");
+    }
+    if (helper.isDev) {
+      helper.addServerHandler("debug", "/debug", "get");
+    }
+    if (helper.options.includeComposables) {
+      helper.addComposable("useGraphqlQuery");
+      helper.addComposable("useGraphqlMutation");
+      helper.addComposable("useGraphqlState");
+      helper.addComposable("useAsyncGraphqlQuery");
+      if (helper.options.enableFileUploads) {
+        helper.addComposable("useGraphqlUploadMutation");
+      }
+      helper.addServerUtil("useGraphqlQuery");
+      helper.addServerUtil("useGraphqlMutation");
+      helper.addServerUtil("doGraphqlRequest");
+    }
+    TEMPLATES.forEach((template) => {
+      if (template.type === "static") {
+        helper.addTemplate(template);
+      } else {
+        collector.addTemplate(template);
+      }
+    });
+    helper.applyBuildConfig();
+    await collector.init();
+    if (!helper.isDev) {
+      return;
+    }
+    const devModeHandler = new DevModeHandler(
+      nuxt,
+      schemaProvider,
+      collector,
+      helper
+    );
+    devModeHandler.init();
   }
 });