@lewebsimple/nuxt-graphql 0.6.20 → 0.7.0

package/dist/module.mjs

@@ -1,18 +1,21 @@
-import { mkdirSync, writeFileSync } from 'node:fs';
-import { relative, resolve, dirname } from 'node:path';
-import { defu } from 'defu';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { relative, resolve, parse, dirname } from 'node:path';
 import { stitchSchemas } from '@graphql-tools/stitch';
-import { addTemplate, addServerTemplate, defineNuxtModule, useLogger, createResolver, addServerHandler, addPlugin, addImportsDir, addServerImportsDir } from '@nuxt/kit';
+import { createResolver, addTemplate, addTypeTemplate, defineNuxtModule, useLogger, addServerImports, updateTemplates, addServerHandler, addPlugin, addImportsDir, addServerImportsDir } from '@nuxt/kit';
+import { defu } from 'defu';
+import { parse as parse$1, printSchema, lexicographicSortSchema, getIntrospectionQuery, buildClientSchema, GraphQLSchema, buildSchema } from 'graphql';
+import { cyan } from 'picocolors';
+import picomatch from 'picomatch';
 import { hash } from 'ohash';
-import { createRequire } from 'node:module';
-import { printSchema, lexicographicSortSchema, buildSchema, getIntrospectionQuery, buildClientSchema, GraphQLSchema, Kind } from 'graphql';
-import { loadDocuments } from '@graphql-tools/load';
+import { CodeFileLoader } from '@graphql-tools/code-file-loader';
 import { GraphQLFileLoader } from '@graphql-tools/graphql-file-loader';
+import { loadDocuments as loadDocuments$1 } from '@graphql-tools/load';
 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 { resolveCacheConfig } from '../dist/runtime/app/lib/cache.js';
+import zodPreset from '@lewebsimple/graphql-codegen-zod';
+import { createRequire } from 'node:module';
+import { resolveCacheConfig } from '../dist/runtime/app/lib/cache-config.js';
+
+const version = "0.7.0";
 
 const buildCache = /* @__PURE__ */ new Map();
 function getCachedLoader(baseKey, loader) {
@@ -30,22 +33,98 @@ function getCachedLoader(baseKey, loader) {
 function clearBuildCache(baseKey) {
   if (!baseKey) {
     buildCache.clear();
+    return;
   }
   const baseKeys = Array.isArray(baseKey) ? baseKey : [baseKey];
   for (const key of buildCache.keys()) {
-    for (const baseKey2 of baseKeys) {
-      if (key.startsWith(`${baseKey2}:`)) {
+    for (const targetBaseKey of baseKeys) {
+      if (key.startsWith(`${targetBaseKey}:`)) {
         buildCache.delete(key);
+        break;
       }
     }
   }
 }
 
-const cyan = "\x1B[36m";
-const reset = "\x1B[0m";
+function toRelativePath(from, to) {
+  let relativePath = relative(resolve(from), resolve(to));
+  relativePath = relativePath.replace(/\\/g, "/");
+  if (!relativePath.startsWith("./") && !relativePath.startsWith("../")) {
+    relativePath = `./${relativePath}`;
+  }
+  return relativePath;
+}
+function stripExtension(filePath) {
+  const { dir, name } = parse(filePath);
+  return dir ? `${dir}/${name}` : name;
+}
+
+async function resolveContextInput({ paths }, nuxt) {
+  const { resolvePath } = createResolver(nuxt.options.rootDir);
+  return {
+    paths: await Promise.all(
+      paths.map(async (contextPath) => {
+        const path = await resolvePath(contextPath, { alias: nuxt.options.alias });
+        return path.replaceAll("\\", "/");
+      })
+    )
+  };
+}
+function getContextTemplate({ paths }) {
+  const imports = [
+    ...paths.map(
+      (path, index) => `import factory${index} from ${JSON.stringify(stripExtension(path))};`
+    ),
+    `import type { H3Event } from "h3";`
+  ];
+  const factories = ["(_event: H3Event) => ({})", ...paths.map((_, index) => `factory${index}`)];
+  const types = ["{}", ...paths.map((_, index) => `Awaited<ReturnType<typeof factory${index}>>`)];
+  return [
+    ...imports,
+    "",
+    `export type GraphQLContext = ${types.join(" & ")};`,
+    "",
+    `const factories = [${factories.join(", ")}];`,
+    "",
+    `export async function createContext(event: H3Event): Promise<GraphQLContext> {`,
+    `  const contexts = await Promise.all(factories.map((factory) => factory(event)));`,
+    `  return Object.assign({}, ...contexts);`,
+    `}`
+  ].join("\n");
+}
+
+async function resolveDocumentGlobs(globs, nuxt) {
+  const { resolvePath } = createResolver(nuxt.options.rootDir);
+  return Promise.all(
+    globs.map(
+      async (glob) => (await resolvePath(glob, { alias: nuxt.options.alias })).replaceAll("\\", "/")
+    )
+  );
+}
+async function loadDocuments(globs) {
+  if (!globs.length) return [];
+  try {
+    const docs = await loadDocuments$1(globs, {
+      loaders: [new GraphQLFileLoader(), new CodeFileLoader()],
+      ignore: ["**/.nuxt/**", "**/.output/**", "**/dist/**", "**/node_modules/**"]
+    });
+    const seen = /* @__PURE__ */ new Set();
+    return docs.filter((doc) => {
+      const key = `${doc.location ?? ""}:${doc.rawSDL ?? ""}`;
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return Boolean(doc.document);
+    });
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "name" in error && error.name === "NoTypeDefinitionsFound") {
+      return [];
+    }
+    throw error;
+  }
+}
 
 const require$1 = createRequire(import.meta.url);
-function splitModule(ts) {
+function compileTsModule(ts) {
   const tsCompiler = require$1("typescript");
   const fileName = "module.ts";
   const outputs = {};
@@ -53,121 +132,251 @@ function splitModule(ts) {
     target: tsCompiler.ScriptTarget.ES2020,
     module: tsCompiler.ModuleKind.ESNext,
     moduleResolution: tsCompiler.ModuleResolutionKind.NodeNext,
-    declaration: true,
-    importsNotUsedAsValues: tsCompiler.ImportsNotUsedAsValues.Remove,
-    preserveValueImports: false
+    declaration: true
   };
   const host = tsCompiler.createCompilerHost(compilerOptions, true);
   host.getSourceFile = (name) => name === fileName ? tsCompiler.createSourceFile(fileName, ts, tsCompiler.ScriptTarget.ESNext, true) : void 0;
   host.readFile = () => ts;
   host.fileExists = (f) => f === fileName;
-  host.writeFile = (name, content) => {
-    outputs[name] = content;
-  };
+  host.writeFile = (name, content) => outputs[name] = content;
   const program = tsCompiler.createProgram([fileName], compilerOptions, host);
   program.emit();
   return {
-    mjs: Object.entries(outputs).find(([n]) => n.endsWith(".js"))?.[1]?.trim() ?? "",
-    dts: Object.entries(outputs).find(([n]) => n.endsWith(".d.ts"))?.[1]?.trim() ?? ""
+    mjs: getCompiledContent(outputs, ".js"),
+    dts: getCompiledContent(outputs, ".d.ts")
   };
 }
-
-function getContextTemplate({ importPaths }) {
-  const contextImports = importPaths.map((importPath, index) => `import context${index} from ${JSON.stringify(importPath)};`);
-  const contextTypes = ["{}", ...importPaths.map((_, index) => `Awaited<ReturnType<typeof context${index}>>`)];
-  const contextArray = ["(event: H3Event) => ({})", ...importPaths.map((_, index) => `context${index}`)];
-  const ts = `
-import type { H3Event } from "h3";
-${contextImports.join("\n")}
-
-export type GraphQLContext = ${contextTypes.join(" & ")};
-
-const contextFactories = [${contextArray.join(", ")}];
-
-export async function createContext(event: H3Event): Promise<GraphQLContext> {
-  return Object.assign(
-    {},
-    ...await Promise.all(contextFactories.map((factory) => factory(event)))
-  )
-}`.trim();
-  return { ts, ...splitModule(ts) };
+function getCompiledContent(outputs, extension) {
+  return Object.entries(outputs).find(([name]) => name.endsWith(extension))?.[1]?.trim() ?? "";
+}
+async function addCompiledTemplate({ filename, getContents }, nuxt) {
+  if (nuxt.options.dev || nuxt.options._prepare) {
+    return addTemplate({ filename: `${filename}.ts`, getContents, write: true });
+  } else {
+    const { mjs, dts } = compileTsModule(await getContents());
+    addTemplate({
+      filename: `${filename}.d.ts`,
+      getContents: () => dts,
+      write: true
+    });
+    return addTemplate({
+      filename: `${filename}.mjs`,
+      getContents: () => mjs,
+      write: true
+    });
+  }
 }
 
-function getRelativePath(from, to) {
-  let relativePath = relative(resolve(from), resolve(to));
-  relativePath = relativePath.replace(/\\/g, "/");
-  if (!relativePath.startsWith("./") && !relativePath.startsWith("../")) {
-    relativePath = `./${relativePath}`;
+async function generateRegistryArtifacts({
+  schema,
+  documents
+}) {
+  const generates = await zodPreset.buildGeneratesSection({
+    baseOutputDir: "registry.ts",
+    schema: parse$1(printSchema(schema)),
+    documents,
+    config: {},
+    pluginMap: {},
+    plugins: [],
+    presetConfig: {}
+  });
+  if (!documents.length) {
+    return {
+      "registry.ts": getRegistryFallback(),
+      "types.d.ts": getTypesFallback()
+    };
   }
-  return relativePath;
+  const files = {};
+  await Promise.all(
+    generates.map(
+      (generate) => codegen(generate).then((content) => {
+        files[generate.filename] = content;
+      })
+    )
+  );
+  const artifacts = {
+    ...files,
+    "registry.ts": files["registry.ts"] || getRegistryFallback(),
+    "types.d.ts": files["types.d.ts"] || getTypesFallback()
+  };
+  return artifacts;
 }
-function removeExtension(path) {
-  return path.replace(/\.(ts|mjs)$/, "");
+async function addRegistryArtifactTemplates(artifacts, nuxt) {
+  let registryDst = "";
+  let typesDts = "";
+  for (const [filename, content] of Object.entries(artifacts)) {
+    switch (filename) {
+      case "types.d.ts":
+        typesDts = addTypeTemplate(
+          {
+            filename: "graphql/types.d.ts",
+            getContents: () => content,
+            write: true
+          },
+          { nitro: true, nuxt: true }
+        ).dst;
+        break;
+      default: {
+        const template = await addCompiledTemplate(
+          {
+            filename: `graphql/${stripExtension(filename)}`,
+            getContents: () => content
+          },
+          nuxt
+        );
+        if (filename === "registry.ts") {
+          registryDst = template.dst;
+        }
+        break;
+      }
+    }
+  }
+  if (!registryDst || !typesDts) {
+    throw new Error("Failed to register GraphQL registry artifacts");
+  }
+  return { registryDst, typesDts };
 }
+function getRegistryFallback() {
+  return `
+import type { TypedDocumentNode } from "@graphql-typed-document-node/core";
+import type * as z from "zod";
 
-function getSchemaTemplate({ local, remote }) {
-  const localImports = Object.entries(local).map(([name, { importPath }]) => `import { schema as ${name}LocalSchema } from ${JSON.stringify(importPath)};`);
-  const localSchemas = Object.keys(local).map((name) => `${name}LocalSchema`);
-  const mergedSchema = `mergeSchemas({ schemas: [${localSchemas.join(", ")}] })`;
-  const remoteImports = Object.entries(remote).map(([name, { importPath }]) => `import { schema as ${name}RemoteSchema } from ${JSON.stringify(importPath)};`);
-  const remoteSchemas = Object.keys(remote).map((name) => `${name}RemoteSchema`);
-  const ts = `
-import { mergeSchemas } from "@graphql-tools/schema";
-import { stitchSchemas } from "@graphql-tools/stitch";
-${localImports.join("\n")}
-${remoteImports.join("\n")}
+type EnumEntry = { schema: z.ZodEnum<Record<string, string>> };
 
-export const schema = stitchSchemas({
-  subschemas: [${[mergedSchema, ...remoteSchemas].join(", ")}],
-});
-  `.trim();
-  return { ts, ...splitModule(ts) };
+type FragmentEntry = { schema: z.ZodObject<z.ZodRawShape> };
+
+type OperationEntry = {
+  kind: "query" | "mutation" | "subscription";
+  document: TypedDocumentNode<any, any>;
+  resultSchema: z.ZodObject<z.ZodRawShape>;
+  variablesSchema: z.ZodObject<z.ZodRawShape>;
+};
+
+export const enums: Record<string, EnumEntry> = {};
+export const fragments: Record<string, FragmentEntry> = {};
+export const operations: Record<string, OperationEntry> = {};
+`.trim();
 }
-async function loadLocalSchema({ importPath }) {
-  const { createJiti } = await import('jiti');
-  const jiti = createJiti(import.meta.url, { interopDefault: true });
-  const module = await jiti.import(importPath);
-  if (!module.schema || !(module.schema instanceof Object) || typeof module.schema.getQueryType !== "function") {
-    throw new Error(`${importPath} must export a valid 'schema' of type GraphQLSchema.`);
-  }
-  return module.schema;
+function getTypesFallback() {
+  return `export type {};`;
 }
-async function getRemoteSchemaTemplate({ endpoint, headers, hooks, loadSchema }) {
-  const hooksImports = hooks.map((hook, index) => `import hook${index} from ${JSON.stringify(hook.importPath)};`);
-  const hooksArray = hooks.map((_, index) => `hook${index}`);
-  const schema = await loadSchema();
-  const sdl = getSchemaSDL(schema);
-  const ts = `
-import type { GraphQLSchema } from "graphql";
-import { buildSchema } from "graphql";
+
+async function resolveSchemaDefs(schemaDefs, nuxt) {
+  const { resolvePath } = createResolver(nuxt.options.rootDir);
+  return Promise.all(
+    schemaDefs.map(async (schemaDef) => {
+      switch (schemaDef.type) {
+        case "local": {
+          const path = await resolvePath(schemaDef.path, { alias: nuxt.options.alias });
+          return {
+            type: "local",
+            path: path.replaceAll("\\", "/")
+          };
+        }
+        case "remote": {
+          const hooks = await Promise.all(
+            (schemaDef.hooks ?? []).map(async (hookPath) => {
+              const path = await resolvePath(hookPath, { alias: nuxt.options.alias });
+              return path.replaceAll("\\", "/");
+            })
+          );
+          return {
+            type: "remote",
+            endpoint: schemaDef.endpoint,
+            headers: schemaDef.headers ?? {},
+            hooks
+          };
+        }
+      }
+    })
+  );
+}
+function getRemoteSchemaServerTemplate({
+  endpoint,
+  headers,
+  hooks,
+  sdl
+}) {
+  const hookImports = hooks.map(
+    (hookPath, index) => `import hook${index} from ${JSON.stringify(hookPath)};`
+  );
+  const hookRefs = hooks.map((_, index) => `hook${index}`);
+  return `
 import { getRemoteExecutor } from "#graphql/runtime/remote-executor";
-${hooksImports.join("\n")}
+import { buildSchema } from "graphql";
+${hookImports.join("\n")}
 
 const executor = getRemoteExecutor({
-  endpoint: "${endpoint}",
+  endpoint: ${JSON.stringify(endpoint)},
   headers: ${JSON.stringify(headers)},
-  hooks: [${hooksArray.join(", ")}],
+  hooks: [${hookRefs.join(", ")}],
 });
 
-const sdl = ${JSON.stringify(sdl)};
-
-// SubschemaConfig exported for stitching
 export const schema = {
-  schema: buildSchema(sdl),
+  schema: buildSchema(${JSON.stringify(sdl)}),
   executor,
-} as unknown as GraphQLSchema;
-  `.trim();
-  return { ts, ...splitModule(ts) };
+};
+`.trim();
 }
-async function introspectRemoteSchema({ endpoint }) {
+function getSchemaServerTemplate({ localPaths, remotePaths }) {
+  const imports = [
+    ...localPaths.map(
+      (schemaPath, index) => `import { schema as localSchema${index} } from ${JSON.stringify(schemaPath)};`
+    ),
+    ...remotePaths.map(
+      (schemaPath, index) => `import { schema as remoteSchema${index} } from ${JSON.stringify(schemaPath)};`
+    )
+  ];
+  const localSchemaRefs = localPaths.map((_, index) => `localSchema${index}`);
+  const remoteSchemaRefs = remotePaths.map((_, index) => `remoteSchema${index}`);
+  const schemaRefs = [];
+  if (localSchemaRefs.length === 1) {
+    schemaRefs.push(localSchemaRefs[0]);
+  } else if (localSchemaRefs.length > 1) {
+    imports.unshift(`import { mergeSchemas } from "@graphql-tools/schema";`);
+    schemaRefs.push(`mergeSchemas({ schemas: [${localSchemaRefs.join(", ")}] })`);
+  }
+  schemaRefs.push(...remoteSchemaRefs);
+  let schemaRef;
+  if (schemaRefs.length === 0) {
+    imports.unshift(`import {  buildSchema } from "graphql";`);
+    schemaRef = `buildSchema("type Query { _empty: String }")`;
+  } else if (schemaRefs.length === 1) {
+    schemaRef = schemaRefs[0];
+  } else {
+    imports.unshift(`import { stitchSchemas } from "@graphql-tools/stitch";`);
+    schemaRef = `stitchSchemas({ subschemas: [${schemaRefs.join(", ")}] })`;
+  }
+  return [...imports, "", `export const schema = ${schemaRef};`].join("\n");
+}
+async function loadLocalSchema(path, nuxt) {
+  const { createJiti } = await import('jiti');
+  const jiti = createJiti(import.meta.url, { interopDefault: true, alias: nuxt.options.alias });
+  const module = await jiti.import(path);
+  if (!module.schema || !(module.schema instanceof Object) || typeof module.schema.getQueryType !== "function") {
+    throw new Error(`${path} must export a valid 'schema' of type GraphQLSchema.`);
+  }
+  return module.schema;
+}
+async function loadRemoteSchema(endpoint, headers) {
   const response = await fetch(endpoint, {
     method: "POST",
-    headers: { "Content-Type": "application/json" },
+    headers: { "Content-Type": "application/json", ...headers },
     body: JSON.stringify({ query: getIntrospectionQuery() })
   });
+  if (!response.ok) {
+    throw new Error(
+      `Failed to introspect remote GraphQL schema at "${endpoint}" (HTTP ${response.status}).`
+    );
+  }
   const json = await response.json();
   if (json.errors) {
-    throw new Error(`Failed to fetch GraphQL schema from ${endpoint}: ${JSON.stringify(json.errors)} `);
+    throw new Error(
+      `Failed to introspect remote GraphQL schema at "${endpoint}": ${JSON.stringify(json.errors)}`
+    );
+  }
+  if (!json.data || typeof json.data !== "object") {
+    throw new Error(`Remote GraphQL introspection at "${endpoint}" returned no data.`);
   }
   const schema = buildClientSchema(json.data);
   return stripSubscriptions(schema);
@@ -187,284 +396,176 @@ function stripSubscriptions(schema) {
 function getSchemaSDL(schema) {
   return printSchema(lexicographicSortSchema(schema));
 }
-function getDefaultSchema() {
-  return buildSchema(`type Query { _empty: String }`);
-}
-
-function addUniversalTemplate({ filename, getContents, emitTs }) {
-  let modulePath;
-  if (emitTs) {
-    modulePath = addTemplate({ filename: `${filename}.ts`, getContents: async () => (await getContents()).ts, write: true }).dst;
-  } else {
-    modulePath = addTemplate({ filename: `${filename}.mjs`, getContents: async () => (await getContents()).mjs, write: true }).dst;
-    addTemplate({ filename: `${filename}.d.ts`, getContents: async () => (await getContents()).dts });
-  }
-  addServerTemplate({ filename: `${filename}.mjs`, getContents: async () => (await getContents()).mjs });
-  return modulePath;
-}
-
-const version = "0.6.20";
-
-async function getDocuments(documentsGlob) {
-  try {
-    return await loadDocuments([
-      documentsGlob,
-      "!**/.cache/**",
-      "!**/.nuxt/**",
-      "!**/.output/**",
-      "!**/dist/**",
-      "!**/node_modules/**"
-    ], { loaders: [new GraphQLFileLoader()] });
-  } catch (error) {
-    if (typeof error === "object" && error !== null && "name" in error && error.name === "NoTypeDefinitionsFound") {
-      return [];
-    }
-    throw error;
-  }
-}
-
-async function getOperationsTemplate({ loadSchema, loadDocuments, documentGlob }) {
-  const ts = await codegen({
-    filename: "operations.ts",
-    schema: await loadSchema(),
-    documents: await loadDocuments(documentGlob),
-    plugins: [
-      {
-        typescript: {
-          avoidOptionals: {
-            field: true,
-            object: true,
-            inputValue: false,
-            defaultValue: false
-          },
-          defaultScalarType: "never",
-          enumsAsConst: true,
-          preResolveTypes: false,
-          strictScalars: true,
-          useTypeImports: true
-        }
-      },
-      {
-        typescriptOperations: {
-          avoidOptionals: {
-            field: true,
-            object: true,
-            inputValue: false,
-            defaultValue: false
-          },
-          defaultScalarType: "never",
-          enumsAsConst: true,
-          exportFragmentSpreadSubTypes: true,
-          inlineFragmentTypes: "combine",
-          operationResultSuffix: "Result",
-          operationVariablesSuffix: "Variables",
-          preResolveTypes: false,
-          skipTypename: true,
-          strictScalars: true,
-          useTypeImports: true
-        }
-      },
-      {
-        typedDocumentNode: {
-          documentVariableSuffix: "Document",
-          operationResultSuffix: "Result",
-          operationVariablesSuffix: "Variables",
-          optimizeDocumentNode: true,
-          useTypeImports: true
-        }
-      }
-    ],
-    pluginMap: {
-      typescript: typescriptPlugin,
-      typescriptOperations: typescriptOperationsPlugin,
-      typedDocumentNode: typedDocumentNodePlugin
-    },
-    config: {}
-  });
-  return { ts, ...splitModule(ts) };
-}
-
-async function getRegistryTemplate({ loadDocuments, documentGlob }) {
-  const documents = await loadDocuments(documentGlob);
-  const operations = collectOperations(documents);
-  function capitalize(value) {
-    if (!value) return value;
-    return value.charAt(0).toUpperCase() + value.slice(1);
-  }
-  const ts = `
-import type { DocumentNode } from "graphql";
-import {
-  ${operations.map(({ name, kind }) => `${name}Document, type ${name}${capitalize(kind)}Variables, type ${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"];
-
-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  ")}
-};`.trim();
-  return { ts, ...splitModule(ts) };
-}
-function collectOperations(documents) {
-  const operations = /* @__PURE__ */ new Map();
-  for (const source of documents) {
-    const doc = source.document;
-    if (!doc) continue;
-    for (const def of doc.definitions) {
-      if (def.kind !== Kind.OPERATION_DEFINITION) continue;
-      const name = def.name?.value;
-      if (!name) {
-        throw new Error("Anonymous GraphQL operations are not allowed");
-      }
-      if (operations.has(name)) {
-        throw new Error(`Duplicate GraphQL operation name "${name}"`);
-      }
-      operations.set(name, { name, kind: def.operation });
-    }
-  }
-  return Array.from(operations.values());
-}
 
 const module$1 = defineNuxtModule({
   meta: {
-    name: "@lewebsimple/nuxt-graphql",
+    name: "nuxt-graphql",
     configKey: "graphql"
   },
   defaults: {},
   async setup(options, nuxt) {
     const logger = useLogger("@lewebsimple/nuxt-graphql");
     logger.info(`@lewebsimple/nuxt-graphql v${version} loaded`);
-    const { resolve: resolveModule } = createResolver(import.meta.url);
     const { rootDir } = nuxt.options;
-    const { resolve: resolveRoot, resolvePath: rawResolveRootPath } = createResolver(rootDir);
-    async function resolveRootPath(path) {
-      return removeExtension(await rawResolveRootPath(path));
-    }
+    const { resolve: resolveModule } = createResolver(import.meta.url);
+    const { resolve: resolveRoot } = createResolver(rootDir);
     const nuxtAliases = {};
     const nitroAliases = {};
-    const emitTs = Boolean(nuxt.options.dev) || Boolean(process.env.NUXT_MODULE_PREPARE);
-    nuxtAliases["#graphql/runtime/remote-executor"] = resolveModule("./runtime/server/lib/remote-executor");
-    nitroAliases["#graphql/runtime/remote-executor"] = resolveModule("./runtime/server/lib/remote-executor");
-    const contextInput = {
-      importPaths: await Promise.all((options.server?.context || []).map((path) => resolveRootPath(path)))
+    const transpileEntries = /* @__PURE__ */ new Set();
+    addServerImports({
+      name: "defineGraphQLContext",
+      from: resolveModule("runtime/server/lib/context")
+    });
+    const contextInput = await resolveContextInput({ paths: options.server?.context ?? [] }, nuxt);
+    contextInput.paths.forEach((path) => transpileEntries.add(dirname(path)));
+    const { dst: contextDst } = await addCompiledTemplate(
+      { filename: "graphql/context", getContents: () => getContextTemplate(contextInput) },
+      nuxt
+    );
+    nitroAliases["#graphql/context"] = contextDst;
+    addServerImports({
+      name: "defineRemoteExecutorHooks",
+      from: resolveModule("runtime/server/lib/remote-executor")
+    });
+    nitroAliases["#graphql/runtime/remote-executor"] = resolveModule(
+      "runtime/server/lib/remote-executor"
+    );
+    const schemaDefs = await resolveSchemaDefs(options.server?.schema ?? [], nuxt);
+    const schemaInput = {
+      localPaths: [],
+      remotePaths: []
     };
-    const contextPath = addUniversalTemplate({ filename: "graphql/context", getContents: () => getContextTemplate(contextInput), emitTs });
-    nuxtAliases["#graphql/context"] = contextPath;
-    nitroAliases["#graphql/context"] = contextPath;
-    const schemaInput = { local: {}, remote: {} };
-    const schemaLoaders = {};
-    for (const [schemaName, schemaDef] of Object.entries(options.server?.schema || {})) {
-      if (!/^[a-z_][\w-]*$/i.test(schemaName)) {
-        throw new Error(`Invalid schema name "${schemaName}". Only alphanumeric characters, underscores and hyphens are allowed, and it cannot start with a number.`);
-      }
-      if (schemaDef.type === "local") {
-        const importPath = await resolveRootPath(schemaDef.path);
-        const loadSchema2 = getCachedLoader(`schema:local:${schemaName}`, async () => await loadLocalSchema({ importPath }));
-        schemaInput.local[schemaName] = { importPath };
-        schemaLoaders[schemaName] = loadSchema2;
-      } else if (schemaDef.type === "remote") {
-        const { endpoint } = schemaDef;
-        const loadSchema2 = getCachedLoader(`schema:remote:${schemaName}`, async () => await introspectRemoteSchema({ endpoint }));
-        const hooks = await Promise.all((schemaDef.hooks || []).map(async (hookPath) => ({ importPath: await resolveRootPath(hookPath) })));
-        const remoteSchemaInput = { endpoint, headers: schemaDef.headers || {}, hooks, loadSchema: loadSchema2 };
-        addUniversalTemplate({ filename: `graphql/schemas/${schemaName}`, getContents: () => getRemoteSchemaTemplate(remoteSchemaInput), emitTs });
-        schemaInput.remote[schemaName] = { importPath: `./schemas/${schemaName}` };
-        schemaLoaders[schemaName] = loadSchema2;
-      } else {
-        throw new Error(`Unknown schema type for schema "${schemaName}"`);
+    const schemaLoaders = [];
+    for (const [index, schemaDef] of schemaDefs.entries()) {
+      switch (schemaDef.type) {
+        case "local": {
+          const loadSchema = getCachedLoader(
+            `graphql:schema:local-${index}`,
+            async () => await loadLocalSchema(schemaDef.path, nuxt)
+          );
+          schemaLoaders.push(loadSchema);
+          transpileEntries.add(dirname(schemaDef.path));
+          schemaInput.localPaths.push(schemaDef.path);
+          break;
+        }
+        case "remote": {
+          const schemaLoader = getCachedLoader(
+            `graphql:schema:remote-${index}`,
+            async () => await loadRemoteSchema(schemaDef.endpoint, schemaDef.headers ?? {})
+          );
+          schemaLoaders.push(schemaLoader);
+          (schemaDef.hooks ?? []).forEach((hookPath) => transpileEntries.add(dirname(hookPath)));
+          await addCompiledTemplate(
+            {
+              filename: `graphql/schemas/remote-${index}`,
+              getContents: async () => getRemoteSchemaServerTemplate({
+                ...schemaDef,
+                sdl: getSchemaSDL(await schemaLoader())
+              })
+            },
+            nuxt
+          );
+          schemaInput.remotePaths.push(`./schemas/remote-${index}`);
+          break;
+        }
       }
     }
-    const schemaPath = addUniversalTemplate({ filename: "graphql/schema", getContents: () => getSchemaTemplate(schemaInput), emitTs });
-    nuxtAliases["#graphql/schema"] = schemaPath;
-    nitroAliases["#graphql/schema"] = schemaPath;
-    const sdlPath = resolveRoot(options.saveSDL || "server/graphql/schema.graphql");
-    const loadSchema = getCachedLoader("schema:stitched", async () => {
-      const subschemas = await Promise.all(Object.values(schemaLoaders).map((loadSchema2) => loadSchema2()));
-      if (subschemas.length === 0) {
-        logger.warn(`No GraphQL schemas defined: using default empty schema.`);
-        subschemas.push(getDefaultSchema());
+    const { dst: schemaDst } = await addCompiledTemplate(
+      {
+        filename: "graphql/schema",
+        getContents: () => getSchemaServerTemplate(schemaInput)
+      },
+      nuxt
+    );
+    nitroAliases["#graphql/schema"] = schemaDst;
+    const sdlPath = resolveRoot(options.saveSDL || ".nuxt/graphql/schema.graphql");
+    await mkdir(dirname(sdlPath), { recursive: true });
+    const loadSchemaCached = getCachedLoader("graphql:schema", async () => {
+      const schemas = await Promise.all(schemaLoaders.map((loader) => loader()));
+      let schema;
+      if (!schemas.length) {
+        if (!nuxt.options._prepare) {
+          logger.warn("No GraphQL schemas loaded: using default empty schema.");
+        }
+        schema = buildSchema("type Query { _empty: String }");
+      } else {
+        schema = stitchSchemas({ subschemas: schemas });
+        if (!schema) {
+          throw new Error("Failed to load GraphQL schema");
+        }
       }
-      const schema = stitchSchemas({ subschemas });
       if (nuxt.options.dev) {
         const sdl = getSchemaSDL(schema);
-        mkdirSync(dirname(sdlPath), { recursive: true });
-        writeFileSync(sdlPath, sdl, { encoding: "utf-8" });
-        logger.info(`Stitched GraphQL SDL saved to: ${cyan}${getRelativePath(rootDir, sdlPath)}${reset}`);
+        await writeFile(sdlPath, sdl);
       }
       return schema;
     });
-    const loadDocuments = getCachedLoader("documents", async (documentsGlob) => {
-      const documents = await getDocuments(documentsGlob);
-      if (documents.length === 0) {
-        logger.warn(`No GraphQL documents found for glob pattern: ${cyan}${documentsGlob}${reset}`);
-      }
-      return documents;
-    });
-    const operationsInput = { loadSchema, loadDocuments, documentGlob: options.client?.documents || "**/*.gql" };
-    const operationsPath = addUniversalTemplate({ filename: "graphql/operations", getContents: () => getOperationsTemplate(operationsInput), emitTs });
-    nuxtAliases["#graphql/operations"] = operationsPath;
-    nitroAliases["#graphql/operations"] = operationsPath;
-    const registryInput = { loadDocuments, documentGlob: options.client?.documents || "**/*.gql" };
-    const registryPath = addUniversalTemplate({ filename: "graphql/registry", getContents: () => getRegistryTemplate(registryInput), emitTs });
-    nuxtAliases["#graphql/registry"] = registryPath;
-    nitroAliases["#graphql/registry"] = registryPath;
+    const documentGlobs = await resolveDocumentGlobs(
+      options.client?.documents ?? nuxt.options._prepare ? [] : ["app/**/*.{gql,ts,vue}", "server/**/*.{gql,ts}", "shared/**/*.{gql,ts}"],
+      nuxt
+    );
+    const loadDocumentsCached = getCachedLoader(
+      "graphql:documents",
+      async (globs) => loadDocuments(globs)
+    );
+    const generateRegistryCached = getCachedLoader(
+      "graphql:registry",
+      async (globs) => await generateRegistryArtifacts({
+        schema: await loadSchemaCached(),
+        documents: await loadDocumentsCached(globs)
+      })
+    );
+    const syncRegistryTemplates = async () => await addRegistryArtifactTemplates(await generateRegistryCached(documentGlobs), nuxt);
+    const { registryDst, typesDts } = await syncRegistryTemplates();
+    const typesPath = typesDts.replace(/\.d\.ts$/, "");
+    nuxtAliases["#graphql/registry"] = registryDst;
+    nitroAliases["#graphql/registry"] = registryDst;
+    nuxtAliases["#graphql/types"] = typesPath;
+    nitroAliases["#graphql/types"] = typesPath;
+    if (nuxt.options.dev) {
+      const schemaWatchPaths = schemaDefs.filter((schemaDef) => schemaDef.type === "local").map((schemaDef) => schemaDef.path);
+      const isDocument = picomatch(documentGlobs);
+      nuxt.hook("builder:watch", async (_event, path) => {
+        if (schemaWatchPaths.some((schemaPath) => path.includes(schemaPath))) {
+          logger.info(`Local schema change detected: ${path}`);
+          clearBuildCache(["graphql:schema", "graphql:registry"]);
+          await syncRegistryTemplates();
+          await updateTemplates({ filter: (template) => template.filename.startsWith("graphql/") });
+        }
+        if (isDocument(path)) {
+          logger.info(`Document change detected: ${path}`);
+          clearBuildCache(["graphql:documents", "graphql:registry"]);
+          await syncRegistryTemplates();
+          await updateTemplates({ filter: (template) => template.filename.startsWith("graphql/") });
+        }
+      });
+    }
     if (nuxt.options.dev) {
       const configPath = resolveRoot(options.saveConfig || "graphql.config.json");
       const config = {
-        schema: getRelativePath(rootDir, sdlPath),
-        documents: options.client?.documents || "**/*.gql"
+        schema: toRelativePath(rootDir, sdlPath),
+        documents: documentGlobs.map((glob) => toRelativePath(rootDir, glob))
       };
-      mkdirSync(dirname(configPath), { recursive: true });
-      writeFileSync(configPath, JSON.stringify(config, null, 2), { encoding: "utf-8" });
-      logger.info(`GraphQL config saved to: ${cyan}${getRelativePath(rootDir, configPath)}${reset}`);
+      await writeFile(configPath, JSON.stringify(config, null, 2));
     }
     nuxt.options.alias = defu(nuxt.options.alias, nuxtAliases);
-    nuxt.hook("nitro:config", (nitroConfig) => {
-      nitroConfig.alias = defu(nitroConfig.alias, nitroAliases);
-    });
+    nuxt.options.nitro.alias = defu(nuxt.options.nitro.alias, nitroAliases);
+    nuxt.options.build.transpile = [...nuxt.options.build.transpile, ...transpileEntries];
     nuxt.options.runtimeConfig.public.graphql = defu(nuxt.options.runtimeConfig.public.graphql, {
       cacheConfig: resolveCacheConfig(options.client?.cache),
       ssrForwardHeaders: options.client?.ssrForwardHeaders || ["authorization", "cookie"]
     });
-    if (nuxt.options.dev) {
-      nuxt.hook("builder:watch", async (_event, changedPath) => {
-        if (changedPath.endsWith(".gql")) {
-          logger.info(`Documents change detected: ${cyan}${getRelativePath(rootDir, changedPath)}${reset}`);
-          clearBuildCache(["documents", "operations", "registry"]);
-        }
-      });
-    }
-    const handler = resolveModule("./runtime/server/api/graphql");
+    const handler = resolveModule("runtime/server/api/graphql");
     addServerHandler({ route: "/api/graphql", handler });
     nuxt.hook("listen", (_, { url }) => {
-      logger.success(`GraphQL Yoga ready: ${cyan}${url.replace(/\/$/, "")}/api/graphql${reset}`);
+      logger.success(`GraphQL endpoint available at ${cyan(`${url}api/graphql`)}`);
     });
-    addPlugin(resolveModule("./runtime/app/plugins/execute-graphql"));
-    addPlugin(resolveModule("./runtime/app/plugins/graphql-sse.client"));
-    addImportsDir(resolveModule("./runtime/app/composables"));
-    addImportsDir(resolveModule("./runtime/shared/utils"));
-    addServerImportsDir(resolveModule("./runtime/server/utils"));
-    addServerImportsDir(resolveModule("./runtime/shared/utils"));
+    addPlugin(resolveModule("runtime/app/plugins/graphql"));
+    addPlugin(resolveModule("runtime/app/plugins/graphql-sse.client"));
+    addImportsDir(resolveModule("runtime/app/composables"));
+    addImportsDir(resolveModule("runtime/shared/utils"));
+    addServerImportsDir(resolveModule("runtime/server/utils"));
+    addServerImportsDir(resolveModule("runtime/shared/utils"));
   }
 });