@lewebsimple/nuxt-graphql 0.1.14 → 0.2.0

package/README.md

@@ -30,8 +30,6 @@ Optionnally adjust options in your Nuxt config. The defaults shown below:
 export default defineNuxtConfig({
   modules: ["@lewebsimple/nuxt-graphql"],
   graphql: {
-    // GraphQL HTTP endpoint served by Yoga
-    endpoint: "/api/graphql",
     // Codegen controls document scanning and outputs
     codegen: {
       enabled: true,

package/dist/module.d.mts

@@ -1,9 +1,8 @@
 import * as _nuxt_schema from '@nuxt/schema';
-import { GraphQLCacheConfig } from '../dist/runtime/utils/graphql-cache.js';
+import { GraphQLCacheConfig } from '../dist/runtime/app/utils/graphql-cache.js';
 import { CodegenConfig } from '@graphql-codegen/cli';
 
 interface ModuleOptions {
-    endpoint?: string;
     headers?: Record<string, string>;
     cache?: Partial<GraphQLCacheConfig>;
     codegen?: {

package/dist/module.json

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

package/dist/module.mjs

@@ -1,9 +1,10 @@
-import { useLogger, defineNuxtModule, createResolver, getLayerDirectories, addServerTemplate, addServerHandler, addImportsDir, addServerImportsDir, addPlugin, addTypeTemplate } from '@nuxt/kit';
+import { useLogger, defineNuxtModule, createResolver, getLayerDirectories, addServerHandler, addImportsDir, addServerImportsDir, addPlugin } from '@nuxt/kit';
 import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
 import { join, dirname, relative } from 'node:path';
 import { glob } from 'tinyglobby';
 import { generate } from '@graphql-codegen/cli';
 import { parse, Kind } from 'graphql';
+import { GRAPHQL_ENDPOINT } from '../dist/runtime/server/lib/constants.js';
 
 const logger = useLogger("@lewebsimple/nuxt-graphql");
 const blue = "\x1B[34m";
@@ -253,7 +254,6 @@ const module$1 = defineNuxtModule({
     configKey: "graphql"
   },
   defaults: {
-    endpoint: "/api/graphql",
     codegen: {
       pattern: "**/*.gql",
       schemaOutput: "server/graphql/schema.graphql"
@@ -261,11 +261,6 @@ const module$1 = defineNuxtModule({
   },
   async setup(options, nuxt) {
     const { resolve } = createResolver(import.meta.url);
-    if (options.endpoint) {
-      if (!options.endpoint.startsWith("/")) {
-        logger.warn("GraphQL endpoint should start with '/' (e.g., '/api/graphql')");
-      }
-    }
     const { rootDir, serverDir } = nuxt.options;
     const layerDirs = [
       ...getLayerDirectories(nuxt),
@@ -275,102 +270,105 @@ const module$1 = defineNuxtModule({
     const layerRootDirs = layerDirs.map(({ root }) => root);
     const schemaPath = await findSingleFile(layerServerDirs, "graphql/schema.{ts,mjs}", true);
     const contextPath = await findSingleFile(layerServerDirs, "graphql/context.{ts,mjs}") || resolve("./runtime/server/graphql/default-context.ts");
-    nuxt.hook("nitro:config", (config) => {
-      config.alias ||= {};
-      config.alias["#graphql/schema"] = schemaPath;
-      config.alias["#graphql/context"] = contextPath;
-    });
-    const endpoint = options.endpoint ?? "/api/graphql";
-    addServerTemplate({
-      filename: "graphql/yoga-handler",
-      getContents: () => readFileSync(resolve("./templates/yoga-handler.mjs"), "utf-8").replace("{{endpoint}}", endpoint)
-    });
-    addServerHandler({ route: endpoint, handler: "graphql/yoga-handler" });
-    nuxt.hook("listen", (_, { url }) => {
-      logger.success(`GraphQL Yoga ready at ${cyan}${url.replace(/\/$/, "")}${endpoint}${reset}`);
-    });
-    nuxt.options.runtimeConfig.public.graphql = {
-      endpoint,
-      headers: options.headers || {},
-      cache: {
-        enabled: options.cache?.enabled ?? false,
-        ttl: options.cache?.ttl ?? 6e4,
-        storage: options.cache?.storage ?? "memory"
-      }
-    };
     const codegenPattern = options.codegen?.pattern ?? "**/*.gql";
     const graphqlrcFile = join(rootDir, ".graphqlrc");
     const operationsFile = join(nuxt.options.buildDir, "graphql/operations.ts");
     const registryFile = join(nuxt.options.buildDir, "graphql/registry.ts");
-    const schemasFile = join(nuxt.options.buildDir, "graphql/schemas.ts");
-    nuxt.options.alias["#graphql/operations"] = operationsFile;
-    nuxt.options.alias["#graphql/registry"] = registryFile;
-    nuxt.options.alias["#graphql/schemas"] = schemasFile;
+    const zodSchemasFile = join(nuxt.options.buildDir, "graphql/zod.ts");
     const schemaOutput = options.codegen?.schemaOutput ?? "server/graphql/schema.graphql";
     if (schemaOutput && !schemaOutput.endsWith(".graphql")) {
       logger.warn(`Schema output '${schemaOutput}' should have .graphql extension.`);
     }
     const schemaFile = join(rootDir, schemaOutput);
-    const generate = async () => {
-      const [schema, documents] = await Promise.all([
-        loadGraphQLSchema(schemaPath),
-        findMultipleFiles(layerRootDirs, codegenPattern)
-      ]);
-      const docs = documents.map((document) => ({ path: document, content: readFileSync(document, "utf-8") }));
-      const analysis = analyzeGraphQLDocuments(docs);
-      for (const doc of docs) {
-        const relativePath = doc.path.startsWith(rootDir) ? doc.path.slice(rootDir.length + 1) : doc.path;
-        const defs = analysis.byFile.get(doc.path) ?? [];
-        logger.info(`${cyan}${relativePath}${reset} [${formatDefinitions(defs)}]`);
-      }
-      await runCodegen({
-        schema,
-        documents,
-        operationsFile,
-        schemasFile,
-        scalars: options.codegen?.scalars,
-        generates: options.codegen?.generates
+    const setupAliases = () => {
+      nuxt.hook("nitro:config", (config) => {
+        config.alias ||= {};
+        config.alias["#graphql/schema"] = schemaPath;
+        config.alias["#graphql/context"] = contextPath;
       });
-      if (writeFileIfChanged(schemaFile, schema)) {
-        logger.info(`GraphQL schema saved to ${cyan}${schemaOutput}${reset}`);
-      }
-      const graphqlrc = {
-        schema: relative(rootDir, schemaFile),
-        documents: codegenPattern
+      nuxt.options.alias["#graphql/operations"] = operationsFile;
+      nuxt.options.alias["#graphql/registry"] = registryFile;
+      nuxt.options.alias["#graphql/zod"] = zodSchemasFile;
+    };
+    const setupHandler = () => {
+      addServerHandler({ route: GRAPHQL_ENDPOINT, handler: resolve("./runtime/server/api/graphql-handler") });
+      nuxt.hook("listen", (_, { url }) => {
+        logger.success(`GraphQL Yoga ready at ${cyan}${url.replace(/\/$/, "")}${GRAPHQL_ENDPOINT}${reset}`);
+      });
+    };
+    const setupRuntimeConfig = () => {
+      nuxt.options.runtimeConfig.public.graphql = {
+        endpoint: GRAPHQL_ENDPOINT,
+        headers: options.headers || {},
+        cache: {
+          enabled: options.cache?.enabled ?? false,
+          ttl: options.cache?.ttl ?? 6e4,
+          storage: options.cache?.storage ?? "memory"
+        }
       };
-      if (options.codegen?.scalars) {
-        graphqlrc.scalars = options.codegen.scalars;
-      }
-      if (writeFileIfChanged(graphqlrcFile, JSON.stringify(graphqlrc, null, 2))) {
-        logger.info(`GraphQL config saved to ${cyan}.graphqlrc${reset}`);
-      }
-      if (writeFileIfChanged(registryFile, generateRegistryByTypeSource(analysis.operationsByType))) {
-        logger.info(`GraphQL registry saved to ${cyan}${relative(rootDir, registryFile)}${reset}`);
-      }
     };
-    nuxt.hook("prepare:types", async ({ references }) => {
-      await generate();
-      if (existsSync(operationsFile)) references.push({ path: operationsFile });
-      if (existsSync(registryFile)) references.push({ path: registryFile });
-      if (existsSync(schemasFile)) references.push({ path: schemasFile });
-    });
-    if (nuxt.options.dev) {
-      nuxt.hook("builder:watch", async (event, path) => {
-        if (path.endsWith(".gql")) {
-          await generate();
+    const setupCodegen = () => {
+      const generate = async () => {
+        const [schema, documents] = await Promise.all([
+          loadGraphQLSchema(schemaPath),
+          findMultipleFiles(layerRootDirs, codegenPattern)
+        ]);
+        const docs = documents.map((document) => ({ path: document, content: readFileSync(document, "utf-8") }));
+        const analysis = analyzeGraphQLDocuments(docs);
+        for (const doc of docs) {
+          const relativePath = doc.path.startsWith(rootDir) ? doc.path.slice(rootDir.length + 1) : doc.path;
+          const defs = analysis.byFile.get(doc.path) ?? [];
+          logger.info(`${cyan}${relativePath}${reset} [${formatDefinitions(defs)}]`);
+        }
+        await runCodegen({
+          schema,
+          documents,
+          operationsFile,
+          schemasFile: zodSchemasFile,
+          scalars: options.codegen?.scalars,
+          generates: options.codegen?.generates
+        });
+        if (writeFileIfChanged(schemaFile, schema)) {
+          logger.info(`GraphQL schema saved to ${cyan}${schemaOutput}${reset}`);
+        }
+        const graphqlrc = {
+          schema: relative(rootDir, schemaFile),
+          documents: codegenPattern
+        };
+        if (options.codegen?.scalars) {
+          graphqlrc.scalars = options.codegen.scalars;
+        }
+        if (writeFileIfChanged(graphqlrcFile, JSON.stringify(graphqlrc, null, 2))) {
+          logger.info(`GraphQL config saved to ${cyan}.graphqlrc${reset}`);
         }
+        if (writeFileIfChanged(registryFile, generateRegistryByTypeSource(analysis.operationsByType))) {
+          logger.info(`GraphQL registry saved to ${cyan}${relative(rootDir, registryFile)}${reset}`);
+        }
+      };
+      nuxt.hook("prepare:types", async ({ references }) => {
+        await generate();
+        if (existsSync(operationsFile)) references.push({ path: operationsFile });
+        if (existsSync(registryFile)) references.push({ path: registryFile });
+        if (existsSync(zodSchemasFile)) references.push({ path: zodSchemasFile });
       });
-    }
-    addImportsDir(resolve("./runtime/composables"));
-    addServerImportsDir(resolve("./runtime/server/utils"));
-    addPlugin(resolve("./runtime/plugins/graphql"));
-    addTypeTemplate({
-      filename: "types/graphql-client.d.ts",
-      getContents: () => readFileSync(resolve("./runtime/types/graphql-client.d.ts"), "utf-8")
-    });
-    nuxt.hook("prepare:types", ({ references }) => {
-      references.push({ path: "./types/graphql-client.d.ts" });
-    });
+      if (nuxt.options.dev) {
+        nuxt.hook("builder:watch", async (event, path) => {
+          if (path.endsWith(".gql")) {
+            await generate();
+          }
+        });
+      }
+    };
+    const setupAppRuntime = () => {
+      addImportsDir(resolve("./runtime/app/composables"));
+      addServerImportsDir(resolve("./runtime/server/utils"));
+      addPlugin(resolve("./runtime/app/plugins/graphql"));
+    };
+    setupAliases();
+    setupHandler();
+    setupRuntimeConfig();
+    setupCodegen();
+    setupAppRuntime();
   }
 });
 

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

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

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

@@ -1,5 +1,5 @@
 import { type MutationName, type MutationResult, type MutationVariables } from "#graphql/registry";
-import type { IsEmptyObject } from "../utils/helpers.js";
+import type { IsEmptyObject } from "../../../helpers/is-empty-object.js";
 /**
  * Client-side GraphQL mutation composable
  *

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

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

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

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

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

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

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

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

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

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

package/dist/{templates/yoga-handler.mjs → runtime/server/api/graphql-handler.js}

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,2 @@
+import { consola } from "consola";
+export declare const logger: consola.ConsolaInstance;

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

@@ -0,0 +1,2 @@
+import { consola } from "consola";
+export const logger = consola.withTag("graphql");

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

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

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

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

package/dist/runtime/server/yoga-handler.d.ts

@@ -0,0 +1 @@
+export { default } from "./api/graphql-handler.js";

package/dist/runtime/server/yoga-handler.js

@@ -0,0 +1 @@
+export { default } from "./api/graphql-handler.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lewebsimple/nuxt-graphql",
-  "version": "0.1.14",
+  "version": "0.2.0",
   "description": "Opinionated Nuxt module for using GraphQL",
   "repository": "lewebsimple/nuxt-graphql",
   "license": "MIT",

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

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

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

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

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

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