nuxt-graphql-middleware 5.0.0-alpha.4 → 5.0.0-alpha.6

package/dist/module.mjs

@@ -1,93 +1,26 @@
-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, 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 { Template } from '../dist/runtime/settings/index.js';
 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, Source } from 'graphql';
+import { printSourceLocation, parse, OperationTypeNode, Source } from 'graphql';
 import { Generator, FieldNotFoundError, TypeNotFoundError, FragmentNotFoundError } from 'graphql-typescript-deluxe';
-import { pascalCase } from 'change-case-all';
-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.4";
-
-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.6";
 
 const logger = useLogger(name);
 const defaultOptions = {
@@ -98,151 +31,27 @@ const defaultOptions = {
   debug: false,
   includeComposables: true,
   documents: [],
-  devtools: true
+  devtools: 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 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
-  ].filter(Boolean).join("\n");
-  const combinedNitroCode = [
-    queryResult.nitroCode,
-    mutationResult.nitroCode,
-    subscriptionResult.nitroCode
-  ].join("\n");
-  const typeImports = allImports.length ? `import type {
-  ${allImports.join(",\n  ")}
-} from './../graphql-operations'` : "";
-  return `
-import type { GraphqlResponse } from '#graphql-middleware-server-options-build'
-${typeImports}
-
-declare module '#nuxt-graphql-middleware/generated-types' {
-  export type GraphqlMiddlewareResponseUnion = ${allResultTypes.join(" | ") || "never"}
-${combinedCode}
-}
-
-declare module 'nitropack' {
-  interface InternalApi {
-${combinedNitroCode}
-  }
-}
-`;
-}
-
 const SYMBOL_CROSS = "x";
 const SYMBOL_CHECK = "\u2714";
 function getMaxLengths(entries) {
@@ -267,11 +76,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");
@@ -280,10 +89,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);
@@ -330,12 +139,80 @@ class CollectedFile {
   }
 }
 
+function ResponseTypes(operations, helper) {
+  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>
+}`;
+}
+
+function NitroTypes(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 OperationSources(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  ")}
+}
+`;
+}
+
+function OperationTypes(generatorOutput) {
+  const typesFile = generatorOutput.getTypes();
+  let output = "";
+  const enumImports = typesFile.getTypeScriptEnumDependencies();
+  if (enumImports.length) {
+    output += `import type { ${enumImports.join(", ")} } from './enums'
+
+`;
+  }
+  output += typesFile.getSource();
+  return output;
+}
+
 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 = {};
     }
@@ -363,23 +240,23 @@ class Collector {
    */
   rpcItems = /* @__PURE__ */ new Map();
   /**
-   * The generated TypeScript type template output.
+   * The generated templates.
    */
-  outputTypes = "";
-  /**
-   * The generated TypeScript enum template output.
-   */
-  outputEnums = "";
-  /**
-   * The generated oeprations file.
-   */
-  outputOperations = "";
-  /**
-   * The generated context template file.
-   */
-  outputContext = "";
+  templates = /* @__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);
@@ -392,16 +269,15 @@ class Collector {
       errors
     };
   }
-  buildOutputTypes(file) {
-    let output = "";
-    const enumImports = file.getTypeScriptEnumDependencies();
-    if (enumImports.length) {
-      output += `import type { ${enumImports.join(", ")} } from './enums'
-
-`;
+  updateTemplate(template, content) {
+    this.templates.set(template, content);
+  }
+  getTemplate(template) {
+    const content = this.templates.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.
@@ -410,12 +286,32 @@ class Collector {
     const output = this.generator.build();
     const operations = output.getCollectedOperations();
     const generatedCode = output.getGeneratedCode();
-    this.outputOperations = output.getOperationsFile().getSource();
-    this.outputEnums = output.buildFile(["enum"]).getSource();
-    this.outputTypes = this.buildOutputTypes(output.getTypes());
-    this.outputContext = generateContextTemplate(
-      operations,
-      this.context.serverApiPrefix
+    this.updateTemplate(
+      Template.Documents,
+      output.getOperationsFile({
+        exportName: "documents",
+        minify: !this.helper.isDev
+      }).getSource()
+    );
+    this.updateTemplate(
+      Template.OperationTypesAll,
+      output.getOperationTypesFile({
+        importFrom: "./../graphql-operations"
+      }).getSource()
+    );
+    this.updateTemplate(
+      Template.NitroTypes,
+      NitroTypes(operations, this.helper.options.serverApiPrefix)
+    );
+    this.updateTemplate(Template.OperationTypes, OperationTypes(output));
+    this.updateTemplate(
+      Template.ResponseTypes,
+      ResponseTypes(operations, this.helper)
+    );
+    this.updateTemplate(Template.Enums, output.buildFile(["enum"]).getSource());
+    this.updateTemplate(
+      Template.OperationSources,
+      OperationSources(operations, this.helper.paths.root)
     );
     const fragmentMap = /* @__PURE__ */ new Map();
     const operationSourceMap = /* @__PURE__ */ new Map();
@@ -445,7 +341,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));
       }
@@ -493,31 +389,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({
@@ -537,6 +447,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,
@@ -545,26 +458,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) {
@@ -593,6 +512,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);
@@ -602,7 +522,6 @@ class Collector {
         hasChanged = this.handleUnlink(filePath);
       } else if (event === "unlinkDir") {
         hasChanged = this.handleUnlinkDir(filePath);
-      } else if (event === "addDir") {
       }
       if (hasChanged) {
         this.buildState();
@@ -613,392 +532,820 @@ 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, 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 getContents = () => this.getTemplate(template);
+    addTemplate({
+      filename: template,
+      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.replace(".mjs", ""),
+      getContents
+    });
+  }
+  /**
+   * Adds a template that dependes on Collector state.
+   */
+  addTemplate(template) {
+    if (template.endsWith(".d.ts")) {
+      addTypeTemplate(
+        {
+          filename: template,
+          write: true,
+          getContents: () => this.getTemplate(template)
+        },
+        {
+          nuxt: true,
+          nitro: true
+        }
+      );
+    } else {
+      addTemplate({
+        filename: template,
+        write: true,
+        getContents: () => this.getTemplate(template)
+      });
+    }
+  }
+}
+
+class SchemaProvider {
+  constructor(helper) {
+    this.helper = helper;
+  }
+  /**
+   * The raw schema content.
+   */
+  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 { hasChanged };
+    return false;
+  }
+  /**
+   * Loads the schema from disk.
+   *
+   * @returns The schema contents from disk.
+   */
+  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 TypeScript types template contents.
+   * Downloads the schema and saves it to disk.
+   *
+   * @returns The schema contents.
    */
-  getTemplateTypes() {
-    return this.outputTypes;
+  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 TypeScript Enums template contents.
+   * Determine if the schema exists on disk.
+   *
+   * @returns True if the schema file exists on disk.
    */
-  getTemplateEnums() {
-    return this.outputEnums;
+  hasSchemaOnDisk() {
+    return fs.access(this.helper.paths.schema).then(() => true).catch(() => false);
   }
   /**
-   * Get the context template contents.
+   * Load the schema either from disk or by downloading it.
+   *
+   * @param forceDownload - Forces downloading the schema.
    */
-  getTemplateContext() {
-    return this.outputContext;
+  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 operations template contents.
+   * Get the schema.
+   *
+   * @returns The parsed GraphQL schema object.
    */
-  getTemplateOperations() {
-    return this.outputOperations;
+  getSchema() {
+    if (!this.schema) {
+      throw new Error("Failed to load schema.");
+    }
+    return this.schema;
   }
 }
 
-function useViteWebSocket(nuxt) {
-  return new Promise((resolve) => {
-    nuxt.hooks.hook("vite:serverCreated", (viteServer) => {
-      resolve(viteServer.ws);
+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);
+  }
+};
+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.13.0"
-    }
-  },
-  defaults: defaultOptions,
-  async setup(passedOptions, nuxt) {
-    const options = defu({}, passedOptions, defaultOptions);
-    function addAlias(name2, arg) {
-      const aliasPath = typeof arg === "string" ? arg : arg.dst;
-      nuxt.options.alias[name2] = aliasPath;
+  }
+  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);
-      }
-    );
-    if (!nuxt.options._prepare) {
-      validateOptions(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: []
+    mergedOptions.autoImportPatterns = (mergedOptions.autoImportPatterns || []).map((pattern) => {
+      return resolveAlias(pattern);
     });
-    const runtimeDir = fileURLToPath(new URL("./runtime", import.meta.url));
-    nuxt.options.build.transpile.push(runtimeDir);
-    const collector = new Collector(
-      schema,
-      {
-        patterns: options.autoImportPatterns || [],
-        srcDir: nuxt.options.srcDir,
-        buildDir: srcResolver.resolve(nuxt.options.buildDir),
-        nuxtConfigPath: rootResolver.resolve("nuxt.config.ts"),
-        schemaPath,
-        serverApiPrefix: options.serverApiPrefix,
-        logOnlyErrors: !!options.logOnlyErrors
-      },
-      options.documents,
-      options.codegenConfig
-    );
-    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()];
-          }
-        });
-      });
+    this.options = mergedOptions;
+    if (!nuxt.options._prepare) {
+      validateOptions(this.options);
     }
-    nuxt.options.runtimeConfig.public["nuxt-graphql-middleware"] = {
-      serverApiPrefix: options.serverApiPrefix
-    };
-    nuxt.options.appConfig.graphqlMiddleware = {
-      clientCacheEnabled: !!options.clientCache?.enabled,
-      clientCacheMaxSize: options.clientCache?.maxSize || 100
+    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)
     };
-    nuxt.options.runtimeConfig.graphqlMiddleware = {
-      graphqlEndpoint: options.graphqlEndpoint || ""
+    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"
     };
-    if (options.includeComposables) {
-      const nuxtComposables = [
-        "useGraphqlQuery",
-        "useGraphqlMutation",
-        "useGraphqlState",
-        "useAsyncGraphqlQuery"
-      ];
-      if (options.enableFileUploads) {
-        nuxtComposables.push("useGraphqlUploadMutation");
+    this.paths.runtimeTypes = this.toModuleBuildRelative(
+      this.resolvers.module.resolve("./runtime/types.ts")
+    );
+  }
+  resolvers;
+  paths;
+  isDev;
+  options;
+  prompt = new ConsolePrompt();
+  /**
+   * 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;
+    }
+    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
-        });
-      });
-      const serverUtils = ["useGraphqlQuery", "useGraphqlMutation"].map(
-        (name2) => {
-          return {
-            from: moduleResolver.resolve("./runtime/server/utils/" + name2),
-            name: name2
-          };
-        }
-      );
-      addServerImports(serverUtils);
     }
-    addAlias(
-      "#graphql-operations",
-      addTemplate({
-        filename: GraphqlMiddlewareTemplate.OperationTypes,
-        write: true,
-        getContents: () => collector.getTemplateTypes()
-      })
+    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
+      }
     );
-    addAlias(
-      "#graphql-operations/enums",
+  }
+  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 + "/*"];
+  }
+  inlineNitroExternals(arg) {
+    const path = typeof arg === "string" ? arg : arg.dst;
+    this.nuxt.options.nitro.externals = this.nuxt.options.nitro.externals || {};
+    this.nuxt.options.nitro.externals.inline = this.nuxt.options.nitro.externals.inline || [];
+    this.nuxt.options.nitro.externals.inline.push(path);
+  }
+  addTemplate(template, cb) {
+    const content = cb(this);
+    if (template.endsWith("d.ts")) {
+      addTypeTemplate({
+        filename: template,
+        write: true,
+        getContents: () => content
+      });
+    } else {
       addTemplate({
-        filename: GraphqlMiddlewareTemplate.Enums,
+        filename: template,
         write: true,
-        getContents: () => collector.getTemplateEnums()
-      })
-    );
-    const templateDocuments = addTemplate({
-      filename: GraphqlMiddlewareTemplate.Documents,
-      write: true,
-      getContents: () => collector.getTemplateOperations()
+        getContents: () => content
+      });
+    }
+  }
+  addPlugin(path) {
+    addPlugin(this.resolvers.module.resolve(path), {
+      append: false
     });
-    addAlias("#graphql-documents", templateDocuments.dst);
-    const templateContext = addTemplate({
-      filename: GraphqlMiddlewareTemplate.ComposableContext,
-      write: true,
-      getContents: () => collector.getTemplateContext()
+  }
+  addServerHandler(name, path, method) {
+    addServerHandler({
+      handler: this.resolvers.module.resolve("./runtime/server/api/" + name),
+      route: this.options.serverApiPrefix + path,
+      method
     });
-    addAlias("#nuxt-graphql-middleware/generated-types", templateContext.dst);
-    addTemplate({
-      write: true,
-      filename: "nuxt-graphql-middleware/graphql-documents.d.ts",
-      getContents: () => {
-        return `
-import type {
-  GraphqlMiddlewareQuery,
-  GraphqlMiddlewareMutation,
-} from '#nuxt-graphql-middleware/generated-types'
+  }
+  addComposable(name) {
+    addImports({
+      from: this.resolvers.module.resolve("./runtime/composables/" + name),
+      name
+    });
+  }
+  addServerUtil(name) {
+    addServerImports([
+      {
+        from: this.resolvers.module.resolve("./runtime/server/utils/" + name),
+        name
+      }
+    ]);
+  }
+}
 
-declare module '#graphql-documents' {
-  type Operations = {
-    query: GraphqlMiddlewareQuery
-    mutation: GraphqlMiddlewareMutation
+function GraphqlConfig(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));
+  });
+  return `
+import type { IGraphQLConfig } from 'graphql-config'
+
+const schema = ${JSON.stringify(schemaPath)}
+
+const documents: string[] = ${JSON.stringify(documents, null, 2)};
+
+const config: IGraphQLConfig = {
+  schema,
+  documents,
+}
+
+export default config
+`;
+}
+
+function DocumentTypes() {
+  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 operations: Operations
-  export { operations, Operations }
+  export const documents: Documents
+}`;
+}
+
+function Types() {
+  return `declare module '#nuxt-graphql-middleware/sources' {
+  export const operationSources: Record<string, string>
+}`;
+}
+
+function HelpersTypes() {
+  return `export const serverApiPrefix: string;
+export function getEndpoint(operation: string, operationName: string): string`;
+}
+
+function Helpers(helper) {
+  return `export const serverApiPrefix = '${helper.options.serverApiPrefix}'
+export function getEndpoint(operation, operationName) {
+  return '${helper.options.serverApiPrefix}' + '/' + operation + '/' + operationName
 }
 `;
-      }
-    });
-    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 = relative(
-      nuxt.options.buildDir,
-      moduleResolver.resolve("./types")
-    );
-    const resolvedPathRelative = resolvedServerOptionsPath ? relative(nuxt.options.buildDir, resolvedServerOptionsPath) : null;
-    const template = addTemplate({
-      filename: "graphqlMiddleware.serverOptions.mjs",
-      write: true,
-      getContents: () => {
-        const serverOptionsLine = resolvedPathRelative ? `import serverOptions from '${resolvedPathRelative}'` : `const serverOptions = {}`;
-        return `
+}
+
+function ServerOptions(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 }
 `;
-      }
-    });
-    addTemplate({
-      filename: "graphqlMiddleware.serverOptions.d.ts",
-      write: true,
-      getContents: () => {
-        const serverOptionsLineTypes = resolvedPathRelative ? `import serverOptions from '${resolvedPathRelative}'` : `const serverOptions: GraphqlMiddlewareServerOptions = {}`;
-        return `
+}
+
+function ServerOptionsTypes(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}
-import type { GraphqlServerResponse } from '${runtimeTypesPath}'
-import type { GraphqlMiddlewareResponseUnion } from '#nuxt-graphql-middleware/generated-types'
 
-type GraphqlResponseAdditions =
+export type GraphqlResponseAdditions =
   typeof serverOptions extends GraphqlMiddlewareServerOptions<infer R, any, any> ? R : {}
 
-export type GraphqlResponse<T> = GraphqlServerResponse<T> & GraphqlResponseAdditions
-
-export type GraphqlResponseTyped = GraphqlResponse<GraphqlMiddlewareResponseUnion>
+export { serverOptions }`;
+}
 
-export { serverOptions }
+function ClientOptions(helper) {
+  if (helper.paths.clientOptions) {
+    const pathRelative = helper.toModuleBuildRelative(
+      helper.paths.clientOptions
+    );
+    return `import clientOptions from '${pathRelative}'
+export { clientOptions }
 `;
-      }
-    });
-    const getClientOptionsImport = () => {
-      const clientOptionsPath = appResolver.resolve(
-        "graphqlMiddleware.clientOptions"
-      );
-      if (fileExists(clientOptionsPath)) {
-        const pathRelative = relative(nuxt.options.buildDir, clientOptionsPath);
-        return `import clientOptions from '${pathRelative}'`;
-      }
-    };
-    const clientOptionsImport = getClientOptionsImport();
-    const clientOptionsTemplate = addTemplate({
-      filename: "graphqlMiddleware.clientOptions.mjs",
-      write: true,
-      getContents: () => {
-        if (clientOptionsImport) {
-          return `${clientOptionsImport}
-export { clientOptions }`;
-        }
-        return `export const clientOptions = {}`;
-      }
-    });
-    const runtimeTypesPath = relative(
-      nuxt.options.buildDir,
-      moduleResolver.resolve("./runtime/types.ts")
+  }
+  return `export const clientOptions = {}`;
+}
+
+function ClientOptionsTypes(helper) {
+  if (helper.paths.clientOptions) {
+    const pathRelative = helper.toModuleBuildRelative(
+      helper.paths.clientOptions
     );
-    addTemplate({
-      filename: "graphqlMiddleware.clientOptions.d.ts",
-      write: true,
-      getContents: () => {
-        if (clientOptionsImport) {
-          return `import type { GraphqlClientOptions } from '${runtimeTypesPath}'
-${clientOptionsImport}
+    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 '${runtimeTypesPath}'
+  }
+  return `
+import type { GraphqlClientOptions } from '${helper.paths.runtimeTypes}'
 export const clientOptions: GraphqlClientOptions
 
 export type GraphqlClientContext = {}
 `;
-      }
-    });
-    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.nitro.externals.inline.push(templateDocuments.dst);
-    addAlias("#graphql-middleware-server-options-build", template.dst);
-    addAlias(
-      "#graphql-middleware/types",
-      moduleResolver.resolve("./runtime/types.ts")
-    );
-    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, "")
+      };
     });
-    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 && 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.16.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);
+    await collector.init();
+    nuxt.options.appConfig.graphqlMiddleware = {
+      clientCacheEnabled: !!helper.options.clientCache?.enabled,
+      clientCacheMaxSize: helper.options.clientCache?.maxSize ?? 100
+    };
+    nuxt.options.runtimeConfig.graphqlMiddleware = {
+      graphqlEndpoint: helper.options.graphqlEndpoint || ""
+    };
+    nuxt.options.build.transpile.push(
+      fileURLToPath(new URL("./runtime", import.meta.url))
+    );
+    helper.inlineNitroExternals(helper.resolvers.module.resolve("./runtime"));
+    helper.inlineNitroExternals(helper.paths.moduleBuildDir);
+    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");
+    }
+    helper.addTemplate(Template.ClientOptions, ClientOptions);
+    helper.addTemplate(Template.ClientOptionsTypes, ClientOptionsTypes);
+    helper.addTemplate(Template.DocumentTypes, DocumentTypes);
+    helper.addTemplate(Template.GraphqlConfig, GraphqlConfig);
+    helper.addTemplate(Template.Helpers, Helpers);
+    helper.addTemplate(Template.HelpersTypes, HelpersTypes);
+    helper.addTemplate(Template.ServerOptions, ServerOptions);
+    helper.addTemplate(Template.ServerOptionsTypes, ServerOptionsTypes);
+    helper.addTemplate(Template.Types, Types);
+    collector.addTemplate(Template.Enums);
+    collector.addTemplate(Template.NitroTypes);
+    collector.addTemplate(Template.OperationSources);
+    collector.addTemplate(Template.OperationTypes);
+    collector.addTemplate(Template.OperationTypesAll);
+    collector.addTemplate(Template.ResponseTypes);
+    collector.addVirtualTemplate(Template.Documents);
+    if (!helper.isDev) {
+      return;
+    }
+    const devModeHandler = new DevModeHandler(
+      nuxt,
+      schemaProvider,
+      collector,
+      helper
+    );
+    devModeHandler.init();
   }
 });