@gambalabs/apollo 6.0.0-alpha.16 → 6.0.0-alpha.19

package/README.md

@@ -1,4 +1,4 @@
-![Nuxt Apollo](./docs/public/cover.jpg)
+[![Nuxt Apollo](./docs/public/cover.jpg)](https://apollo.nuxtjs.org)
 
 <h1 align="center">Nuxt Apollo</h1>
 

package/dist/config.d.mts

@@ -0,0 +1,8 @@
+import { C as ClientConfig } from './shared/apollo.32d05cc9.mjs';
+import 'graphql-ws';
+import '@apollo/client';
+import 'nuxt/app';
+
+declare const defineApolloClient: (config: ClientConfig) => ClientConfig;
+
+export { ClientConfig, defineApolloClient };

package/dist/config.d.ts

@@ -0,0 +1,8 @@
+import { C as ClientConfig } from './shared/apollo.32d05cc9.js';
+import 'graphql-ws';
+import '@apollo/client';
+import 'nuxt/app';
+
+declare const defineApolloClient: (config: ClientConfig) => ClientConfig;
+
+export { ClientConfig, defineApolloClient };

package/dist/config.mjs

@@ -0,0 +1,3 @@
+const defineApolloClient = (config) => config;
+
+export { defineApolloClient };

package/dist/module.d.mts

@@ -0,0 +1,31 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { N as NuxtApolloConfig, C as ClientConfig } from './shared/apollo.32d05cc9.mjs';
+export { ErrorResponse } from '@apollo/client/link/error';
+import 'graphql-ws';
+import '@apollo/client';
+import 'nuxt/app';
+
+type ModuleOptions = NuxtApolloConfig;
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions>;
+
+declare const defineApolloClient: (config: ClientConfig) => ClientConfig;
+interface ModuleRuntimeConfig {
+    apollo: NuxtApolloConfig<any>;
+}
+interface ModulePublicRuntimeConfig {
+    apollo: NuxtApolloConfig<any>;
+}
+declare module '@nuxt/schema' {
+    interface NuxtConfig {
+        ['apollo']?: Partial<ModuleOptions>;
+    }
+    interface NuxtOptions {
+        ['apollo']?: ModuleOptions;
+    }
+    interface RuntimeConfig extends ModuleRuntimeConfig {
+    }
+    interface PublicRuntimeConfig extends ModulePublicRuntimeConfig {
+    }
+}
+
+export { ClientConfig, type ModuleOptions, type ModulePublicRuntimeConfig, type ModuleRuntimeConfig, _default as default, defineApolloClient };

package/dist/module.d.ts

@@ -1,235 +1,31 @@
 import * as _nuxt_schema from '@nuxt/schema';
-import { Ref } from 'vue';
-import { DefaultContext } from '@apollo/client/core';
-import { ClientOptions } from 'graphql-ws';
-import { HttpOptions, DefaultOptions, InMemoryCacheConfig } from '@apollo/client';
-import { CookieOptions } from 'nuxt/dist/app/composables';
-import { ErrorResponse } from '@apollo/client/link/error';
+import { N as NuxtApolloConfig, C as ClientConfig } from './shared/apollo.32d05cc9.js';
 export { ErrorResponse } from '@apollo/client/link/error';
-
-type CookieAttributes = Omit< CookieOptions, 'encode' | 'decode' | 'expires' | 'default'>;
-
-type Pusher = {
-  cluster: string;
-  wsHost: string;
-  wsPort: number;
-  forceTLS: boolean;
-  channelEndpoint: string;
-  pusherAppKey: string;
-}
-
-type ClientConfig = {
-  /**
-   * The GraphQL endpoint.
-   * @type {string}
-   */
-  httpEndpoint: string;
-
-  /**
-   * Provide a GraphQL endpoint to be used client-side. Overrides `httpEndpoint`.
-   * @type {string}
-   **/
-  browserHttpEndpoint?: string;
-
-  /**
-   * Provide additional configuration for the `HttpLink`.
-   * See https://www.apollographql.com/docs/link/links/http.html#options
-   * @type {HttpOptions}
-   **/
-  httpLinkOptions?: Omit<HttpOptions, 'uri'>;
-
-  /**
-   * Provide additional configuration for the `GraphQLWsLink`.
-   * See https://github.com/enisdenjo/graphql-ws/blob/master/docs/interfaces/client.ClientOptions.md
-   **/
-  wsLinkOptions?: Omit<ClientOptions, 'url' | 'connectionParams'>;
-
-  /**
-   * Specify a websocket endpoint to be used for subscriptions.
-   * The `wss` protocol is recommended in production.
-   * @type {string}
-   **/
-  wsEndpoint?: string;
-
-  /**
-   * Specify if the client should solely use WebSocket.
-   * requires `wsEndpoint`.
-   * @type {boolean}
-   * @default false
-   **/
-  websocketsOnly?: boolean;
-
-  /**
-   * Specify a pusher config to be used for subscriptions.
-   * @type {Pusher}
-   **/
-  pusher?: Pusher
-
-  /**
-   * Specify if the client should be able to connect to the Apollo Client Devtools in production mode.
-   * @type {boolean}
-   * @default false
-   **/
-  connectToDevTools?: boolean;
-
-  /**
-   * Configure default options to be applied to the apollo client.
-   **/
-  defaultOptions?: DefaultOptions;
-
-  /**
-   * Configure the in-memory cache.
-   **/
-  inMemoryCacheOptions?: InMemoryCacheConfig;
-
-  /**
-   * Specify the name under which the token will be stored.
-   * as in either a cookie or localStorage.
-   * @type {string}
-   * @default "apollo:<client-name>.token"
-   */
-  tokenName?: string;
-
-  /**
-   * Specify if the auth token should be stored in `cookie` or `localStorage`.
-   * `Cookie` storage is required for SSR.
-   * @type {string}
-   * @default "cookie"
-   **/
-  tokenStorage?: 'cookie' | 'localStorage';
-
-  /**
-   * Specify the Authentication scheme.
-   * @type {string}
-   * @default "Bearer"
-   **/
-  authType?: string | null;
-
-  /**
-   * Name of the Authentication token header.
-   * @type {string}
-   * @default "Authorization"
-   */
-  authHeader?: string;
-
-  /**
-   * Configuration for the auth cookie.
-   **/
-  cookieAttributes?: CookieAttributes;
-
-  /**
-   * Name of the CSRF token header.
-   * @type {string}
-   * @default "X-CSRF-TOKEN"
-   */
-  csrfHeader?: string
-
-  /**
-   * Enable automatic persisted queries.
-   * @type {boolean}
-   * @default false
-   */
-  persistedQueries?: boolean
-};
-
-interface NuxtApolloConfig<T = ClientConfig> {
-  /**
-   * Determine if vue-apollo composables should be automatically imported.
-   * @type {boolean}
-   * @default true
-   **/
-  autoImports?: boolean;
-
-  /**
-   * Configuration of the Apollo clients.
-   **/
-  clients?: Record< string, T extends boolean ? string | ClientConfig : ClientConfig >;
-
-  /**
-   * Default options to be applied to all Apollo clients.
-   * This is useful for setting global defaults, and is overridden by `defaultOptions` passed directly to clients.
-   **/
-  defaultOptions?: DefaultOptions;
-
-  /**
-   * Pass cookies from the browser to the GraphQL API in SSR mode.
-   *
-   * @type boolean
-   * @default true
-   * */
-  proxyCookies?: boolean;
-
-  /**
-   * Specify the Authentication scheme.
-   * @type {string}
-   * @default 'Bearer'
-   **/
-  authType?: string;
-
-  /**
-   * Name of the Authentication token header.
-   * @type {string}
-   * @default "Authorization"
-   */
-  authHeader?: string;
-
-  /**
-   * Name of the CSRF token header.
-   * @type {string}
-   * @default "X-CSRF-TOKEN"
-   */
-  csrfHeader?: string;
-
-  /**
-   * Specify if the auth token should be stored in `cookie` or `localStorage`.
-   * `Cookie` storage is required for SSR.
-   * @type {string}
-   * @default "cookie"
-   **/
-  tokenStorage?: 'cookie' | 'localStorage';
-
-  /**
-   * Configuration for the auth cookie.
-   **/
-  cookieAttributes?: CookieAttributes;
-
-  /**
-   * Apollo client awareness instructs the client to send two additional headers
-   * `apollographql-client-name` and `apollographql-client-version` in each HTTP request.
-   * This behavior is disabled by default.
-   * @type {boolean}
-   * @default false
-   */
-  clientAwareness?: boolean
-}
+import 'graphql-ws';
+import '@apollo/client';
+import 'nuxt/app';
 
 type ModuleOptions = NuxtApolloConfig;
-declare const _default: _nuxt_schema.NuxtModule<NuxtApolloConfig<any>>;
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions>;
 
 declare const defineApolloClient: (config: ClientConfig) => ClientConfig;
-declare module '#app' {
-    interface RuntimeConfig {
-        apollo: NuxtApolloConfig<any>;
-        public: {
-            apollo: NuxtApolloConfig<any>;
-        };
+interface ModuleRuntimeConfig {
+    apollo: NuxtApolloConfig<any>;
+}
+interface ModulePublicRuntimeConfig {
+    apollo: NuxtApolloConfig<any>;
+}
+declare module '@nuxt/schema' {
+    interface NuxtConfig {
+        ['apollo']?: Partial<ModuleOptions>;
+    }
+    interface NuxtOptions {
+        ['apollo']?: ModuleOptions;
+    }
+    interface RuntimeConfig extends ModuleRuntimeConfig {
     }
-    interface RuntimeNuxtHooks {
-        'apollo:auth': (params: {
-            client: string;
-            token: Ref<string | null>;
-        }) => void;
-        'apollo:error': (error: ErrorResponse) => void;
-        'apollo:csrf': (params: {
-            client: string;
-            token: Ref<string | null>;
-        }) => void;
-        'apollo:link': (params: {
-            client: string;
-            context: Ref<DefaultContext | null>;
-            prevContextContext: DefaultContext | null;
-        }) => void;
+    interface PublicRuntimeConfig extends ModulePublicRuntimeConfig {
     }
 }
 
-export { ClientConfig, ModuleOptions, _default as default, defineApolloClient };
+export { ClientConfig, type ModuleOptions, type ModulePublicRuntimeConfig, type ModuleRuntimeConfig, _default as default, defineApolloClient };

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "@gambalabs/apollo",
-  "version": "6.0.0-alpha.16",
+  "version": "6.0.0-alpha.19",
   "configKey": "apollo",
   "compatibility": {
     "nuxt": "^3.0.0-rc.9"

package/dist/module.mjs

@@ -5,7 +5,21 @@ import { useLogger, defineNuxtModule, createResolver, addTemplate, addPlugin, ad
 import GraphQLPlugin from '@rollup/plugin-graphql';
 
 const name = "@gambalabs/apollo";
-const version = "6.0.0-alpha.16";
+const version = "6.0.0-alpha.19";
+
+const serializeConfig = (obj) => {
+  if (typeof obj === "function") {
+    return obj.toString();
+  }
+  if (typeof obj === "object") {
+    if (Array.isArray(obj)) {
+      return `[${obj.map(serializeConfig).join(", ")}]`;
+    } else {
+      return `{${Object.entries(obj).map(([key, value]) => `${serializeConfig(key)}: ${serializeConfig(value)}`).join(", ")}}`;
+    }
+  }
+  return JSON.stringify(obj);
+};
 
 const logger = useLogger(name);
 async function readConfigFile(path) {
@@ -29,19 +43,22 @@ const module = defineNuxtModule({
     proxyCookies: true,
     cookieAttributes: {
       maxAge: 60 * 60 * 24 * 7,
-      secure: process.env.NODE_ENV === "production"
+      secure: process.env.NODE_ENV === "production",
+      sameSite: "lax"
     },
     clientAwareness: false
   },
   async setup(options, nuxt) {
     if (!options.clients || !Object.keys(options.clients).length) {
-      throw new Error("[@nuxtjs/apollo] Atleast one client must be configured.");
+      logger.warn("No apollo clients configured.");
+      return;
     }
     const { resolve } = createResolver(import.meta.url);
     const rootResolver = createResolver(nuxt.options.rootDir);
     nuxt.options.build.transpile = nuxt.options.build.transpile || [];
     nuxt.options.build.transpile.push(
       resolve("runtime"),
+      "tslib",
       "@wry/context",
       "@apollo/client",
       "@vue/apollo-composable",
@@ -63,7 +80,7 @@ const module = defineNuxtModule({
             configPaths[k] = path;
           }
         }
-        v.authType = v?.authType || (v?.authType === "" || v?.authType === null) ? null : options.authType;
+        v.authType = (v?.authType === void 0 ? options.authType : v?.authType) || null;
         v.authHeader = v?.authHeader || options.authHeader;
         v.csrfHeader = v?.csrfHeader || options.csrfHeader;
         v.tokenName = v?.tokenName || `apollo:${k}.token`;
@@ -82,24 +99,29 @@ const module = defineNuxtModule({
       filename: "apollo.d.ts",
       getContents: () => [
         'import type { ClientConfig } from "@nuxtjs/apollo"',
-        "declare const clients: Record<string, ClientConfig>",
-        "declare const clientAwareness: boolean",
-        "declare const proxyCookies: boolean",
-        "declare const cookieAttributes: ClientConfig['cookieAttributes']",
-        "export default { clients, clientAwareness, proxyCookies, cookieAttributes }"
+        "declare module '#apollo' {",
+        `  export type ApolloClientKeys = '${Object.keys(clients).join("' | '")}'`,
+        "  export const NuxtApollo: {",
+        "    clients: Record<ApolloClientKeys, ClientConfig>",
+        "    clientAwareness: boolean",
+        "    proxyCookies: boolean",
+        "    cookieAttributes: ClientConfig['cookieAttributes']",
+        "  }",
+        "}"
       ].join("\n")
     });
-    nuxt.options.alias["#apollo"] = addTemplate({
+    addTemplate({
       filename: "apollo.mjs",
       getContents: () => [
-        "export default {",
+        "export const NuxtApollo = {",
         ` proxyCookies: ${options.proxyCookies},`,
         ` clientAwareness: ${options.clientAwareness},`,
-        ` cookieAttributes: ${JSON.stringify(options.cookieAttributes)},`,
-        ` clients: ${JSON.stringify(clients)}`,
+        ` cookieAttributes: ${serializeConfig(options.cookieAttributes)},`,
+        ` clients: ${serializeConfig(clients)}`,
         "}"
       ].join("\n")
-    }).dst;
+    });
+    nuxt.options.alias["#apollo"] = resolve(nuxt.options.buildDir, "apollo");
     addPlugin(resolve("runtime/plugin"));
     addImports([
       { name: "gql", from: "graphql-tag" },

package/dist/runtime/composables.d.ts

@@ -1,45 +1,97 @@
-import type { OperationVariables, QueryOptions } from '@apollo/client';
-import type { AsyncData } from 'nuxt/dist/app/composables';
+import type { ApolloClient, OperationVariables, QueryOptions, DefaultContext } from '@apollo/client';
+import type { AsyncData, AsyncDataOptions, NuxtError } from 'nuxt/app';
+import type { ApolloClientKeys } from '#apollo';
+type PickFrom<T, K extends Array<string>> = T extends Array<any> ? T : T extends Record<string, any> ? keyof T extends K[number] ? T : K[number] extends never ? T : Pick<T, K[number]> : T;
+type KeysOf<T> = Array<T extends T ? keyof T extends string ? keyof T : never : never>;
 type TQuery<T> = QueryOptions<OperationVariables, T>['query'];
-type TVariables<T> = QueryOptions<OperationVariables, T>['variables'];
+type TVariables<T> = QueryOptions<OperationVariables, T>['variables'] | null;
 type TAsyncQuery<T> = {
+    /**
+     * A unique key to ensure the query can be properly de-duplicated across requests. Defaults to a hash of the query and variables.
+     */
+    key?: string;
+    /**
+     * A GraphQL query string parsed into an AST with the gql template literal.
+     */
     query: TQuery<T>;
+    /**
+     * An object containing all of the GraphQL variables your query requires to execute.
+     *
+     * Each key in the object corresponds to a variable name, and that key's value corresponds to the variable value.
+     */
     variables?: TVariables<T>;
-    key?: string;
+    /**
+     * The name of the Apollo Client to use. Defaults to `default`.
+     */
+    clientId?: ApolloClientKeys;
+    /**
+     * If you're using Apollo Link, this object is the initial value of the context object that's passed along your link chain.
+     */
+    context?: DefaultContext;
+    /**
+     * If `true`, this overrides the default fetchPolicy for the Apollo Client to `cache-first`.
+     * */
     cache?: boolean;
-    clientId?: string;
 };
-export declare function useAsyncQuery<T>(opts: TAsyncQuery<T>): AsyncData<T, Error>;
-export declare function useAsyncQuery<T>(query: TQuery<T>, clientId?: string): AsyncData<T, Error>;
-export declare function useAsyncQuery<T>(query: TQuery<T>, variables?: TVariables<T>, clientId?: string): AsyncData<T, Error>;
-export declare function useLazyAsyncQuery<T>(opts: TAsyncQuery<T>): AsyncData<T, Error>;
-export declare function useLazyAsyncQuery<T>(query: TQuery<T>, clientId?: string): AsyncData<T, Error>;
-export declare function useLazyAsyncQuery<T>(query: TQuery<T>, variables?: TVariables<T>, clientId?: string): AsyncData<T, Error>;
-export declare const useApollo: () => {
+/**
+ * `useAsyncQuery` resolves the GraphQL query asynchronously in a SSR-friendly composable.
+ *
+ * @param opts An object containing the query, variables, clientId, context, and cache options.
+ * @param options Customize the underlying `useAsyncData` composable.
+ */
+export declare function useAsyncQuery<T, DataT = T, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null, NuxtErrorDataT = unknown>(opts: TAsyncQuery<T>, options?: AsyncDataOptions<T, DataT, PickKeys, DefaultT>): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, (NuxtErrorDataT extends Error | NuxtError ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>) | null>;
+/**
+ * `useAsyncQuery` resolves the GraphQL query asynchronously in a SSR-friendly composable.
+ *
+ * @param query A GraphQL query string parsed into an AST with the gql template literal.
+ * @param variables An object containing all of the GraphQL variables your query requires to execute.
+ * @param clientId The name of the Apollo Client to use. Defaults to `default`.
+ * @param context The context object that's passed along your link chain.
+ * @param options Customize the underlying `useAsyncData` composable.
+ */
+export declare function useAsyncQuery<T, DataT = T, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null, NuxtErrorDataT = unknown>(query: TQuery<T>, variables?: TVariables<T>, clientId?: ApolloClientKeys, context?: DefaultContext, options?: AsyncDataOptions<T, DataT, PickKeys, DefaultT>): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, (NuxtErrorDataT extends Error | NuxtError ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>) | null>;
+/**
+ * `useLazyAsyncQuery` resolves the GraphQL query after loading the route, instead of blocking client-side navigation.
+ *
+ * @param opts An object containing the query, variables, clientId, context, and cache options.
+ * @param options Customize the underlying `useAsyncData` composable.
+ */
+export declare function useLazyAsyncQuery<T, DataT = T, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null, NuxtErrorDataT = unknown>(opts: TAsyncQuery<T>, options?: AsyncDataOptions<T, DataT, PickKeys, DefaultT>): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, (NuxtErrorDataT extends Error | NuxtError ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>) | null>;
+/**
+ * `useLazyAsyncQuery` resolves the GraphQL query after loading the route, instead of blocking client-side navigation.
+ *
+ * @param query A GraphQL query string parsed into an AST with the gql template literal.
+ * @param variables An object containing all of the GraphQL variables your query requires to execute.
+ * @param clientId The name of the Apollo Client to use. Defaults to `default`.
+ * @param context The context object that's passed along your link chain.
+ * @param options Customize the underlying `useAsyncData` composable.
+ */
+export declare function useLazyAsyncQuery<T, DataT = T, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null, NuxtErrorDataT = unknown>(query: TQuery<T>, variables?: TVariables<T>, clientId?: string, context?: DefaultContext, options?: AsyncDataOptions<T, DataT, PickKeys, DefaultT>): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, (NuxtErrorDataT extends Error | NuxtError ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>) | null>;
+export declare function useApollo(): {
+    /**
+     * Access the configured apollo clients.
+     */
+    clients: Record<ApolloClientKeys, ApolloClient<any>> | undefined;
     /**
      * Retrieve the auth token for the specified client. Adheres to the `apollo:auth` hook.
      *
      * @param {string} client The client who's token to retrieve. Defaults to `default`.
      */
-    getToken: (client?: string) => Promise<any>;
-    /**
-     * Access the configured apollo clients.
-     */
-    clients: Record<string, import("@apollo/client").ApolloClient<any>> | undefined;
+    getToken: (client?: ApolloClientKeys) => Promise<string | null | undefined>;
     /**
      * Apply auth token to the specified Apollo client, and optionally reset it's cache.
      *
      * @param {string} token The token to be applied.
      * @param {string} client - Name of the Apollo client. Defaults to `default`.
-     * @param {boolean} skipResetStore - If `true`, the cache will not be reset.
+     * @param {boolean} skipResetStore - If `false`, Resets your entire store by clearing out your cache and then re-executing all of your active queries.
      * */
-    onLogin: (token?: string, client?: string, skipResetStore?: boolean) => Promise<void>;
+    onLogin: (token?: string, client?: ApolloClientKeys, skipResetStore?: boolean) => Promise<void>;
     /**
      * Remove the auth token from the Apollo client, and optionally reset it's cache.
      *
      * @param {string} client - Name of the Apollo client. Defaults to `default`.
-     * @param {boolean} skipResetStore - If `true`, the cache will not be reset.
+     * @param {boolean} skipResetStore - If `false`, Resets your entire store by clearing out your cache and then re-executing all of your active queries.
      * */
-    onLogout: (client?: string, skipResetStore?: boolean) => Promise<void>;
+    onLogout: (client?: ApolloClientKeys, skipResetStore?: boolean) => Promise<void>;
 };
 export {};

package/dist/runtime/composables.mjs

@@ -1,44 +1,86 @@
 import { hash } from "ohash";
 import { print } from "graphql";
-import { ref, useCookie, useNuxtApp, useAsyncData } from "#imports";
-import NuxtApollo from "#build/apollo";
+import { ref, unref, isRef, reactive, useCookie, useNuxtApp, useAsyncData } from "#imports";
+import { NuxtApollo } from "#apollo";
 export function useAsyncQuery(...args) {
-  const { key, fn } = prep(...args);
-  return useAsyncData(key, fn);
+  const { key, fn, options } = prep(...args);
+  return useAsyncData(key, fn, options);
 }
 export function useLazyAsyncQuery(...args) {
-  const { key, fn } = prep(...args);
-  return useAsyncData(key, fn, { lazy: true });
+  const { key, fn, options } = prep(...args);
+  return useAsyncData(key, fn, { ...options, lazy: true });
 }
 const prep = (...args) => {
   const { clients } = useApollo();
-  const query = args?.[0]?.query || args?.[0];
-  const cache = args?.[0]?.cache ?? true;
-  const variables = args?.[0]?.variables || typeof args?.[1] !== "string" && args?.[1] || void 0;
-  let clientId = args?.[0]?.clientId || typeof args?.[1] === "string" && args?.[1] || void 0;
+  let query;
+  let variables;
+  let cache;
+  let clientId;
+  let context;
+  let options = {};
+  if (typeof args?.[0] === "object" && "query" in args[0]) {
+    query = args?.[0]?.query;
+    variables = args?.[0]?.variables;
+    cache = args?.[0]?.cache;
+    context = args?.[0]?.context;
+    clientId = args?.[0]?.clientId;
+    if (typeof args?.[1] === "object") {
+      options = args?.[1];
+    }
+  } else {
+    query = args?.[0];
+    variables = args?.[1];
+    clientId = args?.[2];
+    context = args?.[3];
+    if (typeof args?.[4] === "object") {
+      options = args?.[4];
+    }
+  }
+  if (!query) {
+    throw new Error("@nuxtjs/apollo: no query provided");
+  }
   if (!clientId || !clients?.[clientId]) {
-    clientId = clients?.default ? "default" : Object.keys(clients)[0];
+    clientId = clients?.default ? "default" : Object.keys(clients)?.[0];
+    if (!clientId) {
+      throw new Error("@nuxtjs/apollo: no client found");
+    }
+  }
+  if (variables) {
+    variables = isRef(variables) ? variables : reactive(variables);
+    options.watch = options.watch || [];
+    options.watch.push(variables);
   }
-  const key = args?.[0]?.key || hash({ query: print(query), variables, clientId });
-  const fn = () => clients[clientId]?.query({ query, variables, fetchPolicy: "no-cache" }).then((r) => r.data);
-  return { key, query, clientId, variables, fn };
+  const key = args?.[0]?.key || hash({ query: print(query), variables: unref(variables), clientId });
+  const fn = () => clients[clientId]?.query({
+    query,
+    variables: unref(variables) || void 0,
+    ...cache && { fetchPolicy: "cache-first" },
+    context
+  }).then((r) => r.data);
+  return { key, query, clientId, variables, fn, options };
 };
-export const useApollo = () => {
+export function useApollo() {
   const nuxtApp = useNuxtApp();
   const getToken = async (client) => {
     client = client || "default";
     const conf = NuxtApollo?.clients?.[client];
+    if (!conf) {
+      return;
+    }
     const token = ref(null);
     await nuxtApp.callHook("apollo:auth", { token, client });
     if (token.value) {
       return token.value;
     }
     const tokenName = conf.tokenName;
-    return conf?.tokenStorage === "cookie" ? useCookie(tokenName).value : process.client && localStorage.getItem(tokenName) || null;
+    return conf?.tokenStorage === "cookie" ? nuxtApp.runWithContext(() => useCookie(tokenName).value) : process.client && localStorage.getItem(tokenName) || null;
   };
   const updateAuth = async ({ token, client, mode, skipResetStore }) => {
     client = client || "default";
     const conf = NuxtApollo?.clients?.[client];
+    if (!conf) {
+      return;
+    }
     const tokenName = client && conf.tokenName;
     if (conf?.tokenStorage === "cookie") {
       const cookieOpts = client && conf?.cookieAttributes || NuxtApollo?.cookieAttributes;
@@ -63,30 +105,9 @@ export const useApollo = () => {
     await nuxtApp?._apolloClients?.[client].resetStore().catch((e) => console.log("%cError on cache reset", "color: orange;", e.message));
   };
   return {
-    /**
-     * Retrieve the auth token for the specified client. Adheres to the `apollo:auth` hook.
-     *
-     * @param {string} client The client who's token to retrieve. Defaults to `default`.
-     */
     getToken,
-    /**
-     * Access the configured apollo clients.
-     */
     clients: nuxtApp?._apolloClients,
-    /**
-     * Apply auth token to the specified Apollo client, and optionally reset it's cache.
-     *
-     * @param {string} token The token to be applied.
-     * @param {string} client - Name of the Apollo client. Defaults to `default`.
-     * @param {boolean} skipResetStore - If `true`, the cache will not be reset.
-     * */
     onLogin: (token, client, skipResetStore) => updateAuth({ token, client, skipResetStore, mode: "login" }),
-    /**
-     * Remove the auth token from the Apollo client, and optionally reset it's cache.
-     *
-     * @param {string} client - Name of the Apollo client. Defaults to `default`.
-     * @param {boolean} skipResetStore - If `true`, the cache will not be reset.
-     * */
     onLogout: (client, skipResetStore) => updateAuth({ client, skipResetStore, mode: "logout" })
   };
-};
+}

package/dist/runtime/plugin.d.ts

@@ -1,2 +1,34 @@
+import { ApolloClient } from '@apollo/client/core';
+import type { ErrorResponse } from '../types';
+import { useApollo } from './composables';
+import type { Ref } from '#imports';
+import type { ApolloClientKeys } from '#apollo';
 declare const _default: any;
 export default _default;
+export interface ModuleRuntimeHooks {
+    'apollo:auth': (params: {
+        client: ApolloClientKeys;
+        token: Ref<string | null>;
+    }) => void;
+    'apollo:error': (error: ErrorResponse) => void;
+}
+interface DollarApolloHelpers extends ReturnType<typeof useApollo> {
+}
+interface DollarApollo {
+    clients: Record<ApolloClientKeys, ApolloClient<any>>;
+    defaultClient: ApolloClient<any>;
+}
+declare module '#app' {
+    interface RuntimeNuxtHooks extends ModuleRuntimeHooks {
+    }
+    interface NuxtApp {
+        $apolloHelpers: DollarApolloHelpers;
+        $apollo: DollarApollo;
+    }
+}
+declare module 'vue' {
+    interface ComponentCustomProperties {
+        $apolloHelpers: DollarApolloHelpers;
+        $apollo: DollarApollo;
+    }
+}

package/dist/runtime/plugin.mjs

@@ -1,6 +1,7 @@
-import destr from "destr";
+import { destr } from "destr";
 import { onError } from "@apollo/client/link/error";
 import { getMainDefinition } from "@apollo/client/utilities";
+import { createApolloProvider } from "@vue/apollo-option";
 import { ApolloClients, provideApolloClients } from "@vue/apollo-composable";
 import { ApolloClient, ApolloLink, InMemoryCache, split } from "@apollo/client/core";
 import createUploadLink from "apollo-upload-client/createUploadLink.mjs";
@@ -13,20 +14,26 @@ import createRestartableClient from "./ws.mjs";
 import { useApollo } from "./composables.mjs";
 import PusherLink from "./pusher.mjs";
 import { ref, useCookie, defineNuxtPlugin, useRequestHeaders } from "#imports";
-import NuxtApollo from "#apollo";
+import { NuxtApollo } from "#apollo";
 export default defineNuxtPlugin((nuxtApp) => {
   const requestCookies = process.server && NuxtApollo.proxyCookies && useRequestHeaders(["cookie"]) || void 0;
   const clients = {};
   for (const [key, clientConfig] of Object.entries(NuxtApollo.clients)) {
     const getAuth = async () => {
-      const token = ref();
+      const token = ref(null);
       await nuxtApp.callHook("apollo:auth", { token, client: key });
       if (!token.value) {
         if (clientConfig.tokenStorage === "cookie") {
           if (process.client) {
-            token.value = useCookie(clientConfig.tokenName).value;
+            const t = useCookie(clientConfig.tokenName).value;
+            if (t) {
+              token.value = t;
+            }
           } else if (requestCookies?.cookie) {
-            token.value = requestCookies.cookie.split(";").find((c) => c.trim().startsWith(`${clientConfig.tokenName}=`))?.split("=")?.[1];
+            const t = requestCookies.cookie.split(";").find((c) => c.trim().startsWith(`${clientConfig.tokenName}=`))?.split("=")?.[1];
+            if (t) {
+              token.value = t;
+            }
           }
         } else if (process.client && clientConfig.tokenStorage === "localStorage") {
           token.value = localStorage.getItem(clientConfig.tokenName);
@@ -144,7 +151,7 @@ export default defineNuxtPlugin((nuxtApp) => {
         split(
           ({ query }) => {
             const definition = getMainDefinition(query);
-            return definition.kind === "OperationDefinition" && definition.operation === "subscription";
+            return definition.kind === "OperationDefinition" && definition.operation === "query";
           },
           ApolloLink.from([persistedLink, httpEndLink]),
           httpEndLink
@@ -187,6 +194,7 @@ export default defineNuxtPlugin((nuxtApp) => {
   }
   provideApolloClients(clients);
   nuxtApp.vueApp.provide(ApolloClients, clients);
+  nuxtApp.vueApp.use(createApolloProvider({ defaultClient: clients?.default }));
   nuxtApp._apolloClients = clients;
   const defaultClient = clients?.default;
   return {

package/dist/shared/apollo.32d05cc9.d.mts

@@ -0,0 +1,201 @@
+import { ClientOptions } from 'graphql-ws';
+import { HttpOptions, DefaultOptions, InMemoryCacheConfig } from '@apollo/client';
+import { CookieOptions } from 'nuxt/app';
+
+type CookieAttributes = Omit< CookieOptions, 'encode' | 'decode' | 'expires' | 'default'>;
+
+type Pusher = {
+  cluster: string;
+  wsHost: string;
+  wsPort: number;
+  forceTLS: boolean;
+  channelEndpoint: string;
+  pusherAppKey: string;
+}
+
+type ClientConfig = {
+  /**
+   * The GraphQL endpoint.
+   * @type {string}
+   */
+  httpEndpoint: string;
+
+  /**
+   * Provide a GraphQL endpoint to be used client-side. Overrides `httpEndpoint`.
+   * @type {string}
+   **/
+  browserHttpEndpoint?: string;
+
+  /**
+   * Provide additional configuration for the `HttpLink`.
+   * See https://www.apollographql.com/docs/link/links/http.html#options
+   * @type {HttpOptions}
+   **/
+  httpLinkOptions?: Omit<HttpOptions, 'uri'>;
+
+  /**
+   * Provide additional configuration for the `GraphQLWsLink`.
+   * See https://github.com/enisdenjo/graphql-ws/blob/master/docs/interfaces/client.ClientOptions.md
+   **/
+  wsLinkOptions?: Omit<ClientOptions, 'url' | 'connectionParams'>;
+
+  /**
+   * Specify a websocket endpoint to be used for subscriptions.
+   * The `wss` protocol is recommended in production.
+   * @type {string}
+   **/
+  wsEndpoint?: string;
+
+  /**
+   * Specify if the client should solely use WebSocket.
+   * requires `wsEndpoint`.
+   * @type {boolean}
+   * @default false
+   **/
+  websocketsOnly?: boolean;
+
+  /**
+   * Specify a pusher config to be used for subscriptions.
+   * @type {Pusher}
+   **/
+  pusher?: Pusher
+
+  /**
+   * Specify if the client should be able to connect to the Apollo Client Devtools in production mode.
+   * @type {boolean}
+   * @default false
+   **/
+  connectToDevTools?: boolean;
+
+  /**
+   * Configure default options to be applied to the apollo client.
+   **/
+  defaultOptions?: DefaultOptions;
+
+  /**
+   * Configure the in-memory cache.
+   **/
+  inMemoryCacheOptions?: InMemoryCacheConfig;
+
+  /**
+   * Specify the name under which the token will be stored.
+   * as in either a cookie or localStorage.
+   * @type {string}
+   * @default "apollo:<client-name>.token"
+   */
+  tokenName?: string;
+
+  /**
+   * Specify if the auth token should be stored in `cookie` or `localStorage`.
+   * `Cookie` storage is required for SSR.
+   * @type {string}
+   * @default "cookie"
+   **/
+  tokenStorage?: 'cookie' | 'localStorage';
+
+  /**
+   * Specify the Authentication scheme.
+   * @type {string}
+   * @default "Bearer"
+   **/
+  authType?: string | null;
+
+  /**
+   * Name of the Authentication token header.
+   * @type {string}
+   * @default "Authorization"
+   */
+  authHeader?: string;
+
+  /**
+   * Configuration for the auth cookie.
+   **/
+  cookieAttributes?: CookieAttributes;
+
+  /**
+   * Name of the CSRF token header.
+   * @type {string}
+   * @default "X-CSRF-TOKEN"
+   */
+  csrfHeader?: string
+
+  /**
+   * Enable automatic persisted queries.
+   * @type {boolean}
+   * @default false
+   */
+  persistedQueries?: boolean
+};
+
+interface NuxtApolloConfig<T = false> {
+  /**
+   * Determine if vue-apollo composables should be automatically imported.
+   * @type {boolean}
+   * @default true
+   **/
+  autoImports?: boolean;
+
+  /**
+   * Configuration of the Apollo clients.
+   **/
+  clients?: Record< string, T extends false ? string | ClientConfig : ClientConfig >;
+
+  /**
+   * Default options to be applied to all Apollo clients.
+   * This is useful for setting global defaults, and is overridden by `defaultOptions` passed directly to clients.
+   **/
+  defaultOptions?: DefaultOptions;
+
+  /**
+   * Pass cookies from the browser to the GraphQL API in SSR mode.
+   *
+   * @type boolean
+   * @default true
+   * */
+  proxyCookies?: boolean;
+
+  /**
+   * Specify the Authentication scheme.
+   * @type {string}
+   * @default 'Bearer'
+   **/
+  authType?: string;
+
+  /**
+   * Name of the Authentication token header.
+   * @type {string}
+   * @default "Authorization"
+   */
+  authHeader?: string;
+
+  /**
+   * Name of the CSRF token header.
+   * @type {string}
+   * @default "X-CSRF-TOKEN"
+   */
+  csrfHeader?: string;
+
+  /**
+   * Specify if the auth token should be stored in `cookie` or `localStorage`.
+   * `Cookie` storage is required for SSR.
+   * @type {string}
+   * @default "cookie"
+   **/
+  tokenStorage?: 'cookie' | 'localStorage';
+
+  /**
+   * Configuration for the auth cookie.
+   **/
+  cookieAttributes?: CookieAttributes;
+
+  /**
+   * Apollo client awareness instructs the client to send two additional headers
+   * `apollographql-client-name` and `apollographql-client-version` in each HTTP request.
+   * This behavior is disabled by default.
+   * @type {boolean}
+   * @default false
+   */
+  clientAwareness?: boolean
+}
+
+export type { ClientConfig as C, NuxtApolloConfig as N };

package/dist/shared/apollo.32d05cc9.d.ts

@@ -0,0 +1,201 @@
+import { ClientOptions } from 'graphql-ws';
+import { HttpOptions, DefaultOptions, InMemoryCacheConfig } from '@apollo/client';
+import { CookieOptions } from 'nuxt/app';
+
+type CookieAttributes = Omit< CookieOptions, 'encode' | 'decode' | 'expires' | 'default'>;
+
+type Pusher = {
+  cluster: string;
+  wsHost: string;
+  wsPort: number;
+  forceTLS: boolean;
+  channelEndpoint: string;
+  pusherAppKey: string;
+}
+
+type ClientConfig = {
+  /**
+   * The GraphQL endpoint.
+   * @type {string}
+   */
+  httpEndpoint: string;
+
+  /**
+   * Provide a GraphQL endpoint to be used client-side. Overrides `httpEndpoint`.
+   * @type {string}
+   **/
+  browserHttpEndpoint?: string;
+
+  /**
+   * Provide additional configuration for the `HttpLink`.
+   * See https://www.apollographql.com/docs/link/links/http.html#options
+   * @type {HttpOptions}
+   **/
+  httpLinkOptions?: Omit<HttpOptions, 'uri'>;
+
+  /**
+   * Provide additional configuration for the `GraphQLWsLink`.
+   * See https://github.com/enisdenjo/graphql-ws/blob/master/docs/interfaces/client.ClientOptions.md
+   **/
+  wsLinkOptions?: Omit<ClientOptions, 'url' | 'connectionParams'>;
+
+  /**
+   * Specify a websocket endpoint to be used for subscriptions.
+   * The `wss` protocol is recommended in production.
+   * @type {string}
+   **/
+  wsEndpoint?: string;
+
+  /**
+   * Specify if the client should solely use WebSocket.
+   * requires `wsEndpoint`.
+   * @type {boolean}
+   * @default false
+   **/
+  websocketsOnly?: boolean;
+
+  /**
+   * Specify a pusher config to be used for subscriptions.
+   * @type {Pusher}
+   **/
+  pusher?: Pusher
+
+  /**
+   * Specify if the client should be able to connect to the Apollo Client Devtools in production mode.
+   * @type {boolean}
+   * @default false
+   **/
+  connectToDevTools?: boolean;
+
+  /**
+   * Configure default options to be applied to the apollo client.
+   **/
+  defaultOptions?: DefaultOptions;
+
+  /**
+   * Configure the in-memory cache.
+   **/
+  inMemoryCacheOptions?: InMemoryCacheConfig;
+
+  /**
+   * Specify the name under which the token will be stored.
+   * as in either a cookie or localStorage.
+   * @type {string}
+   * @default "apollo:<client-name>.token"
+   */
+  tokenName?: string;
+
+  /**
+   * Specify if the auth token should be stored in `cookie` or `localStorage`.
+   * `Cookie` storage is required for SSR.
+   * @type {string}
+   * @default "cookie"
+   **/
+  tokenStorage?: 'cookie' | 'localStorage';
+
+  /**
+   * Specify the Authentication scheme.
+   * @type {string}
+   * @default "Bearer"
+   **/
+  authType?: string | null;
+
+  /**
+   * Name of the Authentication token header.
+   * @type {string}
+   * @default "Authorization"
+   */
+  authHeader?: string;
+
+  /**
+   * Configuration for the auth cookie.
+   **/
+  cookieAttributes?: CookieAttributes;
+
+  /**
+   * Name of the CSRF token header.
+   * @type {string}
+   * @default "X-CSRF-TOKEN"
+   */
+  csrfHeader?: string
+
+  /**
+   * Enable automatic persisted queries.
+   * @type {boolean}
+   * @default false
+   */
+  persistedQueries?: boolean
+};
+
+interface NuxtApolloConfig<T = false> {
+  /**
+   * Determine if vue-apollo composables should be automatically imported.
+   * @type {boolean}
+   * @default true
+   **/
+  autoImports?: boolean;
+
+  /**
+   * Configuration of the Apollo clients.
+   **/
+  clients?: Record< string, T extends false ? string | ClientConfig : ClientConfig >;
+
+  /**
+   * Default options to be applied to all Apollo clients.
+   * This is useful for setting global defaults, and is overridden by `defaultOptions` passed directly to clients.
+   **/
+  defaultOptions?: DefaultOptions;
+
+  /**
+   * Pass cookies from the browser to the GraphQL API in SSR mode.
+   *
+   * @type boolean
+   * @default true
+   * */
+  proxyCookies?: boolean;
+
+  /**
+   * Specify the Authentication scheme.
+   * @type {string}
+   * @default 'Bearer'
+   **/
+  authType?: string;
+
+  /**
+   * Name of the Authentication token header.
+   * @type {string}
+   * @default "Authorization"
+   */
+  authHeader?: string;
+
+  /**
+   * Name of the CSRF token header.
+   * @type {string}
+   * @default "X-CSRF-TOKEN"
+   */
+  csrfHeader?: string;
+
+  /**
+   * Specify if the auth token should be stored in `cookie` or `localStorage`.
+   * `Cookie` storage is required for SSR.
+   * @type {string}
+   * @default "cookie"
+   **/
+  tokenStorage?: 'cookie' | 'localStorage';
+
+  /**
+   * Configuration for the auth cookie.
+   **/
+  cookieAttributes?: CookieAttributes;
+
+  /**
+   * Apollo client awareness instructs the client to send two additional headers
+   * `apollographql-client-name` and `apollographql-client-version` in each HTTP request.
+   * This behavior is disabled by default.
+   * @type {boolean}
+   * @default false
+   */
+  clientAwareness?: boolean
+}
+
+export type { ClientConfig as C, NuxtApolloConfig as N };

package/dist/types.d.mts

@@ -0,0 +1,20 @@
+
+import type { ModuleOptions, ModuleRuntimeConfig, ModulePublicRuntimeConfig } from './module.js'
+
+
+declare module '@nuxt/schema' {
+  interface NuxtConfig { ['apollo']?: Partial<ModuleOptions> }
+  interface NuxtOptions { ['apollo']?: ModuleOptions }
+  interface RuntimeConfig extends ModuleRuntimeConfig {}
+  interface PublicRuntimeConfig extends ModulePublicRuntimeConfig {}
+}
+
+declare module 'nuxt/schema' {
+  interface NuxtConfig { ['apollo']?: Partial<ModuleOptions> }
+  interface NuxtOptions { ['apollo']?: ModuleOptions }
+  interface RuntimeConfig extends ModuleRuntimeConfig {}
+  interface PublicRuntimeConfig extends ModulePublicRuntimeConfig {}
+}
+
+
+export type { ErrorResponse } from './module.js'

package/dist/types.d.ts

@@ -1,10 +1,20 @@
 
-import { ModuleOptions } from './module'
+import type { ModuleOptions, ModuleRuntimeConfig, ModulePublicRuntimeConfig } from './module'
+
 
 declare module '@nuxt/schema' {
   interface NuxtConfig { ['apollo']?: Partial<ModuleOptions> }
   interface NuxtOptions { ['apollo']?: ModuleOptions }
+  interface RuntimeConfig extends ModuleRuntimeConfig {}
+  interface PublicRuntimeConfig extends ModulePublicRuntimeConfig {}
+}
+
+declare module 'nuxt/schema' {
+  interface NuxtConfig { ['apollo']?: Partial<ModuleOptions> }
+  interface NuxtOptions { ['apollo']?: ModuleOptions }
+  interface RuntimeConfig extends ModuleRuntimeConfig {}
+  interface PublicRuntimeConfig extends ModulePublicRuntimeConfig {}
 }
 
 
-export { ErrorResponse } from './module'
+export type { ErrorResponse } from './module'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gambalabs/apollo",
-  "version": "6.0.0-alpha.16",
+  "version": "6.0.0-alpha.19",
   "license": "MIT",
   "repository": "https://github.com/GambaLabs/apollo",
   "homepage": "https://apollo.nuxtjs.org",
@@ -9,6 +9,10 @@
     ".": {
       "types": "./dist/types.d.ts",
       "import": "./dist/module.mjs"
+    },
+    "./config": {
+      "types": "./dist/config.d.ts",
+      "import": "./dist/config.mjs"
     }
   },
   "main": "./dist/module.mjs",
@@ -17,29 +21,30 @@
     "dist"
   ],
   "dependencies": {
-    "@apollo/client": "^3.8.7",
-    "@nuxt/kit": "^3.8.2",
+    "@apollo/client": "^3.9.5",
+    "@nuxt/kit": "^3.10.3",
     "@rollup/plugin-graphql": "^2.0.4",
-    "@vue/apollo-composable": "4.0.0-beta.4",
+    "@vue/apollo-composable": "^4.0.1",
     "apollo-upload-client": "^18.0.1",
     "crypto-hash": "^2.0.1",
-    "defu": "^6.1.3",
-    "destr": "^1.2.2",
+    "@vue/apollo-option": "^4.0.0",
+    "defu": "^6.1.4",
+    "destr": "^2.0.3",
     "graphql": "^16.8.1",
     "graphql-tag": "^2.12.6",
-    "graphql-ws": "^5.14.2",
+    "graphql-ws": "^5.15.0",
     "jiti": "^1.21.0",
     "ohash": "^1.1.3",
     "pusher-js": "^8.3.0"
   },
   "devDependencies": {
-    "@nuxt/module-builder": "^0.2.1",
-    "@nuxt/schema": "^3.8.2",
-    "@nuxt/ui": "^0.4.1",
+    "@nuxt/module-builder": "^0.5.5",
+    "@nuxt/schema": "^3.10.3",
+    "@nuxt/ui": "^2.14.1",
     "@nuxtjs/eslint-config-typescript": "^12.1.0",
-    "@types/node": "^18.18.13",
-    "eslint": "^8.54.0",
-    "nuxt": "^3.8.2"
+    "@types/node": "^20.11.24",
+    "eslint": "^8.57.0",
+    "nuxt": "^3.10.3"
   },
   "publishConfig": {
     "access": "public"
@@ -47,12 +52,14 @@
   "resolutions": {
     "@nuxtjs/apollo": "link:."
   },
-  "packageManager": "pnpm@7.29.1",
+  "packageManager": "pnpm@8.15.2",
   "scripts": {
-    "build": "nuxt-module-build",
+    "build": "nuxt-module-build build",
     "dev": "nuxi dev playground --dotenv .env --host",
     "dev:build": "nuxi build playground",
-    "dev:prepare": "nuxt-module-build --stub && nuxi prepare playground",
+    "dev:prepare": "nuxt-module-build build --stub && nuxi prepare playground",
+    "lint": "eslint --ext .js,.ts,.vue --ignore-path .gitignore .",
+    "lint:fix": "eslint --fix --ext .js,.ts,.vue --ignore-path .gitignore .",
     "release": "standard-version --prerelease alpha && git push --follow-tags && pnpm publish --tag next"
   }
 }