@lewebsimple/nuxt-graphql 0.4.0 → 0.5.1

package/dist/runtime/server/api/graphql.js

@@ -0,0 +1,16 @@
+import { createError, defineEventHandler, sendWebResponse, toWebRequest } from "h3";
+import { createContext } from "#graphql/context";
+import { getYogaInstance } from "../lib/yoga.js";
+export default defineEventHandler(async (event) => {
+  try {
+    const request = toWebRequest(event);
+    const context = await createContext(event);
+    const yoga = getYogaInstance();
+    const response = await yoga.handleRequest(request, context);
+    return sendWebResponse(event, response);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error("GraphQL server error:", message);
+    throw createError({ statusCode: 500, message: "GraphQL server error (see server logs for details)." });
+  }
+});

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

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

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

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

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

@@ -0,0 +1,7 @@
+/**
+ * Export the default schema definition wrapper.
+ */
+declare const _default: {
+    schema: import("graphql").GraphQLSchema | import("@graphql-tools/delegate").SubschemaConfig<any, any, any, Record<string, any>>;
+};
+export default _default;

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

@@ -0,0 +1,18 @@
+import { createSchema } from "graphql-yoga";
+import { defineGraphQLSchema } from "../utils/defineGraphQLSchema.js";
+const schema = createSchema({
+  typeDefs: (
+    /* GraphQL */
+    `
+    type Query {
+      hello(name: String): String!
+    }
+  `
+  ),
+  resolvers: {
+    Query: {
+      hello: (_parent, { name }) => `Hello ${name || "world"}!`
+    }
+  }
+});
+export default defineGraphQLSchema({ schema });

package/dist/runtime/server/lib/execute-schema.d.ts

@@ -0,0 +1,11 @@
+import type { H3Event } from "h3";
+import type { VariablesOf, ResultOf, QueryName, MutationName } from "#graphql/registry";
+/**
+ * Execute a GraphQL operation directly against the stitched schema.
+ *
+ * @param event H3 event for context creation.
+ * @param operationName Operation name from the registry.
+ * @param variables Operation variables.
+ * @returns Operation result data.
+ */
+export declare function executeGraphQLSchema<TName extends QueryName | MutationName>(event: H3Event, operationName: TName, variables: VariablesOf<TName>): Promise<ResultOf<TName>>;

package/dist/runtime/server/lib/execute-schema.js

@@ -0,0 +1,23 @@
+import { execute } from "graphql";
+import { createContext } from "#graphql/context";
+import { schema } from "#graphql/schema";
+import { normalizeError } from "../../shared/lib/error.js";
+import { getOperationDocument } from "../../shared/lib/registry.js";
+export async function executeGraphQLSchema(event, operationName, variables) {
+  const document = getOperationDocument(operationName);
+  const result = await execute({
+    schema,
+    document,
+    variableValues: variables,
+    contextValue: await createContext(event)
+  });
+  if (result.errors?.length) {
+    throw normalizeError(result.errors);
+  }
+  if (!result.data) {
+    throw normalizeError(
+      new Error("GraphQL execution returned no data")
+    );
+  }
+  return result.data;
+}

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

@@ -1,35 +1,19 @@
 import type { Executor } from "@graphql-tools/utils";
-import type { GraphQLContext } from "#graphql/context";
-export type RemoteExecMiddlewareOnRequestArgs = {
-    remoteName: string;
-    operationName: string;
-    context: GraphQLContext;
-    fetchOptions: {
-        headers: Headers;
-    };
-};
-export type RemoteExecMiddlewareOnResponseArgs = {
-    remoteName: string;
-    operationName: string;
-    context: GraphQLContext;
-    response: Response;
-};
-export type RemoteExecMiddlewareOnErrorArgs = {
-    remoteName: string;
-    operationName: string;
-    context: GraphQLContext;
-    error: unknown;
-    response?: Response;
-};
-export type RemoteExecMiddlewareHandler = {
-    onRequest?: (args: RemoteExecMiddlewareOnRequestArgs) => Promise<void> | void;
-    onResponse?: (args: RemoteExecMiddlewareOnResponseArgs) => Promise<void> | void;
-    onError?: (args: RemoteExecMiddlewareOnErrorArgs) => Promise<void> | void;
-};
-export interface CreateRemoteExecutorOptions {
+import { type HeadersInput } from "../../shared/lib/headers.js";
+import type { GraphQLRemoteExecHooks } from "../utils/defineRemoteExecutorHooks.js";
+type CreateRemoteExecutorInput = {
     url: string;
-    remoteName: string;
-    headers?: HeadersInit;
-    middleware?: RemoteExecMiddlewareHandler;
-}
-export declare function createRemoteExecutor(options: CreateRemoteExecutorOptions): Executor;
+    headers?: HeadersInput;
+    hooks: GraphQLRemoteExecHooks[];
+};
+/**
+ * Create an HTTP executor for a remote GraphQL schema.
+ *
+ * @param {CreateRemoteExecutorInput} options Remote executor configuration.
+ * @param options.url Remote GraphQL endpoint.
+ * @param options.headers Static headers for all requests.
+ * @param options.hooks Per-operation hooks.
+ * @returns Executor function for GraphQL Tools.
+ */
+export declare function createRemoteExecutor({ url, headers, hooks }: CreateRemoteExecutorInput): Executor;
+export {};

package/dist/runtime/server/lib/remote-executor.js

@@ -1,68 +1,33 @@
-import { parse, print, getOperationAST } from "graphql";
-import { normalizeGraphQLError } from "../../shared/lib/graphql-error.js";
-export function createRemoteExecutor(options) {
-  const { url, remoteName, headers = {}, middleware } = options;
-  const { onRequest, onResponse, onError } = middleware ?? {};
-  let executionDepth = 0;
-  return async ({ document, variables, context, operationName }) => {
-    executionDepth++;
-    const parsedDocument = typeof document === "string" ? parse(document) : document;
-    const op = getOperationAST(parsedDocument, operationName);
-    const resolvedOperationName = op?.name?.value ?? operationName ?? "anonymous";
-    const query = typeof document === "string" ? document : print(document);
-    const graphQLContext = context;
-    const requestHeaders = new Headers({ "Content-Type": "application/json", ...headers });
-    const fetchOptions = {
-      method: "POST",
-      headers: requestHeaders,
-      body: JSON.stringify({ query, variables, operationName: resolvedOperationName })
-    };
-    if (onRequest && executionDepth === 1) {
-      await onRequest({
-        remoteName,
-        operationName: resolvedOperationName,
-        context: graphQLContext,
-        fetchOptions: { headers: requestHeaders }
-      });
-    }
+import { buildHTTPExecutor } from "@graphql-tools/executor-http";
+import { mergeHeaders } from "../../shared/lib/headers.js";
+export function createRemoteExecutor({ url, headers, hooks }) {
+  function getHeaders(request) {
+    const extHeaders = request?.extensions?.headers || {};
+    const mergedHeaders = mergeHeaders(headers, extHeaders);
+    return Object.fromEntries(mergedHeaders.entries());
+  }
+  const executor = buildHTTPExecutor({
+    endpoint: url,
+    headers: (request) => getHeaders(request),
+    fetch: globalThis.fetch
+  });
+  return async (request) => {
     try {
-      const response = await fetch(url, fetchOptions);
-      const safeResponse = response.clone();
-      if (!response.ok) {
-        const statusError = normalizeGraphQLError(new Error(`Remote ${remoteName} responded with status ${response.status}`));
-        if (onError) {
-          await onError({ remoteName, operationName: resolvedOperationName, context: graphQLContext, error: statusError, response: safeResponse });
-        }
-        throw statusError;
+      for (const hook of hooks) {
+        await hook.onRequest?.(request);
       }
-      if (onResponse && executionDepth === 1) {
-        await onResponse({ remoteName, operationName: resolvedOperationName, context: graphQLContext, response: safeResponse });
-      }
-      try {
-        const json = await response.json();
-        if (json && typeof json === "object" && Array.isArray(json.errors)) {
-          const normalized = normalizeGraphQLError({ errors: json.errors });
-          if (onError) {
-            await onError({ remoteName, operationName: resolvedOperationName, context: graphQLContext, error: normalized, response: safeResponse });
-          }
-          throw normalized;
-        }
-        return json;
-      } catch (error) {
-        const normalized = normalizeGraphQLError(error);
-        if (onError) {
-          await onError({ remoteName, operationName: resolvedOperationName, context: graphQLContext, error: normalized, response: safeResponse });
+      const result = await executor(request);
+      if (!(Symbol.asyncIterator in result)) {
+        for (const hook of hooks) {
+          await hook.onResult?.(result);
         }
-        throw normalized;
       }
+      return result;
     } catch (error) {
-      const normalized = normalizeGraphQLError(error);
-      if (onError) {
-        await onError({ remoteName, operationName: resolvedOperationName, context: graphQLContext, error: normalized });
+      for (const hook of hooks) {
+        await hook.onError?.(error);
       }
-      throw normalized;
-    } finally {
-      executionDepth--;
+      throw error;
     }
   };
 }

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

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

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

@@ -0,0 +1,20 @@
+import { createYoga } from "graphql-yoga";
+import { schema } from "#graphql/schema";
+let yoga = null;
+export function getYogaInstance() {
+  if (!yoga) {
+    yoga = createYoga({
+      schema,
+      graphqlEndpoint: "/api/graphql",
+      fetchAPI: globalThis,
+      graphiql: process.env.NODE_ENV !== "production",
+      // @ts-expect-error subscriptions type available at runtime
+      subscriptions: { protocol: "SSE" }
+    });
+    if (!yoga) {
+      throw new Error("Failed to create Yoga instance");
+    }
+  }
+  return yoga;
+}
+;

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

@@ -0,0 +1,10 @@
+import type { H3Event } from "h3";
+type GraphQLContextFactory<TContext extends Record<string, unknown>> = (event: H3Event) => TContext | Promise<TContext>;
+/**
+ * Define a GraphQL context factory with proper typing.
+ *
+ * @param factory 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 {};

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

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

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

@@ -0,0 +1,14 @@
+import type { GraphQLSchema } from "graphql";
+import type { SubschemaConfig } from "@graphql-tools/delegate";
+/**
+ * Wrap a GraphQL schema or subschema config for module consumption.
+ *
+ * @param {{ schema: GraphQLSchema | SubschemaConfig }} options Schema wrapper input.
+ * @param options.schema Local schema or subschema config.
+ * @returns Wrapper object containing the schema.
+ */
+export declare function defineGraphQLSchema({ schema }: {
+    schema: GraphQLSchema | SubschemaConfig;
+}): {
+    schema: GraphQLSchema | SubschemaConfig<any, any, any, Record<string, any>>;
+};

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

@@ -0,0 +1,3 @@
+export function defineGraphQLSchema({ schema }) {
+  return { schema };
+}

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

@@ -0,0 +1,13 @@
+import type { ExecutionRequest, ExecutionResult } from "@graphql-tools/utils";
+export interface GraphQLRemoteExecHooks {
+    onRequest?: (request: ExecutionRequest) => void | Promise<void>;
+    onResult?: (result: ExecutionResult) => void | Promise<void>;
+    onError?: (error: unknown) => void | Promise<void>;
+}
+/**
+ * Define remote executor hooks with proper typing.
+ *
+ * @param hooks Hooks implementation.
+ * @returns The same hooks object.
+ */
+export declare function defineRemoteExecutorHooks(hooks: GraphQLRemoteExecHooks): GraphQLRemoteExecHooks;

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

@@ -0,0 +1,3 @@
+export function defineRemoteExecutorHooks(hooks) {
+  return hooks;
+}

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

@@ -1,9 +1,17 @@
 import type { H3Event } from "h3";
-import { type MutationName, type MutationResult, type MutationVariables } from "#graphql/registry";
-import { type ExecuteServerGraphQLOptions } from "../lib/execute-server-graphql.js";
-export interface ServerMutateOptions {
-    headers?: HeadersInit;
-}
-export declare function useServerGraphQLMutation<N extends MutationName>(event: H3Event, operationName: N, options?: ExecuteServerGraphQLOptions): {
-    mutate: (...args: IsEmptyObject<MutationVariables<N>> extends true ? [variables?: MutationVariables<N>, mutateOptions?: ServerMutateOptions] : [variables: MutationVariables<N>, mutateOptions?: ServerMutateOptions]) => Promise<MutationResult<N>>;
-};
+import type { MutationName, VariablesOf, ResultOf } from "#graphql/registry";
+import { type SafeResult } from "../../shared/lib/error.js";
+import type { IsEmptyObject } from "../../shared/lib/utils.js";
+/**
+ * Execute a GraphQL mutation against the local stitched schema (server-side).
+ *
+ * - Schema execution only (no HTTP)
+ * - Context comes from the H3 event
+ * - Errors are normalized
+ *
+ * @param event H3 event used to create context.
+ * @param operationName Operation name from the registry.
+ * @param variables Operation variables.
+ * @returns SafeResult containing data or a normalized error.
+ */
+export declare function useServerGraphQLMutation<TName extends MutationName>(event: H3Event, operationName: TName, ...args: IsEmptyObject<VariablesOf<TName>> extends true ? [variables?: VariablesOf<TName>] : [variables: VariablesOf<TName>]): Promise<SafeResult<ResultOf<TName>>>;

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

@@ -1,13 +1,14 @@
-import { mutations } from "#graphql/registry";
-import { executeServerGraphQL } from "../lib/execute-server-graphql.js";
-import { mergeHeaders } from "../../shared/lib/headers.js";
-export function useServerGraphQLMutation(event, operationName, options) {
-  async function mutate(...args) {
-    const [variables, mutateOptions] = args;
-    return executeServerGraphQL(event, mutations[operationName], variables, {
-      ...options,
-      headers: mergeHeaders(options?.headers, mutateOptions?.headers)
-    });
+import { executeGraphQLSchema } from "../lib/execute-schema.js";
+import { normalizeError } from "../../shared/lib/error.js";
+export async function useServerGraphQLMutation(event, operationName, ...args) {
+  try {
+    const [variables] = args;
+    const data = await executeGraphQLSchema(event, operationName, variables);
+    return { data, error: null };
+  } catch (err) {
+    return {
+      data: null,
+      error: normalizeError(err)
+    };
   }
-  return { mutate };
 }

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

@@ -1,4 +1,17 @@
 import type { H3Event } from "h3";
-import { type QueryName, type QueryResult, type QueryVariables } from "#graphql/registry";
-import { type ExecuteServerGraphQLOptions } from "../lib/execute-server-graphql.js";
-export declare function useServerGraphQLQuery<N extends QueryName>(event: H3Event, operationName: N, ...args: IsEmptyObject<QueryVariables<N>> extends true ? [variables?: QueryVariables<N>, options?: ExecuteServerGraphQLOptions] : [variables: QueryVariables<N>, options?: ExecuteServerGraphQLOptions]): Promise<QueryResult<N>>;
+import type { QueryName, VariablesOf, ResultOf } from "#graphql/registry";
+import { type SafeResult } from "../../shared/lib/error.js";
+import type { IsEmptyObject } from "../../shared/lib/utils.js";
+/**
+ * Execute a GraphQL query against the local stitched schema (server-side).
+ *
+ * - Schema execution only (no HTTP)
+ * - Context comes from the H3 event
+ * - Errors are normalized
+ *
+ * @param event H3 event used to create context.
+ * @param operationName Operation name from the registry.
+ * @param variables Operation variables.
+ * @returns SafeResult containing data or a normalized error.
+ */
+export declare function useServerGraphQLQuery<TName extends QueryName>(event: H3Event, operationName: TName, ...args: IsEmptyObject<VariablesOf<TName>> extends true ? [variables?: VariablesOf<TName>] : [variables: VariablesOf<TName>]): Promise<SafeResult<ResultOf<TName>>>;

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

@@ -1,6 +1,18 @@
-import { queries } from "#graphql/registry";
-import { executeServerGraphQL } from "../lib/execute-server-graphql.js";
+import { executeGraphQLSchema } from "../lib/execute-schema.js";
+import { normalizeError } from "../../shared/lib/error.js";
 export async function useServerGraphQLQuery(event, operationName, ...args) {
-  const [variables, options] = args;
-  return executeServerGraphQL(event, queries[operationName], variables, options);
+  const [variables] = args;
+  try {
+    const data = await executeGraphQLSchema(
+      event,
+      operationName,
+      variables
+    );
+    return { data, error: null };
+  } catch (err) {
+    return {
+      data: null,
+      error: normalizeError(err)
+    };
+  }
 }

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

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

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

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

package/dist/runtime/shared/lib/error.d.ts

@@ -0,0 +1,56 @@
+import type { GraphQLError } from "graphql";
+/**
+ * Safe result type.
+ *
+ * - On success, `data` contains the result and `error` is `null`.
+ * - On failure, `data` is `null` and `error` contains a NormalizedError.
+ */
+export type SafeResult<T> = {
+    data: T;
+    error: null;
+} | {
+    data: null;
+    error: NormalizedError;
+};
+/**
+ * Base GraphQL error codes.
+ * Users may extend this interface via declaration merging.
+ */
+export interface GraphQLErrorCodeMap {
+    INTERNAL_ERROR: true;
+    NETWORK_ERROR: true;
+    BAD_REQUEST: true;
+    UNAUTHORIZED: true;
+    FORBIDDEN: true;
+}
+/**
+ * Typed GraphQL error code.
+ * Extensible via interface augmentation.
+ */
+type GraphQLErrorCode = keyof GraphQLErrorCodeMap;
+/**
+ * Unified, transport-agnostic GraphQL error.
+ *
+ * - `message`  : human-readable summary
+ * - `code`     : typed, extensible error code
+ * - `errors[]` : underlying GraphQL execution errors (lossless)
+ */
+export declare class NormalizedError extends Error {
+    readonly errors: readonly GraphQLError[];
+    readonly code?: GraphQLErrorCode;
+    constructor(input: {
+        message: string;
+        errors?: readonly GraphQLError[];
+        code?: GraphQLErrorCode;
+    });
+}
+/**
+ * Normalize an unknown error into a NormalizedError.
+ *
+ * This function is the **only** place where untrusted errors are interpreted.
+ *
+ * @param error Unknown error value.
+ * @returns NormalizedError instance.
+ */
+export declare function normalizeError(error: unknown): NormalizedError;
+export {};

package/dist/runtime/shared/lib/error.js

@@ -0,0 +1,61 @@
+export class NormalizedError extends Error {
+  errors;
+  code;
+  constructor(input) {
+    super(input.message);
+    this.name = "NormalizedError";
+    this.errors = input.errors ?? [];
+    this.code = input.code;
+  }
+}
+function isGraphQLError(error) {
+  return typeof error === "object" && error !== null && "message" in error && "extensions" in error;
+}
+function isGraphQLErrorArray(error) {
+  return Array.isArray(error) && error.every(isGraphQLError);
+}
+function isGraphQLClientError(error) {
+  return typeof error === "object" && error !== null && "response" in error;
+}
+function extractCode(error) {
+  const code = error?.extensions?.code;
+  return typeof code === "string" ? code : void 0;
+}
+export function normalizeError(error) {
+  if (error instanceof NormalizedError) {
+    return error;
+  }
+  if (isGraphQLError(error)) {
+    return new NormalizedError({
+      message: error.message,
+      errors: [error],
+      code: extractCode(error)
+    });
+  }
+  if (isGraphQLClientError(error)) {
+    const errors = error.response?.errors;
+    if (errors && isGraphQLErrorArray(errors)) {
+      return new NormalizedError({
+        message: errors.map(({ message }) => message).join("\n"),
+        errors,
+        code: extractCode(errors[0])
+      });
+    }
+    return new NormalizedError({
+      message: error.message ?? "GraphQL network error",
+      code: "NETWORK_ERROR"
+    });
+  }
+  if (typeof error === "object" && error !== null && "errors" in error && isGraphQLErrorArray(error.errors)) {
+    const errors = error.errors;
+    return new NormalizedError({
+      message: errors.map(({ message }) => message).join("\n"),
+      errors,
+      code: extractCode(errors[0])
+    });
+  }
+  return new NormalizedError({
+    message: error instanceof Error ? error.message : String(error),
+    code: "INTERNAL_ERROR"
+  });
+}

package/dist/runtime/shared/lib/headers.d.ts

@@ -1,3 +1,13 @@
-import type { H3Event } from "h3";
-export declare function getClientForwardHeaders(event: H3Event): HeadersInit | undefined;
-export declare function mergeHeaders(...headers: Array<HeadersInit | undefined>): HeadersInit | undefined;
+/**
+ * Header map where:
+ * - string  → set / override header
+ * - null    → delete header
+ */
+export type HeadersInput = Record<string, string | null>;
+/**
+ * Merge multiple header inputs into a single Headers instance.
+ *
+ * @param inputs Header input objects (later inputs override earlier).
+ * @returns Merged Headers instance.
+ */
+export declare function mergeHeaders(...inputs: Array<HeadersInput | undefined>): Headers;