@lewebsimple/nuxt-graphql 0.2.2 → 0.3.0

package/dist/module.mjs

@@ -1,19 +1,34 @@
-import { useLogger, defineNuxtModule, createResolver, getLayerDirectories, addServerHandler, addPlugin, addImportsDir, addServerImportsDir } from '@nuxt/kit';
-import { join, parse, relative, dirname } from 'node:path';
+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 as parse$1, Kind, getIntrospectionQuery, buildClientSchema, printSchema } from 'graphql';
-import { GRAPHQL_ENDPOINT } from '../dist/runtime/server/lib/constants.js';
+import { parse, Kind } from 'graphql';
+export { defineGraphQLContext } from '../dist/runtime/server/lib/define-graphql-context.js';
+export { defineRemoteExecMiddleware } from '../dist/runtime/server/lib/define-remote-exec-middleware.js';
+export { defineYogaMiddleware } from '../dist/runtime/server/lib/define-yoga-middleware.js';
 
-const logger = useLogger("@lewebsimple/nuxt-graphql");
-const blue = "\x1B[34m";
-const cyan = "\x1B[36m";
-const dim = "\x1B[2m";
-const green = "\x1B[32m";
-const magenta = "\x1B[35m";
-const reset = "\x1B[0m";
-const yellow = "\x1B[33m";
+function removeFileExtension(filePath) {
+  return filePath.replace(/\.[^/.]+$/, "");
+}
+function getGenericServerProxy(modulePath) {
+  return `export * from ${JSON.stringify(removeFileExtension(modulePath))};`;
+}
+
+function getGraphQLContextProxy(contextPath) {
+  if (!contextPath) {
+    return [
+      `export const getGraphQLContext = async () => ({});`,
+      `export type GraphQLContext = Awaited<ReturnType<typeof getGraphQLContext>>;`
+    ].join("\n");
+  }
+  return [
+    `import context from ${JSON.stringify(removeFileExtension(contextPath))};`,
+    ``,
+    `export const getGraphQLContext = context.getGraphQLContext;`,
+    `export type GraphQLContext = Awaited<ReturnType<typeof getGraphQLContext>>;`
+  ].join("\n");
+}
 
 async function findSingleFile(dirs, pattern, isRequired = false) {
   for (const dir of dirs) {
@@ -24,7 +39,7 @@ async function findSingleFile(dirs, pattern, isRequired = false) {
     }
   }
   if (isRequired) {
-    throw new Error(`File not found: ${cyan}${pattern}${reset} in directories:
+    throw new Error(`File not found: ${pattern} in directories:
 ${dirs.join("\n")}`);
   }
 }
@@ -44,299 +59,253 @@ function writeFileIfChanged(path, content) {
   writeFileSync(path, content, "utf-8");
   return true;
 }
-function toImportPath(from, to) {
-  const { dir, name } = parse(to);
-  let importPath = relative(dirname(from), join(dir, name));
-  if (!importPath.startsWith(".")) {
-    importPath = "./" + importPath;
+function toRelativePath(from, to) {
+  let relativePath = relative(resolve(from), resolve(to));
+  relativePath = relativePath.replace(/\\/g, "/");
+  if (!relativePath.startsWith("./") && !relativePath.startsWith("../")) {
+    relativePath = `./${relativePath}`;
   }
-  return importPath;
+  return relativePath;
 }
 
-async function loadSchemaSdl(schemaPath) {
-  const { createJiti } = await import('jiti');
-  const jiti = createJiti(import.meta.url, { interopDefault: true });
-  const module = await jiti.import(schemaPath);
-  if (!module.schema) {
-    throw new Error(`${schemaPath} must export a 'schema' variable`);
-  }
-  const { printSchema, lexicographicSortSchema } = await import('graphql');
-  return printSchema(lexicographicSortSchema(module.schema));
+const defaultCacheConfig = {
+  cachePolicy: "cache-first",
+  cacheVersion: "1",
+  keyPrefix: "gql",
+  ttl: 60
+};
+function resolveCacheConfig(...overrides) {
+  return Object.assign({}, defaultCacheConfig, ...overrides);
 }
-async function runCodegen({ schema, documents, operationsPath, zodPath, scalars }) {
-  const generates = {
-    [operationsPath]: {
-      schema,
-      documents,
-      plugins: ["typescript", "typescript-operations", "typed-document-node"],
-      config: {
-        useTypeImports: true,
-        enumsAsTypes: true,
-        skipTypename: true,
-        documentVariableSuffix: "Document",
-        documentMode: "documentNode",
-        strictScalars: true,
-        defaultScalarType: "never",
-        scalars
-      }
-    }
-  };
-  if (zodPath) {
-    const zodScalars = {};
-    if (scalars) {
-      for (const [name, config] of Object.entries(scalars)) {
-        const inputType = typeof config === "string" ? config : config.input;
-        switch (inputType) {
-          case "Date":
-            zodScalars[name] = "z.coerce.date()";
-            break;
-          case "number":
-            zodScalars[name] = "z.coerce.number()";
-            break;
-          case "boolean":
-            zodScalars[name] = "z.coerce.boolean()";
-            break;
-          default:
-            zodScalars[name] = "z.string()";
+
+async function runGraphQLCodegen({ schema, documents, typedDocumentsPath, zodPath }) {
+  const config = {
+    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
+        }
+      },
+      // Zod schemas
+      [zodPath]: {
+        plugins: ["typescript-validation-schema"],
+        config: {
+          schema: "zodv4",
+          importFrom: "#graphql/operations",
+          useTypeImports: true
         }
       }
-    }
-    generates[zodPath] = {
-      schema,
-      documents,
-      plugins: ["typescript-validation-schema"],
-      config: {
-        schema: "zodv4",
-        importFrom: "#graphql/operations",
-        useTypeImports: true,
-        directives: {
-          constraint: {
-            minLength: "min",
-            maxLength: "max",
-            pattern: "regex"
-          }
-        },
-        scalarSchemas: zodScalars
-      }
-    };
-  }
-  await generate({ generates, silent: true, errorsOnly: true }, true);
+    },
+    ignoreNoDocuments: true,
+    silent: true
+  };
+  const result = await generate(config, true);
+  return result.map(({ filename }) => filename);
 }
-function analyzeDocuments(documents) {
-  const docs = documents.map((path) => ({ path, content: readFileSync(path, "utf-8") }));
-  const byFile = /* @__PURE__ */ new Map();
-  const operationsByType = {
-    query: [],
-    mutation: [],
-    subscription: []
+
+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()
+    }
   };
-  const operationNameToFile = /* @__PURE__ */ new Map();
-  const fragmentNameToFile = /* @__PURE__ */ new Map();
   for (const doc of docs) {
-    const ast = parse$1(doc.content);
-    const defs = [];
+    const ast = parse(doc.content);
     for (const def of ast.definitions) {
-      if (def.kind === Kind.FRAGMENT_DEFINITION) {
-        const name2 = def.name.value;
-        const prev2 = fragmentNameToFile.get(name2);
-        if (prev2) {
-          throw new Error(`Duplicate fragment name '${name2}' in:
-- ${prev2}
-- ${doc.path}`);
+      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;
         }
-        fragmentNameToFile.set(name2, doc.path);
-        defs.push({ kind: "fragment", name: name2 });
-        continue;
-      }
-      if (def.kind !== Kind.OPERATION_DEFINITION) continue;
-      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 ${doc.path}`);
-      }
-      const prev = operationNameToFile.get(name);
-      if (prev) {
-        throw new Error(`Duplicate ${type} operation name '${name}' in:
-- ${prev}
-- ${doc.path}`);
       }
-      operationNameToFile.set(name, doc.path);
-      const op = { kind: "operation", type, name };
-      defs.push(op);
-      operationsByType[type].push(op);
     }
-    byFile.set(doc.path, defs);
   }
-  return { byFile, operationsByType };
-}
-function formatDefinitions(defs) {
-  if (defs.length === 0) return "";
-  const colorOf = (def) => {
-    if (def.kind === "fragment") return green;
-    switch (def.type) {
-      case "query":
-        return blue;
-      case "mutation":
-        return magenta;
-      case "subscription":
-        return yellow;
-    }
-  };
-  return defs.map((def) => `${colorOf(def)}${def.name}${reset}`).join(`${dim} / ${reset}`);
-}
-function writeRegistryModule({ registryPath, operationsByType }) {
-  const queries = operationsByType.query.map((o) => o.name);
-  const mutations = operationsByType.mutation.map((o) => o.name);
-  const subscriptions = operationsByType.subscription.map((o) => o.name);
   const content = [
-    `import type { TypedDocumentNode } from "@graphql-typed-document-node/core";`,
-    `import * as ops from "#graphql/operations";`,
+    `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;`
+    `type VariablesOf<T> = T extends { __apiType?: (variables: infer V) => infer _ } ? V : never;`,
+    ``
   ];
-  if (queries.length > 0) {
-    content.push(
-      ``,
-      `// Queries`,
-      `export const queries = {`,
-      ...queries.map((name) => `  ${name}: ops.${name}Document,`),
-      `} as const;`
-    );
-  } else {
-    content.push(``, `export const queries = {} as const;`);
-  }
+  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]>;`
+    `export type QueryVariables<N extends QueryName> = VariablesOf<(typeof queries)[N]>;`,
+    ``
   );
-  if (mutations.length > 0) {
-    content.push(
-      ``,
-      `// Mutations`,
-      `export const mutations = {`,
-      ...mutations.map((name) => `  ${name}: ops.${name}Document,`),
-      `} as const;`
-    );
-  } else {
-    content.push(``, `export const mutations = {} as const;`);
-  }
+  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]>;`
+    `export type MutationVariables<N extends MutationName> = VariablesOf<(typeof mutations)[N]>;`,
+    ``
   );
-  if (subscriptions.length > 0) {
-    content.push(
-      ``,
-      `// Subscriptions`,
-      `export const subscriptions = {`,
-      ...subscriptions.map((name) => `  ${name}: ops.${name}Document,`),
-      `} as const;`
-    );
-  } else {
-    content.push(``, `export const subscriptions = {} as const;`);
-  }
+  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]>;`
+    `export type SubscriptionVariables<N extends SubscriptionName> = VariablesOf<(typeof subscriptions)[N]>;`,
+    ``
   );
-  return writeFileIfChanged(registryPath, content.join("\n") + "\n");
+  return content.join("\n");
 }
 
-function writeLocalSchemaModule({ localPath, modulePath }) {
-  if (!existsSync(localPath)) {
-    throw new Error(`Local schema file not found at path: ${localPath}`);
+function getRemoteExecMiddlewareProxy(middlewarePath) {
+  if (!middlewarePath) {
+    return [
+      `export const remoteExecMiddlewareHandler = undefined;`
+    ].join("\n");
   }
-  const content = [
-    `export { schema } from ${JSON.stringify(toImportPath(modulePath, localPath))};`
+  return [
+    `import middleware from ${JSON.stringify(removeFileExtension(middlewarePath))};`,
+    ``,
+    `export const remoteExecMiddlewareHandler = middleware.remoteExecMiddlewareHandler;`
   ].join("\n");
-  return writeFileIfChanged(modulePath, content);
 }
-async function writeRemoteSchemaSdl({ schemaDef: { url, headers }, sdlPath }) {
-  const response = await fetch(url, {
-    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 remote schema from ${url}: ${JSON.stringify(json.errors)}`);
-  }
-  const schema = buildClientSchema(json.data);
-  const sdl = printSchema(schema);
-  const content = `export const sdl = /* GraphQL */ \`${sdl.replace(/`/g, "\\`")}\`;`;
-  return writeFileIfChanged(sdlPath, content);
-}
-function writeRemoteSchemaModule({ name, schemaDef: { url, headers }, sdlPath, modulePath, middlewarePath }) {
-  const headerSource = headers && Object.keys(headers).length > 0 ? JSON.stringify(headers, null, 2) : "{}";
-  const middlewareImport = middlewarePath ? `import middleware from ${JSON.stringify(toImportPath(modulePath, middlewarePath))};` : "";
+
+async function getLocalSchemaProxy({ layerRootDirs, schemaDef }) {
+  const schemaPath = await findSingleFile(layerRootDirs, schemaDef.path, true);
   const content = [
-    `import { buildSchema, print } from "graphql";`,
-    `import type { Executor } from "@graphql-tools/utils";`,
+    `export { schema } from ${JSON.stringify(removeFileExtension(schemaPath))};`
+  ].join("\n");
+  return content;
+}
+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 = [
+    `import { buildSchema } from "graphql";`,
     `import type { SubschemaConfig } from "@graphql-tools/delegate";`,
-    `import { sdl } from ${JSON.stringify(toImportPath(modulePath, sdlPath))};`,
-    middlewareImport,
+    `import { remoteExecMiddlewareHandler } from "./${schemaName}-middleware";`,
+    `import { sdl } from "./${schemaName}-sdl";`,
+    `import { createRemoteExecutor } from "../remote-executor";`,
     ``,
-    `const endpoint = ${JSON.stringify(url)};`,
-    `const headers = ${headerSource} as Record<string, string>;`,
-    `const remoteName = ${JSON.stringify(name)};`,
-    `const mw = (typeof middleware === 'object' && middleware) || {};`,
+    `const headers = ${JSON.stringify(schemaDef.headers ?? {}, null, 2)} as HeadersInit;`,
     ``,
-    `const executor: Executor = async ({ document, variables, context, operationName }) => {`,
-    `  const query = typeof document === "string" ? document : print(document);`,
-    `  let fetchOptions = {`,
-    `    method: "POST",`,
-    `    headers: { "Content-Type": "application/json", ...headers },`,
-    `    body: JSON.stringify({ query, variables }),`,
-    `  };`,
-    `  const mwContext = { remoteName, operationName, context, fetchOptions };`,
-    `  if (typeof mw.onRequest === "function") {`,
-    `    const maybeOverride = await mw.onRequest(mwContext);`,
-    `    if (maybeOverride && typeof maybeOverride === "object") {`,
-    `      fetchOptions = maybeOverride;`,
-    `    }`,
-    `  }`,
-    `  const response = await fetch(endpoint, fetchOptions);`,
-    `  if (typeof mw.onResponse === "function") {`,
-    `    await mw.onResponse({ ...mwContext, response });`,
-    `  }`,
-    `  return response.json();`,
-    `};`,
+    `const executor = createRemoteExecutor({`,
+    `  url: ${JSON.stringify(schemaDef.url)},`,
+    `  remoteName: ${JSON.stringify(schemaName)},`,
+    `  headers,`,
+    `  middleware: remoteExecMiddlewareHandler,`,
+    `});`,
     ``,
     `export const schema: SubschemaConfig = {`,
     `  schema: buildSchema(sdl),`,
     `  executor,`,
-    `};`,
-    ``
+    `};`
   ].join("\n");
-  return writeFileIfChanged(modulePath, content);
+  return { middlewareContent, sdlContent, schemaContent };
 }
-function writeStitchedSchemaModule({ schemaNames, modulePath }) {
-  const schemas = schemaNames.map((name) => ({
-    path: `./schemas/${name}`,
-    ref: `${name}Schema`
-  }));
+async function getStitchedSchemaProxy({ schemaNames }) {
   const content = [
-    `import { stitchSchemas } from "@graphql-tools/stitch";`,
-    `import type { GraphQLSchema } from "graphql";`,
-    `import type { SubschemaConfig } from "@graphql-tools/delegate";`,
-    ...schemas.map(({ path, ref }) => `import { schema as ${ref} } from ${JSON.stringify(path)};`),
+    `import { stitchSchemas } from "@graphql-tools/stitch"; `,
+    `import type { GraphQLSchema } from "graphql"; `,
+    `import type { SubschemaConfig } from "@graphql-tools/delegate"; `,
+    ...schemaNames.map((name) => `import { schema as ${name}Schema } from ${JSON.stringify(`./schemas/${name}`)}; `),
     ``,
     `const subschemas: Array<GraphQLSchema | SubschemaConfig> = [`,
-    ...schemas.map(({ ref }) => `  ${ref},`),
-    `];`,
+    ...schemaNames.map((name) => `  ${name}Schema, `),
+    `]; `,
     ``,
-    `export const schema = stitchSchemas({ subschemas });`,
-    ``
+    `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.`);
+  }
+  return module.schema;
+}
+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);
+}
+async function getSDLFromGraphQLSchema(schema) {
+  const { printSchema, lexicographicSortSchema } = await import('graphql');
+  return printSchema(lexicographicSortSchema(schema));
+}
+
+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");
-  return writeFileIfChanged(modulePath, content);
 }
 
 const module$1 = defineNuxtModule({
@@ -344,136 +313,131 @@ const module$1 = defineNuxtModule({
     name: "@lewebsimple/nuxt-graphql",
     configKey: "graphql"
   },
-  defaults: {
-    schemas: {},
-    codegen: {
-      documents: "**/*.gql",
-      saveSchema: "server/graphql/schema.graphql"
-    },
-    client: {
-      headers: {},
-      cache: {
-        enabled: false,
-        ttl: 6e4,
-        storage: "memory"
-      }
-    }
-  },
+  defaults: {},
   async setup(options, nuxt) {
     const { resolve } = createResolver(import.meta.url);
+    const { buildDir, rootDir } = nuxt.options;
     const layerRootDirs = getLayerDirectories(nuxt).map(({ root }) => root);
-    const middlewarePath = resolve("./runtime/server/utils/remote-middleware");
-    const stitchedPath = join(nuxt.options.buildDir, "graphql/schema.ts");
-    const sdlPath = join(nuxt.options.rootDir, options.codegen?.saveSchema || ".nuxt/graphql/schema.graphql");
     nuxt.options.alias ||= {};
-    async function setupContextSchemas() {
-      let contextPath;
-      if (options.context) {
-        contextPath = await findSingleFile(layerRootDirs, options.context, true);
-        logger.info(`Using GraphQL context from ${cyan}${relative(nuxt.options.rootDir, contextPath)}${reset}`);
-      } else {
-        contextPath = resolve("./runtime/server/lib/default-context.ts");
-        logger.info(`Using default GraphQL context`);
-      }
-      const schemasPath = {};
-      const middlewaresPath = {};
-      for (const [name, schemaDef] of Object.entries(options.schemas)) {
-        schemasPath[name] = join(nuxt.options.buildDir, `graphql/schemas/${name}.ts`);
-        if (schemaDef.type === "local") {
-          const localPath = await findSingleFile(layerRootDirs, schemaDef.path, true);
-          writeLocalSchemaModule({ localPath, modulePath: schemasPath[name] });
-          logger.info(`Local GraphQL schema "${blue}${name}${reset}" loaded from ${cyan}${relative(nuxt.options.rootDir, localPath)}${reset}`);
-        } else if (schemaDef.type === "remote") {
-          const sdlPath2 = join(nuxt.options.buildDir, `graphql/schemas/${name}-sdl.ts`);
-          if (schemaDef.middleware) {
-            middlewaresPath[name] = await findSingleFile(layerRootDirs, schemaDef.middleware, true);
-          }
-          await writeRemoteSchemaSdl({ schemaDef, sdlPath: sdlPath2 });
-          writeRemoteSchemaModule({ name, schemaDef, sdlPath: sdlPath2, modulePath: schemasPath[name], middlewarePath: middlewaresPath[name] });
-          logger.info(`Remote GraphQL schema "${magenta}${name}${reset}" loaded from ${cyan}${schemaDef.url}${reset}`);
-        } else {
-          throw new Error(`Unknown schema type for schema '${name}'`);
-        }
-      }
-      writeStitchedSchemaModule({ schemaNames: Object.keys(options.schemas), modulePath: stitchedPath });
-      nuxt.hook("nitro:config", (config) => {
-        config.alias ||= {};
-        config.alias["#graphql/context"] = contextPath;
-        config.alias["#graphql/middleware"] = middlewarePath;
-        for (const name of Object.keys(options.schemas)) {
-          config.alias[`#graphql/schemas/${name}`] = schemasPath[name];
+    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"));
+    for (const [schemaName, schemaDef] of Object.entries(options.schemas)) {
+      switch (schemaDef.type) {
+        case "local": {
+          serverProxies[`schemas/${schemaName}`] = await getLocalSchemaProxy({ layerRootDirs, schemaDef });
+          break;
         }
-        for (const name of Object.keys(middlewaresPath)) {
-          config.alias[`#graphql/middlewares/${name}`] = middlewaresPath[name];
+        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;
         }
-        config.alias["#graphql/schema"] = stitchedPath;
-      });
+        default:
+          throw new Error(`Unsupported GraphQL schema type: ${schemaDef.type}`);
+      }
     }
-    async function setupCodegen() {
-      const configPath = join(nuxt.options.rootDir, ".graphqlrc");
-      const operationsPath = nuxt.options.alias["#graphql/operations"] = join(nuxt.options.buildDir, "graphql/operations.ts");
-      const registryPath = nuxt.options.alias["#graphql/registry"] = join(nuxt.options.buildDir, "graphql/registry.ts");
-      const zodPath = nuxt.options.alias["#graphql/zod"] = join(nuxt.options.buildDir, "graphql/zod.ts");
-      async function generate() {
-        try {
-          const sdlContent = await loadSchemaSdl(stitchedPath);
-          writeFileIfChanged(sdlPath, sdlContent);
-          const documentsPattern = options.codegen?.documents ?? "**/*.gql";
-          const documents = await findMultipleFiles(layerRootDirs, documentsPattern);
-          await runCodegen({ schema: sdlPath, documents, operationsPath, zodPath, scalars: options.codegen?.scalars });
-          const { byFile, operationsByType } = analyzeDocuments(documents);
-          byFile.forEach((defs, path) => {
-            const relativePath = relative(nuxt.options.rootDir, path);
-            logger.info(`${cyan}${relativePath}${reset} [${formatDefinitions(defs)}]`);
-          });
-          writeRegistryModule({ registryPath, operationsByType });
-          const config = {
-            schema: relative(nuxt.options.rootDir, sdlPath),
-            documents: documentsPattern
-          };
-          writeFileIfChanged(configPath, JSON.stringify(config, null, 2));
-        } catch (error) {
-          logger.warn(`GraphQL codegen failed: ${error.message}`);
-        }
+    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}`);
       }
-      nuxt.hook("prepare:types", async ({ references }) => {
-        await generate();
-        references.push({ path: operationsPath });
-        references.push({ path: registryPath });
-        references.push({ path: zodPath });
-      });
-      if (nuxt.options.dev) {
-        nuxt.hook("builder:watch", async (event, path) => {
-          if (path.endsWith(".gql")) {
-            await generate();
-          }
-        });
+    }
+    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 setupYogaHandler() {
-      addServerHandler({ route: GRAPHQL_ENDPOINT, handler: resolve("./runtime/server/api/graphql-handler") });
-      nuxt.hook("listen", (_, { url }) => {
-        logger.success(`GraphQL Yoga ready at ${cyan}${url.replace(/\/$/, "")}${GRAPHQL_ENDPOINT}${reset}`);
-      });
+    const typedDocumentsPath = join(buildDir, "graphql/typed-documents.ts");
+    nuxt.options.alias["#graphql/typed-documents"] = typedDocumentsPath;
+    const zodPath = join(buildDir, "graphql/zod.ts");
+    nuxt.options.alias["#graphql/zod"] = zodPath;
+    async function generateGraphQLCodegen() {
+      try {
+        const files = await runGraphQLCodegen({ schema: sdlPath, documents, typedDocumentsPath, zodPath });
+        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);
+      }
     }
-    function setupClient() {
-      nuxt.options.runtimeConfig.public.graphql = {
-        endpoint: GRAPHQL_ENDPOINT,
-        headers: options.client?.headers || {},
-        cache: {
-          enabled: options.client?.cache?.enabled ?? false,
-          ttl: options.client?.cache?.ttl ?? 6e4,
-          storage: options.client?.cache?.storage ?? "memory"
+    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);
+    }
+    let artifactsPromise;
+    async function generateGraphQLArtifacts() {
+      if (!artifactsPromise) {
+        artifactsPromise = (async () => {
+          await generateGraphQLSDL();
+          await generateGraphQLConfig();
+          await generateGraphQLCodegen();
+          await generateGraphQLRegistry();
+        })();
+      }
+      return artifactsPromise;
+    }
+    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}`);
+    });
+    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();
+    });
+    nuxt.hook("prepare:types", async ({ references }) => {
+      await generateGraphQLArtifacts();
+      references.push({ path: registryPath });
+      references.push({ path: typedDocumentsPath });
+      references.push({ path: zodPath });
+    });
+    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();
         }
-      };
-      addPlugin(resolve("./runtime/app/plugins/graphql"));
-      addImportsDir(resolve("./runtime/app/composables"));
-      addServerImportsDir(resolve("./runtime/server/utils"));
+      });
     }
-    await setupContextSchemas();
-    await setupCodegen();
-    setupYogaHandler();
-    setupClient();
   }
 });