nuxt-graphql-middleware 5.0.0-alpha.2 → 5.0.0-alpha.20

package/dist/module.mjs

@@ -1,94 +1,27 @@
-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 { promises, existsSync as existsSync$1 } from 'node:fs';
-import { generate } from '@graphql-codegen/cli';
-import * as PluginSchemaAst from '@graphql-codegen/schema-ast';
+import { useLogger, addTemplate, addServerTemplate, addTypeTemplate, createResolver, resolveAlias, resolveFiles, addPlugin, addServerHandler, addImports, addServerImports, useNitro, defineNuxtModule } from '@nuxt/kit';
+import { existsSync, promises } from 'node:fs';
 import { basename } from 'node:path';
-import { Source, parse, printSourceLocation } from 'graphql';
-import { Generator } from 'graphql-typescript-deluxe';
-import { pascalCase } from 'change-case-all';
-import colors from 'picocolors';
+import { relative, join } from 'pathe';
+import { printSourceLocation, parse, Source, OperationTypeNode } from 'graphql';
+import { Generator, FieldNotFoundError, TypeNotFoundError, FragmentNotFoundError } from 'graphql-typescript-deluxe';
+import color from 'picocolors';
 import { validateGraphQlDocuments } from '@graphql-tools/utils';
+import fs from 'node:fs/promises';
+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 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.2";
-
-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.20";
 
-const logger = useLogger(name);
+const logger = useLogger("nuxt-graphql-middleware");
 const defaultOptions = {
   downloadSchema: true,
   schemaPath: "~~/schema.graphql",
@@ -97,150 +30,29 @@ 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 promises.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 promises.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
-  ].join("\n");
-  const combinedNitroCode = [
-    queryResult.nitroCode,
-    mutationResult.nitroCode,
-    subscriptionResult.nitroCode
-  ].join("\n");
-  return `
-import type { GraphqlResponse } from '#graphql-middleware-server-options-build'
-import type {
-  ${allImports.join(",\n  ")}
-} from './../graphql-operations'
-
-declare module '#nuxt-graphql-middleware/generated-types' {
-  export type GraphqlMiddlewareResponseUnion = ${allResultTypes.join(" | ")}
-${combinedCode}
-}
-
-declare module 'nitropack' {
-  interface InternalApi {
-${combinedNitroCode}
-  }
-}
-`;
-}
-
+const SYMBOL_CROSS = "x";
+const SYMBOL_CHECK = "\u2714";
 function getMaxLengths(entries) {
   let name = 0;
   let path = 0;
@@ -263,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("x") : colors.green("\u2714");
+    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");
@@ -276,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);
@@ -293,6 +105,7 @@ function logAllEntries(entries) {
   }
   logger.restoreStd();
 }
+
 class CollectedFile {
   filePath;
   fileContents;
@@ -306,6 +119,9 @@ class CollectedFile {
   }
   static async fromFilePath(filePath) {
     const content = (await promises.readFile(filePath)).toString();
+    if (!content) {
+      return null;
+    }
     return new CollectedFile(filePath, content, true);
   }
   /**
@@ -324,17 +140,37 @@ class CollectedFile {
     return false;
   }
 }
+
 class Collector {
-  constructor(schema, context, nuxtConfigDocuments = [], generatorOptions) {
+  constructor(schema, helper) {
     this.schema = schema;
-    this.context = context;
-    this.nuxtConfigDocuments = nuxtConfigDocuments;
-    this.generator = new Generator(schema, generatorOptions);
+    this.helper = helper;
+    const mappedOptions = { ...helper.options.codegenConfig };
+    if (!mappedOptions.output) {
+      mappedOptions.output = {};
+    }
+    if (!mappedOptions.output.buildTypeDocFilePath) {
+      mappedOptions.output.buildTypeDocFilePath = (filePath) => {
+        if (filePath.startsWith("/")) {
+          return this.filePathToBuildRelative(filePath);
+        }
+        return filePath;
+      };
+    }
+    this.generator = new Generator(schema, mappedOptions);
   }
   /**
    * All collected files.
    */
   files = /* @__PURE__ */ new Map();
+  /**
+   * All documents provided by hooks.
+   */
+  hookDocuments = /* @__PURE__ */ new Map();
+  /**
+   * All file paths provided by hooks.
+   */
+  hookFiles = /* @__PURE__ */ new Set();
   /**
    * The code generator.
    */
@@ -348,45 +184,78 @@ class Collector {
    */
   rpcItems = /* @__PURE__ */ new Map();
   /**
-   * The generated TypeScript type template output.
-   */
-  outputTypes = "";
-  /**
-   * The generated oeprations file.
-   */
-  outputOperations = "";
-  /**
-   * The generated context template file.
+   * The registered templates.
    */
-  outputContext = "";
+  templates = [];
   /**
-   * Whether we need to rebuild the Generator state.
+   * The generated template contents.
    */
-  needsRebuild = false;
-  filePathToRelative(filePath) {
-    return "./" + relative(this.context.buildDir, filePath);
+  templateResult = /* @__PURE__ */ new Map();
+  isInitialised = false;
+  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 "./" + this.helper.toModuleBuildRelative(filePath);
+  }
+  filePathToSourceRelative(filePath) {
+    if (filePath.startsWith("/")) {
+      return "./" + relative(process.cwd(), filePath);
+    }
+    return filePath;
   }
   operationToLogEntry(operation, errors) {
     return {
       name: operation.graphqlName,
       type: operation.operationType,
-      path: operation.filePath,
+      path: this.filePathToSourceRelative(operation.filePath),
       errors
     };
   }
+  getTemplate(template, type) {
+    const content = this.templateResult.get(template + "-" + type);
+    if (content === void 0) {
+      throw new Error(`Missing template content: ${template}`);
+    }
+    return content;
+  }
   /**
    * Executes code gen and performs validation for operations.
    */
-  buildState() {
+  async buildState() {
     const output = this.generator.build();
     const operations = output.getCollectedOperations();
     const generatedCode = output.getGeneratedCode();
-    this.outputOperations = output.getOperationsFile();
-    this.outputTypes = output.getEverything();
-    this.outputContext = generateContextTemplate(
-      operations,
-      this.context.serverApiPrefix
-    );
+    this.templates.forEach((template) => {
+      const path = template.options.path;
+      if (template.build) {
+        this.templateResult.set(
+          path + "-default",
+          this.helper.processTemplate(
+            template.options.path,
+            template.build(output, this.helper, this)
+          )
+        );
+      }
+      if (template.buildTypes) {
+        this.templateResult.set(
+          template.options.path + "-types",
+          this.helper.processTemplate(
+            template.options.path,
+            template.buildTypes(output, this.helper, this)
+          )
+        );
+      }
+    });
     const fragmentMap = /* @__PURE__ */ new Map();
     const operationSourceMap = /* @__PURE__ */ new Map();
     for (const code of generatedCode) {
@@ -415,90 +284,191 @@ class Collector {
       } else {
         this.operationTimestamps.set(operation.graphqlName, operation.timestamp);
       }
-      logEntries.push(this.operationToLogEntry(operation, errors));
+      const shouldLog = errors.length || !this.helper.options.logOnlyErrors;
+      if (shouldLog) {
+        logEntries.push(this.operationToLogEntry(operation, errors));
+      }
     }
-    logAllEntries(logEntries);
+    logAllEntries(
+      logEntries.sort((a, b) => {
+        return a.type.localeCompare(b.type) || a.name.localeCompare(b.name);
+      })
+    );
     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;
+    await this.helper.nuxt.callHook("nuxt-graphql-middleware:build", { output });
+    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
-        });
       }
     }
   }
+  buildErrorMessage(error) {
+    let output = "";
+    if (error instanceof FieldNotFoundError || error instanceof TypeNotFoundError || error instanceof FragmentNotFoundError) {
+      const filePath = error.context?.filePath;
+      const file = filePath ? this.files.get(filePath) : null;
+      if (filePath) {
+        output += ` | ${this.filePathToSourceRelative(filePath)}
+`;
+      }
+      output += "\n" + error.message + "\n\n";
+      if (file) {
+        output += file.fileContents;
+      }
+    } else if (error instanceof Error) {
+      output += "\n" + error.message;
+    }
+    return output;
+  }
+  logError(error) {
+    let output = `${SYMBOL_CROSS}`;
+    output += this.buildErrorMessage(error);
+    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 {
+      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();
+          await this.init();
+          this.isInitialised = true;
+          return;
+        }
+      }
+      throw new Error("Graphql document validation failed.");
+    }
+  }
+  addHookDocument(identifier, source) {
+    this.hookDocuments.set("hook:" + identifier, source);
+  }
+  async addOrUpdateHookDocument(identifier, source) {
+    const fullIdentifier = "hook:" + identifier;
+    const exists = this.hookDocuments.has(fullIdentifier);
+    this.hookDocuments.set(fullIdentifier, source);
+    if (exists && this.isInitialised) {
+      this.generator.update({
+        filePath: fullIdentifier,
+        document: source
       });
+      await this.buildState();
     }
-    return [];
+  }
+  addHookFile(filePath) {
+    this.hookFiles.add(filePath);
   }
   /**
    * Initialise the collector.
    */
-  async init() {
-    const files = await this.getImportPatternFiles();
-    for (const filePath of files) {
-      await this.addFile(filePath);
-    }
-    this.nuxtConfigDocuments.forEach((docString, i) => {
-      const pseudoPath = `nuxt.config.ts[${i}]`;
-      const file = new CollectedFile(pseudoPath, docString, false);
-      this.files.set(pseudoPath, file);
-      this.generator.add({
-        filePath: this.filePathToRelative("nuxt.config.ts"),
-        documentNode: file.parsed
+  async initDocuments() {
+    try {
+      const files = await this.helper.getImportPatternFiles();
+      for (const filePath of files) {
+        await this.addFile(filePath);
+      }
+      const nuxtConfigDocuments = this.helper.options.documents.join("\n\n");
+      if (nuxtConfigDocuments.length) {
+        const filePath = this.helper.paths.nuxtConfig;
+        const file = new CollectedFile(filePath, nuxtConfigDocuments, false);
+        this.files.set(filePath, file);
+        this.generator.add({
+          filePath,
+          documentNode: file.parsed
+        });
+      }
+      const hookDocuments = [...this.hookDocuments.entries()];
+      hookDocuments.forEach(([identifier, source]) => {
+        const file = new CollectedFile(identifier, source, false);
+        this.files.set(identifier, file);
+        this.generator.add({
+          filePath: identifier,
+          documentNode: file.parsed
+        });
       });
-    });
-    this.buildState();
-    logger.success("All GraphQL documents are valid.");
+      for (const filePath of this.hookFiles) {
+        await this.addFile(filePath);
+      }
+      await this.buildState();
+      logger.success("All GraphQL documents are valid.");
+    } catch (e) {
+      this.logError(e);
+      throw new Error("GraphQL document validation failed.");
+    }
   }
   /**
    * Add a file.
    */
   async addFile(filePath) {
     const file = await CollectedFile.fromFilePath(filePath);
+    if (!file?.fileContents) {
+      return null;
+    }
     this.files.set(filePath, file);
     this.generator.add({
-      filePath: this.filePathToRelative(filePath),
+      filePath,
       documentNode: file.parsed
     });
     return file;
   }
+  matchesPatternOrExists(filePath) {
+    return this.files.has(filePath) || this.hookFiles.has(filePath) || this.hookDocuments.has(filePath) || this.helper.matchesImportPattern(filePath);
+  }
   async handleAdd(filePath) {
-    await this.addFile(filePath);
-    return true;
+    if (!this.matchesPatternOrExists(filePath)) {
+      return false;
+    }
+    const result = await this.addFile(filePath);
+    return !!result;
   }
   async handleChange(filePath) {
+    if (!this.matchesPatternOrExists(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: this.filePathToRelative(filePath),
-      documentNode: file.parsed
-    });
     return true;
   }
   handleUnlink(filePath) {
@@ -507,7 +477,7 @@ class Collector {
       return false;
     }
     this.files.delete(filePath);
-    this.generator.remove(this.filePathToRelative(filePath));
+    this.generator.remove(filePath);
     return true;
   }
   handleUnlinkDir(folderPath) {
@@ -527,6 +497,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);
@@ -536,357 +507,1181 @@ class Collector {
         hasChanged = this.handleUnlink(filePath);
       } else if (event === "unlinkDir") {
         hasChanged = this.handleUnlinkDir(filePath);
-      } else if (event === "addDir") {
       }
       if (hasChanged) {
-        this.buildState();
+        await this.buildState();
       }
     } catch (e) {
       this.generator.resetCaches();
       logger.error("Failed to update GraphQL code.");
-      logger.error(e);
-      return false;
+      this.logError(e);
+      return {
+        hasChanged: false,
+        affectedOperations: [],
+        error: { message: this.buildErrorMessage(e) }
+      };
     }
+    const affectedOperations = [];
     if (hasChanged) {
-      logger.success("Finished GraphQL code update.");
+      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(template.options.path, "default");
+    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 path = template.options.path;
+        const filename = template.options.isFullPath ? path : path + ".js";
+        addTemplate({
+          filename,
+          write: true,
+          getContents: () => this.getTemplate(path, "default")
+        });
+      }
+    }
+    if (template.buildTypes) {
+      const path = template.options.path;
+      const filename = template.options.path + ".d.ts";
+      addTypeTemplate(
+        {
+          filename,
+          write: true,
+          getContents: () => this.getTemplate(path, "types")
+        },
+        {
+          nuxt: true,
+          nitro: true
+        }
+      );
+    }
   }
   /**
-   * Get the context template contents.
+   * Get the hook documents.
    */
-  getTemplateContext() {
-    return this.outputContext;
+  getHookDocuments() {
+    return [...this.hookDocuments.entries()].map(([identifier, source]) => {
+      return {
+        identifier,
+        source
+      };
+    });
   }
   /**
-   * Get the operations template contents.
+   * Get the hook documents.
    */
-  getTemplateOperations() {
-    return this.outputOperations;
+  getHookFiles() {
+    return [...this.hookFiles.values()];
   }
 }
 
-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, aliasPath) {
-      nuxt.options.alias[name2] = aliasPath;
-    }
-    const isModuleBuild = process.env.MODULE_BUILD === "true" && nuxt.options._prepare;
-    if (isModuleBuild) {
-      options.graphqlEndpoint = "http://localhost";
-      options.downloadSchema = false;
-      options.schemaPath = "~~/schema.graphql";
-      options.autoImportPatterns = [
-        "~~/playground/**/*.{gql,graphql}",
-        "!node_modules"
-      ];
-    }
-    if (!passedOptions.autoImportPatterns) {
-      options.autoImportPatterns = ["~~/**/*.{gql,graphql}", "!node_modules"];
-    }
-    options.autoImportPatterns = (options.autoImportPatterns || []).map(
-      (pattern) => {
-        return resolveAlias(pattern);
+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.");
       }
-    );
-    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: []
-    });
-    const runtimeDir = fileURLToPath(new URL("./runtime", import.meta.url));
-    nuxt.options.build.transpile.push(runtimeDir);
-    const context = {
-      patterns: options.autoImportPatterns || [],
-      srcDir: nuxt.options.srcDir,
-      buildDir: srcResolver.resolve(nuxt.options.buildDir),
-      schemaPath,
-      serverApiPrefix: options.serverApiPrefix
-    };
-    const collector = new Collector(
-      schema,
-      context,
-      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()];
-          }
-        });
-      });
     }
-    nuxt.options.runtimeConfig.public["nuxt-graphql-middleware"] = {
-      serverApiPrefix: options.serverApiPrefix
-    };
-    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");
+  }
+  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;
       }
-      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
-          };
-        }
+    }
+    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
       );
-      addServerImports(serverUtils);
+      throw new Error("Missing GraphQL schema.");
     }
-    const templateTypescript = addTemplate({
-      filename: GraphqlMiddlewareTemplate.OperationTypes,
-      write: true,
-      getContents: () => collector.getTemplateTypes()
-    });
-    addAlias("#graphql-operations", templateTypescript.dst);
-    const templateDocuments = addTemplate({
-      filename: GraphqlMiddlewareTemplate.Documents,
-      write: true,
-      getContents: () => collector.getTemplateOperations()
-    });
-    addAlias("#graphql-documents", templateDocuments.dst);
-    const templateContext = addTemplate({
-      filename: GraphqlMiddlewareTemplate.ComposableContext,
-      write: true,
-      getContents: () => collector.getTemplateContext()
-    });
-    addAlias("#nuxt-graphql-middleware/generated-types", templateContext.dst);
-    addTemplate({
-      write: true,
-      filename: "nuxt-graphql-middleware/graphql-documents.d.ts",
-      getContents: () => {
-        return `
-import type {
-  GraphqlMiddlewareQuery,
-  GraphqlMiddlewareMutation,
-} from '#nuxt-graphql-middleware/generated-types'
-
-declare module '#graphql-documents' {
-  type Operations = {
-    query: GraphqlMiddlewareQuery
-    mutation: GraphqlMiddlewareMutation
+    logger.info(`Loading GraphQL schema from disk: ${this.helper.paths.schema}`);
+    return await fs.readFile(this.helper.paths.schema).then((v) => v.toString());
   }
-  const operations: Operations
-  export { operations, Operations }
-}
-`;
-      }
-    });
-    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;
+  /**
+   * Downloads the schema and saves it to disk.
+   *
+   * @returns The schema contents.
+   */
+  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("No graphqlMiddleware.serverOptions file found.");
     };
-    const resolvedPath = findServerOptions();
-    const moduleTypesPath = relative(
-      nuxt.options.buildDir,
-      moduleResolver.resolve("./types")
-    );
-    const resolvedPathRelative = resolvedPath ? relative(nuxt.options.buildDir, resolvedPath) : null;
-    const template = addTemplate({
-      filename: "graphqlMiddleware.serverOptions.mjs",
-      write: true,
-      getContents: () => {
-        const serverOptionsLine = resolvedPathRelative ? `import serverOptions from '${resolvedPathRelative}'` : `const serverOptions = {}`;
-        return `
-${serverOptionsLine}
-export { serverOptions }
-`;
-      }
+    logger.info(`Downloading GraphQL schema from "${endpoint}".`);
+    return generate(config, true).then((v) => v[0]?.content);
+  }
+  /**
+   * Determine if the schema exists on disk.
+   *
+   * @returns True if the schema file exists on disk.
+   */
+  hasSchemaOnDisk() {
+    return fs.access(this.helper.paths.schema).then(() => true).catch(() => false);
+  }
+  /**
+   * Load the schema either from disk or by downloading it.
+   *
+   * @param forceDownload - Forces downloading the schema.
+   */
+  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: []
     });
-    addTemplate({
-      filename: "graphqlMiddleware.serverOptions.d.ts",
-      write: true,
-      getContents: () => {
-        const serverOptionsLineTypes = resolvedPathRelative ? `import serverOptions from '${resolvedPathRelative}'` : `const serverOptions: GraphqlMiddlewareServerOptions = {}`;
-        return `
-import type { GraphqlMiddlewareServerOptions } from '${moduleTypesPath}'
-${serverOptionsLineTypes}
-import type { GraphqlServerResponse } from '${runtimeTypesPath}'
-import type { GraphqlMiddlewareResponseUnion } from '#nuxt-graphql-middleware/generated-types'
-
-type GraphqlResponseAdditions =
-  typeof serverOptions extends GraphqlMiddlewareServerOptions<infer R, any, any> ? R : {}
-
-export type GraphqlResponse<T> = GraphqlServerResponse<T> & GraphqlResponseAdditions
-
-export type GraphqlResponseTyped = GraphqlResponse<GraphqlMiddlewareResponseUnion>
+  }
+  /**
+   * Get the schema.
+   *
+   * @returns The parsed GraphQL schema object.
+   */
+  getSchema() {
+    if (!this.schema) {
+      throw new Error("Failed to load schema.");
+    }
+    return this.schema;
+  }
+}
 
-export { serverOptions }
+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 getClientOptionsImport = () => {
-      const clientOptionsPath = appResolver.resolve(
-        "graphqlMiddleware.clientOptions"
-      );
-      if (fileExists(clientOptionsPath)) {
-        const pathRelative = relative(nuxt.options.buildDir, clientOptionsPath);
-        return `import clientOptions from '${pathRelative}'`;
+  }
+  abort() {
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = null;
+    }
+  }
+}
+
+class ModuleHelper {
+  constructor(nuxt, moduleUrl, options) {
+    this.nuxt = nuxt;
+    const mergedOptions = defu({}, options, defaultOptions);
+    if (!mergedOptions.autoImportPatterns) {
+      mergedOptions.autoImportPatterns = [
+        "~~/**/*.{gql,graphql}",
+        "!node_modules"
+      ];
+    }
+    const layerAliases = nuxt.options._layers.map((layer) => {
+      return {
+        "~~": layer.config.rootDir,
+        "@@": layer.config.rootDir,
+        "~": layer.config.srcDir,
+        "@": layer.config.srcDir,
+        // Merge any additional aliases defined by the layer.
+        // Must be last so that the layer may override the "default" aliases.
+        ...layer.config.alias || {}
+      };
+    });
+    const srcResolver = createResolver(nuxt.options.srcDir);
+    const rootResolver = createResolver(nuxt.options.rootDir);
+    mergedOptions.autoImportPatterns = (mergedOptions.autoImportPatterns || []).flatMap((pattern) => {
+      if (pattern.startsWith("!") || pattern.startsWith("/")) {
+        return pattern;
+      } else if (pattern.startsWith("~") || pattern.startsWith("@")) {
+        return layerAliases.map((aliases) => resolveAlias(pattern, aliases));
       }
+      return rootResolver.resolve(pattern);
+    }).map((pattern) => {
+      return pattern.replace(".{graphql}", ".graphql").replace(".{gql}", ".gql");
+    });
+    this.options = mergedOptions;
+    if (!nuxt.options._prepare) {
+      validateOptions(this.options);
+    }
+    this.isDev = nuxt.options.dev;
+    this.resolvers = {
+      module: createResolver(moduleUrl),
+      server: createResolver(nuxt.options.serverDir),
+      src: srcResolver,
+      app: createResolver(nuxt.options.dir.app),
+      root: rootResolver
     };
-    const clientOptionsImport = getClientOptionsImport();
-    const clientOptionsTemplate = addTemplate({
-      filename: "graphqlMiddleware.clientOptions.mjs",
-      write: true,
-      getContents: () => {
-        if (clientOptionsImport) {
-          return `${clientOptionsImport}
-export { clientOptions }`;
-        }
-        return `export const clientOptions = {}`;
+    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: "",
+      clientOptions: this.findClientOptions(),
+      moduleBuildDir: nuxt.options.buildDir + "/nuxt-graphql-middleware",
+      moduleTypesDir: nuxt.options.buildDir + "/graphql-operations"
+    };
+    this.paths.runtimeTypes = this.toModuleBuildRelative(
+      this.resolvers.module.resolve("./runtime/types.ts")
+    );
+    this.paths.serverOptions = this.findServerOptions();
+  }
+  resolvers;
+  paths;
+  isDev;
+  options;
+  prompt = new ConsolePrompt();
+  nitroExternals = [];
+  tsPaths = {};
+  /**
+   * 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").`
+        );
       }
-    });
-    const runtimeTypesPath = relative(
-      nuxt.options.buildDir,
-      moduleResolver.resolve("./runtime/types.ts")
+    }
+    logger.info("No graphqlMiddleware.serverOptions file found.");
+    return null;
+  }
+  findClientOptions() {
+    const clientOptionsPath = this.resolvers.app.resolve(
+      "graphqlMiddleware.clientOptions"
     );
-    addTemplate({
-      filename: "graphqlMiddleware.clientOptions.d.ts",
-      write: true,
-      getContents: () => {
-        if (clientOptionsImport) {
-          return `import type { GraphqlClientOptions } from '${runtimeTypesPath}'
-${clientOptionsImport}
+    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
+    );
+  }
+  matchesImportPattern(filePath) {
+    return micromatch.isMatch(filePath, this.options.autoImportPatterns) || this.options.autoImportPatterns.includes(filePath);
+  }
+  addAlias(name, path) {
+    this.nuxt.options.alias[name] = path;
+    const pathFromName = `./${name.substring(1)}`;
+    this.tsPaths[name] = pathFromName;
+    this.tsPaths[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);
+    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.typescript.tsConfig ||= {};
+    this.nuxt.options.typescript.tsConfig.compilerOptions ||= {};
+    this.nuxt.options.typescript.tsConfig.compilerOptions.paths ||= {};
+    for (const [name, path] of Object.entries(this.tsPaths)) {
+      this.nuxt.options.nitro.typescript.tsConfig.compilerOptions.paths[name] = [path];
+      this.nuxt.options.typescript.tsConfig.compilerOptions.paths[name] = [path];
+    }
+  }
+  processTemplate(path, content) {
+    if (path.includes("graphql-operations/") || path.endsWith(".graphql")) {
+      return content.trim();
+    }
+    const name = path.split("/")[1];
+    return `/*
+ * @see [Documentation](https://nuxt-graphql-middleware.dulnan.net/advanced/templates#${name})
+ */
+${content.trim()}`;
+  }
+  addTemplate(template) {
+    if (template.build) {
+      const content = this.processTemplate(
+        template.options.path,
+        template.build(this)
+      );
+      addTemplate({
+        filename: template.options.path + ".js",
+        write: true,
+        getContents: () => content
+      });
+    }
+    if (template.buildTypes) {
+      const content = this.processTemplate(
+        template.options.path,
+        template.buildTypes(this)
+      );
+      const filename = template.options.path + ".d.ts";
+      addTypeTemplate({
+        filename,
+        write: true,
+        getContents: () => content
+      });
+    }
+  }
+  addPlugin(name) {
+    addPlugin(this.resolvers.module.resolve("./runtime/plugins/" + name), {
+      append: false
+    });
+  }
+  addServerHandler(name, path, method) {
+    addServerHandler({
+      handler: this.resolvers.module.resolve("./runtime/server/api/" + name),
+      route: this.options.serverApiPrefix + path,
+      method
+    });
+  }
+  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
+      }
+    ]);
+  }
+}
+
+function defineGeneratorTemplate(options, build, buildTypes) {
+  return {
+    type: "generator",
+    options,
+    build,
+    buildTypes
+  };
+}
+function defineStaticTemplate(options, build, buildTypes) {
+  return {
+    type: "static",
+    options,
+    build,
+    buildTypes
+  };
+}
 
-export type GraphqlClientContext = typeof clientOptions extends GraphqlClientOptions<infer R> ? R : {}
+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 clientOptionsImport from '${pathRelative}'
 
-export { clientOptions }`;
-        }
-        return `import type { GraphqlClientOptions } from '${runtimeTypesPath}'
-export const clientOptions: GraphqlClientOptions
+declare export const clientOptions: GraphqlClientOptions
+export type GraphqlClientContext = typeof clientOptionsImport extends GraphqlClientOptions<infer R> ? R : {}
+`;
+    }
+    return `
+import type { GraphqlClientOptions } from '${helper.paths.runtimeTypes}'
 
+declare 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")
+  }
+);
+
+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",
+        ""
+      )
     );
-    addServerHandler({
-      handler: moduleResolver.resolve("./runtime/serverHandler/index"),
-      route: options.serverApiPrefix + "/:operation/:name"
+    const schemaPath = "./" + relative(configPath, helper.paths.schema);
+    const documents = patterns.filter((v) => !v.includes("!")).map((pattern) => {
+      return "./" + relative(configPath, helper.resolvers.root.resolve(pattern));
     });
-    if (options.enableFileUploads) {
-      addServerHandler({
-        handler: moduleResolver.resolve("./runtime/serverHandler/upload"),
-        route: options.serverApiPrefix + "/upload/:name"
-      });
+    documents.push(
+      "./" + relative(
+        configPath,
+        join(helper.paths.moduleBuildDir, "hook-documents.graphql")
+      )
+    );
+    return `
+import { hookFiles } from './hook-files'
+
+const schema = ${JSON.stringify(schemaPath)}
+
+const documents = ${JSON.stringify(documents, null, 2)};
+
+const config = {
+  schema,
+  documents: [
+    ...documents,
+    ...hookFiles
+  ]
+}
+
+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 serverApiPrefix + '/' + operation + '/' + operationName
+}
+`;
+  },
+  () => {
+    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}>
+    }`
+      );
     }
-    addPlugin(moduleResolver.resolve("./runtime/plugins/provideState"), {
-      append: false
+    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 }
+`;
+  },
+  (helper) => {
+    if (helper.paths.serverOptions) {
+      const resolvedPathRelative = helper.toModuleBuildRelative(
+        helper.paths.serverOptions
+      );
+      return `
+import type { GraphqlMiddlewareServerOptions } from '${helper.paths.runtimeTypes}'
+import serverOptionsImport from '${resolvedPathRelative}'
+
+export type GraphqlResponseAdditions =
+  typeof serverOptionsImport extends GraphqlMiddlewareServerOptions<infer R, any, any> ? R : {}
+
+declare export const serverOptions: GraphqlMiddlewareServerOptions
+`;
+    }
+    return `
+import type { GraphqlMiddlewareServerOptions } from '${helper.paths.runtimeTypes}'
+
+declare export const serverOptions: GraphqlMiddlewareServerOptions
+
+export type GraphqlResponseAdditions = object
+`;
+  }
+);
+
+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 = operation.filePath.startsWith("/") ? relative(srcDir, operation.filePath) : operation.filePath;
+      lines.push(
+        `${operation.operationType}_${operation.graphqlName}: '${filePath}',`
+      );
+    }
+    return `
+export const operationSources = {
+  ${lines.join("\n  ")}
+}
+`;
+  },
+  () => {
+    return `export const operationSources: Record<string, string>`;
+  }
+);
+
+const HookDocuments = defineGeneratorTemplate(
+  {
+    path: "nuxt-graphql-middleware/hook-documents.graphql",
+    virtual: false,
+    isFullPath: true
+  },
+  (_output, _helper, collector) => {
+    return collector.getHookDocuments().map((v) => {
+      return `
+# ${v.identifier}
+${v.source}
+`;
+    }).join("\n\n");
+  },
+  null
+);
+
+const HookFiles = defineGeneratorTemplate(
+  {
+    path: "nuxt-graphql-middleware/hook-files",
+    virtual: false
+  },
+  (_output, helper, collector) => {
+    const configPath = helper.resolvers.root.resolve(
+      (helper.options.graphqlConfigFilePath || "").replace(
+        "/graphql.config.ts",
+        ""
+      )
+    );
+    const files = collector.getHookFiles().map((filePath) => {
+      return "./" + relative(configPath, filePath);
     });
-    nuxt.hook("nitro:config", (nitroConfig) => {
-      nitroConfig.externals = defu(
-        typeof nitroConfig.externals === "object" ? nitroConfig.externals : {},
-        {
-          inline: [moduleResolver.resolve("./runtime")]
-        }
+    return `export const hookFiles = ${JSON.stringify(files, null, 2)}`;
+  },
+  null
+);
+
+const TEMPLATES = [
+  ClientOptions,
+  Documents,
+  GraphqlConfig,
+  Helpers,
+  NitroTypes,
+  OperationTypesAll,
+  Operations,
+  Response,
+  ServerOptions,
+  Sources,
+  HookDocuments,
+  HookFiles
+];
+
+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 (nuxt.options.dev || nuxt.options._prepare) {
-      addServerHandler({
-        handler: moduleResolver.resolve("./runtime/serverHandler/debug"),
-        route: options.serverApiPrefix + "/debug"
+  } 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
+      }
+    });
+  });
+}
+
+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()];
+            }
+          }
+        );
       });
-      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, providedFilePath) {
+    if (!providedFilePath.endsWith(".graphql") && !providedFilePath.endsWith(".gql")) {
+      return;
+    }
+    const pathAbsolute = providedFilePath.startsWith("/") ? providedFilePath : this.helper.resolvers.src.resolve(providedFilePath);
+    if (pathAbsolute === this.helper.paths.schema) {
+      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 = await collector.handleWatchEvent(event, pathAbsolute);
-        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 }
+    });
+  }
+}
+
+class ModuleContext {
+  constructor(schemaProvider, collector) {
+    this.schemaProvider = schemaProvider;
+    this.collector = collector;
+  }
+  /**
+   * Return the GraphQL schema.
+   *
+   * Note that the schema may be updated during development, so it can become
+   * stale. Prefer using methods like `schemaHasType()` to query the schema.
+   *
+   * @returns The GraphQL schema.
+   */
+  getSchema() {
+    return this.schemaProvider.getSchema();
+  }
+  /**
+   * Check if the given GraphQL type (interface, concrete type, enum, input type)
+   * exists in the schema.
+   *
+   * @param name - The name of the type.
+   *
+   * @returns True if the type exists in the schema.
+   */
+  schemaHasType(name) {
+    return !!this.schemaProvider.getSchema().getType(name);
+  }
+  /**
+   * Get a type from the schema.
+   *
+   * @param name - The name of the type.
+   *
+   * @returns The type.
+   */
+  schemaGetType(name) {
+    return this.schemaProvider.getSchema().getType(name);
+  }
+  /**
+   * Add an additional static document.
+   *
+   * @param identifier - The unique identifier for your document.
+   * @param source - The document source.
+   */
+  addDocument(identifier, source) {
+    this.collector.addHookDocument(identifier, source);
+    return this;
+  }
+  /**
+   * Add or update an additional static document.
+   *
+   * @param identifier - The unique identifier for your document.
+   * @param source - The document source.
+   */
+  async addOrUpdateDocument(identifier, source) {
+    await this.collector.addOrUpdateHookDocument(identifier, source);
+    return this;
+  }
+  /**
+   * Add an additional GraphQL file to import.
+   *
+   * @param filePath - The absolute path to the file.
+   */
+  addImportFile(filePath) {
+    if (!filePath.startsWith("/")) {
+      throw new Error(
+        `The provided file path "${filePath}" must be an absolute path.`
+      );
+    }
+    if (!filePath.endsWith(".graphql") && !filePath.endsWith(".gql")) {
+      throw new Error(
+        `The provided file path "${filePath}" should have a .graphql or .gql extension.`
+      );
     }
+    this.collector.addHookFile(filePath);
+    return this;
+  }
+}
+
+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);
+    const moduleContext = new ModuleContext(schemaProvider, collector);
+    nuxt._nuxt_graphql_middleware = moduleContext;
+    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("provideState");
+    if (helper.isDev && helper.options.errorOverlay) {
+      helper.addPlugin("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();
+    nuxt.hooks.hookOnce("modules:done", async () => {
+      await nuxt.hooks.callHook("nuxt-graphql-middleware:init", moduleContext);
+      await collector.init();
+    });
+    if (!helper.isDev) {
+      return;
+    }
+    const devModeHandler = new DevModeHandler(
+      nuxt,
+      schemaProvider,
+      collector,
+      helper
+    );
+    devModeHandler.init();
   }
 });