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

package/dist/module.mjs

@@ -1,14 +1,13 @@
 import { fileURLToPath } from 'url';
 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, promises } from 'node:fs';
 import { relative } from 'pathe';
 import { basename } from 'node:path';
-import { printSourceLocation, parse, OperationTypeNode, Source } from 'graphql';
+import { printSourceLocation, parse, Source, OperationTypeNode } from 'graphql';
 import { Generator, FieldNotFoundError, TypeNotFoundError, FragmentNotFoundError } from 'graphql-typescript-deluxe';
 import 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';
@@ -20,7 +19,7 @@ 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.6";
+const version = "5.0.0-alpha.8";
 
 const logger = useLogger(name);
 const defaultOptions = {
@@ -139,75 +138,6 @@ 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, helper) {
     this.schema = schema;
@@ -240,9 +170,13 @@ class Collector {
    */
   rpcItems = /* @__PURE__ */ new Map();
   /**
-   * The generated templates.
+   * The registered templates.
+   */
+  templates = [];
+  /**
+   * The generated template contents.
    */
-  templates = /* @__PURE__ */ new Map();
+  templateResult = /* @__PURE__ */ new Map();
   async reset() {
     this.files.clear();
     this.generator.reset();
@@ -269,11 +203,8 @@ class Collector {
       errors
     };
   }
-  updateTemplate(template, content) {
-    this.templates.set(template, content);
-  }
   getTemplate(template) {
-    const content = this.templates.get(template);
+    const content = this.templateResult.get(template);
     if (content === void 0) {
       throw new Error(`Missing template content: ${template}`);
     }
@@ -286,33 +217,22 @@ class Collector {
     const output = this.generator.build();
     const operations = output.getCollectedOperations();
     const generatedCode = output.getGeneratedCode();
-    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)
-    );
+    this.templates.forEach((template) => {
+      if (template.build) {
+        const filename = template.options.path + ".js";
+        this.templateResult.set(
+          filename,
+          template.build(output, this.helper).trim()
+        );
+      }
+      if (template.buildTypes) {
+        const filename = template.options.path + ".d.ts";
+        this.templateResult.set(
+          filename,
+          template.buildTypes(output, this.helper).trim()
+        );
+      }
+    });
     const fragmentMap = /* @__PURE__ */ new Map();
     const operationSourceMap = /* @__PURE__ */ new Map();
     for (const code of generatedCode) {
@@ -350,21 +270,23 @@ class Collector {
     if (hasErrors) {
       throw new Error("GraphQL errors");
     }
-    for (const code of generatedCode) {
-      const id = `${code.identifier}_${code.graphqlName}`;
-      if (code.identifier === "fragment" || code.identifier === "mutation" || code.identifier === "query") {
-        if (this.rpcItems.get(id)?.timestamp === code.timestamp) {
-          continue;
+    if (this.helper.isDev) {
+      for (const code of generatedCode) {
+        const id = `${code.identifier}_${code.graphqlName}`;
+        if (code.identifier === "fragment" || code.identifier === "mutation" || code.identifier === "query") {
+          if (this.rpcItems.get(id)?.timestamp === code.timestamp) {
+            continue;
+          }
+          const fragmentDepdendencies = code.getGraphQLFragmentDependencies().map((name) => fragmentMap.get(name) || "").join("\n\n");
+          this.rpcItems.set(id, {
+            id,
+            timestamp: code.timestamp,
+            source: code.source + "\n\n" + fragmentDepdendencies,
+            name: code.graphqlName,
+            filePath: code.filePath,
+            identifier: code.identifier
+          });
         }
-        const fragmentDepdendencies = code.getGraphQLFragmentDependencies().map((name) => fragmentMap.get(name) || "").join("\n\n");
-        this.rpcItems.set(id, {
-          id,
-          timestamp: code.timestamp,
-          source: code.source + "\n\n" + fragmentDepdendencies,
-          name: code.graphqlName,
-          filePath: code.filePath,
-          identifier: code.identifier
-        });
       }
     }
   }
@@ -403,7 +325,7 @@ class Collector {
   async init() {
     try {
       await this.initDocuments();
-    } catch (e) {
+    } catch {
       if (this.helper.isDev) {
         const shouldRevalidate = await this.helper.prompt.confirm(
           "Do you want to revalidate the GraphQL documents?"
@@ -555,9 +477,10 @@ class Collector {
    * but a virtual template requires adding two templates.
    */
   addVirtualTemplate(template) {
-    const getContents = () => this.getTemplate(template);
+    const filename = template.options.path + ".js";
+    const getContents = () => this.getTemplate(filename);
     addTemplate({
-      filename: template,
+      filename,
       getContents
     });
     addServerTemplate({
@@ -567,7 +490,7 @@ class Collector {
       //
       // That way we can reference the same template using the alias in both
       // Nuxt and Nitro environments.
-      filename: "#" + template.replace(".mjs", ""),
+      filename: "#" + template.options.path,
       getContents
     });
   }
@@ -575,24 +498,32 @@ class Collector {
    * Adds a template that dependes on Collector state.
    */
   addTemplate(template) {
-    if (template.endsWith(".d.ts")) {
+    this.templates.push(template);
+    if (template.build) {
+      if (template.options.virtual) {
+        this.addVirtualTemplate(template);
+      } else {
+        const filename = template.options.path + ".js";
+        addTemplate({
+          filename,
+          write: true,
+          getContents: () => this.getTemplate(filename)
+        });
+      }
+    }
+    if (template.buildTypes) {
+      const filename = template.options.path + ".d.ts";
       addTypeTemplate(
         {
-          filename: template,
+          filename,
           write: true,
-          getContents: () => this.getTemplate(template)
+          getContents: () => this.getTemplate(filename)
         },
         {
           nuxt: true,
           nitro: true
         }
       );
-    } else {
-      addTemplate({
-        filename: template,
-        write: true,
-        getContents: () => this.getTemplate(template)
-      });
     }
   }
 }
@@ -853,6 +784,7 @@ class ModuleHelper {
   isDev;
   options;
   prompt = new ConsolePrompt();
+  nitroExternals = [];
   /**
    * Find the path to the graphqlMiddleware.serverOptions.ts file.
    */
@@ -936,24 +868,44 @@ class ModuleHelper {
       pathFromName
     ];
     this.nuxt.options.nitro.typescript.tsConfig.compilerOptions.paths[name + "/*"] = [pathFromName + "/*"];
+    this.nuxt.options.typescript.tsConfig ||= {};
+    this.nuxt.options.typescript.tsConfig.compilerOptions ||= {};
+    this.nuxt.options.typescript.tsConfig.compilerOptions.paths ||= {};
+    this.nuxt.options.typescript.tsConfig.compilerOptions.paths[name] = [
+      pathFromName
+    ];
+    this.nuxt.options.typescript.tsConfig.compilerOptions.paths[name + "/*"] = [
+      pathFromName + "/*"
+    ];
+    this.inlineNitroExternals(name);
   }
   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);
+    this.nitroExternals.push(path);
+    this.transpile(path);
   }
-  addTemplate(template, cb) {
-    const content = cb(this);
-    if (template.endsWith("d.ts")) {
-      addTypeTemplate({
-        filename: template,
+  transpile(path) {
+    this.nuxt.options.build.transpile.push(path);
+  }
+  applyBuildConfig() {
+    this.nuxt.options.nitro.externals ||= {};
+    this.nuxt.options.nitro.externals.inline ||= [];
+    this.nuxt.options.nitro.externals.inline.push(...this.nitroExternals);
+  }
+  addTemplate(template) {
+    if (template.build) {
+      const content = template.build(this).trim();
+      addTemplate({
+        filename: template.options.path + ".js",
         write: true,
         getContents: () => content
       });
-    } else {
-      addTemplate({
-        filename: template,
+    }
+    if (template.buildTypes) {
+      const content = template.buildTypes(this).trim();
+      const filename = template.options.path + ".d.ts";
+      addTypeTemplate({
+        filename,
         write: true,
         getContents: () => content
       });
@@ -987,37 +939,68 @@ class ModuleHelper {
   }
 }
 
-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'
+function defineGeneratorTemplate(options, build, buildTypes) {
+  return {
+    type: "generator",
+    options,
+    build,
+    buildTypes
+  };
+}
+function defineStaticTemplate(options, build, buildTypes) {
+  return {
+    type: "static",
+    options,
+    build,
+    buildTypes
+  };
+}
 
-const schema = ${JSON.stringify(schemaPath)}
+const ClientOptions = defineStaticTemplate(
+  { path: "nuxt-graphql-middleware/client-options" },
+  (helper) => {
+    if (helper.paths.clientOptions) {
+      const pathRelative = helper.toModuleBuildRelative(
+        helper.paths.clientOptions
+      );
+      return `import clientOptions from '${pathRelative}'
+export { clientOptions }
+`;
+    }
+    return `export const clientOptions = {}`;
+  },
+  (helper) => {
+    if (helper.paths.clientOptions) {
+      const pathRelative = helper.toModuleBuildRelative(
+        helper.paths.clientOptions
+      );
+      return `import type { GraphqlClientOptions } from '${helper.paths.runtimeTypes}'
+import { clientOptions } from '${pathRelative}'
 
-const documents: string[] = ${JSON.stringify(documents, null, 2)};
+export type GraphqlClientContext = typeof clientOptions extends GraphqlClientOptions<infer R> ? R : {}
 
-const config: IGraphQLConfig = {
-  schema,
-  documents,
-}
+export { clientOptions }`;
+    }
+    return `
+import type { GraphqlClientOptions } from '${helper.paths.runtimeTypes}'
+export const clientOptions: GraphqlClientOptions
 
-export default config
+export type GraphqlClientContext = {}
 `;
-}
+  }
+);
 
-function DocumentTypes() {
-  return `
-import type { Query, Mutation } from './operations'
+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 = {
@@ -1026,83 +1009,196 @@ declare module '#nuxt-graphql-middleware/documents' {
   }
   export const documents: Documents
 }`;
-}
+  }
+);
 
-function Types() {
-  return `declare module '#nuxt-graphql-middleware/sources' {
-  export const operationSources: Record<string, string>
-}`;
-}
+const GraphqlConfig = defineStaticTemplate(
+  { path: "nuxt-graphql-middleware/graphql.config" },
+  (helper) => {
+    const patterns = helper.options.autoImportPatterns || [];
+    const configPath = helper.resolvers.root.resolve(
+      (helper.options.graphqlConfigFilePath || "").replace(
+        "/graphql.config.ts",
+        ""
+      )
+    );
+    const schemaPath = "./" + relative(configPath, helper.paths.schema);
+    const documents = patterns.filter((v) => !v.includes("!")).map((pattern) => {
+      return "./" + relative(configPath, helper.resolvers.root.resolve(pattern));
+    });
+    return `const schema = ${JSON.stringify(schemaPath)}
 
-function HelpersTypes() {
-  return `export const serverApiPrefix: string;
-export function getEndpoint(operation: string, operationName: string): string`;
+const documents = ${JSON.stringify(documents, null, 2)};
+
+const config = {
+  schema,
+  documents,
 }
 
-function Helpers(helper) {
-  return `export const serverApiPrefix = '${helper.options.serverApiPrefix}'
+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 '${helper.options.serverApiPrefix}' + '/' + 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}>
+    }`
+      );
+    }
+    return `import type { GraphqlResponse } from './response'
+import type {
+  ${imports.sort().join(",\n  ")}
+} from './../graphql-operations'
 
-function ServerOptions(helper) {
-  const resolvedPathRelative = helper.paths.serverOptions ? helper.toModuleBuildRelative(helper.paths.serverOptions) : null;
-  const serverOptionsLine = resolvedPathRelative ? `import serverOptions from '${resolvedPathRelative}'` : `const serverOptions = {}`;
-  return `
+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 }
 `;
-}
-
-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}'
+  },
+  (helper) => {
+    const resolvedPathRelative = helper.paths.serverOptions ? helper.toModuleBuildRelative(helper.paths.serverOptions) : null;
+    const serverOptionsLineTypes = resolvedPathRelative ? `import serverOptions from '${resolvedPathRelative}'` : `const serverOptions: GraphqlMiddlewareServerOptions = {}`;
+    return `
+import type { GraphqlMiddlewareServerOptions } from '${helper.paths.runtimeTypes}'
 ${serverOptionsLineTypes}
 
 export type GraphqlResponseAdditions =
   typeof serverOptions extends GraphqlMiddlewareServerOptions<infer R, any, any> ? R : {}
 
 export { serverOptions }`;
-}
-
-function ClientOptions(helper) {
-  if (helper.paths.clientOptions) {
-    const pathRelative = helper.toModuleBuildRelative(
-      helper.paths.clientOptions
-    );
-    return `import clientOptions from '${pathRelative}'
-export { clientOptions }
-`;
   }
-  return `export const clientOptions = {}`;
-}
-
-function ClientOptionsTypes(helper) {
-  if (helper.paths.clientOptions) {
-    const pathRelative = helper.toModuleBuildRelative(
-      helper.paths.clientOptions
-    );
-    return `import type { GraphqlClientOptions } from '${helper.paths.runtimeTypes}'
-import { clientOptions } from '${pathRelative}'
-
-export type GraphqlClientContext = typeof clientOptions extends GraphqlClientOptions<infer R> ? R : {}
+);
 
-export { clientOptions }`;
+const Sources = defineGeneratorTemplate(
+  { path: "nuxt-graphql-middleware/sources" },
+  (output, helper) => {
+    const operations = output.getCollectedOperations();
+    const srcDir = helper.paths.root;
+    const lines = [];
+    for (const operation of operations) {
+      const filePath = relative(srcDir, operation.filePath);
+      lines.push(
+        `${operation.operationType}_${operation.graphqlName}: '${filePath}',`
+      );
+    }
+    return `
+export const operationSources = {
+  ${lines.join("\n  ")}
+}
+`;
+  },
+  () => {
+    return `export const operationSources: Record<string, string>`;
   }
-  return `
-import type { GraphqlClientOptions } from '${helper.paths.runtimeTypes}'
-export const clientOptions: GraphqlClientOptions
+);
 
-export type GraphqlClientContext = {}
-`;
-}
+const TEMPLATES = [
+  ClientOptions,
+  Documents,
+  GraphqlConfig,
+  Helpers,
+  NitroTypes,
+  OperationTypesAll,
+  Operations,
+  Response,
+  ServerOptions,
+  Sources
+];
 
 const DEVTOOLS_UI_ROUTE = "/__nuxt-graphql-middleware";
 const DEVTOOLS_UI_LOCAL_PORT = 3300;
@@ -1272,7 +1368,7 @@ const module = defineNuxtModule({
     configKey: "graphqlMiddleware",
     version,
     compatibility: {
-      nuxt: ">=3.16.0"
+      nuxt: ">=3.15.0"
     }
   },
   defaults: defaultOptions,
@@ -1281,7 +1377,6 @@ const module = defineNuxtModule({
     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
@@ -1289,11 +1384,10 @@ const module = defineNuxtModule({
     nuxt.options.runtimeConfig.graphqlMiddleware = {
       graphqlEndpoint: helper.options.graphqlEndpoint || ""
     };
-    nuxt.options.build.transpile.push(
-      fileURLToPath(new URL("./runtime", import.meta.url))
-    );
+    helper.transpile(fileURLToPath(new URL("./runtime", import.meta.url)));
     helper.inlineNitroExternals(helper.resolvers.module.resolve("./runtime"));
     helper.inlineNitroExternals(helper.paths.moduleBuildDir);
+    helper.inlineNitroExternals(helper.paths.moduleTypesDir);
     helper.addAlias("#nuxt-graphql-middleware", helper.paths.moduleBuildDir);
     helper.addAlias("#graphql-operations", helper.paths.moduleTypesDir);
     helper.addPlugin("./runtime/plugins/provideState");
@@ -1320,22 +1414,15 @@ const module = defineNuxtModule({
       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);
+    TEMPLATES.forEach((template) => {
+      if (template.type === "static") {
+        helper.addTemplate(template);
+      } else {
+        collector.addTemplate(template);
+      }
+    });
+    helper.applyBuildConfig();
+    await collector.init();
     if (!helper.isDev) {
       return;
     }