@lewebsimple/nuxt-graphql 0.2.2 → 0.3.0

package/dist/runtime/server/lib/define-yoga-middleware.js

@@ -0,0 +1,3 @@
+export function defineYogaMiddleware(yogaMiddlewareHandler) {
+  return { yogaMiddlewareHandler };
+}

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

@@ -0,0 +1,7 @@
+import type { H3Event } from "h3";
+import type { DocumentNode } from "graphql";
+import type { TypedDocumentNode } from "@graphql-typed-document-node/core";
+export interface ExecuteServerGraphQLOptions {
+    headers?: HeadersInit;
+}
+export declare function executeServerGraphQL<TResult = unknown, TVariables extends Record<string, unknown> = Record<string, unknown>>(event: H3Event, document: TypedDocumentNode<TResult, TVariables> | DocumentNode, variables?: TVariables, options?: ExecuteServerGraphQLOptions): Promise<TResult>;

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

@@ -0,0 +1,34 @@
+import { execute } from "graphql";
+import { getGraphQLContext } from "#graphql/context";
+import { schema } from "#graphql/schema";
+import { normalizeGraphQLError } from "../../shared/lib/graphql-error.js";
+async function buildContextWithHeaders(event, headers) {
+  if (!headers) {
+    return getGraphQLContext(event);
+  }
+  const headerOverrides = Object.fromEntries(new Headers(headers).entries());
+  if (Object.keys(headerOverrides).length === 0) {
+    return getGraphQLContext(event);
+  }
+  const req = event.node.req;
+  const originalHeaders = req.headers;
+  req.headers = { ...originalHeaders, ...headerOverrides };
+  try {
+    return await getGraphQLContext(event);
+  } finally {
+    req.headers = originalHeaders;
+  }
+}
+export async function executeServerGraphQL(event, document, variables, options) {
+  const contextValue = await buildContextWithHeaders(event, options?.headers);
+  const result = await execute({
+    schema,
+    document,
+    variableValues: variables,
+    contextValue
+  });
+  if (result.errors?.length) {
+    throw normalizeGraphQLError({ errors: result.errors });
+  }
+  return result.data;
+}

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

@@ -0,0 +1,35 @@
+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 {
+    url: string;
+    remoteName: string;
+    headers?: HeadersInit;
+    middleware?: RemoteExecMiddlewareHandler;
+}
+export declare function createRemoteExecutor(options: CreateRemoteExecutorOptions): Executor;

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

@@ -0,0 +1,64 @@
+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 ?? {};
+  return async ({ document, variables, context, operationName }) => {
+    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) {
+      await onRequest({
+        remoteName,
+        operationName: resolvedOperationName,
+        context: graphQLContext,
+        fetchOptions: { headers: requestHeaders }
+      });
+    }
+    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;
+      }
+      if (onResponse) {
+        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 });
+        }
+        throw normalized;
+      }
+    } catch (error) {
+      const normalized = normalizeGraphQLError(error);
+      if (onError) {
+        await onError({ remoteName, operationName: resolvedOperationName, context: graphQLContext, error: normalized });
+      }
+      throw normalized;
+    }
+  };
+}

package/dist/runtime/server/tsconfig.json

@@ -1,3 +1,3 @@
 {
   "extends": "../../../.nuxt/tsconfig.server.json",
-}
+}

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

@@ -1,15 +1,9 @@
 import type { H3Event } from "h3";
-import { type MutationName, type MutationResult } from "#graphql/registry";
-/**
- * Server-side GraphQL mutation composable
- *
- * @param event H3 event
- * @param operationName Mutation operation name
- * @returns Object with mutate function
- */
-export declare function useServerGraphQLMutation<N extends MutationName>(event: H3Event, operationName: N): Promise<{
-    mutate: (variables: MutationVariables<N>, headers?: HeadersInit | undefined) => Promise<{
-        data: MutationResult<N> | null;
-        error: Error | null;
-    }>;
-}>;
+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>>;
+};

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

@@ -1,16 +1,13 @@
-import { getGraphQLClient } from "./graphql-client.js";
 import { mutations } from "#graphql/registry";
-export async function useServerGraphQLMutation(event, operationName) {
-  const client = getGraphQLClient(event);
+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) {
-    try {
-      const [variables, headers] = args;
-      const result = await client.request(mutations[operationName], variables, headers);
-      return { data: result, error: null };
-    } catch (e) {
-      const error = e instanceof Error ? e : new Error(String(e));
-      return { data: null, error };
-    }
+    const [variables, mutateOptions] = args;
+    return executeServerGraphQL(event, mutations[operationName], variables, {
+      ...options,
+      headers: mergeHeaders(options?.headers, mutateOptions?.headers)
+    });
   }
   return { mutate };
 }

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

@@ -1,12 +1,4 @@
 import type { H3Event } from "h3";
 import { type QueryName, type QueryResult, type QueryVariables } from "#graphql/registry";
-import type { IsEmptyObject } from "../../../helpers/is-empty-object.js";
-/**
- * Server-side GraphQL query composable
- *
- * @param event H3 event
- * @param operationName Query operation name
- * @param args Variables and optional headers
- * @returns Query result
- */
-export declare function useServerGraphQLQuery<N extends QueryName>(event: H3Event, operationName: N, ...args: IsEmptyObject<QueryVariables<N>> extends true ? [variables?: QueryVariables<N>, headers?: HeadersInit] : [variables: QueryVariables<N>, headers?: HeadersInit]): Promise<QueryResult<N>>;
+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>>;

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

@@ -1,7 +1,6 @@
-import { getGraphQLClient } from "./graphql-client.js";
 import { queries } from "#graphql/registry";
+import { executeServerGraphQL } from "../lib/execute-server-graphql.js";
 export async function useServerGraphQLQuery(event, operationName, ...args) {
-  const client = getGraphQLClient(event);
-  const [variables, headers] = args;
-  return client.request(queries[operationName], variables, headers);
+  const [variables, options] = args;
+  return executeServerGraphQL(event, queries[operationName], variables, options);
 }

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

@@ -0,0 +1,17 @@
+import type { GraphQLError } from "graphql";
+export declare class NormalizedGraphQLError extends Error {
+    readonly errors: GraphQLError[];
+    constructor(message: string, errors?: GraphQLError[]);
+}
+/**
+ * Normalize a generic error into a NormalizedGraphQLError
+ *
+ * @param error Generic error from various sources
+ * @returns Normalized GraphQL error
+ */
+export declare function normalizeGraphQLError(error: unknown): NormalizedGraphQLError;
+declare module "#app" {
+    interface RuntimeNuxtHooks {
+        "graphql:error": (error: NormalizedGraphQLError) => void;
+    }
+}

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

@@ -0,0 +1,28 @@
+export class NormalizedGraphQLError extends Error {
+  errors;
+  constructor(message, errors = []) {
+    super(message);
+    this.name = "NormalizedGraphQLError";
+    this.errors = errors;
+  }
+}
+export function normalizeGraphQLError(error) {
+  if (error instanceof NormalizedGraphQLError) {
+    return error;
+  }
+  if (error && typeof error === "object" && "message" in error && "locations" in error) {
+    const graphQLError = error;
+    return new NormalizedGraphQLError(graphQLError.message, [graphQLError]);
+  }
+  if (error && typeof error === "object" && "response" in error) {
+    const clientError = error;
+    return new NormalizedGraphQLError(clientError.message, clientError.response?.errors);
+  }
+  if (error && typeof error === "object" && "errors" in error) {
+    const { errors } = error;
+    const message2 = errors.map((e) => e.message).join(", ");
+    return new NormalizedGraphQLError(message2, errors);
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return new NormalizedGraphQLError(message);
+}

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

@@ -0,0 +1,3 @@
+import type { H3Event } from "h3";
+export declare function getClientForwardHeaders(event: H3Event): HeadersInit | undefined;
+export declare function mergeHeaders(...headers: Array<HeadersInit | undefined>): HeadersInit | undefined;

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

@@ -0,0 +1,39 @@
+import { getRequestHeader } from "h3";
+export function getClientForwardHeaders(event) {
+  if (import.meta.client) return void 0;
+  const allowedHeaders = [
+    "accept-language",
+    "authorization",
+    "cookie",
+    "user-agent",
+    "x-forwarded-for",
+    "x-forwarded-host",
+    "x-forwarded-proto",
+    "x-request-id"
+  ];
+  const headers = new Headers();
+  let hasHeaders = false;
+  for (const header of allowedHeaders) {
+    const value = getRequestHeader(event, header);
+    if (value) {
+      headers.set(header, Array.isArray(value) ? value.join(", ") : value);
+      hasHeaders = true;
+    }
+  }
+  return hasHeaders ? headers : void 0;
+}
+export function mergeHeaders(...headers) {
+  const present = headers.filter(Boolean);
+  if (present.length === 0) return void 0;
+  if (present.length === 1) return present[0];
+  if (typeof Headers === "undefined") {
+    throw new TypeError("mergeHeaders: Node 18+ is required (global Headers is not available).");
+  }
+  const merged = new Headers();
+  for (const headerInit of present) {
+    for (const [key, value] of new Headers(headerInit).entries()) {
+      merged.set(key, value);
+    }
+  }
+  return merged;
+}

package/dist/types.d.mts

@@ -1,3 +1,15 @@
+import type { NuxtModule } from '@nuxt/schema'
+
+import type { default as Module } from './module.mjs'
+
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { type defineGraphQLContext } from '../dist/runtime/server/lib/define-graphql-context.js'
+
+export { type defineRemoteExecMiddleware } from '../dist/runtime/server/lib/define-remote-exec-middleware.js'
+
+export { type defineYogaMiddleware } from '../dist/runtime/server/lib/define-yoga-middleware.js'
+
 export { default } from './module.mjs'
 
-export { type ModuleOptions } from './module.mjs'
+export { type NuxtGraphQLModuleOptions } from './module.mjs'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lewebsimple/nuxt-graphql",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "Opinionated Nuxt module for using GraphQL",
   "repository": "lewebsimple/nuxt-graphql",
   "license": "MIT",
@@ -25,24 +25,21 @@
   "scripts": {
     "prepack": "nuxt-module-build build",
     "dev": "npm run dev:prepare && nuxi dev playground",
-    "dev:build": "nuxi build playground",
-    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxi prepare playground",
+    "dev:build": "export PLAYGROUND_MODULE_BUILD=true && nuxi build playground",
+    "dev:prepare": "export PLAYGROUND_MODULE_BUILD=true && nuxt-module-build build --stub && nuxt-module-build prepare && nuxi prepare playground",
     "release": "npm run lint && npm run test && npm run prepack && changelogen --release --push && npm publish",
     "lint": "eslint .",
     "test": "vitest run",
     "test:watch": "vitest watch",
-    "test:coverage": "vitest run --coverage",
     "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit"
   },
   "dependencies": {
-    "@graphql-codegen/cli": "^6.1.0",
+    "@graphql-codegen/cli": "^6.1.1",
     "@graphql-codegen/typed-document-node": "^6.1.5",
     "@graphql-codegen/typescript": "^5.0.7",
     "@graphql-codegen/typescript-operations": "^5.0.7",
-    "@graphql-tools/delegate": "^12.0.2",
-    "@graphql-tools/stitch": "^10.1.6",
-    "@graphql-tools/utils": "^10.11.0",
-    "@graphql-tools/wrap": "^11.1.2",
+    "@graphql-tools/delegate": "^12.0.4",
+    "@graphql-tools/stitch": "^10.1.8",
     "@graphql-typed-document-node/core": "^3.2.0",
     "@nuxt/kit": "^4.2.2",
     "graphql": "^16.12.0",
@@ -61,22 +58,21 @@
     "@nuxt/eslint-config": "^1.12.1",
     "@nuxt/module-builder": "^1.0.2",
     "@nuxt/schema": "^4.2.2",
-    "@nuxt/test-utils": "^3.22.0",
+    "@nuxt/test-utils": "^3.23.0",
     "@types/node": "latest",
-    "@vitest/coverage-v8": "^3.2.4",
     "changelogen": "^0.6.2",
     "eslint": "^9.39.2",
     "nuxt": "^4.2.2",
     "typescript": "~5.9.3",
-    "vitest": "^3.2.4",
+    "vitest": "^4.0.17",
     "vue-tsc": "^3.2.2"
   },
   "publishConfig": {
     "access": "public"
   },
-  "changlog": {
+  "changelog": {
     "types": {
       "chore": false
     }
   }
-}
+}

package/dist/runtime/app/composables/useGraphQLCache.d.ts

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

package/dist/runtime/app/composables/useGraphQLCache.js

@@ -1,15 +0,0 @@
-import { useRuntimeConfig } from "#imports";
-import { cacheInvalidate, initCache } from "../utils/graphql-cache.js";
-export function useGraphQLCache() {
-  const { public: { graphql: { cache: cacheConfig } } } = useRuntimeConfig();
-  if (import.meta.client && cacheConfig.enabled) {
-    initCache(cacheConfig.storage);
-  }
-  async function invalidate(operationName, variables) {
-    await cacheInvalidate(operationName, variables);
-  }
-  return {
-    enabled: cacheConfig.enabled,
-    invalidate
-  };
-}

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

@@ -1,31 +0,0 @@
-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/app/plugins/graphql.js

@@ -1,42 +0,0 @@
-import { GraphQLClient } from "graphql-request";
-import { createClient } from "graphql-sse";
-import { defineNuxtPlugin, useRequestHeaders, useRequestURL, useRuntimeConfig } from "#imports";
-import { wrapError } from "../utils/graphql-error.js";
-export default defineNuxtPlugin((nuxtApp) => {
-  const { public: { graphql: { endpoint, headers: staticHeaders } } } = useRuntimeConfig();
-  const { origin } = useRequestURL();
-  const url = `${origin}${endpoint}`;
-  const getClient = () => {
-    const headers = { ...staticHeaders };
-    if (import.meta.server) {
-      const ssrHeaders = useRequestHeaders(["cookie", "authorization"]);
-      Object.assign(headers, ssrHeaders);
-    }
-    const client = new GraphQLClient(url, {
-      headers,
-      responseMiddleware: (response) => {
-        if (response instanceof Error) {
-          nuxtApp.callHook("graphql:error", wrapError(response));
-        }
-      }
-    });
-    return client;
-  };
-  let sseClient = null;
-  const getSSEClient = () => {
-    if (import.meta.server) {
-      throw new Error("SSE subscriptions are not available on the server");
-    }
-    if (!sseClient) {
-      sseClient = createClient({ url, headers: staticHeaders });
-    }
-    return sseClient;
-  };
-  return {
-    provide: {
-      graphql: getClient,
-      graphqlSSE: getSSEClient
-    }
-  };
-});
-export {};

package/dist/runtime/app/utils/graphql-cache.d.ts

@@ -1,36 +0,0 @@
-export interface GraphQLCacheConfig {
-    enabled: boolean;
-    ttl: number;
-    storage: "memory" | "localStorage";
-}
-export interface CacheOptions {
-    enabled?: boolean;
-    ttl?: number;
-}
-export declare function initCache(type: "memory" | "localStorage"): void;
-export declare function getCacheKey(operationName: string, variables: unknown): string;
-export declare function cacheGet<T>(operationName: string, variables: unknown): Promise<T | null>;
-export declare function cacheSet<T>(operationName: string, variables: unknown, data: T, ttl: number): Promise<void>;
-export declare function dedupeGet(operationName: string, variables: unknown): Promise<unknown> | null;
-export declare function dedupeSet(operationName: string, variables: unknown, promise: Promise<unknown>): void;
-/**
- * Register a refresh callback for a query
- *
- * @param operationName GraphQL operation name
- * @param variables Query variables
- * @param refresh Callback to execute on cache invalidation
- * @returns Unregister function
- */
-export declare function registerRefresh(operationName: string, variables: unknown, refresh: () => void): () => void;
-/**
- * Invalidate cached queries and trigger refresh callbacks
- *
- * @param operationName Optional operation name to filter invalidation
- * @param variables Optional variables to target specific query
- *
- * Usage:
- * - No args: invalidate all queries
- * - operationName only: invalidate all queries with that name
- * - operationName + variables: invalidate specific query
- */
-export declare function cacheInvalidate(operationName?: string, variables?: unknown): Promise<void>;

package/dist/runtime/app/utils/graphql-cache.js

@@ -1,65 +0,0 @@
-import { createStorage } from "unstorage";
-import memoryDriver from "unstorage/drivers/memory";
-import localStorageDriver from "unstorage/drivers/localstorage";
-import { hash } from "ohash";
-const inFlight = /* @__PURE__ */ new Map();
-const refreshCallbacks = /* @__PURE__ */ new Map();
-let storage = null;
-export function initCache(type) {
-  if (storage) return;
-  storage = createStorage({
-    driver: type === "localStorage" ? localStorageDriver({ base: "graphql:" }) : memoryDriver()
-  });
-}
-export function getCacheKey(operationName, variables) {
-  return `${operationName}:${hash(variables ?? {})}`;
-}
-export async function cacheGet(operationName, variables) {
-  if (!storage) return null;
-  const key = getCacheKey(operationName, variables);
-  const entry = await storage.getItem(key);
-  if (!entry) return null;
-  if (Date.now() > entry.expires) {
-    await storage.removeItem(key);
-    return null;
-  }
-  return entry.data;
-}
-export async function cacheSet(operationName, variables, data, ttl) {
-  if (!storage) return;
-  const key = getCacheKey(operationName, variables);
-  const entry = { data, expires: Date.now() + ttl };
-  await storage.setItem(key, entry);
-}
-export function dedupeGet(operationName, variables) {
-  const key = getCacheKey(operationName, variables);
-  return inFlight.get(key) ?? null;
-}
-export function dedupeSet(operationName, variables, promise) {
-  const key = getCacheKey(operationName, variables);
-  inFlight.set(key, promise);
-  promise.finally(() => inFlight.delete(key));
-}
-export function registerRefresh(operationName, variables, refresh) {
-  const key = getCacheKey(operationName, variables);
-  if (!refreshCallbacks.has(key)) {
-    refreshCallbacks.set(key, /* @__PURE__ */ new Set());
-  }
-  refreshCallbacks.get(key).add(refresh);
-  return () => refreshCallbacks.get(key)?.delete(refresh);
-}
-export async function cacheInvalidate(operationName, variables) {
-  if (!storage) return;
-  if (operationName && variables !== void 0) {
-    const key = getCacheKey(operationName, variables);
-    await storage.removeItem(key);
-    refreshCallbacks.get(key)?.forEach((cb) => cb());
-  } else {
-    const keys = await storage.getKeys();
-    const toRemove = operationName ? keys.filter((k) => k.startsWith(`${operationName}:`)) : keys;
-    await Promise.all(toRemove.map((k) => storage.removeItem(k)));
-    for (const key of toRemove) {
-      refreshCallbacks.get(key)?.forEach((cb) => cb());
-    }
-  }
-}

package/dist/runtime/app/utils/graphql-error.d.ts

@@ -1,12 +0,0 @@
-import type { GraphQLError } from "graphql";
-export declare class GraphQLClientError extends Error {
-    readonly errors: GraphQLError[];
-    constructor(message: string, errors?: GraphQLError[]);
-}
-/**
- * Wrap a generic error into a GraphQLClientError
- *
- * @param error Generic error from various sources
- * @returns Wrapped GraphQLClientError
- */
-export declare function wrapError(error: unknown): GraphQLClientError;

package/dist/runtime/app/utils/graphql-error.js

@@ -1,24 +0,0 @@
-export class GraphQLClientError extends Error {
-  errors;
-  constructor(message, errors = []) {
-    super(message);
-    this.name = "GraphQLClientError";
-    this.errors = errors;
-  }
-}
-export function wrapError(error) {
-  if (error instanceof GraphQLClientError) {
-    return error;
-  }
-  if (error && typeof error === "object" && "response" in error) {
-    const clientError = error;
-    return new GraphQLClientError(clientError.message, clientError.response?.errors);
-  }
-  if (error && typeof error === "object" && "errors" in error) {
-    const { errors } = error;
-    const message2 = errors.map((e) => e.message).join(", ");
-    return new GraphQLClientError(message2, errors);
-  }
-  const message = error instanceof Error ? error.message : String(error);
-  return new GraphQLClientError(message);
-}