@lewebsimple/nuxt-graphql 0.5.4 → 0.5.6

package/dist/module.d.mts

@@ -1,6 +1,5 @@
 import * as _nuxt_schema from '@nuxt/schema';
 import { HeadersInput } from '../dist/runtime/shared/lib/headers.js';
-import { CacheConfig } from '../dist/runtime/shared/lib/cache-config.js';
 
 interface LocalSchemaDef {
     type: "local";
@@ -39,7 +38,7 @@ interface NuxtGraphQLModuleOptions {
         /**
          * Global cache configuration for queries.
          */
-        cache?: Partial<CacheConfig>;
+        cache?: Partial<GraphQLCacheConfig>;
         /**
          * GraphQL documents glob pattern.
          * Default: "**\/*.gql"

package/dist/module.json

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

package/dist/module.mjs

@@ -1,89 +1,49 @@
 import { mkdirSync, writeFileSync } from 'node:fs';
 import { dirname, relative, resolve } from 'node:path';
-import { defineNuxtModule, useLogger, createResolver, addTemplate, addServerTemplate, addTypeTemplate, addServerHandler, addPlugin, addImportsDir, addServerImportsDir } from '@nuxt/kit';
 import { defu } from 'defu';
-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 { loadDocuments } from '@graphql-tools/load';
+import { stitchSchemas } from '@graphql-tools/stitch';
+import { defineNuxtModule, useLogger, createResolver, addTemplate, addServerTemplate, addTypeTemplate, addServerHandler, addPlugin, addImportsDir, addServerImportsDir } from '@nuxt/kit';
 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 { Kind, getIntrospectionQuery, buildClientSchema, GraphQLSchema } from 'graphql';
 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';
+import { resolveCacheConfig } from '../dist/runtime/shared/lib/cache.js';
+import { hash } from 'ohash';
 
 const cyan = "\x1B[36m";
 const reset = "\x1B[0m";
 
 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 type { H3Event } from "h3";`,
-    ...imports,
-    "",
-    `export type GraphQLContext = ${types.join(" & ")};`,
-    "",
-    "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");
-}
+  const contextImports = contextModules.map((contextModule, index) => `import { createContext as createContext${index} } from '${contextModule}';`);
+  const contexts = contextModules.map((_, index) => `createContext${index}(event)`);
+  return `
+${contextImports.join("\n")}
 
-async function loadDocuments(documents) {
-  try {
-    return await loadDocuments$1([
-      documents,
-      "!**/.cache/**",
-      "!**/.nuxt/**",
-      "!**/.output/**",
-      "!**/dist/**",
-      "!**/node_modules/**"
-    ], { loaders: [new GraphQLFileLoader()] });
-  } catch {
-    return [];
-  }
+export async function createContext(event) {
+  const parts = await Promise.all([${contexts.join(", ")}]);
+  return Object.assign({}, ...parts);
+}`.trim();
 }
+function renderContextTypesTemplate({ contextModules }) {
+  const contextImports = contextModules.map((module, index) => `import createContext${index} from ${JSON.stringify(module)};`);
+  const contextTypes = ["{}", ...contextModules.map((_, index) => `Awaited<ReturnType<typeof createContext${index}>>`)];
+  return `
+import type { H3Event } from "h3";
+${contextImports.join("\n")}
 
-async function renderFragmentsTemplate({ documents }) {
-  const fragments = collectFragments(documents);
-  if (fragments.length === 0) {
-    return `export { }`;
-  }
-  return [
-    `export type {`,
-    ...fragments.map((name) => `  ${name}Fragment,`),
-    `} from "./operations";`
-  ].join("\n");
-}
-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 [...fragments.values()];
+declare module "#graphql/context" {
+  export type GraphQLContext = ${contextTypes.join(" & ")};
+  export function createContext(event: H3Event): Promise<GraphQLContext>;
+}`.trim();
 }
 
 async function renderOperationsTemplate({ schema, documents }) {
-  const output = await codegen({
+  const content = await codegen({
     filename: "operations.ts",
-    // @graphql-codegen/core codegen supports GraphQLSchema at runtime, but types expect DocumentNode
     schema,
     documents,
     plugins: [
@@ -133,51 +93,72 @@ async function renderOperationsTemplate({ schema, documents }) {
     },
     config: {}
   });
-  return output;
+  const docs = splitDocuments(content);
+  const module = docs.map(({ name, object }) => `export const ${name} = ${object};`).join("\n");
+  const types = `${content.replace(/export const \w+ = [\s\S]*?;\n?/g, "")}
+declare module "#graphql/operations" {
+  ${docs.map(({ name, type }) => `export type ${name} = ${type};`).join("\n  ")}
+}`.trim();
+  return { module, types };
+}
+function splitDocuments(content) {
+  const documents = [];
+  const documentRegex = /export const (\w+) = ([\s\S]*?) as unknown as (DocumentNode<[^>]+>);/g;
+  let match;
+  while (match = documentRegex.exec(content)) {
+    const [, name, object, type] = match;
+    if (!name || !object || !type) {
+      throw new Error("Invalid typed document matched while splitting documents.");
+    }
+    documents.push({ name, object: object.trim(), type });
+  }
+  return documents;
 }
 
 async function renderRegistryTemplate({ documents }) {
   const operations = collectOperations(documents);
-  return [
-    `import type { DocumentNode } from "graphql";`,
-    `import {`,
-    ...operations.map(
-      ({ name }) => `  ${name}Document, type ${name}QueryVariables, type ${name}QueryResult,`
-    ),
-    `} from "./operations";`,
-    ``,
-    // Operation entry
-    `export interface OperationEntry<TVariables, TResult, TKind extends "query" | "mutation" | "subscription"> {`,
-    `  kind: TKind;`,
-    `  variables: TVariables;`,
-    `  result: TResult;`,
-    `  document: DocumentNode;`,
-    `}`,
-    ``,
-    // Operation registry type
-    `export type OperationRegistry = {`,
-    ...operations.map(
-      ({ name, kind }) => `  ${name}: OperationEntry<${name}QueryVariables, ${name}QueryResult, "${kind}">;`
-    ),
-    `};`,
-    ``,
-    // Operation name types
-    `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];`,
-    ``,
-    // Projection helpers (variables / result)
-    `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");
+  const module = `
+import {
+  ${operations.map(({ name }) => `${name}Document`).join(",\n  ")}
+} from "./operations";
+
+export const registry = {
+  ${operations.map(({ name, kind }) => `${name}: { kind: "${kind}", document: ${name}Document },`).join("\n  ")}
+};`.trim();
+  const types = `
+import type { DocumentNode } from "graphql";
+import type {
+  ${operations.map(({ name, kind }) => `${name}${capitalize(kind)}Variables, ${name}${capitalize(kind)}Result,`).join("\n  ")}
+} from "./operations";
+
+// Operation entry
+export interface OperationEntry<TVariables, TResult, TKind extends "query" | "mutation" | "subscription"> {
+  kind: TKind;
+  variables: TVariables;
+  result: TResult;
+  document: DocumentNode;
+}
+
+// Operation registry type
+export type OperationRegistry = {
+  ${operations.map(({ name, kind }) => `${name}: OperationEntry<${name}${capitalize(kind)}Variables, ${name}${capitalize(kind)}Result, "${kind}">;`).join("\n  ")}
+};
+
+// Operation name types
+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];
+
+// Projection helpers (variables / result)
+export type VariablesOf<TName extends keyof OperationRegistry> = OperationRegistry[TName]["variables"];
+export type ResultOf<TName extends keyof OperationRegistry> = OperationRegistry[TName]["result"];
+
+declare module "#graphql/registry" {
+  export const registry: { [K in keyof OperationRegistry]: { kind: OperationRegistry[K]["kind"]; document: DocumentNode; }; };
+  export type { OperationRegistry, OperationName, QueryName, MutationName, SubscriptionName, VariablesOf, ResultOf };
+}`.trim();
+  return { module, types };
 }
 function collectOperations(documents) {
   const operations = /* @__PURE__ */ new Map();
@@ -193,50 +174,71 @@ function collectOperations(documents) {
       if (operations.has(name)) {
         throw new Error(`Duplicate GraphQL operation name "${name}"`);
       }
-      operations.set(name, {
-        name,
-        kind: def.operation
-      });
+      operations.set(name, { name, kind: def.operation });
     }
   }
-  return [...operations.values()];
+  return Array.from(operations.values());
+}
+function capitalize(value) {
+  if (!value) return value;
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+
+function renderLocalSchemaTemplate({ schemaModule }) {
+  return `export { schema } from ${JSON.stringify(schemaModule)};`;
+}
+async function renderRemoteSchemaTemplate({ remoteExecutorModule, hooksModules, schemaDef, schemaLoader }) {
+  const importHooks = hooksModules.map((hookPath, index) => `import hooks${index} from ${JSON.stringify(hookPath)};`);
+  const hooks = hooksModules.map((_, index) => `hooks${index}`);
+  const { url, headers } = schemaDef;
+  const schema = await schemaLoader();
+  const sdl = await printSchemaSDL(schema);
+  return `
+import { buildSchema } from "graphql";
+import { createRemoteExecutor } from ${JSON.stringify(remoteExecutorModule)};
+${importHooks.join("\n")}
+
+const sdl = /* GraphQL */ \`${sdl.replace(/`/g, "\\`")}\`;
+
+export const schema = {
+  schema: buildSchema(sdl),
+  executor: createRemoteExecutor({
+    url: ${JSON.stringify(url)},
+    headers: ${JSON.stringify(headers || {})},
+    hooks: [${hooks.join(", ")}]
+  }),
+};
+`.trim();
+}
+function renderSchemaTemplate({ schemaNames }) {
+  const importSchemas = schemaNames.map((name) => `import { schema as ${name}Schema } from ${JSON.stringify(`./schemas/${name}`)};`);
+  const schemas = schemaNames.map((name) => `${name}Schema`);
+  return `
+import { stitchSchemas } from "@graphql-tools/stitch";
+${importSchemas.join("\n")}
+
+export const schema = stitchSchemas({
+  subschemas: [${schemas.join(", ")}],
+});`.trim();
 }
+function renderSchemaTypesTemplate() {
+  return `
+import type { GraphQLSchema } from "graphql";
 
-function renderLocalSchemaTemplate({ path }) {
-  return `export { schema } from ${JSON.stringify(path)};`;
+declare module "#graphql/schema" {
+  export const schema: GraphQLSchema;
+}
+`.trim();
 }
-async function loadLocalSchema({ path }) {
+async function loadLocalSchema({ schemaModule }) {
   const { createJiti } = await import('jiti');
   const jiti = createJiti(import.meta.url, { interopDefault: true });
-  const module = await jiti.import(path);
+  const module = await jiti.import(schemaModule);
   if (!module.schema || !(module.schema instanceof Object) || typeof module.schema.getQueryType !== "function") {
-    throw new Error(`${path} must export a valid 'schema' of type GraphQLSchema.`);
+    throw new Error(`${schemaModule} must export a valid 'schema' of type GraphQLSchema.`);
   }
   return module.schema;
 }
-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 { createRemoteExecutor } from ${JSON.stringify(remoteExecutorModule)};`,
-    ...imports,
-    ``,
-    `const sdl = /* GraphQL */ \`${sdl.replace(/`/g, "\\`")}\`;`,
-    ``,
-    `export const schema: SubschemaConfig = {`,
-    `  schema: buildSchema(sdl),`,
-    `  executor: createRemoteExecutor({`,
-    `    ...${JSON.stringify(schemaDef)},`,
-    `    hooks: [`,
-    ...(hooks || []).map((_, index) => `      hooks${index},`),
-    `    ]`,
-    `  }),`,
-    `};`
-  ].join("\n");
-}
 async function introspectRemoteSchema({ url, headers }) {
   const response = await fetch(url, {
     method: "POST",
@@ -266,34 +268,9 @@ 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> = [`,
-    ...schemaNames.map((name) => `  ${name}Schema, `),
-    `]; `,
-    ``,
-    `export const schema = stitchSchemas({ subschemas }); `
-  ].join("\n");
-}
-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 stitchSchemas({ subschemas });
-}
 
 function renderAppTypesTemplate() {
-  return `// Nuxt GraphQL types (app)
+  return `
 import type { GraphQLClient } from "graphql-request";
 import type { Client as SSEClient } from "graphql-sse";
 
@@ -312,20 +289,10 @@ declare module "#app" {
 }
 
 export {};
-`;
+`.trim();
 }
 function renderServerTypesTemplate() {
-  return `// Nuxt GraphQL types (server)
-import type { GraphQLSchema } from "graphql";
-
-declare module "#graphql/context" {
-  export type { GraphQLContext };
-}
-
-declare module "#graphql/schema" {
-  export const schema: GraphQLSchema;
-}
-
+  return `
 declare module "h3" {
   interface H3EventContext {
     _graphqlInFlightRequestsMap?: Map<string, Promise<unknown>>;
@@ -333,24 +300,34 @@ declare module "h3" {
 }
 
 export {};
-`;
+`.trim();
 }
 function renderSharedTypesTemplate() {
-  return `// Nuxt GraphQL types (shared)
+  return `
 import type { DocumentNode } from "graphql";
 import type { CacheConfig } from "nuxt-graphql/runtime/shared/lib/cache-config";
 
+declare global {
+  type GraphQLCacheConfig = {
+    policy: "no-cache" | "cache-first" | "network-first" | "swr";
+    ttl?: number;
+    keyPrefix: string;
+    keyVersion: string | number;
+  };;
+}
+
 declare module "nuxt/schema" {
   interface PublicRuntimeConfig {
     graphql: {
-      cacheConfig?: CacheConfig;
+      cacheConfig: GraphQLCacheConfig;
       ssrForwardHeaders: string[];
     };
   }
 }
 
-export {};
-`;
+export { };
+
+`.trim();
 }
 
 const module$1 = defineNuxtModule({
@@ -384,87 +361,107 @@ const module$1 = defineNuxtModule({
     }
     nuxt.options.alias ||= {};
     nuxt.options.alias["#graphql"] ||= resolveBuild("graphql");
-    const contextModules = [
-      ...await Promise.all((options.yoga?.context || []).map((path) => resolveRootPath(path, true)))
-    ];
-    addTemplate({ filename: "graphql/context.ts", getContents: () => renderContextTemplate({ contextModules }), write: true });
-    addServerTemplate({ filename: "#graphql/#context.ts", getContents: () => renderContextTemplate({ contextModules }) });
-    const schemaDefs = {};
+    const buildCache = /* @__PURE__ */ new Map();
+    function cachedLoader(baseKey, loader) {
+      return async (...args) => {
+        const key = `${baseKey}:${hash(args)}`;
+        const cached = buildCache.get(key);
+        if (cached?.key === key) {
+          return cached.data;
+        }
+        const data = await loader(...args);
+        buildCache.set(key, { key, data });
+        return data;
+      };
+    }
+    const contextModules = await Promise.all((options.yoga?.context || []).map((path) => resolveRootPath(path, true)));
+    addTemplate({ filename: "graphql/context.mjs", getContents: () => renderContextTemplate({ contextModules }), write: true });
+    addTemplate({ filename: "graphql/context.d.ts", getContents: () => renderContextTypesTemplate({ contextModules }), write: true });
+    addServerTemplate({ filename: "#graphql/context.mjs", getContents: () => renderContextTemplate({ contextModules }) });
+    const remoteExecutorModule = resolveModule("./runtime/server/lib/remote-executor");
+    const schemaCachedLoaders = {};
     for (const [schemaName, schemaDef] of Object.entries(options.yoga?.schemas || {})) {
       if (schemaDef.type === "local") {
-        const localSchemaDef = {
-          ...schemaDef,
-          path: await resolveRootPath(schemaDef.path, true)
-        };
-        schemaDefs[schemaName] = localSchemaDef;
-        addTemplate({ filename: `graphql/schemas/${schemaName}.ts`, getContents: async () => renderLocalSchemaTemplate({ ...localSchemaDef }), write: true });
-        addServerTemplate({ filename: `#graphql/schemas/${schemaName}.ts`, getContents: async () => renderLocalSchemaTemplate({ ...localSchemaDef }) });
+        const schemaModule = await resolveRootPath(schemaDef.path, true);
+        schemaCachedLoaders[schemaName] = cachedLoader(`schema:local:${schemaName}`, async () => await loadLocalSchema({ schemaModule }));
+        addTemplate({ filename: `graphql/schemas/${schemaName}.mjs`, getContents: async () => renderLocalSchemaTemplate({ schemaModule }), write: true });
+        addServerTemplate({ filename: `#graphql/schemas/${schemaName}.mjs`, getContents: async () => renderLocalSchemaTemplate({ schemaModule }) });
       } 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")
+        schemaCachedLoaders[schemaName] = cachedLoader(`schema:remote:${schemaName}`, async () => await introspectRemoteSchema(schemaDef));
+        const input = {
+          remoteExecutorModule,
+          hooksModules: await Promise.all((schemaDef.hooks || []).map((hookPath) => resolveRootPath(hookPath, true))),
+          schemaDef,
+          schemaLoader: schemaCachedLoaders[schemaName]
         };
-        schemaDefs[schemaName] = remoteSchemaDef;
-        addTemplate({ filename: `graphql/schemas/${schemaName}.ts`, getContents: async () => await renderRemoteSchemaTemplate({ ...remoteSchemaDef }), write: true });
-        addServerTemplate({ filename: `#graphql/schemas/${schemaName}.ts`, getContents: async () => await renderRemoteSchemaTemplate({ ...remoteSchemaDef }) });
+        addTemplate({ filename: `graphql/schemas/${schemaName}.mjs`, getContents: async () => await renderRemoteSchemaTemplate(input), write: true });
+        addServerTemplate({ filename: `#graphql/schemas/${schemaName}.mjs`, getContents: async () => await renderRemoteSchemaTemplate(input) });
       } else {
         throw new Error(`Unknown schema type for schema "${schemaName}"`);
       }
     }
-    addTemplate({ filename: "graphql/schema.ts", getContents: () => renderStitchedSchemaTemplate({ schemaNames: Object.keys(options.yoga?.schemas || {}) }), write: true });
-    addServerTemplate({ filename: "#graphql/schema.ts", getContents: () => renderStitchedSchemaTemplate({ schemaNames: Object.keys(options.yoga?.schemas || {}) }) });
-    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;
-    }
     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 loadCachedSchema = cachedLoader("schema:stitched", async () => {
+      const schema = stitchSchemas({
+        subschemas: await Promise.all(Object.values(schemaCachedLoaders).map((loader) => loader()))
+      });
       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;
-    }
-    addTemplate({
-      filename: "graphql/operations.ts",
-      getContents: async () => await renderOperationsTemplate({
-        schema: await getStitchedSchema(schemaDefs),
-        documents: await getDocuments(options.client?.documents || "**/*.gql")
-      }),
-      write: true
+    });
+    addTemplate({ filename: "graphql/schema.mjs", getContents: () => renderSchemaTemplate({ schemaNames: Object.keys(options.yoga?.schemas || {}) }), write: true });
+    addTemplate({ filename: "graphql/schema.d.ts", getContents: () => renderSchemaTypesTemplate(), write: true });
+    addServerTemplate({ filename: "#graphql/schema.mjs", getContents: () => renderSchemaTemplate({ schemaNames: Object.keys(options.yoga?.schemas || {}) }) });
+    const loadCachedDocuments = cachedLoader("documents", async (documentsGlob) => {
+      try {
+        return await loadDocuments([
+          documentsGlob,
+          "!**/.cache/**",
+          "!**/.nuxt/**",
+          "!**/.output/**",
+          "!**/dist/**",
+          "!**/node_modules/**"
+        ], { loaders: [new GraphQLFileLoader()] });
+      } catch {
+        return [];
+      }
+    });
+    const loadCachedOperations = cachedLoader("operations", async (documentsGlob) => {
+      const schema = await loadCachedSchema();
+      const documents = await loadCachedDocuments(documentsGlob);
+      return await renderOperationsTemplate({ schema, documents });
+    });
+    addTemplate({ filename: "graphql/operations.mjs", getContents: async () => (await loadCachedOperations(options.client?.documents || "**/*.gql")).module, write: true });
+    addServerTemplate({ filename: "#graphql/operations.mjs", getContents: async () => (await loadCachedOperations(options.client?.documents || "**/*.gql")).module });
+    addTemplate({ filename: "graphql/operations.d.ts", getContents: async () => (await loadCachedOperations(options.client?.documents || "**/*.gql")).types, write: true });
+    const loadCachedRegistry = cachedLoader("registry", async (documentsGlob) => {
+      const documents = await loadCachedDocuments(documentsGlob);
+      return await renderRegistryTemplate({ documents });
     });
     addTemplate({
-      filename: "graphql/fragments.ts",
-      getContents: async () => await renderFragmentsTemplate({
-        documents: await getDocuments(options.client?.documents || "**/*.gql")
-      }),
+      filename: "graphql/registry.mjs",
+      getContents: async () => (await loadCachedRegistry(options.client?.documents || "**/*.gql")).module,
       write: true
     });
+    addServerTemplate({
+      filename: "#graphql/registry.mjs",
+      getContents: async () => (await loadCachedRegistry(options.client?.documents || "**/*.gql")).module
+    });
     addTemplate({
-      filename: "graphql/registry.ts",
-      getContents: async () => await renderRegistryTemplate({
-        documents: await getDocuments(options.client?.documents || "**/*.gql")
-      }),
+      filename: "graphql/registry.d.ts",
+      getContents: async () => (await loadCachedRegistry(options.client?.documents || "**/*.gql")).types,
       write: true
     });
-    addTypeTemplate({ filename: "types/nuxt-graphql.app.d.ts", getContents: () => renderAppTypesTemplate() }, { nuxt: true });
-    addTypeTemplate({ filename: "types/nuxt-graphql.server.d.ts", getContents: () => renderServerTypesTemplate() }, { nitro: true });
-    addTypeTemplate({ filename: "types/nuxt-graphql.shared.d.ts", getContents: () => renderSharedTypesTemplate() }, { nuxt: true, nitro: true });
     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}`);
+    addTypeTemplate({ filename: "types/nuxt-graphql.app.d.ts", getContents: () => renderAppTypesTemplate() }, { nuxt: true });
+    addTypeTemplate({ filename: "types/nuxt-graphql.server.d.ts", getContents: () => renderServerTypesTemplate() }, { nitro: true, node: true });
+    addTypeTemplate({ filename: "types/nuxt-graphql.shared.d.ts", getContents: () => renderSharedTypesTemplate() }, { nuxt: true, nitro: true, node: true });
     nuxt.options.runtimeConfig.public.graphql = defu(nuxt.options.runtimeConfig.public.graphql, {
       cacheConfig: resolveCacheConfig(options.client?.cache),
       ssrForwardHeaders: options.client?.ssrForwardHeaders || ["authorization", "cookie"]
@@ -473,7 +470,8 @@ const module$1 = defineNuxtModule({
       nuxt.hook("builder:watch", async (_event, changedPath) => {
         if (changedPath.endsWith(".gql")) {
           logger.info(`Documents change detected: ${cyan}${getRelativePath(changedPath)}${reset}`);
-          documentsCache = null;
+          buildCache.delete("documents");
+          buildCache.delete("operations");
         }
       });
     }

package/dist/runtime/app/composables/useAsyncGraphQLQuery.d.ts

@@ -2,10 +2,9 @@ import { useAsyncData, type AsyncDataOptions } from "#app";
 import type { QueryName, ResultOf, VariablesOf } from "#graphql/registry";
 import { type MaybeRefOrGetter } from "#imports";
 import { type ExecuteGraphQLHTTPOptions } from "../lib/execute-http.js";
-import { type CacheConfig } from "../../shared/lib/cache-config.js";
 import type { IsEmptyObject } from "../../shared/lib/utils.js";
 type UseAsyncGraphQLQueryOptions<TName extends QueryName> = ExecuteGraphQLHTTPOptions & {
-    cache?: Partial<CacheConfig>;
+    cache?: Partial<GraphQLCacheConfig>;
 } & AsyncDataOptions<ResultOf<TName>>;
 /**
  * Async GraphQL query composable with caching support.

package/dist/runtime/app/composables/useAsyncGraphQLQuery.js

@@ -1,10 +1,9 @@
 import { useAsyncData, useNuxtData, useRuntimeConfig } from "#app";
 import { computed, toValue } from "#imports";
-import { getCacheKeyParts } from "../lib/cache.js";
 import { executeGraphQLHTTP } from "../lib/execute-http.js";
 import { getInFlightRequests } from "../lib/in-flight.js";
 import { getPersistedEntry, setPersistedEntry } from "../lib/persisted.js";
-import { resolveCacheConfig } from "../../shared/lib/cache-config.js";
+import { getCacheKeyParts, resolveCacheConfig } from "../../shared/lib/cache.js";
 export function useAsyncGraphQLQuery(operationName, ...args) {
   const [variables, options] = args;
   const isClient = import.meta.client;

package/dist/runtime/app/composables/useGraphQLCache.client.js

@@ -1,5 +1,5 @@
 import { clearNuxtData, useRuntimeConfig } from "#imports";
-import { getCacheKeyParts } from "../lib/cache.js";
+import { getCacheKeyParts } from "../../shared/lib/cache.js";
 import { deletePersistedByPrefix, deletePersistedEntry } from "../lib/persisted.js";
 export function useGraphQLCache() {
   const { public: { graphql: { cacheConfig } } } = useRuntimeConfig();

package/dist/runtime/server/lib/remote-executor.d.ts

@@ -1,9 +1,7 @@
 import type { Executor } from "@graphql-tools/utils";
-import { type HeadersInput } from "../../shared/lib/headers.js";
 import type { GraphQLRemoteExecHooks } from "../utils/defineRemoteExecutorHooks.js";
-type CreateRemoteExecutorInput = {
-    url: string;
-    headers?: HeadersInput;
+import type { RemoteSchemaDef } from "../../../lib/schemas.js";
+type CreateRemoteExecutorInput = Pick<RemoteSchemaDef, "url" | "headers"> & {
     hooks: GraphQLRemoteExecHooks[];
 };
 /**

package/dist/runtime/server/tsconfig.json

@@ -1,3 +1,3 @@
 {
-  "extends": "../../../.nuxt/tsconfig.server.json",
-}
+  "extends": "../../../.nuxt/tsconfig.server.json"
+}

package/dist/runtime/{app → shared}/lib/cache.d.ts

@@ -1,4 +1,10 @@
-import type { CacheConfig } from "../../shared/lib/cache-config.js";
+/**
+ * Merge the default cache config with user overrides.
+ *
+ * @param overrides Partial cache config overrides.
+ * @returns Resolved cache configuration.
+ */
+export declare function resolveCacheConfig(...overrides: Array<Partial<GraphQLCacheConfig> | undefined>): GraphQLCacheConfig;
 type CacheKeyParts = {
     key: string;
     opPrefix: string;
@@ -6,7 +12,7 @@ type CacheKeyParts = {
 /**
  * Build cache key parts from config, operation name, and variables.
  *
- * @param {CacheConfig} options Cache configuration.
+ * @param {GraphQLCacheConfig} options Cache configuration.
  * @param options.keyPrefix Cache key prefix.
  * @param options.keyVersion Cache key version.
  * @param operationName Operation name.
@@ -14,5 +20,5 @@ type CacheKeyParts = {
  * @param scope Optional cache scope segment.
  * @returns Key parts including full key and operation prefix.
  */
-export declare function getCacheKeyParts({ keyPrefix, keyVersion }: CacheConfig, operationName: string, variables: unknown, scope?: string): CacheKeyParts;
+export declare function getCacheKeyParts({ keyPrefix, keyVersion }: GraphQLCacheConfig, operationName: string, variables: unknown, scope?: string): CacheKeyParts;
 export {};

package/dist/runtime/{app → shared}/lib/cache.js

@@ -1,4 +1,13 @@
 import { hash } from "ohash";
+const defaultCacheConfig = {
+  keyPrefix: "gql",
+  keyVersion: "1",
+  policy: "no-cache",
+  ttl: void 0
+};
+export function resolveCacheConfig(...overrides) {
+  return Object.assign({}, defaultCacheConfig, ...overrides);
+}
 export function getCacheKeyParts({ keyPrefix, keyVersion }, operationName, variables, scope) {
   const parts = [keyPrefix, keyVersion];
   if (scope) parts.push(scope);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lewebsimple/nuxt-graphql",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "description": "Opinionated Nuxt module for using GraphQL",
   "repository": "lewebsimple/nuxt-graphql",
   "license": "AGPL-3.0-only",

package/dist/runtime/shared/lib/cache-config.d.ts

@@ -1,42 +0,0 @@
-type GraphQLCachePolicy = "no-cache" | "cache-first" | "network-first" | "swr";
-export type CacheConfig = {
-    /**
-     * Prefix used for all persisted cache keys.
-     *
-     * Used for namespacing and bulk invalidation.
-     * Default: 'graphql'
-     */
-    keyPrefix: string;
-    /**
-     * Version included in cache keys.
-     *
-     * Changing this value invalidates all existing cache entries.
-     * Default: '1'
-     */
-    keyVersion: string | number;
-    /**
-     * Cache strategy used by useAsyncGraphQLQuery.
-     *
-     * - 'no-cache'        → always fetch, never read/write cache
-     * - 'cache-first'     → return cache if valid, otherwise fetch
-     * - 'network-first'   → fetch first, fallback to cache on failure
-     * - 'swr'             → return cache immediately, revalidate in background
-     */
-    policy: GraphQLCachePolicy;
-    /**
-     * Time-to-live in seconds.
-     *
-     * - undefined → inherit from higher-level config
-     * - 0         → never expires
-     * - > 0       → expires after TTL
-     */
-    ttl?: number;
-};
-/**
- * Merge the default cache config with user overrides.
- *
- * @param overrides Partial cache config overrides.
- * @returns Resolved cache configuration.
- */
-export declare function resolveCacheConfig(...overrides: Array<Partial<CacheConfig> | undefined>): CacheConfig;
-export {};

package/dist/runtime/shared/lib/cache-config.js

@@ -1,9 +0,0 @@
-const defaultCacheConfig = {
-  keyPrefix: "gql",
-  keyVersion: "1",
-  policy: "no-cache",
-  ttl: void 0
-};
-export function resolveCacheConfig(...overrides) {
-  return Object.assign({}, defaultCacheConfig, ...overrides);
-}