@lewebsimple/nuxt-graphql 0.5.2 → 0.5.4

package/dist/module.json

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

package/dist/module.mjs

@@ -1,6 +1,7 @@
 import { mkdirSync, writeFileSync } from 'node:fs';
-import { resolve, dirname, relative } from 'node:path';
-import { defineNuxtModule, useLogger, createResolver, addTemplate, addServerHandler, addPlugin, addImportsDir, addServerImportsDir } from '@nuxt/kit';
+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';
@@ -18,15 +19,16 @@ 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}>>`);
+  const types = ["{}", ...contextModules.map((_, index) => `Awaited<ReturnType<typeof context${index}>>`)];
   return [
     `import type { H3Event } from "h3";`,
     ...imports,
     "",
-    `export type GraphQLContext = ${types.join("\n  & ")};`,
+    `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;",
@@ -56,7 +58,7 @@ async function renderFragmentsTemplate({ documents }) {
   }
   return [
     `export type {`,
-    ...fragments.map((name) => `  ${name} as ${name}Fragment,`),
+    ...fragments.map((name) => `  ${name}Fragment,`),
     `} from "./operations";`
   ].join("\n");
 }
@@ -85,29 +87,51 @@ async function renderOperationsTemplate({ schema, documents }) {
     schema,
     documents,
     plugins: [
-      { typescript: {} },
-      { typescriptOperations: {} },
-      { typedDocumentNode: {} }
+      {
+        typescript: {
+          avoidOptionals: true,
+          defaultScalarType: "never",
+          enumsAsTypes: true,
+          immutableTypes: true,
+          maybeValue: "T | null",
+          preResolveTypes: false,
+          strictScalars: true,
+          useTypeImports: true
+        }
+      },
+      {
+        typescriptOperations: {
+          avoidOptionals: true,
+          defaultScalarType: "never",
+          enumsAsTypes: true,
+          exportFragmentSpreadSubTypes: true,
+          immutableTypes: true,
+          inlineFragmentTypes: "combine",
+          maybeValue: "T | null",
+          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: {
-      defaultScalarType: "never",
-      documentMode: "documentNode",
-      documentVariableSuffix: "Document",
-      enumsAsTypes: true,
-      inlineFragmentTypes: "combine",
-      omitOperationSuffix: true,
-      operationResultSuffix: "Result",
-      operationVariablesSuffix: "Variables",
-      preResolveTypes: false,
-      skipTypename: true,
-      strictScalars: true,
-      useTypeImports: true
-    }
+    config: {}
   });
   return output;
 }
@@ -118,63 +142,41 @@ async function renderRegistryTemplate({ documents }) {
     `import type { DocumentNode } from "graphql";`,
     `import {`,
     ...operations.map(
-      ({ name }) => `  ${name}Document, type ${name}Variables, type ${name}Result,`
+      ({ name }) => `  ${name}Document, type ${name}QueryVariables, type ${name}QueryResult,`
     ),
     `} from "./operations";`,
     ``,
     // Operation entry
-    `export interface OperationEntry<`,
-    `  TVariables,`,
-    `  TResult,`,
-    `  TKind extends "query" | "mutation" | "subscription"`,
-    `> {`,
+    `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}Variables, ${name}Result, "${kind}">;`
+      ({ name, kind }) => `  ${name}: OperationEntry<${name}QueryVariables, ${name}QueryResult, "${kind}">;`
     ),
     `};`,
     ``,
-    `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
-    `export type VariablesOf<TName extends keyof OperationRegistry> =`,
-    `  OperationRegistry[TName]["variables"];`,
+    // 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];`,
     ``,
-    `export type ResultOf<TName extends keyof OperationRegistry> =`,
-    `  OperationRegistry[TName]["result"];`,
+    // 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;`,
-    `  };`,
-    `} = {`,
+    `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");
 }
 function collectOperations(documents) {
@@ -290,30 +292,65 @@ async function loadStitchedSchema(schemaDefs) {
   return stitchSchemas({ subschemas });
 }
 
-function renderTypesTemplate() {
-  return `// Nuxt GraphQL types
-declare module "#graphql/context" {
-  export { createContext } from "#build/graphql/context";
-  export type { GraphQLContext } from "#build/graphql/context";
+function renderAppTypesTemplate() {
+  return `// Nuxt GraphQL types (app)
+import type { GraphQLClient } from "graphql-request";
+import type { Client as SSEClient } from "graphql-sse";
+
+declare module "#app/nuxt" {
+  interface NuxtApp {
+    $getGraphQLClient: () => GraphQLClient;
+    $getGraphQLSSEClient: () => SSEClient;
+  }
 }
 
-declare module "#graphql/operations" {
-  export * from "#build/graphql/operations";
+declare module "#app" {
+  interface NuxtApp {
+    $getGraphQLClient: () => GraphQLClient;
+    $getGraphQLSSEClient: () => SSEClient;
+  }
 }
 
-declare module "#graphql/fragments" {
-  export * from "#build/graphql/fragments";
+export {};
+`;
 }
+function renderServerTypesTemplate() {
+  return `// Nuxt GraphQL types (server)
+import type { GraphQLSchema } from "graphql";
 
-declare module "#graphql/registry" {
-  import type { DocumentNode } from "graphql";
-  export type { OperationName, QueryName, MutationName, SubscriptionName, VariablesOf, ResultOf } from "#build/graphql/registry";
-  export const registry: Readonly<Record<OperationName, { readonly document: DocumentNode; }>>;
+declare module "#graphql/context" {
+  export type { GraphQLContext };
 }
 
 declare module "#graphql/schema" {
-  export { schema } from "#build/graphql/schema";
-}`;
+  export const schema: GraphQLSchema;
+}
+
+declare module "h3" {
+  interface H3EventContext {
+    _graphqlInFlightRequestsMap?: Map<string, Promise<unknown>>;
+  }
+}
+
+export {};
+`;
+}
+function renderSharedTypesTemplate() {
+  return `// Nuxt GraphQL types (shared)
+import type { DocumentNode } from "graphql";
+import type { CacheConfig } from "nuxt-graphql/runtime/shared/lib/cache-config";
+
+declare module "nuxt/schema" {
+  interface PublicRuntimeConfig {
+    graphql: {
+      cacheConfig?: CacheConfig;
+      ssrForwardHeaders: string[];
+    };
+  }
+}
+
+export {};
+`;
 }
 
 const module$1 = defineNuxtModule({
@@ -324,6 +361,7 @@ const module$1 = defineNuxtModule({
   defaults: {},
   async setup(options, nuxt) {
     const logger = useLogger("graphql");
+    const { resolve: resolveBuild } = createResolver(nuxt.options.buildDir);
     const { resolve: resolveModule } = createResolver(import.meta.url);
     const { resolve: resolveRoot, resolvePath: _resolveRootPath } = createResolver(nuxt.options.rootDir);
     async function resolveRootPath(path, required = true) {
@@ -345,32 +383,22 @@ const module$1 = defineNuxtModule({
       return relativePath;
     }
     nuxt.options.alias ||= {};
-    nuxt.options.alias["#graphql"] = resolve(nuxt.options.buildDir, "graphql");
-    const nitroAlias = {};
+    nuxt.options.alias["#graphql"] ||= resolveBuild("graphql");
     const contextModules = [
-      resolveModule("./runtime/server/lib/default-context"),
       ...await Promise.all((options.yoga?.context || []).map((path) => resolveRootPath(path, true)))
     ];
-    const contextTemplate = addTemplate({
-      filename: "graphql/context.ts",
-      getContents: () => renderContextTemplate({ contextModules }),
-      write: true
-    });
-    nitroAlias["#graphql/context"] = contextTemplate.dst;
+    addTemplate({ filename: "graphql/context.ts", getContents: () => renderContextTemplate({ contextModules }), write: true });
+    addServerTemplate({ filename: "#graphql/#context.ts", getContents: () => renderContextTemplate({ contextModules }) });
     const schemaDefs = {};
     for (const [schemaName, schemaDef] of Object.entries(options.yoga?.schemas || {})) {
-      let schemaTemplate2;
       if (schemaDef.type === "local") {
         const localSchemaDef = {
           ...schemaDef,
           path: await resolveRootPath(schemaDef.path, true)
         };
         schemaDefs[schemaName] = localSchemaDef;
-        schemaTemplate2 = addTemplate({
-          filename: `graphql/schemas/${schemaName}.ts`,
-          getContents: async () => renderLocalSchemaTemplate({ ...localSchemaDef }),
-          write: true
-        });
+        addTemplate({ filename: `graphql/schemas/${schemaName}.ts`, getContents: async () => renderLocalSchemaTemplate({ ...localSchemaDef }), write: true });
+        addServerTemplate({ filename: `#graphql/schemas/${schemaName}.ts`, getContents: async () => renderLocalSchemaTemplate({ ...localSchemaDef }) });
       } else if (schemaDef.type === "remote") {
         const remoteSchemaDef = {
           ...schemaDef,
@@ -378,24 +406,14 @@ const module$1 = defineNuxtModule({
           remoteExecutorModule: resolveModule("./runtime/server/lib/remote-executor")
         };
         schemaDefs[schemaName] = remoteSchemaDef;
-        schemaTemplate2 = addTemplate({
-          filename: `graphql/schemas/${schemaName}.ts`,
-          getContents: async () => await renderRemoteSchemaTemplate({ ...remoteSchemaDef }),
-          write: true
-        });
+        addTemplate({ filename: `graphql/schemas/${schemaName}.ts`, getContents: async () => await renderRemoteSchemaTemplate({ ...remoteSchemaDef }), write: true });
+        addServerTemplate({ filename: `#graphql/schemas/${schemaName}.ts`, getContents: async () => await renderRemoteSchemaTemplate({ ...remoteSchemaDef }) });
       } else {
         throw new Error(`Unknown schema type for schema "${schemaName}"`);
       }
-      nitroAlias[`#graphql/schemas/${schemaName}`] = schemaTemplate2.dst;
     }
-    const schemaTemplate = addTemplate({
-      filename: "graphql/schema.ts",
-      getContents: () => renderStitchedSchemaTemplate({
-        schemaNames: Object.keys(options.yoga?.schemas || {})
-      }),
-      write: true
-    });
-    nitroAlias["#graphql/schema"] = schemaTemplate.dst;
+    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}`;
@@ -439,27 +457,17 @@ const module$1 = defineNuxtModule({
       }),
       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}`);
-    const typesTemplate = addTemplate({
-      filename: "graphql/types.d.ts",
-      getContents: () => renderTypesTemplate(),
-      write: true
-    });
-    nuxt.options.runtimeConfig.public.graphql = {
+    nuxt.options.runtimeConfig.public.graphql = defu(nuxt.options.runtimeConfig.public.graphql, {
       cacheConfig: resolveCacheConfig(options.client?.cache),
       ssrForwardHeaders: options.client?.ssrForwardHeaders || ["authorization", "cookie"]
-    };
-    nuxt.hook("prepare:types", ({ sharedReferences }) => {
-      sharedReferences.push({ path: typesTemplate.dst });
-      sharedReferences.push({ path: resolveModule("./runtime/shared/types/nuxt-graphql.d.ts") });
-    });
-    nuxt.hook("nitro:config", (nitroConfig) => {
-      nitroConfig.alias ||= {};
-      Object.assign(nitroConfig.alias, nitroAlias);
     });
     if (nuxt.options.dev) {
       nuxt.hook("builder:watch", async (_event, changedPath) => {
@@ -471,7 +479,7 @@ const module$1 = defineNuxtModule({
     }
     addServerHandler({ route: "/api/graphql", handler: resolveModule("./runtime/server/api/graphql") });
     nuxt.hook("listen", (_, { url }) => {
-      logger.success(`GraphQL Yoga ready: ${cyan}${url.replace(/\/$/, "")} / api / graphql${reset}`);
+      logger.success(`GraphQL Yoga ready: ${cyan}${url.replace(/\/$/, "")}/api/graphql${reset}`);
     });
     addPlugin(resolveModule("./runtime/app/plugins/graphql-request"));
     addPlugin(resolveModule("./runtime/app/plugins/graphql-sse.client"));

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

@@ -1,6 +1,7 @@
+import type { GraphQLContext } from "#graphql/context";
 /**
  * Get or create the singleton GraphQL Yoga instance.
  *
  * @returns GraphQL Yoga server instance.
  */
-export declare function getYogaInstance(): import("graphql-yoga").YogaServerInstance<{}, {}>;
+export declare function getYogaInstance(): import("graphql-yoga").YogaServerInstance<GraphQLContext, {}>;

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

@@ -1,5 +1,5 @@
 type GraphQLCachePolicy = "no-cache" | "cache-first" | "network-first" | "swr";
-export interface CacheConfig {
+export type CacheConfig = {
     /**
      * Prefix used for all persisted cache keys.
      *
@@ -31,7 +31,7 @@ export interface CacheConfig {
      * - > 0       → expires after TTL
      */
     ttl?: number;
-}
+};
 /**
  * Merge the default cache config with user overrides.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lewebsimple/nuxt-graphql",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "description": "Opinionated Nuxt module for using GraphQL",
   "repository": "lewebsimple/nuxt-graphql",
   "license": "AGPL-3.0-only",
@@ -36,6 +36,7 @@
     "@graphql-tools/load": "^8.1.8",
     "@graphql-tools/stitch": "^10.1.8",
     "@nuxt/kit": "^4.2.2",
+    "defu": "^6.1.4",
     "graphql": "^16.12.0",
     "graphql-request": "^7.4.0",
     "graphql-sse": "^2.6.0",

package/dist/runtime/server/lib/default-context.d.ts

@@ -1,5 +0,0 @@
-/**
- * Default empty GraphQL context factory.
- */
-declare const _default: (event: import("h3").H3Event) => {} | Promise<{}>;
-export default _default;

package/dist/runtime/server/lib/default-context.js

@@ -1,2 +0,0 @@
-import { defineGraphQLContext } from "../utils/defineGraphQLContext.js";
-export default defineGraphQLContext(() => ({}));

package/dist/runtime/shared/types/nuxt-graphql.d.ts

@@ -1,33 +0,0 @@
-import type { GraphQLClient } from "graphql-request";
-import type { Client as SSEClient } from "graphql-sse";
-
-declare module "h3" {
-  interface H3EventContext {
-    _graphqlInFlightRequestsMap?: Map<string, Promise<unknown>>;
-  }
-}
-
-declare module "nuxt/schema" {
-  interface PublicRuntimeConfig {
-    graphql: {
-      cacheConfig: GraphQLCacheConfig;
-      ssrForwardHeaders: string[];
-    };
-  }
-}
-
-declare module "#app/nuxt" {
-  interface NuxtApp {
-    $getGraphQLClient: () => GraphQLClient;
-    $getGraphQLSSEClient: () => SSEClient;
-  }
-}
-
-declare module "#app" {
-  interface NuxtApp {
-    $getGraphQLClient: () => GraphQLClient;
-    $getGraphQLSSEClient: () => SSEClient;
-  }
-}
-
-export { };