@lewebsimple/nuxt-graphql 0.4.0 → 0.5.0

package/dist/module.mjs

@@ -1,260 +1,276 @@
-import { join, relative, resolve, dirname } from 'node:path';
-import { useLogger, defineNuxtModule, createResolver, getLayerDirectories, addServerHandler, addServerImportsDir, addPlugin, addImportsDir } from '@nuxt/kit';
-import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
-import { glob } from 'tinyglobby';
-import { generate } from '@graphql-codegen/cli';
-import { parse, Kind } from 'graphql';
-import { resolveCacheConfig } from '../dist/runtime/app/lib/cache-config.js';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { resolve, dirname, relative } from 'node:path';
+import { defineNuxtModule, useLogger, createResolver, addTemplate, addServerHandler, addPlugin, addImportsDir, addServerImportsDir } from '@nuxt/kit';
+import { hash } from 'ohash';
+import { loadDocuments as loadDocuments$1 } from '@graphql-tools/load';
+import { GraphQLFileLoader } from '@graphql-tools/graphql-file-loader';
+import { Kind, getIntrospectionQuery, buildClientSchema, GraphQLSchema } from 'graphql';
+import { codegen } from '@graphql-codegen/core';
+import * as typescriptPlugin from '@graphql-codegen/typescript';
+import * as typescriptOperationsPlugin from '@graphql-codegen/typescript-operations';
+import * as typedDocumentNodePlugin from '@graphql-codegen/typed-document-node';
+import { mergeHeaders } from '../dist/runtime/shared/lib/headers.js';
+import { stitchSchemas } from '@graphql-tools/stitch';
+import { resolveCacheConfig } from '../dist/runtime/shared/lib/cache-config.js';
+export { defineGraphQLContext } from '../dist/runtime/server/lib/context.js';
+export { defineRemoteExecutorHooks } from '../dist/runtime/server/lib/remote-executor.js';
 
-function removeFileExtension(filePath) {
-  return filePath.replace(/\.[^/.]+$/, "");
-}
-function getGenericServerProxy(modulePath) {
-  return `export * from ${JSON.stringify(removeFileExtension(modulePath))};`;
-}
+const cyan = "\x1B[36m";
+const reset = "\x1B[0m";
 
-function getGraphQLContextProxy(contextPath) {
-  if (!contextPath) {
-    return [
-      `export const getGraphQLContext = async () => ({});`,
-      `export type GraphQLContext = Awaited<ReturnType<typeof getGraphQLContext>>;`
-    ].join("\n");
-  }
+function renderContextTemplate({ contextModules }) {
+  const imports = contextModules.map((module, index) => `import context${index} from ${JSON.stringify(module)};`);
+  const types = contextModules.map((_, index) => `Awaited<ReturnType<typeof context${index}>>`);
   return [
-    `import context from ${JSON.stringify(removeFileExtension(contextPath))};`,
-    ``,
-    `export const getGraphQLContext = context.getGraphQLContext;`,
-    `export type GraphQLContext = Awaited<ReturnType<typeof getGraphQLContext>>;`
+    `import type { H3Event } from "h3";`,
+    ...imports,
+    "",
+    `export type GraphQLContext = ${types.join("\n  & ")};`,
+    "",
+    "export async function createContext(event: H3Event): Promise<GraphQLContext> {",
+    "  const parts = await Promise.all([",
+    ...contextModules.map((_, index) => `    context${index}(event),`),
+    "  ]);",
+    "  return Object.assign({}, ...parts) as GraphQLContext;",
+    "}"
   ].join("\n");
 }
 
-async function findSingleFile(dirs, pattern, isRequired = false) {
-  for (const dir of dirs) {
-    const fullPattern = join(dir, pattern);
-    const files = await glob(fullPattern, { absolute: true });
-    if (files.length > 0) {
-      return files[0];
-    }
-  }
-  if (isRequired) {
-    throw new Error(`File not found: ${pattern} in directories:
-${dirs.join("\n")}`);
+async function loadDocuments(documents) {
+  try {
+    return await loadDocuments$1([
+      documents,
+      "!**/.cache/**",
+      "!**/.nuxt/**",
+      "!**/.output/**",
+      "!**/dist/**",
+      "!**/node_modules/**"
+    ], { loaders: [new GraphQLFileLoader()] });
+  } catch {
+    return [];
   }
 }
-async function findMultipleFiles(dirs, pattern) {
-  const files = [];
-  for (const dir of dirs) {
-    const foundFiles = await glob(pattern, { cwd: dir, absolute: true });
-    files.push(...foundFiles);
-  }
-  return Array.from(new Set(files));
-}
-function writeFileIfChanged(path, content) {
-  if (existsSync(path) && readFileSync(path, "utf-8") === content) {
-    return false;
+
+async function renderFragmentsTemplate({ documents }) {
+  const fragments = collectFragments(documents);
+  if (fragments.length === 0) {
+    return `export { }`;
   }
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, content, "utf-8");
-  return true;
+  return [
+    `export type {`,
+    ...fragments.map((name) => `  ${name},`),
+    `} from "./operations";`
+  ].join("\n");
 }
-function toRelativePath(from, to) {
-  let relativePath = relative(resolve(from), resolve(to));
-  relativePath = relativePath.replace(/\\/g, "/");
-  if (!relativePath.startsWith("./") && !relativePath.startsWith("../")) {
-    relativePath = `./${relativePath}`;
+function collectFragments(documents) {
+  const fragments = /* @__PURE__ */ new Set();
+  for (const source of documents) {
+    const doc = source.document;
+    if (!doc) continue;
+    for (const def of doc.definitions) {
+      if (def.kind !== Kind.FRAGMENT_DEFINITION) continue;
+      const name = def.name?.value;
+      if (!name) continue;
+      if (fragments.has(name)) {
+        throw new Error(`Duplicate GraphQL fragment name "${name}"`);
+      }
+      fragments.add(name);
+    }
   }
-  return relativePath;
+  return [...fragments.values()];
 }
 
-async function runGraphQLCodegen({ schema, documents, typedDocumentsPath }) {
-  const config = {
+async function renderOperationsTemplate({ schema, documents }) {
+  const output = await codegen({
+    filename: "operations.ts",
+    // @graphql-codegen/core codegen supports GraphQLSchema at runtime, but types expect DocumentNode
     schema,
     documents,
-    generates: {
-      // Typed document nodes
-      [typedDocumentsPath]: {
-        plugins: ["typescript", "typescript-operations", "typed-document-node"],
-        config: {
-          defaultScalarType: "never",
-          documentMode: "documentNode",
-          documentVariableSuffix: "Document",
-          enumsAsTypes: true,
-          inlineFragmentTypes: "combine",
-          preResolveTypes: false,
-          skipTypename: true,
-          strictScalars: true,
-          useTypeImports: true
-        }
-      }
+    plugins: [
+      { typescript: {} },
+      { typescriptOperations: {} },
+      { typedDocumentNode: {} }
+    ],
+    pluginMap: {
+      typescript: typescriptPlugin,
+      typescriptOperations: typescriptOperationsPlugin,
+      typedDocumentNode: typedDocumentNodePlugin
     },
-    ignoreNoDocuments: true,
-    silent: true
-  };
-  const result = await generate(config, true);
-  return result.map(({ filename }) => filename);
-}
-
-const logger = useLogger("graphql");
-const cyan = "\x1B[36m";
-const reset = "\x1B[0m";
-
-async function getRegistryContent({ layerRootDirs, rootDir, documents }) {
-  const docs = (await findMultipleFiles(layerRootDirs, documents)).map((path) => ({
-    path: toRelativePath(rootDir, path),
-    content: readFileSync(path, "utf-8")
-  }));
-  const parsed = {
-    fragments: /* @__PURE__ */ new Map(),
-    operations: {
-      query: /* @__PURE__ */ new Map(),
-      mutation: /* @__PURE__ */ new Map(),
-      subscription: /* @__PURE__ */ new Map()
-    }
-  };
-  for (const doc of docs) {
-    const ast = parse(doc.content);
-    for (const def of ast.definitions) {
-      switch (def.kind) {
-        // Process fragment definitions
-        case Kind.FRAGMENT_DEFINITION: {
-          const name = def.name.value;
-          const existing = parsed.fragments.get(name);
-          if (existing) {
-            throw new Error(`Duplicate fragment name ${name} in document ${doc.path} (previously defined in ${existing.path})`);
-          }
-          parsed.fragments.set(name, { kind: "fragment", name, path: doc.path });
-          break;
-        }
-        // Process operation definitions
-        case Kind.OPERATION_DEFINITION: {
-          const type = def.operation;
-          if (!["query", "mutation", "subscription"].includes(type)) continue;
-          const name = def.name?.value;
-          if (!name) throw new Error(`Unnamed ${type} operation in document ${doc.path}`);
-          const existing = parsed.operations[type].get(name);
-          if (existing) {
-            throw new Error(`Duplicate operation name ${name} in document ${doc.path} (previously defined in ${existing.path})`);
-          }
-          parsed.operations[type].set(name, { kind: "operation", type, name, path: doc.path });
-          break;
-        }
-      }
+    config: {
+      defaultScalarType: "never",
+      documentMode: "documentNode",
+      documentVariableSuffix: "Document",
+      enumsAsTypes: true,
+      inlineFragmentTypes: "combine",
+      omitOperationSuffix: true,
+      operationResultSuffix: "Result",
+      operationVariablesSuffix: "Variables",
+      preResolveTypes: false,
+      skipTypename: true,
+      strictScalars: true,
+      useTypeImports: true
     }
-  }
-  const content = [
-    `import * as ops from "#graphql/typed-documents";`,
-    ``,
-    `type ResultOf<T> = T extends { __apiType?: (variables: infer _) => infer R } ? R : never;`,
-    `type VariablesOf<T> = T extends { __apiType?: (variables: infer V) => infer _ } ? V : never;`,
-    ``
-  ];
-  const queries = Array.from(parsed.operations.query.values());
-  content.push(
-    `// Queries`,
-    `export const queries = {`,
-    ...queries.map(({ name }) => `  ${name}: ops.${name}Document,`),
-    `};`,
-    `export type QueryName = keyof typeof queries;`,
-    `export type QueryResult<N extends QueryName> = ResultOf<(typeof queries)[N]>;`,
-    `export type QueryVariables<N extends QueryName> = VariablesOf<(typeof queries)[N]>;`,
-    ``
-  );
-  const mutations = Array.from(parsed.operations.mutation.values());
-  content.push(
-    `// Mutations`,
-    `export const mutations = {`,
-    ...mutations.map(({ name }) => `  ${name}: ops.${name}Document,`),
-    `};`,
-    `export type MutationName = keyof typeof mutations;`,
-    `export type MutationResult<N extends MutationName> = ResultOf<(typeof mutations)[N]>;`,
-    `export type MutationVariables<N extends MutationName> = VariablesOf<(typeof mutations)[N]>;`,
-    ``
-  );
-  const subscriptions = Array.from(parsed.operations.subscription.values());
-  content.push(
-    `// Subscriptions`,
-    `export const subscriptions = {`,
-    ...subscriptions.map(({ name }) => `  ${name}: ops.${name}Document,`),
-    `};`,
-    `export type SubscriptionName = keyof typeof subscriptions;`,
-    `export type SubscriptionResult<N extends SubscriptionName> = ResultOf<(typeof subscriptions)[N]>;`,
-    `export type SubscriptionVariables<N extends SubscriptionName> = VariablesOf<(typeof subscriptions)[N]>;`,
-    ``
-  );
-  return content.join("\n");
+  });
+  return output;
 }
 
-function getRemoteExecMiddlewareProxy(middlewarePath) {
-  if (!middlewarePath) {
-    return [
-      `export const remoteExecMiddlewareHandler = undefined;`
-    ].join("\n");
-  }
+async function renderRegistryTemplate({ documents }) {
+  const operations = collectOperations(documents);
   return [
-    `import middleware from ${JSON.stringify(removeFileExtension(middlewarePath))};`,
+    `import type { DocumentNode } from "graphql";`,
+    `import {`,
+    ...operations.map(
+      ({ name }) => `  ${name}Document, type ${name}Variables, type ${name}Result,`
+    ),
+    `} from "./operations";`,
+    ``,
+    // Operation entry
+    `export interface OperationEntry<`,
+    `  TVariables,`,
+    `  TResult,`,
+    `  TKind extends "query" | "mutation" | "subscription"`,
+    `> {`,
+    `  kind: TKind;`,
+    `  variables: TVariables;`,
+    `  result: TResult;`,
+    `  document: DocumentNode;`,
+    `}`,
+    ``,
+    `export type OperationRegistry = {`,
+    ...operations.map(
+      ({ name, kind }) => `  ${name}: OperationEntry<${name}Variables, ${name}Result, "${kind}">;`
+    ),
+    `};`,
+    ``,
+    `export type OperationName = keyof OperationRegistry;`,
+    ``,
+    `export type QueryName = {`,
+    `  [K in keyof OperationRegistry]:`,
+    `    OperationRegistry[K]["kind"] extends "query" ? K : never`,
+    `}[keyof OperationRegistry];`,
+    ``,
+    `export type MutationName = {`,
+    `  [K in keyof OperationRegistry]:`,
+    `    OperationRegistry[K]["kind"] extends "mutation" ? K : never`,
+    `}[keyof OperationRegistry];`,
+    ``,
+    `export type SubscriptionName = {`,
+    `  [K in keyof OperationRegistry]:`,
+    `    OperationRegistry[K]["kind"] extends "subscription" ? K : never`,
+    `}[keyof OperationRegistry];`,
     ``,
-    `export const remoteExecMiddlewareHandler = middleware.remoteExecMiddlewareHandler;`
+    // Projection helpers
+    `export type VariablesOf<TName extends keyof OperationRegistry> =`,
+    `  OperationRegistry[TName]["variables"];`,
+    ``,
+    `export type ResultOf<TName extends keyof OperationRegistry> =`,
+    `  OperationRegistry[TName]["result"];`,
+    ``,
+    // Runtime registry (document + kind only)
+    `export const registry: {`,
+    `  [K in keyof OperationRegistry]: {`,
+    `    kind: OperationRegistry[K]["kind"];`,
+    `    document: DocumentNode;`,
+    `  };`,
+    `} = {`,
+    ...operations.map(
+      ({ name, kind }) => `  ${name}: { kind: "${kind}", document: ${name}Document },`
+    ),
+    `};`
   ].join("\n");
 }
+function collectOperations(documents) {
+  const operations = /* @__PURE__ */ new Map();
+  for (const source of documents) {
+    const doc = source.document;
+    if (!doc) continue;
+    for (const def of doc.definitions) {
+      if (def.kind !== Kind.OPERATION_DEFINITION) continue;
+      const name = def.name?.value;
+      if (!name) {
+        throw new Error("Anonymous GraphQL operations are not allowed");
+      }
+      if (operations.has(name)) {
+        throw new Error(`Duplicate GraphQL operation name "${name}"`);
+      }
+      operations.set(name, {
+        name,
+        kind: def.operation
+      });
+    }
+  }
+  return [...operations.values()];
+}
 
-function getDummySchemaProxy() {
-  return [
-    `import { createSchema } from "graphql-yoga";`,
-    ``,
-    `export const schema = createSchema({`,
-    `  typeDefs: /* GraphQL */ \``,
-    `    type Query {`,
-    `      hello: String!`,
-    `    } `,
-    `  \`,`,
-    `  resolvers: {`,
-    `    Query: {`,
-    `      hello: () => "Hello world!",`,
-    `    },`,
-    `  },`,
-    `});`
-  ].join("\n");
+function renderLocalSchemaTemplate({ path }) {
+  return `export { schema } from ${JSON.stringify(path)};`;
 }
-async function getLocalSchemaProxy({ layerRootDirs, schemaDef }) {
-  const schemaPath = await findSingleFile(layerRootDirs, schemaDef.path, true);
-  const content = [
-    `export { schema } from ${JSON.stringify(removeFileExtension(schemaPath))};`
-  ].join("\n");
-  return content;
+async function loadLocalSchema({ path }) {
+  const { createJiti } = await import('jiti');
+  const jiti = createJiti(import.meta.url, { interopDefault: true });
+  const module = await jiti.import(path);
+  if (!module.schema || !(module.schema instanceof Object) || typeof module.schema.getQueryType !== "function") {
+    throw new Error(`${path} must export a valid 'schema' of type GraphQLSchema.`);
+  }
+  return module.schema;
 }
-async function getRemoteSchemaProxy({ rootDir, schemaName, schemaDef }) {
-  const middlewareContent = getRemoteExecMiddlewareProxy(schemaDef.middleware ? join(rootDir, schemaDef.middleware) : void 0);
-  const schema = await fetchGraphQLSchema(schemaDef.url, schemaDef.headers);
-  const sdl = await getSDLFromGraphQLSchema(schema);
-  const sdlContent = `export const sdl = /* GraphQL */ \`${sdl.replace(/`/g, "\\`")}\`;`;
-  const schemaContent = [
+async function renderRemoteSchemaTemplate({ remoteExecutorModule, type, hooks, ...schemaDef }) {
+  const schema = await introspectRemoteSchema(schemaDef);
+  const sdl = await printSchemaSDL(schema);
+  const imports = (hooks || []).map((hookPath, index) => `import hooks${index} from ${JSON.stringify(hookPath)};`);
+  return [
     `import { buildSchema } from "graphql";`,
     `import type { SubschemaConfig } from "@graphql-tools/delegate";`,
-    `import { remoteExecMiddlewareHandler } from "./${schemaName}-middleware";`,
-    `import { sdl } from "./${schemaName}-sdl";`,
-    `import { createRemoteExecutor } from "../remote-executor";`,
-    ``,
-    `const headers = ${JSON.stringify(schemaDef.headers ?? {}, null, 2)} as HeadersInit;`,
+    `import { createRemoteExecutor } from ${JSON.stringify(remoteExecutorModule)};`,
+    ...imports,
     ``,
-    `const executor = createRemoteExecutor({`,
-    `  url: ${JSON.stringify(schemaDef.url)},`,
-    `  remoteName: ${JSON.stringify(schemaName)},`,
-    `  headers,`,
-    `  middleware: remoteExecMiddlewareHandler,`,
-    `});`,
+    `const sdl = /* GraphQL */ \`${sdl.replace(/`/g, "\\`")}\`;`,
     ``,
     `export const schema: SubschemaConfig = {`,
     `  schema: buildSchema(sdl),`,
-    `  executor,`,
+    `  executor: createRemoteExecutor({`,
+    `    ...${JSON.stringify(schemaDef)},`,
+    `    hooks: [`,
+    ...(hooks || []).map((_, index) => `      hooks${index},`),
+    `    ]`,
+    `  }),`,
     `};`
   ].join("\n");
-  return { middlewareContent, sdlContent, schemaContent };
 }
-async function getStitchedSchemaProxy({ schemaNames }) {
-  const content = [
-    `import { stitchSchemas } from "@graphql-tools/stitch"; `,
+async function introspectRemoteSchema({ url, headers }) {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: mergeHeaders({ "Content-Type": "application/json" }, headers),
+    body: JSON.stringify({ query: getIntrospectionQuery() })
+  });
+  const json = await response.json();
+  if (json.errors) {
+    throw new Error(`Failed to fetch GraphQL schema from ${url}: ${JSON.stringify(json.errors)} `);
+  }
+  const schema = buildClientSchema(json.data);
+  return stripSubscriptions(schema);
+}
+function stripSubscriptions(schema) {
+  if (!schema.getSubscriptionType()) {
+    return schema;
+  }
+  return new GraphQLSchema({
+    query: schema.getQueryType() ?? void 0,
+    mutation: schema.getMutationType() ?? void 0,
+    subscription: void 0,
+    types: Object.values(schema.getTypeMap()),
+    directives: schema.getDirectives()
+  });
+}
+async function printSchemaSDL(schema) {
+  const { printSchema, lexicographicSortSchema } = await import('graphql');
+  return printSchema(lexicographicSortSchema(schema));
+}
+function renderStitchedSchemaTemplate({ schemaNames }) {
+  return [
     `import type { GraphQLSchema } from "graphql"; `,
     `import type { SubschemaConfig } from "@graphql-tools/delegate"; `,
+    `import { stitchSchemas } from "@graphql-tools/stitch"; `,
     ...schemaNames.map((name) => `import { schema as ${name}Schema } from ${JSON.stringify(`./schemas/${name}`)}; `),
     ``,
     `const subschemas: Array<GraphQLSchema | SubschemaConfig> = [`,
@@ -263,183 +279,206 @@ async function getStitchedSchemaProxy({ schemaNames }) {
     ``,
     `export const schema = stitchSchemas({ subschemas }); `
   ].join("\n");
-  return content;
 }
-async function loadGraphQLSchema(schemaPath) {
-  const { createJiti } = await import('jiti');
-  const jiti = createJiti(import.meta.url, { interopDefault: true });
-  const module = await jiti.import(schemaPath);
-  if (!module.schema || !(module.schema instanceof Object) || typeof module.schema.getQueryType !== "function") {
-    throw new Error(`${schemaPath} must export a valid 'schema' of type GraphQLSchema.`);
+async function loadStitchedSchema(schemaDefs) {
+  const subschemas = [];
+  for (const schemaDef of Object.values(schemaDefs)) {
+    if (schemaDef.type === "local") {
+      subschemas.push(await loadLocalSchema(schemaDef));
+    } else if (schemaDef.type === "remote") {
+      subschemas.push(await introspectRemoteSchema(schemaDef));
+    }
   }
-  return module.schema;
+  return stitchSchemas({ subschemas });
 }
-async function fetchGraphQLSchema(schemaUrl, headers) {
-  const { getIntrospectionQuery, buildClientSchema } = await import('graphql');
-  const response = await fetch(schemaUrl, {
-    method: "POST",
-    headers: { "Content-Type": "application/json", ...headers },
-    body: JSON.stringify({ query: getIntrospectionQuery() })
-  });
-  const json = await response.json();
-  if (json.errors) {
-    throw new Error(`Failed to fetch GraphQL schema from ${schemaUrl}: ${JSON.stringify(json.errors)} `);
-  }
-  return buildClientSchema(json.data);
+
+function renderTypesTemplate() {
+  return `// Nuxt GraphQL types
+declare module "#graphql/context" {
+  export { createContext } from "#build/graphql/context";
+  export type { GraphQLContext } from "#build/graphql/context";
 }
-async function getSDLFromGraphQLSchema(schema) {
-  const { printSchema, lexicographicSortSchema } = await import('graphql');
-  return printSchema(lexicographicSortSchema(schema));
+
+declare module "#graphql/operations" {
+  export * from "#build/graphql/operations";
 }
 
-function getYogaMiddlewareProxy(middlewarePath) {
-  if (!middlewarePath) {
-    return [
-      `export const yogaMiddlewareHandler = undefined;`
-    ].join("\n");
-  }
-  return [
-    `import middleware from ${JSON.stringify(removeFileExtension(middlewarePath))};`,
-    ``,
-    `export const yogaMiddlewareHandler = middleware.yogaMiddlewareHandler;`
-  ].join("\n");
+declare module "#graphql/fragments" {
+  export * from "#build/graphql/fragments";
+}
+
+declare module "#graphql/registry" {
+  import type { DocumentNode } from "graphql";
+  export type { OperationName, QueryName, MutationName, SubscriptionName, VariablesOf, ResultOf } from "#build/graphql/registry";
+  export const registry: Readonly<Record<OperationName, { readonly document: DocumentNode; }>>;
+}
+
+declare module "#graphql/schema" {
+  export { schema } from "#build/graphql/schema";
+}`;
 }
 
 const module$1 = defineNuxtModule({
   meta: {
-    name: "@lewebsimple/nuxt-graphql",
+    name: "nuxt-graphql",
     configKey: "graphql"
   },
-  defaults: {
-    schemas: {}
-  },
+  defaults: {},
   async setup(options, nuxt) {
-    const { resolve } = createResolver(import.meta.url);
-    const { buildDir, rootDir } = nuxt.options;
-    const layerRootDirs = getLayerDirectories(nuxt).map(({ root }) => root);
-    nuxt.options.alias ||= {};
-    nuxt.options.runtimeConfig.public.graphql = {
-      cacheConfig: resolveCacheConfig(options.cache)
-    };
-    const serverProxies = {};
-    const contextPath = options.context ? await findSingleFile(layerRootDirs, options.context, true) : void 0;
-    if (contextPath) {
-      logger.info(`GraphQL context registered: ${cyan}${toRelativePath(rootDir, contextPath)}${reset}`);
-    }
-    serverProxies["context"] = getGraphQLContextProxy(contextPath);
-    serverProxies["remote-executor"] = getGenericServerProxy(resolve("./runtime/server/lib/remote-executor.ts"));
-    if (Object.keys(options.schemas || {}).length === 0) {
-      logger.warn("No GraphQL schemas defined in nuxt.config.ts, using dummy schema.");
-      serverProxies["schemas/dummy"] = getDummySchemaProxy();
-      serverProxies["schema"] = await getStitchedSchemaProxy({ schemaNames: ["dummy"] });
-    } else {
-      for (const [schemaName, schemaDef] of Object.entries(options.schemas)) {
-        switch (schemaDef.type) {
-          case "local": {
-            serverProxies[`schemas/${schemaName}`] = await getLocalSchemaProxy({ layerRootDirs, schemaDef });
-            break;
-          }
-          case "remote": {
-            const { middlewareContent, sdlContent, schemaContent } = await getRemoteSchemaProxy({ rootDir, schemaName, schemaDef });
-            serverProxies[`schemas/${schemaName}-middleware`] = middlewareContent;
-            serverProxies[`schemas/${schemaName}-sdl`] = sdlContent;
-            serverProxies[`schemas/${schemaName}`] = schemaContent;
-            break;
-          }
-          default:
-            throw new Error(`Unsupported GraphQL schema type: ${schemaDef.type}`);
-        }
-      }
-      serverProxies["schema"] = await getStitchedSchemaProxy({ schemaNames: Object.keys(options.schemas) });
-    }
-    if (options.middleware) {
-      const yogaMiddlewarePath = await findSingleFile(layerRootDirs, options.middleware, true);
-      logger.info(`GraphQL Yoga middleware registered: ${cyan}${toRelativePath(nuxt.options.rootDir, yogaMiddlewarePath)}${reset}`);
-      serverProxies["yoga-middleware"] = getYogaMiddlewareProxy(yogaMiddlewarePath);
-    } else {
-      serverProxies["yoga-middleware"] = getYogaMiddlewareProxy();
-    }
-    const sdlPath = options.saveSdl ? join(rootDir, options.saveSdl) : join(buildDir, "graphql/schema.graphql");
-    async function generateGraphQLSDL() {
-      const schema = await loadGraphQLSchema(join(buildDir, "graphql/schema.ts"));
-      const sdlContent = await getSDLFromGraphQLSchema(schema);
-      if (writeFileIfChanged(sdlPath, sdlContent)) {
-        logger.info(`GraphQL SDL generated: ${cyan}${toRelativePath(rootDir, sdlPath)}${reset}`);
+    const logger = useLogger("graphql");
+    const { resolve: resolveModule } = createResolver(import.meta.url);
+    const { resolve: resolveRoot, resolvePath: _resolveRootPath } = createResolver(nuxt.options.rootDir);
+    async function resolveRootPath(path, required = true) {
+      try {
+        if (!path) throw new Error("No path provided");
+        const resolvedPath = await _resolveRootPath(path);
+        return resolvedPath.replace(/\.(ts|mjs)$/u, "");
+      } catch {
+        if (required) throw new Error(`Cannot resolve path in rootDir: ${path}`);
+        return void 0;
       }
     }
-    const configPath = join(rootDir, options.saveConfig || "graphql.config.json");
-    const documents = options.documents || "**/*.gql";
-    async function generateGraphQLConfig() {
-      const configContent = JSON.stringify({ schema: toRelativePath(rootDir, sdlPath), documents }, null, 2);
-      if (writeFileIfChanged(configPath, configContent)) {
-        logger.info(`GraphQL Config generated: ${cyan}${toRelativePath(rootDir, configPath)}${reset}`);
+    function getRelativePath(to) {
+      let relativePath = relative(resolve(nuxt.options.rootDir), resolve(to));
+      relativePath = relativePath.replace(/\\/g, "/");
+      if (!relativePath.startsWith("./") && !relativePath.startsWith("../")) {
+        relativePath = `./${relativePath}`;
       }
+      return relativePath;
     }
-    const typedDocumentsPath = join(buildDir, "graphql/typed-documents.ts");
-    nuxt.options.alias["#graphql/typed-documents"] = typedDocumentsPath;
-    async function generateGraphQLCodegen() {
-      try {
-        const files = await runGraphQLCodegen({ schema: sdlPath, documents, typedDocumentsPath });
-        for (const file of files) {
-          logger.info(`GraphQL Codegen generated: ${cyan}${toRelativePath(rootDir, file)}${reset}`);
-        }
-      } catch (error) {
-        if (!nuxt.options.dev) {
-          throw error;
-        }
-        const message = error instanceof AggregateError ? error.errors[0].message : String(error);
-        logger.warn(message);
+    nuxt.options.alias ||= {};
+    nuxt.options.alias["#graphql"] = resolve(nuxt.options.buildDir, "graphql");
+    const nitroAlias = {};
+    const contextModules = [
+      resolveModule("./runtime/server/lib/default-context"),
+      ...await Promise.all((options.yoga?.context || []).map((path) => resolveRootPath(path, true)))
+    ];
+    const contextTemplate = addTemplate({
+      filename: "graphql/context.ts",
+      getContents: () => renderContextTemplate({ contextModules }),
+      write: true
+    });
+    nitroAlias["#graphql/context"] = contextTemplate.dst;
+    const schemaDefs = {};
+    for (const [schemaName, schemaDef] of Object.entries(options.yoga?.schemas || {})) {
+      let schemaTemplate2;
+      if (schemaDef.type === "local") {
+        const localSchemaDef = {
+          ...schemaDef,
+          path: await resolveRootPath(schemaDef.path, true)
+        };
+        schemaDefs[schemaName] = localSchemaDef;
+        schemaTemplate2 = addTemplate({
+          filename: `graphql/schemas/${schemaName}.ts`,
+          getContents: async () => renderLocalSchemaTemplate({ ...localSchemaDef }),
+          write: true
+        });
+      } else if (schemaDef.type === "remote") {
+        const remoteSchemaDef = {
+          ...schemaDef,
+          hooks: await Promise.all((schemaDef.hooks || []).map((hookPath) => resolveRootPath(hookPath, true))),
+          remoteExecutorModule: resolveModule("./runtime/server/lib/remote-executor")
+        };
+        schemaDefs[schemaName] = remoteSchemaDef;
+        schemaTemplate2 = addTemplate({
+          filename: `graphql/schemas/${schemaName}.ts`,
+          getContents: async () => await renderRemoteSchemaTemplate({ ...remoteSchemaDef }),
+          write: true
+        });
+      } else {
+        throw new Error(`Unknown schema type for schema "${schemaName}"`);
       }
+      nitroAlias[`#graphql/schemas/${schemaName}`] = schemaTemplate2.dst;
     }
-    const registryPath = join(buildDir, "graphql/registry.ts");
-    nuxt.options.alias["#graphql/registry"] = registryPath;
-    async function generateGraphQLRegistry() {
-      const registryContent = await getRegistryContent({ layerRootDirs, rootDir, documents });
-      writeFileIfChanged(registryPath, registryContent);
+    const schemaTemplate = addTemplate({
+      filename: "graphql/schema.ts",
+      getContents: () => renderStitchedSchemaTemplate({
+        schemaNames: Object.keys(options.yoga?.schemas || {})
+      }),
+      write: true
+    });
+    nitroAlias["#graphql/schema"] = schemaTemplate.dst;
+    let documentsCache = null;
+    async function getDocuments(glob) {
+      const key = `documents:${glob}`;
+      if (documentsCache?.key === key) return documentsCache.data;
+      const documents = await loadDocuments(glob);
+      documentsCache = { key, data: documents };
+      return documents;
     }
-    let artifactsPromise;
-    async function generateGraphQLArtifacts() {
-      if (!artifactsPromise) {
-        artifactsPromise = (async () => {
-          await generateGraphQLSDL();
-          await generateGraphQLConfig();
-          await generateGraphQLCodegen();
-          await generateGraphQLRegistry();
-        })();
-      }
-      return artifactsPromise;
+    const sdlPath = resolveRoot(options.saveSDL || "server/graphql/schema.graphql");
+    let schemaCache = null;
+    async function getStitchedSchema(schemaDefs2) {
+      const key = `schema:${hash(schemaDefs2)}`;
+      if (schemaCache?.key === key) return schemaCache.data;
+      const schema = await loadStitchedSchema(schemaDefs2);
+      schemaCache = { key, data: schema };
+      const sdl = await printSchemaSDL(schema);
+      mkdirSync(dirname(sdlPath), { recursive: true });
+      writeFileSync(sdlPath, sdl, { encoding: "utf-8" });
+      logger.info(`GraphQL SDL saved to: ${cyan}${getRelativePath(sdlPath)}${reset}`);
+      return schema;
     }
-    addServerHandler({ route: "/api/graphql", handler: resolve("./runtime/server/api/yoga-handler") });
-    nuxt.hook("listen", (_, { url }) => {
-      logger.success(`GraphQL Yoga ready: ${cyan}${url.replace(/\/$/, "")}/api/graphql${reset}`);
+    addTemplate({
+      filename: "graphql/operations.ts",
+      getContents: async () => await renderOperationsTemplate({
+        schema: await getStitchedSchema(schemaDefs),
+        documents: await getDocuments(options.client?.documents || "**/*.gql")
+      }),
+      write: true
     });
-    addServerImportsDir(resolve("./runtime/server/utils"));
-    addPlugin(resolve("./runtime/app/plugins/graphql-request"));
-    addPlugin(resolve("./runtime/app/plugins/graphql-sse.client"));
-    addImportsDir(resolve("./runtime/app/composables"));
-    nuxt.hook("nitro:config", async (nitroConfig) => {
-      nitroConfig.alias ||= {};
-      for (const [proxyName, proxyContent] of Object.entries(serverProxies)) {
-        const proxyPath = join(buildDir, "graphql", `${proxyName}.ts`);
-        nitroConfig.alias[`#graphql/${proxyName}`] = proxyPath;
-        writeFileIfChanged(proxyPath, proxyContent);
-      }
-      await generateGraphQLArtifacts();
+    addTemplate({
+      filename: "graphql/fragments.ts",
+      getContents: async () => await renderFragmentsTemplate({
+        documents: await getDocuments(options.client?.documents || "**/*.gql")
+      }),
+      write: true
+    });
+    addTemplate({
+      filename: "graphql/registry.ts",
+      getContents: async () => await renderRegistryTemplate({
+        documents: await getDocuments(options.client?.documents || "**/*.gql")
+      }),
+      write: true
     });
-    nuxt.hook("prepare:types", async ({ references }) => {
-      await generateGraphQLArtifacts();
-      references.push({ path: registryPath });
-      references.push({ path: typedDocumentsPath });
+    const configPath = resolveRoot(options.saveConfig || "graphql.config.json");
+    const config = { schema: getRelativePath(sdlPath), documents: options.client?.documents || "**/*.gql" };
+    mkdirSync(dirname(configPath), { recursive: true });
+    writeFileSync(configPath, JSON.stringify(config, null, 2), { encoding: "utf-8" });
+    logger.info(`GraphQL config saved to: ${cyan}${getRelativePath(configPath)}${reset}`);
+    const typesTemplate = addTemplate({
+      filename: "graphql/types.d.ts",
+      getContents: () => renderTypesTemplate(),
+      write: true
+    });
+    nuxt.options.runtimeConfig.public.graphql = {
+      cacheConfig: resolveCacheConfig(options.client?.cache),
+      ssrForwardHeaders: options.client?.ssrForwardHeaders || ["authorization", "cookie"]
+    };
+    nuxt.hook("prepare:types", ({ sharedReferences }) => {
+      sharedReferences.push({ path: typesTemplate.dst });
+      sharedReferences.push({ path: resolveModule("./runtime/shared/types/nuxt-graphql.d.ts") });
+    });
+    nuxt.hook("nitro:config", (nitroConfig) => {
+      nitroConfig.alias ||= {};
+      Object.assign(nitroConfig.alias, nitroAlias);
     });
     if (nuxt.options.dev) {
-      nuxt.hook("builder:watch", async (_event, path) => {
-        if (path.endsWith(".gql")) {
-          logger.info(`GraphQL document change detected: ${cyan}${toRelativePath(nuxt.options.rootDir, path)}${reset}`);
-          await generateGraphQLCodegen();
-          await generateGraphQLRegistry();
+      nuxt.hook("builder:watch", async (_event, changedPath) => {
+        if (changedPath.endsWith(".gql")) {
+          logger.info(`Documents change detected: ${cyan}${getRelativePath(changedPath)}${reset}`);
+          documentsCache = null;
         }
       });
     }
+    addServerHandler({ route: "/api/graphql", handler: resolveModule("./runtime/server/api/graphql") });
+    nuxt.hook("listen", (_, { url }) => {
+      logger.success(`GraphQL Yoga ready: ${cyan}${url.replace(/\/$/, "")} / api / graphql${reset}`);
+    });
+    addPlugin(resolveModule("./runtime/app/plugins/graphql-request"));
+    addPlugin(resolveModule("./runtime/app/plugins/graphql-sse.client"));
+    addImportsDir(resolveModule("./runtime/app/composables"));
+    addServerImportsDir(resolveModule("./runtime/server/utils"));
   }
 });