@lewebsimple/nuxt-graphql 0.5.5 → 0.5.7

package/dist/module.json

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

package/dist/module.mjs

@@ -1,18 +1,18 @@
 import { mkdirSync, writeFileSync } from 'node:fs';
 import { dirname, relative, resolve } from 'node:path';
 import { defu } from 'defu';
-import { hash } from 'ohash';
+import { GraphQLFileLoader } from '@graphql-tools/graphql-file-loader';
+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 { loadDocuments as loadDocuments$1 } from '@graphql-tools/load';
-import { GraphQLFileLoader } from '@graphql-tools/graphql-file-loader';
-import { Kind, getIntrospectionQuery, buildClientSchema, GraphQLSchema } from 'graphql';
 import { codegen } from '@graphql-codegen/core';
 import * as typescriptPlugin from '@graphql-codegen/typescript';
 import * as typescriptOperationsPlugin from '@graphql-codegen/typescript-operations';
 import * as typedDocumentNodePlugin from '@graphql-codegen/typed-document-node';
+import { Kind, getIntrospectionQuery, buildClientSchema, GraphQLSchema } from 'graphql';
 import { mergeHeaders } from '../dist/runtime/shared/lib/headers.js';
 import { resolveCacheConfig } from '../dist/runtime/shared/lib/cache.js';
+import { hash } from 'ohash';
 
 const cyan = "\x1B[36m";
 const reset = "\x1B[0m";
@@ -41,50 +41,9 @@ declare module "#graphql/context" {
 }`.trim();
 }
 
-async function loadDocuments(documents) {
-  try {
-    return await loadDocuments$1([
-      documents,
-      "!**/.cache/**",
-      "!**/.nuxt/**",
-      "!**/.output/**",
-      "!**/dist/**",
-      "!**/node_modules/**"
-    ], { loaders: [new GraphQLFileLoader()] });
-  } catch {
-    return [];
-  }
-}
-
-async function renderFragmentsTemplate({ documents }) {
-  const fragments = collectFragments(documents);
-  return fragments.length === 0 ? "export { }" : `
-export type {
-${fragments.map((name) => `  ${name}Fragment,`).join("\n")}
-} from "./operations";`.trim();
-}
-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()];
-}
-
 async function renderOperationsTemplate({ schema, documents }) {
-  return await codegen({
+  const content = await codegen({
     filename: "operations.ts",
-    // @graphql-codegen/core codegen supports GraphQLSchema at runtime, but types expect DocumentNode
     schema,
     documents,
     plugins: [
@@ -134,14 +93,42 @@ async function renderOperationsTemplate({ schema, documents }) {
     },
     config: {}
   });
+  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";
+  const module = `
 import {
-${operations.map(({ name }) => `  ${name}Document, type ${name}QueryVariables, type ${name}QueryResult,`).join("\n")}
+  ${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
@@ -154,7 +141,7 @@ export interface OperationEntry<TVariables, TResult, TKind extends "query" | "mu
 
 // Operation registry type
 export type OperationRegistry = {
-${operations.map(({ name, kind }) => `  ${name}: OperationEntry<${name}QueryVariables, ${name}QueryResult, "${kind}">;`).join("\n")}
+  ${operations.map(({ name, kind }) => `${name}: OperationEntry<${name}${capitalize(kind)}Variables, ${name}${capitalize(kind)}Result, "${kind}">;`).join("\n  ")}
 };
 
 // Operation name types
@@ -167,11 +154,11 @@ export type SubscriptionName = { [K in keyof OperationRegistry]: OperationRegist
 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")}
-};`.trim();
+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();
@@ -187,13 +174,14 @@ 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 }) {
@@ -373,36 +361,38 @@ const module$1 = defineNuxtModule({
     }
     nuxt.options.alias ||= {};
     nuxt.options.alias["#graphql"] ||= resolveBuild("graphql");
+    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 schemasCache = /* @__PURE__ */ new Map([]);
-    function cachedSchemaLoader(schemaDef, loader) {
-      return async () => {
-        const key = `schemaDef:${hash(schemaDef)}`;
-        const cached = schemasCache.get(key);
-        if (cached?.key === key) return cached.data;
-        const schema = await loader();
-        schemasCache.set(key, { key, data: schema });
-        return schema;
-      };
-    }
     const remoteExecutorModule = resolveModule("./runtime/server/lib/remote-executor");
-    const schemaLoaders = {};
+    const schemaCachedLoaders = {};
     for (const [schemaName, schemaDef] of Object.entries(options.yoga?.schemas || {})) {
       if (schemaDef.type === "local") {
         const schemaModule = await resolveRootPath(schemaDef.path, true);
-        schemaLoaders[schemaName] = cachedSchemaLoader(schemaDef, async () => await loadLocalSchema({ schemaModule }));
+        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") {
-        schemaLoaders[schemaName] = cachedSchemaLoader(schemaDef, async () => await introspectRemoteSchema(schemaDef));
+        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: schemaLoaders[schemaName]
+          schemaLoader: schemaCachedLoaders[schemaName]
         };
         addTemplate({ filename: `graphql/schemas/${schemaName}.mjs`, getContents: async () => await renderRemoteSchemaTemplate(input), write: true });
         addServerTemplate({ filename: `#graphql/schemas/${schemaName}.mjs`, getContents: async () => await renderRemoteSchemaTemplate(input) });
@@ -411,9 +401,9 @@ const module$1 = defineNuxtModule({
       }
     }
     const sdlPath = resolveRoot(options.saveSDL || "server/graphql/schema.graphql");
-    const loadStitchedSchema = cachedSchemaLoader({ type: "stitched" }, async () => {
+    const loadCachedSchema = cachedLoader("schema:stitched", async () => {
       const schema = stitchSchemas({
-        subschemas: await Promise.all(Object.values(schemaLoaders).map((loader) => loader()))
+        subschemas: await Promise.all(Object.values(schemaCachedLoaders).map((loader) => loader()))
       });
       const sdl = await printSchemaSDL(schema);
       mkdirSync(dirname(sdlPath), { recursive: true });
@@ -424,39 +414,48 @@ const module$1 = defineNuxtModule({
     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 documentsGlob = options.client?.documents || "**/*.gql";
-    let documentsCache = null;
-    async function loadDocumentsCached(glob) {
-      const key = `documents:${glob}`;
-      if (documentsCache?.key === key) return documentsCache.data;
-      const documents = await loadDocuments(glob);
-      documentsCache = { key, data: documents };
-      return documents;
-    }
-    addTemplate({
-      filename: "graphql/operations.ts",
-      getContents: async () => await renderOperationsTemplate({
-        schema: await loadStitchedSchema(),
-        documents: await loadDocumentsCached(documentsGlob)
-      }),
-      write: true
+    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 loadDocumentsCached(documentsGlob)
-      }),
+      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 loadDocumentsCached(documentsGlob)
-      }),
+      filename: "graphql/registry.d.ts",
+      getContents: async () => (await loadCachedRegistry(options.client?.documents || "**/*.gql")).types,
       write: true
     });
     const configPath = resolveRoot(options.saveConfig || "graphql.config.json");
-    const config = { schema: getRelativePath(sdlPath), documents: documentsGlob };
+    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}`);
@@ -471,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/server/utils/defineGraphQLContext.d.ts

@@ -3,8 +3,10 @@ type GraphQLContextFactory<TContext extends Record<string, unknown>> = (event: H
 /**
  * Define a GraphQL context factory with proper typing.
  *
- * @param factory Context factory function.
+ * @param createContext Context factory function.
  * @returns The same factory, typed for inference.
  */
-export declare function defineGraphQLContext<TContext extends Record<string, unknown>>(factory: GraphQLContextFactory<TContext>): GraphQLContextFactory<TContext>;
+export declare function defineGraphQLContext<TContext extends Record<string, unknown>>(createContext: GraphQLContextFactory<TContext>): {
+    createContext: GraphQLContextFactory<TContext>;
+};
 export {};

package/dist/runtime/server/utils/defineGraphQLContext.js

@@ -1,3 +1,3 @@
-export function defineGraphQLContext(factory) {
-  return factory;
+export function defineGraphQLContext(createContext) {
+  return { createContext };
 }

package/package.json

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