@lewebsimple/nuxt-graphql 0.1.14 → 0.2.1

package/README.md

@@ -14,6 +14,7 @@ Opinionated Nuxt module for using GraphQL Yoga with graphql-request / graphql-ss
 - 🧘‍♂️ GraphQL Yoga server handler with user-provided schema / context
 - 📄 Auto-import GraphQL documents from `**/*.gql` (configurable)
 - 🧩 Type-safe composables to call operations by name, i.e. `useGraphQLQuery("Hello")`
+- 🧵 Optional stitching of local schema with remote schemas (custom headers), with stitched SDL emitted to `server/graphql/schema.graphql`
 
 ## Quick Setup
 
@@ -30,8 +31,6 @@ Optionnally adjust options in your Nuxt config. The defaults shown below:
 export default defineNuxtConfig({
   modules: ["@lewebsimple/nuxt-graphql"],
   graphql: {
-    // GraphQL HTTP endpoint served by Yoga
-    endpoint: "/api/graphql",
     // Codegen controls document scanning and outputs
     codegen: {
       enabled: true,

package/dist/module.d.mts

@@ -1,19 +1,31 @@
 import * as _nuxt_schema from '@nuxt/schema';
-import { GraphQLCacheConfig } from '../dist/runtime/utils/graphql-cache.js';
-import { CodegenConfig } from '@graphql-codegen/cli';
+import { GraphQLCacheConfig } from '../dist/runtime/app/utils/graphql-cache.js';
 
-interface ModuleOptions {
-    endpoint?: string;
+type LocalSchema = {
+    type: "local";
+    path: string;
+};
+type RemoteSchema = {
+    type: "remote";
+    url: string;
     headers?: Record<string, string>;
-    cache?: Partial<GraphQLCacheConfig>;
+};
+type SchemaDefinition = LocalSchema | RemoteSchema;
+
+interface ModuleOptions {
+    context?: string;
+    schemas: Record<string, SchemaDefinition>;
     codegen?: {
-        pattern?: string;
-        schemaOutput?: string;
+        documents?: string;
+        saveSchema?: string;
         scalars?: Record<string, string | {
             input: string;
             output: string;
         }>;
-        generates?: CodegenConfig["generates"];
+    };
+    client?: {
+        cache?: Partial<GraphQLCacheConfig>;
+        headers?: Record<string, string>;
     };
 }
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "@lewebsimple/nuxt-graphql",
   "configKey": "graphql",
-  "version": "0.1.14",
+  "version": "0.2.1",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -1,9 +1,10 @@
-import { useLogger, defineNuxtModule, createResolver, getLayerDirectories, addServerTemplate, addServerHandler, addImportsDir, addServerImportsDir, addPlugin, addTypeTemplate } from '@nuxt/kit';
+import { useLogger, defineNuxtModule, createResolver, getLayerDirectories, addServerHandler, addPlugin, addImportsDir, addServerImportsDir } from '@nuxt/kit';
+import { join, parse, relative, dirname } from 'node:path';
 import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
-import { join, dirname, relative } from 'node:path';
 import { glob } from 'tinyglobby';
 import { generate } from '@graphql-codegen/cli';
-import { parse, Kind } from 'graphql';
+import { parse as parse$1, Kind, getIntrospectionQuery, buildClientSchema, printSchema } from 'graphql';
+import { GRAPHQL_ENDPOINT } from '../dist/runtime/server/lib/constants.js';
 
 const logger = useLogger("@lewebsimple/nuxt-graphql");
 const blue = "\x1B[34m";
@@ -43,8 +44,16 @@ 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;
+  }
+  return importPath;
+}
 
-async function loadGraphQLSchema(schemaPath) {
+async function loadSchemaSdl(schemaPath) {
   const { createJiti } = await import('jiti');
   const jiti = createJiti(import.meta.url, { interopDefault: true });
   const module = await jiti.import(schemaPath);
@@ -54,7 +63,67 @@ async function loadGraphQLSchema(schemaPath) {
   const { printSchema, lexicographicSortSchema } = await import('graphql');
   return printSchema(lexicographicSortSchema(module.schema));
 }
-function analyzeGraphQLDocuments(docs) {
+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()";
+        }
+      }
+    }
+    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);
+}
+function analyzeDocuments(documents) {
+  const docs = documents.map((path) => ({ path, content: readFileSync(path, "utf-8") }));
   const byFile = /* @__PURE__ */ new Map();
   const operationsByType = {
     query: [],
@@ -64,7 +133,7 @@ function analyzeGraphQLDocuments(docs) {
   const operationNameToFile = /* @__PURE__ */ new Map();
   const fragmentNameToFile = /* @__PURE__ */ new Map();
   for (const doc of docs) {
-    const ast = parse(doc.content);
+    const ast = parse$1(doc.content);
     const defs = [];
     for (const def of ast.definitions) {
       if (def.kind === Kind.FRAGMENT_DEFINITION) {
@@ -101,11 +170,26 @@ function analyzeGraphQLDocuments(docs) {
   }
   return { byFile, operationsByType };
 }
-function generateRegistryByTypeSource(analysis) {
-  const queries = analysis.query.map((o) => o.name);
-  const mutations = analysis.mutation.map((o) => o.name);
-  const subscriptions = analysis.subscription.map((o) => o.name);
-  const lines = [
+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";`,
     ``,
@@ -113,138 +197,135 @@ function generateRegistryByTypeSource(analysis) {
     `type VariablesOf<T> = T extends { __apiType?: (variables: infer V) => infer _ } ? V : never;`
   ];
   if (queries.length > 0) {
-    lines.push(
+    content.push(
       ``,
+      `// Queries`,
       `export const queries = {`,
       ...queries.map((name) => `  ${name}: ops.${name}Document,`),
       `} as const;`
     );
   } else {
-    lines.push(``, `export const queries = {} as const;`);
+    content.push(``, `export const queries = {} as const;`);
   }
-  lines.push(
+  content.push(
+    ``,
     `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]>;`
   );
   if (mutations.length > 0) {
-    lines.push(
+    content.push(
       ``,
+      `// Mutations`,
       `export const mutations = {`,
       ...mutations.map((name) => `  ${name}: ops.${name}Document,`),
       `} as const;`
     );
   } else {
-    lines.push(``, `export const mutations = {} as const;`);
+    content.push(``, `export const mutations = {} as const;`);
   }
-  lines.push(
+  content.push(
+    ``,
     `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]>;`
   );
   if (subscriptions.length > 0) {
-    lines.push(
+    content.push(
       ``,
+      `// Subscriptions`,
       `export const subscriptions = {`,
       ...subscriptions.map((name) => `  ${name}: ops.${name}Document,`),
       `} as const;`
     );
   } else {
-    lines.push(``, `export const subscriptions = {} as const;`);
+    content.push(``, `export const subscriptions = {} as const;`);
   }
-  lines.push(
+  content.push(
+    ``,
     `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 lines.join("\n") + "\n";
+  return writeFileIfChanged(registryPath, content.join("\n") + "\n");
 }
-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}`);
-}
-async function runCodegen(options) {
-  const { schema, documents, operationsFile, schemasFile, scalars, generates: customGenerates } = options;
-  if (documents.length === 0) {
-    logger.warn("No GraphQL documents found");
-    return;
-  }
-  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()";
-      }
-    }
+
+const schemaHeader = "/* GraphQL */";
+const escapeSDL = (sdl) => sdl.replace(/`/g, "\\`");
+const serializeSDL = (sdl) => `${schemaHeader} \`${escapeSDL(sdl)}\``;
+function writeLocalSchemaModule(localPath, modulePath) {
+  if (!existsSync(localPath)) {
+    throw new Error(`Local schema file not found at path: ${localPath}`);
   }
-  try {
-    const generates = {
-      [operationsFile]: {
-        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 (schemasFile) {
-      generates[schemasFile] = {
-        schema,
-        documents,
-        plugins: ["typescript-validation-schema"],
-        config: {
-          schema: "zodv4",
-          importFrom: "#graphql/operations",
-          useTypeImports: true,
-          directives: {
-            constraint: {
-              minLength: "min",
-              maxLength: "max",
-              pattern: "regex"
-            }
-          },
-          scalarSchemas: zodScalars
-        }
-      };
-      if (customGenerates) {
-        Object.assign(generates, customGenerates);
-      }
-    }
-    await generate({ generates, silent: true, errorsOnly: true }, true);
-    logger.success(`Generated types for ${documents.length} document(s)`);
-  } catch (error) {
-    logger.error("GraphQL codegen failed:", error instanceof Error ? error.message : error);
+  const content = [
+    `export { schema } from ${JSON.stringify(toImportPath(modulePath, localPath))};`
+  ].join("\n");
+  return writeFileIfChanged(modulePath, content);
+}
+async function writeRemoteSchemaSdl({ 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 = ${serializeSDL(sdl)};`, ""].join("\n");
+  return writeFileIfChanged(sdlPath, content);
+}
+function writeRemoteSchemaModule({ url, headers }, remoteSdlPath, modulePath) {
+  const headerSource = headers && Object.keys(headers).length > 0 ? JSON.stringify(headers, null, 2) : "{}";
+  const content = [
+    `import { buildSchema, print } from "graphql";`,
+    `import type { Executor } from "@graphql-tools/utils";`,
+    `import type { SubschemaConfig } from "@graphql-tools/delegate";`,
+    `import { sdl } from ${JSON.stringify(toImportPath(modulePath, remoteSdlPath))};`,
+    ``,
+    `const endpoint = ${JSON.stringify(url)};`,
+    `const headers = ${headerSource} as Record<string, string>;`,
+    ``,
+    `const executor: Executor = async ({ document, variables }) => {`,
+    `  const query = typeof document === "string" ? document : print(document);`,
+    `  const response = await fetch(endpoint, {`,
+    `    method: "POST",`,
+    `    headers: { "Content-Type": "application/json", ...headers },`,
+    `    body: JSON.stringify({ query, variables }),`,
+    `  });`,
+    ``,
+    `  return response.json();`,
+    `};`,
+    ``,
+    `export const schema: SubschemaConfig = {`,
+    `  schema: buildSchema(sdl),`,
+    `  executor,`,
+    `};`,
+    ``
+  ].join("\n");
+  return writeFileIfChanged(modulePath, content);
+}
+function writeStitchedSchemaModule(schemaNames, modulePath) {
+  const schemas = schemaNames.map((name) => ({
+    path: `./schemas/${name}`,
+    ref: `${name}Schema`
+  }));
+  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)};`),
+    ``,
+    `const subschemas: Array<GraphQLSchema | SubschemaConfig> = [`,
+    ...schemas.map(({ ref }) => `  ${ref},`),
+    `];`,
+    ``,
+    `export const schema = stitchSchemas({ subschemas });`,
+    ``
+  ].join("\n");
+  return writeFileIfChanged(modulePath, content);
 }
 
 const module$1 = defineNuxtModule({
@@ -253,124 +334,129 @@ const module$1 = defineNuxtModule({
     configKey: "graphql"
   },
   defaults: {
-    endpoint: "/api/graphql",
+    schemas: {},
     codegen: {
-      pattern: "**/*.gql",
-      schemaOutput: "server/graphql/schema.graphql"
+      documents: "**/*.gql",
+      saveSchema: "server/graphql/schema.graphql"
+    },
+    client: {
+      headers: {},
+      cache: {
+        enabled: false,
+        ttl: 6e4,
+        storage: "memory"
+      }
     }
   },
   async setup(options, nuxt) {
     const { resolve } = createResolver(import.meta.url);
-    if (options.endpoint) {
-      if (!options.endpoint.startsWith("/")) {
-        logger.warn("GraphQL endpoint should start with '/' (e.g., '/api/graphql')");
-      }
+    const layerRootDirs = getLayerDirectories(nuxt).map(({ root }) => root);
+    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 ||= {};
+    if (!Object.keys(options.schemas || {}).length) {
+      throw new Error("No GraphQL schemas configured. Please set 'graphql.schemas' with at least one local or remote schema.");
     }
-    const { rootDir, serverDir } = nuxt.options;
-    const layerDirs = [
-      ...getLayerDirectories(nuxt),
-      { root: rootDir, server: serverDir.replace(rootDir, `${rootDir}/playground`) }
-    ];
-    const layerServerDirs = layerDirs.map(({ server }) => server);
-    const layerRootDirs = layerDirs.map(({ root }) => root);
-    const schemaPath = await findSingleFile(layerServerDirs, "graphql/schema.{ts,mjs}", true);
-    const contextPath = await findSingleFile(layerServerDirs, "graphql/context.{ts,mjs}") || resolve("./runtime/server/graphql/default-context.ts");
-    nuxt.hook("nitro:config", (config) => {
-      config.alias ||= {};
-      config.alias["#graphql/schema"] = schemaPath;
-      config.alias["#graphql/context"] = contextPath;
-    });
-    const endpoint = options.endpoint ?? "/api/graphql";
-    addServerTemplate({
-      filename: "graphql/yoga-handler",
-      getContents: () => readFileSync(resolve("./templates/yoga-handler.mjs"), "utf-8").replace("{{endpoint}}", endpoint)
-    });
-    addServerHandler({ route: endpoint, handler: "graphql/yoga-handler" });
-    nuxt.hook("listen", (_, { url }) => {
-      logger.success(`GraphQL Yoga ready at ${cyan}${url.replace(/\/$/, "")}${endpoint}${reset}`);
-    });
-    nuxt.options.runtimeConfig.public.graphql = {
-      endpoint,
-      headers: options.headers || {},
-      cache: {
-        enabled: options.cache?.enabled ?? false,
-        ttl: options.cache?.ttl ?? 6e4,
-        storage: options.cache?.storage ?? "memory"
+    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/graphql/context");
+        logger.info(`Using default GraphQL context`);
       }
-    };
-    const codegenPattern = options.codegen?.pattern ?? "**/*.gql";
-    const graphqlrcFile = join(rootDir, ".graphqlrc");
-    const operationsFile = join(nuxt.options.buildDir, "graphql/operations.ts");
-    const registryFile = join(nuxt.options.buildDir, "graphql/registry.ts");
-    const schemasFile = join(nuxt.options.buildDir, "graphql/schemas.ts");
-    nuxt.options.alias["#graphql/operations"] = operationsFile;
-    nuxt.options.alias["#graphql/registry"] = registryFile;
-    nuxt.options.alias["#graphql/schemas"] = schemasFile;
-    const schemaOutput = options.codegen?.schemaOutput ?? "server/graphql/schema.graphql";
-    if (schemaOutput && !schemaOutput.endsWith(".graphql")) {
-      logger.warn(`Schema output '${schemaOutput}' should have .graphql extension.`);
-    }
-    const schemaFile = join(rootDir, schemaOutput);
-    const generate = async () => {
-      const [schema, documents] = await Promise.all([
-        loadGraphQLSchema(schemaPath),
-        findMultipleFiles(layerRootDirs, codegenPattern)
-      ]);
-      const docs = documents.map((document) => ({ path: document, content: readFileSync(document, "utf-8") }));
-      const analysis = analyzeGraphQLDocuments(docs);
-      for (const doc of docs) {
-        const relativePath = doc.path.startsWith(rootDir) ? doc.path.slice(rootDir.length + 1) : doc.path;
-        const defs = analysis.byFile.get(doc.path) ?? [];
-        logger.info(`${cyan}${relativePath}${reset} [${formatDefinitions(defs)}]`);
+      const schemasPath = {};
+      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, 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 remoteSdlPath = join(nuxt.options.buildDir, `graphql/schemas/${name}-sdl.ts`);
+          await writeRemoteSchemaSdl(schemaDef, remoteSdlPath);
+          writeRemoteSchemaModule(schemaDef, remoteSdlPath, schemasPath[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}'`);
+        }
       }
-      await runCodegen({
-        schema,
-        documents,
-        operationsFile,
-        schemasFile,
-        scalars: options.codegen?.scalars,
-        generates: options.codegen?.generates
+      writeStitchedSchemaModule(Object.keys(options.schemas), stitchedPath);
+      nuxt.hook("nitro:config", (config) => {
+        config.alias ||= {};
+        config.alias["#graphql/context"] = contextPath;
+        for (const name of Object.keys(options.schemas)) {
+          config.alias[`#graphql/schemas/${name}`] = schemasPath[name];
+        }
+        config.alias["#graphql/schema"] = stitchedPath;
       });
-      if (writeFileIfChanged(schemaFile, schema)) {
-        logger.info(`GraphQL schema saved to ${cyan}${schemaOutput}${reset}`);
-      }
-      const graphqlrc = {
-        schema: relative(rootDir, schemaFile),
-        documents: codegenPattern
-      };
-      if (options.codegen?.scalars) {
-        graphqlrc.scalars = options.codegen.scalars;
-      }
-      if (writeFileIfChanged(graphqlrcFile, JSON.stringify(graphqlrc, null, 2))) {
-        logger.info(`GraphQL config saved to ${cyan}.graphqlrc${reset}`);
+    }
+    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 analysis = analyzeDocuments(documents);
+          analysis.byFile.forEach((defs, path) => {
+            const relativePath = relative(nuxt.options.rootDir, path);
+            logger.info(`${cyan}${relativePath}${reset} [${formatDefinitions(defs)}]`);
+          });
+          writeRegistryModule(registryPath, analysis);
+          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}`);
+        }
       }
-      if (writeFileIfChanged(registryFile, generateRegistryByTypeSource(analysis.operationsByType))) {
-        logger.info(`GraphQL registry saved to ${cyan}${relative(rootDir, registryFile)}${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();
+          }
+        });
       }
-    };
-    nuxt.hook("prepare:types", async ({ references }) => {
-      await generate();
-      if (existsSync(operationsFile)) references.push({ path: operationsFile });
-      if (existsSync(registryFile)) references.push({ path: registryFile });
-      if (existsSync(schemasFile)) references.push({ path: schemasFile });
-    });
-    if (nuxt.options.dev) {
-      nuxt.hook("builder:watch", async (event, path) => {
-        if (path.endsWith(".gql")) {
-          await generate();
-        }
+    }
+    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}`);
       });
     }
-    addImportsDir(resolve("./runtime/composables"));
-    addServerImportsDir(resolve("./runtime/server/utils"));
-    addPlugin(resolve("./runtime/plugins/graphql"));
-    addTypeTemplate({
-      filename: "types/graphql-client.d.ts",
-      getContents: () => readFileSync(resolve("./runtime/types/graphql-client.d.ts"), "utf-8")
-    });
-    nuxt.hook("prepare:types", ({ references }) => {
-      references.push({ path: "./types/graphql-client.d.ts" });
-    });
+    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"
+        }
+      };
+      addPlugin(resolve("./runtime/app/plugins/graphql"));
+      addImportsDir(resolve("./runtime/app/composables"));
+      addServerImportsDir(resolve("./runtime/server/utils"));
+    }
+    await setupContextSchemas();
+    await setupCodegen();
+    setupYogaHandler();
+    setupClient();
   }
 });
 

package/dist/runtime/{composables → app/composables}/useGraphQLCache.d.ts

@@ -5,6 +5,6 @@ import type { QueryName, QueryVariables } from "#graphql/registry";
  * @returns Object with enabled flag and invalidate function
  */
 export declare function useGraphQLCache(): {
-    enabled: any;
+    enabled: boolean;
     invalidate: <N extends QueryName>(operationName?: N, variables?: QueryVariables<N>) => Promise<void>;
 };

package/dist/runtime/{composables → app/composables}/useGraphQLMutation.d.ts

@@ -1,5 +1,4 @@
-import { type MutationName, type MutationResult, type MutationVariables } from "#graphql/registry";
-import type { IsEmptyObject } from "../utils/helpers.js";
+import { type MutationName, type MutationResult } from "#graphql/registry";
 /**
  * Client-side GraphQL mutation composable
  *
@@ -7,7 +6,7 @@ import type { IsEmptyObject } from "../utils/helpers.js";
  * @returns Object with mutate function and pending state
  */
 export declare function useGraphQLMutation<N extends MutationName>(operationName: N): {
-    mutate: (...args: IsEmptyObject<MutationVariables<N>> extends true ? [variables?: MutationVariables<N>, headers?: HeadersInit] : [variables: MutationVariables<N>, headers?: HeadersInit]) => Promise<{
+    mutate: (variables: MutationVariables<N>, headers?: HeadersInit | undefined) => Promise<{
         data: MutationResult<N> | null;
         error: Error | null;
     }>;

package/dist/runtime/{composables → app/composables}/useGraphQLQuery.d.ts

@@ -1,7 +1,7 @@
 import type { AsyncData, AsyncDataOptions } from "#app";
 import { type QueryName, type QueryResult, type QueryVariables } from "#graphql/registry";
 import { type CacheOptions } from "../utils/graphql-cache.js";
-import type { IsEmptyObject } from "../utils/helpers.js";
+import type { IsEmptyObject } from "../../../helpers/is-empty-object.js";
 export interface UseGraphQLQueryOptions<T> extends AsyncDataOptions<T> {
     cache?: CacheOptions | false;
     headers?: HeadersInit;

package/dist/runtime/{composables → app/composables}/useGraphQLSubscription.d.ts

@@ -1,7 +1,7 @@
 import { type MaybeRefOrGetter, type Ref } from "vue";
 import { type SubscriptionName, type SubscriptionResult, type SubscriptionVariables } from "#graphql/registry";
 import { type GraphQLClientError } from "../utils/graphql-error.js";
-import type { IsEmptyObject } from "../utils/helpers.js";
+import type { IsEmptyObject } from "../../../helpers/is-empty-object.js";
 export type UseGraphQLSubscriptionReturn<N extends SubscriptionName> = {
     data: Ref<SubscriptionResult<N> | null>;
     error: Ref<GraphQLClientError | null>;

package/dist/runtime/app/plugins/graphql.d.ts

@@ -0,0 +1,31 @@
+import { GraphQLClient } from "graphql-request";
+import { type Client as SSEClient } from "graphql-sse";
+import { type GraphQLClientError } from "../utils/graphql-error.js";
+import type { GraphQLCacheConfig } from "../utils/graphql-cache.js";
+declare const _default: import("#app").Plugin<{
+    graphql: () => GraphQLClient;
+    graphqlSSE: () => SSEClient;
+}> & import("#app").ObjectPlugin<{
+    graphql: () => GraphQLClient;
+    graphqlSSE: () => SSEClient;
+}>;
+export default _default;
+declare module "#app" {
+    interface NuxtApp {
+        $graphql: () => GraphQLClient;
+        $graphqlSSE: () => SSEClient;
+    }
+    interface RuntimeNuxtHooks {
+        "graphql:error": (error: GraphQLClientError) => void;
+    }
+}
+declare module "nuxt/schema" {
+    interface PublicRuntimeConfig {
+        graphql: {
+            endpoint: string;
+            headers: Record<string, string>;
+            cache: GraphQLCacheConfig;
+        };
+    }
+}
+export {};

package/dist/runtime/{plugins → app/plugins}/graphql.js

@@ -39,3 +39,4 @@ export default defineNuxtPlugin((nuxtApp) => {
     }
   };
 });
+export {};

package/dist/runtime/server/api/graphql-handler.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;
+export default _default;

package/dist/runtime/server/api/graphql-handler.js

@@ -0,0 +1,14 @@
+import { defineEventHandler, toWebRequest, sendWebResponse, createError } from "h3";
+import { getYoga } from "../lib/create-yoga.js";
+export default defineEventHandler(async (event) => {
+  try {
+    const request = toWebRequest(event);
+    const context = {};
+    const response = await getYoga().handleRequest(request, context);
+    return sendWebResponse(event, response);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error("GraphQL Server Error:", message);
+    throw createError({ statusCode: 500, message: "GraphQL server error" });
+  }
+});

package/dist/runtime/server/lib/constants.d.ts

@@ -0,0 +1 @@
+export declare const GRAPHQL_ENDPOINT = "/api/graphql";

package/dist/runtime/server/lib/constants.js

@@ -0,0 +1 @@
+export const GRAPHQL_ENDPOINT = "/api/graphql";

package/dist/runtime/server/lib/create-yoga.d.ts

@@ -0,0 +1 @@
+export declare function getYoga(): import("graphql-yoga").YogaServerInstance<Record<string, any>, Record<string, any>>;

package/dist/runtime/server/lib/create-yoga.js

@@ -0,0 +1,17 @@
+import { createYoga } from "graphql-yoga";
+import { schema } from "#graphql/schema";
+import { GRAPHQL_ENDPOINT } from "./constants.js";
+let yoga = null;
+export function getYoga() {
+  if (!yoga) {
+    yoga = createYoga({
+      schema,
+      graphqlEndpoint: GRAPHQL_ENDPOINT,
+      fetchAPI: globalThis,
+      graphiql: process.env.NODE_ENV !== "production",
+      // @ts-expect-error Subscriptions type missing in module context
+      subscriptions: { protocol: "SSE" }
+    });
+  }
+  return yoga;
+}

package/dist/runtime/server/utils/useServerGraphQLMutation.d.ts

@@ -1,6 +1,5 @@
 import type { H3Event } from "h3";
-import { type MutationName, type MutationResult, type MutationVariables } from "#graphql/registry";
-import type { IsEmptyObject } from "../../utils/helpers.js";
+import { type MutationName, type MutationResult } from "#graphql/registry";
 /**
  * Server-side GraphQL mutation composable
  *
@@ -9,7 +8,7 @@ import type { IsEmptyObject } from "../../utils/helpers.js";
  * @returns Object with mutate function
  */
 export declare function useServerGraphQLMutation<N extends MutationName>(event: H3Event, operationName: N): Promise<{
-    mutate: (...args: IsEmptyObject<MutationVariables<N>> extends true ? [variables?: MutationVariables<N>, headers?: HeadersInit] : [variables: MutationVariables<N>, headers?: HeadersInit]) => Promise<{
+    mutate: (variables: MutationVariables<N>, headers?: HeadersInit | undefined) => Promise<{
         data: MutationResult<N> | null;
         error: Error | null;
     }>;

package/dist/runtime/server/utils/useServerGraphQLQuery.d.ts

@@ -1,6 +1,6 @@
 import type { H3Event } from "h3";
 import { type QueryName, type QueryResult, type QueryVariables } from "#graphql/registry";
-import type { IsEmptyObject } from "../../utils/helpers.js";
+import type { IsEmptyObject } from "../../../helpers/is-empty-object.js";
 /**
  * Server-side GraphQL query composable
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lewebsimple/nuxt-graphql",
-  "version": "0.1.14",
+  "version": "0.2.1",
   "description": "Opinionated Nuxt module for using GraphQL",
   "repository": "lewebsimple/nuxt-graphql",
   "license": "MIT",
@@ -39,6 +39,10 @@
     "@graphql-codegen/typed-document-node": "^6.1.5",
     "@graphql-codegen/typescript": "^5.0.7",
     "@graphql-codegen/typescript-operations": "^5.0.7",
+    "@graphql-tools/delegate": "^12.0.2",
+    "@graphql-tools/stitch": "^10.1.6",
+    "@graphql-tools/utils": "^10.11.0",
+    "@graphql-tools/wrap": "^11.1.2",
     "@graphql-typed-document-node/core": "^3.2.0",
     "@nuxt/kit": "^4.2.2",
     "graphql": "^16.12.0",
@@ -59,13 +63,13 @@
     "@nuxt/schema": "^4.2.2",
     "@nuxt/test-utils": "^3.22.0",
     "@types/node": "latest",
-    "@vitest/coverage-v8": "^4.0.16",
+    "@vitest/coverage-v8": "^3.2.4",
     "changelogen": "^0.6.2",
     "eslint": "^9.39.2",
     "nuxt": "^4.2.2",
     "typescript": "~5.9.3",
-    "vitest": "^4.0.16",
-    "vue-tsc": "^3.2.1"
+    "vitest": "^3.2.4",
+    "vue-tsc": "^3.2.2"
   },
   "publishConfig": {
     "access": "public"

package/dist/runtime/plugins/graphql.d.ts

@@ -1,10 +0,0 @@
-import { GraphQLClient } from "graphql-request";
-import { type Client as SSEClient } from "graphql-sse";
-declare const _default: import("nuxt/app").Plugin<{
-    graphql: () => GraphQLClient;
-    graphqlSSE: () => SSEClient;
-}> & import("nuxt/app").ObjectPlugin<{
-    graphql: () => GraphQLClient;
-    graphqlSSE: () => SSEClient;
-}>;
-export default _default;

package/dist/runtime/types/graphql-client.d.ts

@@ -1,28 +0,0 @@
-import type { GraphQLClient } from "graphql-request";
-import type { Client as SSEClient } from "graphql-sse";
-import type { GraphQLClientError } from "../utils/graphql-error";
-
-// Extend NuxtApp with GraphQL clients
-declare module "#app" {
-  interface NuxtApp {
-    $graphql: () => GraphQLClient;
-    $graphqlSSE: () => SSEClient;
-  }
-
-  interface RuntimeNuxtHooks {
-    "graphql:error": (error: GraphQLClientError) => void;
-  }
-}
-
-// Extend Nuxt runtime config with GraphQL options
-declare module "nuxt/schema" {
-  interface PublicRuntimeConfig {
-    graphql: {
-      endpoint: string;
-      headers: Record<string, string>;
-      cache: GraphQLCacheConfig;
-    };
-  }
-}
-
-export { };

package/dist/runtime/utils/helpers.d.ts

@@ -1 +0,0 @@
-export type IsEmptyObject<T> = T extends Record<string, never> ? true : keyof T extends never ? true : false;

package/dist/templates/yoga-handler.mjs

@@ -1,35 +0,0 @@
-import { createYoga } from "graphql-yoga";
-import { defineEventHandler, toWebRequest, sendWebResponse, createError } from "h3";
-import { schema } from "#graphql/schema";
-import { createContext } from "#graphql/context";
-import { useLogger } from "@nuxt/kit";
-
-let yoga = null;
-
-function getYoga() {
-  if (!yoga) {
-    yoga = createYoga({
-      schema,
-      graphqlEndpoint: "{{endpoint}}",
-      fetchAPI: globalThis,
-      graphiql: process.env.NODE_ENV !== "production",
-      subscriptions: { protocol: "SSE" },
-    });
-  }
-  return yoga;
-}
-
-export default defineEventHandler(async (event) => {
-  const logger = useLogger();
-  try {
-    const request = toWebRequest(event);
-    const context = await createContext(event);
-    const response = await getYoga().handleRequest(request, context);
-    return sendWebResponse(event, response);
-  }
-  catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    logger.error("GraphQL Server Error:", message);
-    throw createError({ statusCode: 500, message: "GraphQL server error" });
-  }
-});