@lewebsimple/nuxt-graphql 0.2.2 → 0.3.0

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

@@ -0,0 +1,10 @@
+export type InvalidateCacheLayer = "both" | "memory" | "persisted";
+export interface InvalidateCacheOptions {
+    layer?: InvalidateCacheLayer;
+}
+export declare function useGraphQLCache(): {
+    readonly cacheConfig: any;
+    readonly invalidateByKey: (operationName: string, variables: unknown, options?: InvalidateCacheOptions) => Promise<void>;
+    readonly invalidateByOperation: (operationName: string, options?: InvalidateCacheOptions) => Promise<void>;
+    readonly invalidateAll: (options?: InvalidateCacheOptions) => Promise<void>;
+};

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

@@ -0,0 +1,41 @@
+import { clearNuxtData, useRuntimeConfig } from "#imports";
+import { getCacheKeyParts } from "../lib/graphql-cache.js";
+import { deletePersistedByPrefix, deletePersistedEntry } from "../lib/persisted.js";
+export function useGraphQLCache() {
+  const { public: { graphql: { cacheConfig } } } = useRuntimeConfig();
+  async function invalidateByKey(operationName, variables, options) {
+    const cacheLayer = options?.layer ?? "both";
+    const { key } = getCacheKeyParts(cacheConfig, operationName, variables);
+    if (cacheLayer === "both" || cacheLayer === "memory") {
+      clearNuxtData(key);
+    }
+    if (cacheLayer === "both" || cacheLayer === "persisted") {
+      await deletePersistedEntry(key);
+    }
+  }
+  async function invalidateByOperation(operationName, options) {
+    const cacheLayer = options?.layer ?? "both";
+    const { opPrefix } = getCacheKeyParts(cacheConfig, operationName, {});
+    if (cacheLayer === "both" || cacheLayer === "memory") {
+      clearNuxtData((k) => k.startsWith(opPrefix));
+    }
+    if (cacheLayer === "both" || cacheLayer === "persisted") {
+      await deletePersistedByPrefix(opPrefix);
+    }
+  }
+  async function invalidateAll(options) {
+    const cacheLayer = options?.layer ?? "both";
+    if (cacheLayer === "both" || cacheLayer === "memory") {
+      clearNuxtData((k) => k.startsWith(`${cacheConfig.keyPrefix}:${cacheConfig.cacheVersion}:`));
+    }
+    if (cacheLayer === "both" || cacheLayer === "persisted") {
+      await deletePersistedByPrefix(`${cacheConfig.keyPrefix}:${cacheConfig.cacheVersion}:`);
+    }
+  }
+  return {
+    cacheConfig,
+    invalidateByKey,
+    invalidateByOperation,
+    invalidateAll
+  };
+}

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

@@ -1,14 +1,23 @@
-import { type MutationName, type MutationResult } from "#graphql/registry";
+import { type MutationName, type MutationVariables } from "#graphql/registry";
+export interface UseGraphQLMutationOptions {
+    headers?: HeadersInit;
+}
+export interface MutateOptions {
+    headers?: HeadersInit;
+}
 /**
- * Client-side GraphQL mutation composable
+ * GraphQL mutation composable
  *
- * @param operationName Mutation operation name
- * @returns Object with mutate function and pending state
+ * @param operationName Name of the GraphQL mutation operation in the registry
+ * @returns Mutation handler
  */
-export declare function useGraphQLMutation<N extends MutationName>(operationName: N): {
-    mutate: (variables: MutationVariables<N>, headers?: HeadersInit | undefined) => Promise<{
-        data: MutationResult<N> | null;
-        error: Error | null;
+export declare function useGraphQLMutation<N extends MutationName>(operationName: N, options?: UseGraphQLMutationOptions): {
+    mutate: (...args: IsEmptyObject<MutationVariables<N>> extends true ? [variables?: MutationVariables<N>, mutateOptions?: MutateOptions] : [variables: MutationVariables<N>, mutateOptions?: MutateOptions]) => Promise<{
+        data: any;
+        error: null;
+    } | {
+        data: null;
+        error: import("../../shared/lib/graphql-error.js").NormalizedGraphQLError;
     }>;
     pending: import("vue").Ref<boolean, boolean>;
 };

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

@@ -1,19 +1,20 @@
-import { ref } from "vue";
-import { useNuxtApp } from "#imports";
+import { ref, useNuxtApp } from "#imports";
 import { mutations } from "#graphql/registry";
-import { wrapError } from "../utils/graphql-error.js";
-export function useGraphQLMutation(operationName) {
+import { normalizeGraphQLError } from "../../shared/lib/graphql-error.js";
+import { mergeHeaders } from "../../shared/lib/headers.js";
+export function useGraphQLMutation(operationName, options) {
+  const { $getGraphQLClient } = useNuxtApp();
   const document = mutations[operationName];
-  const { $graphql } = useNuxtApp();
   const pending = ref(false);
   async function mutate(...args) {
     pending.value = true;
     try {
-      const [variables, headers] = args;
-      const result = await $graphql().request(document, variables, headers);
-      return { data: result, error: null };
+      const [variables, mutateOptions] = args;
+      const headers = mergeHeaders(options?.headers, mutateOptions?.headers);
+      const data = await $getGraphQLClient().request(document, variables, headers);
+      return { data, error: null };
     } catch (error) {
-      return { data: null, error: wrapError(error) };
+      return { data: null, error: normalizeGraphQLError(error) };
     } finally {
       pending.value = false;
     }

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

@@ -1,16 +1,9 @@
-import type { AsyncData, AsyncDataOptions } from "#app";
+import type { AsyncDataOptions } from "#app";
+import { useAsyncData, type MaybeRefOrGetter } from "#imports";
 import { type QueryName, type QueryResult, type QueryVariables } from "#graphql/registry";
-import { type CacheOptions } from "../utils/graphql-cache.js";
-import type { IsEmptyObject } from "../../../helpers/is-empty-object.js";
+import { type CacheConfig } from "../../../helpers/cache-config.js";
 export interface UseGraphQLQueryOptions<T> extends AsyncDataOptions<T> {
-    cache?: CacheOptions | false;
     headers?: HeadersInit;
+    cache?: CacheConfig;
 }
-/**
- * Client-side GraphQL query composable with caching and deduplication
- *
- * @param operationName Query operation name
- * @param args Variables and optional configuration
- * @returns AsyncData object with query result
- */
-export declare function useGraphQLQuery<N extends QueryName>(operationName: N, ...args: IsEmptyObject<QueryVariables<N>> extends true ? [variables?: QueryVariables<N>, options?: UseGraphQLQueryOptions<QueryResult<N>>] : [variables: QueryVariables<N>, options?: UseGraphQLQueryOptions<QueryResult<N>>]): AsyncData<QueryResult<N>, Error | null>;
+export declare function useGraphQLQuery<N extends QueryName>(operationName: N, ...args: IsEmptyObject<QueryVariables<N>> extends true ? [variables?: MaybeRefOrGetter<QueryVariables<N>>, options?: UseGraphQLQueryOptions<QueryResult<N>>] : [variables: MaybeRefOrGetter<QueryVariables<N>>, options?: UseGraphQLQueryOptions<QueryResult<N>>]): ReturnType<typeof useAsyncData<QueryResult<N>>>;

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

@@ -1,37 +1,83 @@
-import { useAsyncData, useNuxtApp, useRuntimeConfig, onScopeDispose } from "#imports";
+import { computed, toValue, useAsyncData, useNuxtApp, useNuxtData, useRuntimeConfig } from "#imports";
 import { queries } from "#graphql/registry";
-import { cacheGet, cacheSet, dedupeGet, dedupeSet, registerRefresh, initCache, getCacheKey } from "../utils/graphql-cache.js";
+import { resolveCacheConfig } from "../../../helpers/cache-config";
+import { getCacheKeyParts, getInFlightRequests } from "../lib/graphql-cache.js";
+import { getPersistedEntry, setPersistedEntry } from "../lib/persisted.js";
 export function useGraphQLQuery(operationName, ...args) {
-  const { $graphql } = useNuxtApp();
-  const { public: { graphql: { cache: globalCache } } } = useRuntimeConfig();
+  const { $getGraphQLClient } = useNuxtApp();
+  const inFlightRequests = getInFlightRequests();
+  const isClient = import.meta.client;
+  const { public: { graphql: { cacheConfig: runtimeCacheConfig } } } = useRuntimeConfig();
   const document = queries[operationName];
   const [variables, options] = args;
-  const cacheEnabled = options?.cache !== false && globalCache.enabled;
-  const cacheTtl = options?.cache === false ? 0 : options?.cache?.ttl ?? globalCache.ttl;
-  if (import.meta.client && cacheEnabled) {
-    initCache(globalCache.storage);
+  const { headers, cache, ...asyncDataOptions } = options ?? {};
+  const cacheConfig = resolveCacheConfig(runtimeCacheConfig, cache);
+  const cacheKey = computed(() => getCacheKeyParts(cacheConfig, operationName, toValue(variables)).key);
+  async function executeNetwork() {
+    const existing = inFlightRequests.get(cacheKey.value);
+    if (existing) {
+      return existing;
+    }
+    const promise = $getGraphQLClient().request(document, toValue(variables), headers).then((result) => {
+      if (isClient && cacheConfig.ttl !== void 0) {
+        setPersistedEntry(cacheKey.value, result, cacheConfig.ttl);
+      }
+      return result;
+    });
+    inFlightRequests.set(cacheKey.value, promise);
+    promise.finally(() => {
+      inFlightRequests.delete(cacheKey.value);
+    });
+    return promise;
   }
-  const key = getCacheKey(operationName, variables);
-  const fetcher = async () => {
-    if (import.meta.client && cacheEnabled) {
-      const cached = await cacheGet(operationName, variables);
-      if (cached) return cached;
+  ;
+  async function asyncDataHandler() {
+    const nuxtData = useNuxtData(cacheKey.value);
+    let cachedValue = nuxtData.data.value;
+    if (cacheConfig.cachePolicy === "no-cache") {
+      return await executeNetwork();
+    }
+    if (isClient && cachedValue === void 0 && cacheConfig.ttl !== void 0) {
+      const persisted = await getPersistedEntry(cacheKey.value);
+      if (persisted !== void 0) {
+        cachedValue = nuxtData.data.value = persisted;
+      }
     }
-    const inFlight = dedupeGet(operationName, variables);
-    if (inFlight) return inFlight;
-    const promise = $graphql().request(document, variables, options?.headers);
-    dedupeSet(operationName, variables, promise);
-    const result = await promise;
-    if (import.meta.client && cacheEnabled && cacheTtl) {
-      await cacheSet(operationName, variables, result, cacheTtl);
+    switch (cacheConfig.cachePolicy) {
+      // Cache-first: return cached value if exists, else fetch from network
+      case "cache-first": {
+        if (cachedValue !== void 0) {
+          return cachedValue;
+        }
+        return await executeNetwork();
+      }
+      // Network-first: try network request, fallback to cache on error
+      case "network-first": {
+        try {
+          return await executeNetwork();
+        } catch (error) {
+          if (cachedValue !== void 0) {
+            return cachedValue;
+          }
+          throw error;
+        }
+      }
+      // Stale-while-revalidate: return cached value if exists, then revalidate in background
+      case "swr": {
+        if (cachedValue !== void 0) {
+          if (!inFlightRequests.has(cacheKey.value)) {
+            executeNetwork().then((result) => {
+              nuxtData.data.value = result;
+            }).catch(() => {
+            });
+          }
+          return cachedValue;
+        }
+        return await executeNetwork();
+      }
+      default:
+        return await executeNetwork();
     }
-    return result;
-  };
-  const { cache: _cache, headers: _headers, ...asyncDataOptions } = options ?? {};
-  const asyncData = useAsyncData(key, fetcher, asyncDataOptions);
-  if (import.meta.client) {
-    const unregister = registerRefresh(operationName, variables, () => asyncData.refresh());
-    onScopeDispose(unregister);
   }
-  return asyncData;
+  return useAsyncData(cacheKey, asyncDataHandler, asyncDataOptions);
 }

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

@@ -1,18 +1,17 @@
 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 "../../../helpers/is-empty-object.js";
+import { type NormalizedGraphQLError } from "../../shared/lib/graphql-error.js";
 export type UseGraphQLSubscriptionReturn<N extends SubscriptionName> = {
     data: Ref<SubscriptionResult<N> | null>;
-    error: Ref<GraphQLClientError | null>;
+    error: Ref<NormalizedGraphQLError | null>;
     start: () => void;
     stop: () => void;
 };
 /**
- * Client-side GraphQL subscription composable using SSE
+ * GraphQL subscription composable (client-side only)
  *
  * @param operationName Subscription operation name
- * @param args Variables (can be reactive)
- * @returns Object with data, error, start, and stop
+ * @param args Variables (reactive or not)
+ * @returns Object with reactive data, error and  start / stop helpers
  */
 export declare function useGraphQLSubscription<N extends SubscriptionName>(operationName: N, ...args: IsEmptyObject<SubscriptionVariables<N>> extends true ? [variables?: MaybeRefOrGetter<SubscriptionVariables<N>>] : [variables: MaybeRefOrGetter<SubscriptionVariables<N>>]): UseGraphQLSubscriptionReturn<N>;

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

@@ -1,18 +1,21 @@
-import { ref, onScopeDispose, toValue } from "vue";
+import { shallowRef, onScopeDispose, toValue } from "vue";
 import { print } from "graphql";
 import { useNuxtApp } from "#imports";
 import { subscriptions } from "#graphql/registry";
-import { wrapError } from "../utils/graphql-error.js";
+import { normalizeGraphQLError } from "../../shared/lib/graphql-error.js";
 export function useGraphQLSubscription(operationName, ...args) {
-  const { $graphqlSSE } = useNuxtApp();
+  if (import.meta.server) {
+    throw new Error("useGraphQLSubscription is not available on the server");
+  }
+  const { $getGraphQLSSEClient } = useNuxtApp();
   const [variables] = args;
-  const data = ref(null);
-  const error = ref(null);
+  const data = shallowRef(null);
+  const error = shallowRef(null);
   let unsubscribe = null;
   function start() {
     stop();
     error.value = null;
-    unsubscribe = $graphqlSSE().subscribe(
+    unsubscribe = $getGraphQLSSEClient().subscribe(
       {
         query: print(subscriptions[operationName]),
         variables: toValue(variables)
@@ -20,13 +23,13 @@ export function useGraphQLSubscription(operationName, ...args) {
       {
         next: (result) => {
           if (result.errors?.length) {
-            error.value = wrapError({ errors: result.errors });
+            error.value = normalizeGraphQLError({ errors: result.errors });
           } else if (result.data) {
             data.value = result.data;
           }
         },
-        error: (e) => {
-          error.value = wrapError(e);
+        error: (err) => {
+          error.value = normalizeGraphQLError(err);
         },
         complete: () => {
           unsubscribe = null;
@@ -38,9 +41,7 @@ export function useGraphQLSubscription(operationName, ...args) {
     unsubscribe?.();
     unsubscribe = null;
   }
-  if (import.meta.client) {
-    start();
-  }
+  start();
   onScopeDispose(stop);
   return { data, error, start, stop };
 }

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

@@ -0,0 +1,7 @@
+import type { CacheConfig } from "../../../helpers/cache-config.js";
+export type CacheKeyParts = {
+    key: string;
+    opPrefix: string;
+};
+export declare function getCacheKeyParts(config: CacheConfig, operationName: string, variables: unknown, scope?: string): CacheKeyParts;
+export declare function getInFlightRequests(): Map<string, Promise<unknown>>;

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

@@ -0,0 +1,24 @@
+import { hash } from "ohash";
+import { useRequestEvent } from "#imports";
+export function getCacheKeyParts(config, operationName, variables, scope) {
+  const parts = [config.keyPrefix, config.cacheVersion];
+  if (scope) parts.push(scope);
+  parts.push(operationName);
+  const opPrefix = parts.join(":") + ":";
+  const key = opPrefix + hash(variables || {});
+  return { key, opPrefix };
+}
+const clientInFlightRequests = /* @__PURE__ */ new Map();
+export function getInFlightRequests() {
+  if (import.meta.server) {
+    const event = useRequestEvent();
+    if (!event) {
+      throw new Error("Undefined event context while accessing in-flight requests map on server");
+    }
+    if (!event.context._graphqlInFlightRequestsMap) {
+      event.context._graphqlInFlightRequestsMap = /* @__PURE__ */ new Map();
+    }
+    return event.context._graphqlInFlightRequestsMap;
+  }
+  return clientInFlightRequests;
+}

package/dist/runtime/app/lib/persisted.d.ts

@@ -0,0 +1,4 @@
+export declare function getPersistedEntry<T>(key: string): Promise<T | undefined>;
+export declare function setPersistedEntry<T>(key: string, value: T, ttl: number): Promise<void>;
+export declare function deletePersistedEntry(key: string): Promise<void>;
+export declare function deletePersistedByPrefix(prefix: string): Promise<void>;

package/dist/runtime/app/lib/persisted.js

@@ -0,0 +1,70 @@
+import { createStorage } from "unstorage";
+import localStorageDriver from "unstorage/drivers/localstorage";
+function isPersistedStorageAvailable() {
+  return import.meta.client && typeof window.localStorage !== "undefined";
+}
+let storage = null;
+function getPersistedStorage() {
+  if (!storage && isPersistedStorageAvailable()) {
+    try {
+      storage = createStorage({
+        driver: localStorageDriver({ base: "nuxt-graphql:" })
+      });
+    } catch {
+      storage = null;
+    }
+  }
+  return storage;
+}
+export async function getPersistedEntry(key) {
+  const ps = getPersistedStorage();
+  if (!ps) {
+    return void 0;
+  }
+  try {
+    const payload = await ps.getItem(key);
+    if (!payload) {
+      return void 0;
+    }
+    if (payload.expiresAt && payload.expiresAt < Date.now()) {
+      await ps.removeItem(key);
+      return void 0;
+    }
+    return payload.value;
+  } catch {
+    return void 0;
+  }
+}
+export async function setPersistedEntry(key, value, ttl) {
+  const ps = getPersistedStorage();
+  if (!ps) {
+    return;
+  }
+  const expiresAt = ttl > 0 ? Date.now() + ttl * 1e3 : null;
+  try {
+    const payload = { value, expiresAt };
+    await ps.setItem(key, payload);
+  } catch {
+  }
+}
+export async function deletePersistedEntry(key) {
+  const ps = getPersistedStorage();
+  if (!ps) {
+    return;
+  }
+  try {
+    await ps.removeItem(key);
+  } catch {
+  }
+}
+export async function deletePersistedByPrefix(prefix) {
+  const ps = getPersistedStorage();
+  if (!ps) {
+    return;
+  }
+  try {
+    const keys = await ps.getKeys(prefix);
+    await Promise.all(keys.map((key) => ps.removeItem(key)));
+  } catch {
+  }
+}

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

@@ -0,0 +1,7 @@
+import { GraphQLClient } from "graphql-request";
+declare const _default: import("#app").Plugin<{
+    getGraphQLClient: () => GraphQLClient;
+}> & import("#app").ObjectPlugin<{
+    getGraphQLClient: () => GraphQLClient;
+}>;
+export default _default;

package/dist/runtime/app/plugins/graphql-request.js

@@ -0,0 +1,21 @@
+import { GraphQLClient } from "graphql-request";
+import { defineNuxtPlugin, useRequestEvent, useRequestURL } from "#app";
+import { normalizeGraphQLError } from "../../shared/lib/graphql-error.js";
+import { getClientForwardHeaders } from "../../shared/lib/headers.js";
+export default defineNuxtPlugin((nuxtApp) => {
+  const { origin } = useRequestURL();
+  const event = useRequestEvent();
+  const headers = event ? getClientForwardHeaders(event) : void 0;
+  function getGraphQLClient() {
+    return new GraphQLClient(`${origin}/api/graphql`, {
+      headers,
+      responseMiddleware: (response, _request) => {
+        if (response instanceof Error) {
+          nuxtApp.callHook("graphql:error", normalizeGraphQLError(response));
+          return;
+        }
+      }
+    });
+  }
+  return { provide: { getGraphQLClient } };
+});

package/dist/runtime/app/plugins/graphql-sse.client.d.ts

@@ -0,0 +1,7 @@
+import { type Client as SSEClient } from "graphql-sse";
+declare const _default: import("#app").Plugin<{
+    getGraphQLSSEClient: () => SSEClient;
+}> & import("#app").ObjectPlugin<{
+    getGraphQLSSEClient: () => SSEClient;
+}>;
+export default _default;

package/dist/runtime/app/plugins/graphql-sse.client.js

@@ -0,0 +1,15 @@
+import { defineNuxtPlugin, useRequestURL } from "#app";
+import { createClient } from "graphql-sse";
+export default defineNuxtPlugin((_nuxtApp) => {
+  const { origin } = useRequestURL();
+  let sseClient;
+  function getGraphQLSSEClient() {
+    if (import.meta.server) {
+      throw new Error("GraphQL SSE client is not available on the server");
+    }
+    if (sseClient) return sseClient;
+    return sseClient = createClient({ url: `${origin}/api/graphql` });
+  }
+  ;
+  return { provide: { getGraphQLSSEClient } };
+});

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

@@ -0,0 +1,37 @@
+import type { GraphQLClient } from "graphql-request";
+import type { Client as SSEClient } from "graphql-sse";
+import type { GraphQLCacheConfig } from "../lib/graphql-cache";
+
+declare global {
+  type IsEmptyObject<T> = T extends Record<string, never> ? true : keyof T extends never ? true : false;
+}
+
+declare module "h3" {
+  interface H3EventContext {
+    _graphqlInFlightRequestsMap?: Map<string, Promise<unknown>>;
+  }
+}
+
+declare module "nuxt/schema" {
+  interface PublicRuntimeConfig {
+    graphql: {
+      cacheConfig: GraphQLCacheConfig;
+    };
+  }
+}
+
+declare module "#app/nuxt" {
+  interface NuxtApp {
+    $getGraphQLClient: () => GraphQLClient;
+    $getGraphQLSSEClient: () => SSEClient;
+  }
+}
+
+declare module "#app" {
+  interface NuxtApp {
+    $getGraphQLClient: () => GraphQLClient;
+    $getGraphQLSSEClient: () => SSEClient;
+  }
+}
+
+export { };

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

@@ -0,0 +1,42 @@
+import { defineEventHandler, toWebRequest, sendWebResponse, createError } from "h3";
+import { createYoga } from "graphql-yoga";
+import { getGraphQLContext } from "#graphql/context";
+import { yogaMiddlewareHandler } from "#graphql/yoga-middleware";
+import { schema } from "#graphql/schema";
+let yoga = null;
+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" }
+    });
+  }
+  return yoga;
+}
+export default defineEventHandler(async (event) => {
+  try {
+    const request = toWebRequest(event);
+    const context = await getGraphQLContext(event);
+    const { onRequest, onResponse } = yogaMiddlewareHandler ?? {};
+    if (onRequest) {
+      await onRequest({ event, context, request });
+    }
+    const response = await getYogaInstance().handleRequest(request, context);
+    let finalResponse = response;
+    const setResponse = (next) => {
+      finalResponse = next;
+    };
+    if (onResponse) {
+      await onResponse({ event, context, request, response, setResponse });
+    }
+    return sendWebResponse(event, finalResponse);
+  } 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/define-graphql-context.d.ts

@@ -0,0 +1,5 @@
+import type { H3Event } from "h3";
+export type GetGraphQLContextFn<TContext extends Record<string, unknown>> = (event: H3Event) => Promise<TContext> | TContext;
+export declare function defineGraphQLContext<TContext extends Record<string, unknown>>(getGraphQLContext: GetGraphQLContextFn<TContext>): {
+    getGraphQLContext: GetGraphQLContextFn<TContext>;
+};

package/dist/runtime/server/lib/define-graphql-context.js

@@ -0,0 +1,4 @@
+export function defineGraphQLContext(getGraphQLContext) {
+  return { getGraphQLContext };
+}
+;

package/dist/runtime/server/lib/define-remote-exec-middleware.d.ts

@@ -0,0 +1,30 @@
+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 declare function defineRemoteExecMiddleware(remoteExecMiddlewareHandler: RemoteExecMiddlewareHandler): {
+    remoteExecMiddlewareHandler: RemoteExecMiddlewareHandler;
+};

package/dist/runtime/server/lib/define-remote-exec-middleware.js

@@ -0,0 +1,3 @@
+export function defineRemoteExecMiddleware(remoteExecMiddlewareHandler) {
+  return { remoteExecMiddlewareHandler };
+}

package/dist/runtime/server/lib/define-yoga-middleware.d.ts

@@ -0,0 +1,21 @@
+import type { H3Event } from "h3";
+import type { GraphQLContext } from "#graphql/context";
+export type YogaMiddlewareRequestArgs = {
+    event: H3Event;
+    context: GraphQLContext;
+    request: Request;
+};
+export type YogaMiddlewareResponseArgs = {
+    event: H3Event;
+    context: GraphQLContext;
+    request: Request;
+    response: Response;
+    setResponse: (next: Response) => void;
+};
+export type YogaMiddlewareHandler = {
+    onRequest?: (args: YogaMiddlewareRequestArgs) => Promise<void> | void;
+    onResponse?: (args: YogaMiddlewareResponseArgs) => Promise<void> | void;
+};
+export declare function defineYogaMiddleware(yogaMiddlewareHandler: YogaMiddlewareHandler): {
+    yogaMiddlewareHandler: YogaMiddlewareHandler;
+};