@gambalabs/apollo 6.0.0-alpha.10

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Sebastien Chopin (@Atinux)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,47 @@
+![Nuxt Apollo](./docs/public/cover.jpg)
+
+<h1 align="center">Nuxt Apollo</h1>
+
+<p align="center">Effortlessly integrate GraphQL into your Nuxt 3 projects.</p>
+
+<p align="center">
+  <!-- <a href="https://github.com/nuxt-community/apollo-module/actions?query=branch%3Amain+event%3Apush">
+    <img alt="CI" src="https://github.com/nuxt-community/apollo-module/actions/workflows/ci.yml/badge.svg?branch=main"/>
+  </a> -->
+  
+  <a href="https://npmjs.com/package/@nuxtjs/apollo/v/next">
+      <img alt="Version" src="https://img.shields.io/npm/v/@nuxtjs/apollo/next?color=blue&style=flat-square"/>
+  </a>
+  
+  <a href="https://npmjs.com/package/@nuxtjs/apollo/v/next">
+      <img alt="Downloads" src="https://img.shields.io/npm/dt/@nuxtjs/apollo/next?color=blue&style=flat-square"/>
+  </a>
+  
+  <a href="https://opensource.org/licenses/MIT">
+      <img alt="MIT" src="https://img.shields.io/badge/License-MIT-blue.svg?style=flat-square"/>
+  </a>
+</p>
+
+❯  [📖 Documentation](https://apollo.nuxtjs.org)
+
+---
+
+**Note:** This branch is for **Nuxt 3** compatible module. Checkout the [`v4` branch](https://github.com/nuxt-modules/apollo/tree/v4) for **Nuxt 2** support. 
+
+---
+
+## Preview
+
+[![Open in StackBlitz](https://developer.stackblitz.com/img/open_in_stackblitz.svg)](https://stackblitz.com/edit/nuxt-apollo-demo)
+
+## Development
+
+- Clone this repository
+- Ensure you have the latest LTS version of Node.js installed
+- Run `corepack enable`
+- Install dependencies using `pnpm install`
+- Start playground with `pnpm dev`
+
+## License
+
+[MIT License](./LICENSE)

package/dist/module.cjs

@@ -0,0 +1,5 @@
+module.exports = function(...args) {
+  return import('./module.mjs').then(m => m.default.call(this, ...args))
+}
+const _meta = module.exports.meta = require('./module.json')
+module.exports.getMeta = () => Promise.resolve(_meta)

package/dist/module.d.ts

@@ -0,0 +1,235 @@
+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';
+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
+}
+
+type ModuleOptions = NuxtApolloConfig;
+declare const _default: _nuxt_schema.NuxtModule<NuxtApolloConfig<any>>;
+
+declare const defineApolloClient: (config: ClientConfig) => ClientConfig;
+declare module '#app' {
+    interface RuntimeConfig {
+        apollo: NuxtApolloConfig<any>;
+        public: {
+            apollo: NuxtApolloConfig<any>;
+        };
+    }
+    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;
+    }
+}
+
+export { ClientConfig, ModuleOptions, _default as default, defineApolloClient };

package/dist/module.json

@@ -0,0 +1,8 @@
+{
+  "name": "@gambalabs/apollo",
+  "version": "6.0.0-alpha.10",
+  "configKey": "apollo",
+  "compatibility": {
+    "nuxt": "^3.0.0-rc.9"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,161 @@
+import { existsSync } from 'fs';
+import jiti from 'jiti';
+import { defu } from 'defu';
+import { useLogger, defineNuxtModule, createResolver, addTemplate, addPlugin, addImports } from '@nuxt/kit';
+import GraphQLPlugin from '@rollup/plugin-graphql';
+
+const name = "@gambalabs/apollo";
+const version = "6.0.0-alpha.10";
+
+const logger = useLogger(name);
+async function readConfigFile(path) {
+  return await jiti(import.meta.url, { esmResolve: true, interopDefault: true, requireCache: false })(path);
+}
+const module = defineNuxtModule({
+  meta: {
+    name,
+    version,
+    configKey: "apollo",
+    compatibility: {
+      nuxt: "^3.0.0-rc.9"
+    }
+  },
+  defaults: {
+    autoImports: true,
+    authType: "Bearer",
+    authHeader: "Authorization",
+    csrfHeader: "X-CSRF-TOKEN",
+    tokenStorage: "cookie",
+    proxyCookies: true,
+    cookieAttributes: {
+      maxAge: 60 * 60 * 24 * 7,
+      secure: process.env.NODE_ENV === "production"
+    },
+    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.");
+    }
+    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"),
+      "@wry/context",
+      "@apollo/client",
+      "@vue/apollo-composable",
+      "ts-invariant/process"
+    );
+    const clients = {};
+    const configPaths = {};
+    async function prepareClients() {
+      for (let [k, v] of Object.entries(options.clients || {})) {
+        if (typeof v === "string") {
+          const path = rootResolver.resolve(v);
+          const resolvedConfig = existsSync(path) && await readConfigFile(path);
+          if (!resolvedConfig) {
+            logger.warn(`Unable to resolve Apollo config for client: ${k}`);
+            continue;
+          }
+          v = resolvedConfig;
+          if (!configPaths[k]) {
+            configPaths[k] = path;
+          }
+        }
+        v.authType = v?.authType || (v?.authType === "" || v?.authType === null) ? null : options.authType;
+        v.authHeader = v?.authHeader || options.authHeader;
+        v.csrfHeader = v?.csrfHeader || options.csrfHeader;
+        v.tokenName = v?.tokenName || `apollo:${k}.token`;
+        v.tokenStorage = v?.tokenStorage || options.tokenStorage;
+        if (v.cookieAttributes) {
+          v.cookieAttributes = defu(v?.cookieAttributes, options.cookieAttributes);
+        }
+        v.defaultOptions = v?.defaultOptions || options.defaultOptions;
+        if (!v?.httpEndpoint && !v?.wsEndpoint) {
+          logger.error(`Either \`httpEndpoint\` or \`wsEndpoint\` must be provided for client: \`${k}\``);
+        }
+        clients[k] = v;
+      }
+    }
+    addTemplate({
+      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 }"
+      ].join("\n")
+    });
+    nuxt.options.alias["#apollo"] = addTemplate({
+      filename: "apollo.mjs",
+      getContents: () => [
+        "export default {",
+        ` proxyCookies: ${options.proxyCookies},`,
+        ` clientAwareness: ${options.clientAwareness},`,
+        ` cookieAttributes: ${JSON.stringify(options.cookieAttributes)},`,
+        ` clients: ${JSON.stringify(clients)}`,
+        "}"
+      ].join("\n")
+    }).dst;
+    addPlugin(resolve("runtime/plugin"));
+    addImports([
+      { name: "gql", from: "graphql-tag" },
+      ...[
+        "useApollo",
+        "useAsyncQuery",
+        "useLazyAsyncQuery"
+      ].map((n) => ({ name: n, from: resolve("runtime/composables") })),
+      ...!options?.autoImports ? [] : [
+        "useQuery",
+        "useLazyQuery",
+        "useMutation",
+        "useSubscription",
+        "useApolloClient",
+        "useQueryLoading",
+        "useMutationLoading",
+        "useSubscriptionLoading",
+        "useGlobalQueryLoading",
+        "useGlobalMutationLoading",
+        "useGlobalSubscriptionLoading"
+      ].map((n) => ({ name: n, from: "@vue/apollo-composable" }))
+    ]);
+    nuxt.hook("vite:extendConfig", (config) => {
+      config.optimizeDeps = config.optimizeDeps || {};
+      config.optimizeDeps.exclude = config.optimizeDeps.exclude || [];
+      config.optimizeDeps.exclude.push("@vue/apollo-composable");
+      config.plugins = config.plugins || [];
+      config.plugins.push(GraphQLPlugin());
+      if (!nuxt.options.dev) {
+        config.define = { ...config.define, __DEV__: false };
+      }
+    });
+    nuxt.hook("webpack:config", (configs) => {
+      for (const config of configs) {
+        const hasGqlLoader = config.module.rules.some((rule) => rule?.use === "graphql-tag/loader");
+        if (hasGqlLoader) {
+          return;
+        }
+        config.module.rules.push({
+          test: /\.(graphql|gql)$/,
+          use: "graphql-tag/loader",
+          exclude: /(node_modules)/
+        });
+      }
+    });
+    nuxt.hook("builder:watch", async (_event, path) => {
+      if (!Object.values(configPaths).some((p) => p.includes(path))) {
+        return;
+      }
+      logger.log("[@nuxtjs/apollo] Reloading Apollo configuration");
+      await prepareClients();
+      await nuxt.callHook("builder:generateApp");
+    });
+    await prepareClients();
+  }
+});
+const defineApolloClient = (config) => config;
+
+export { module as default, defineApolloClient };

package/dist/runtime/composables.d.ts

@@ -0,0 +1,45 @@
+import type { OperationVariables, QueryOptions } from '@apollo/client';
+import type { AsyncData } from 'nuxt/dist/app/composables';
+type TQuery<T> = QueryOptions<OperationVariables, T>['query'];
+type TVariables<T> = QueryOptions<OperationVariables, T>['variables'];
+type TAsyncQuery<T> = {
+    query: TQuery<T>;
+    variables?: TVariables<T>;
+    key?: string;
+    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: () => {
+    /**
+     * 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;
+    /**
+     * 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?: string, client?: string, 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.
+     * */
+    onLogout: (client?: string, skipResetStore?: boolean) => Promise<void>;
+};
+export {};

package/dist/runtime/composables.mjs

@@ -0,0 +1,92 @@
+import { hash } from "ohash";
+import { print } from "graphql";
+import { ref, useCookie, useNuxtApp, useAsyncData } from "#imports";
+import NuxtApollo from "#build/apollo";
+export function useAsyncQuery(...args) {
+  const { key, fn } = prep(...args);
+  return useAsyncData(key, fn);
+}
+export function useLazyAsyncQuery(...args) {
+  const { key, fn } = prep(...args);
+  return useAsyncData(key, fn, { 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;
+  if (!clientId || !clients?.[clientId]) {
+    clientId = clients?.default ? "default" : Object.keys(clients)[0];
+  }
+  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 };
+};
+export const useApollo = () => {
+  const nuxtApp = useNuxtApp();
+  const getToken = async (client) => {
+    client = client || "default";
+    const conf = NuxtApollo?.clients?.[client];
+    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;
+  };
+  const updateAuth = async ({ token, client, mode, skipResetStore }) => {
+    client = client || "default";
+    const conf = NuxtApollo?.clients?.[client];
+    const tokenName = client && conf.tokenName;
+    if (conf?.tokenStorage === "cookie") {
+      const cookieOpts = client && conf?.cookieAttributes || NuxtApollo?.cookieAttributes;
+      const cookie = useCookie(tokenName, cookieOpts);
+      if (!cookie.value && mode === "logout") {
+        return;
+      }
+      cookie.value = mode === "login" && token || null;
+    } else if (process.client && conf?.tokenStorage === "localStorage") {
+      if (mode === "login" && token) {
+        localStorage.setItem(tokenName, token);
+      } else if (mode === "logout") {
+        localStorage.removeItem(tokenName);
+      }
+    }
+    if (nuxtApp?._apolloWsClients?.[client]) {
+      nuxtApp._apolloWsClients[client].restart();
+    }
+    if (skipResetStore) {
+      return;
+    }
+    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

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/plugin.mjs

@@ -0,0 +1,189 @@
+import destr from "destr";
+import { onError } from "@apollo/client/link/error";
+import { getMainDefinition } from "@apollo/client/utilities";
+import { ApolloClients, provideApolloClients } from "@vue/apollo-composable";
+import { ApolloClient, ApolloLink, InMemoryCache, split } from "@apollo/client/core";
+import createUploadLink from "apollo-upload-client/createUploadLink.mjs";
+import { createPersistedQueryLink } from "@apollo/client/link/persisted-queries";
+import { sha256 } from "crypto-hash";
+import { GraphQLWsLink } from "@apollo/client/link/subscriptions";
+import { setContext } from "@apollo/client/link/context";
+import Pusher from "pusher-js";
+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";
+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();
+      await nuxtApp.callHook("apollo:auth", { token, client: key });
+      if (!token.value) {
+        if (clientConfig.tokenStorage === "cookie") {
+          if (process.client) {
+            token.value = useCookie(clientConfig.tokenName).value;
+          } else if (requestCookies?.cookie) {
+            token.value = requestCookies.cookie.split(";").find((c) => c.trim().startsWith(`${clientConfig.tokenName}=`))?.split("=")?.[1];
+          }
+        } else if (process.client && clientConfig.tokenStorage === "localStorage") {
+          token.value = localStorage.getItem(clientConfig.tokenName);
+        }
+        if (!token.value) {
+          return;
+        }
+      }
+      const authScheme = !!token.value?.match(/^[a-zA-Z]+\s/)?.[0];
+      if (authScheme || clientConfig?.authType === null) {
+        return token.value;
+      }
+      return `${clientConfig?.authType} ${token.value}`;
+    };
+    const authLink = setContext(async (_, { headers }) => {
+      const auth = await getAuth();
+      if (!auth) {
+        return;
+      }
+      return {
+        headers: {
+          ...headers,
+          ...requestCookies && requestCookies,
+          [clientConfig.authHeader]: auth
+        }
+      };
+    });
+    const getCsrfToken = async () => {
+      const token = ref();
+      await nuxtApp.callHook("apollo:csrf", { token, client: key });
+      return token.value;
+    };
+    const csrfLink = setContext(async (_, { headers }) => {
+      const token = await getCsrfToken();
+      if (!token) {
+        return;
+      }
+      return {
+        headers: {
+          ...headers,
+          ...requestCookies && requestCookies,
+          [clientConfig.csrfHeader]: token
+        }
+      };
+    });
+    const contextLink = setContext(async (_, prevContext) => {
+      const context = ref(null);
+      await nuxtApp.callHook("apollo:link", { prevContext, context, client: key });
+      if (!context.value) {
+        return;
+      }
+      return context.value;
+    });
+    let baseLink = csrfLink.concat(authLink).concat(contextLink);
+    if (clientConfig.persistedQueries) {
+      const persistedLink = createPersistedQueryLink({ sha256, useGETForHashedQueries: true });
+      baseLink = baseLink.concat(persistedLink);
+    }
+    const httpEndLink = createUploadLink({
+      ...clientConfig?.httpLinkOptions && clientConfig.httpLinkOptions,
+      uri: process.client && clientConfig.browserHttpEndpoint || clientConfig.httpEndpoint,
+      headers: { ...clientConfig?.httpLinkOptions?.headers || {} }
+    });
+    const httpLink = baseLink.concat(httpEndLink);
+    let wsLink = null;
+    if (process.client && clientConfig.wsEndpoint) {
+      const wsClient = createRestartableClient({
+        ...clientConfig.wsLinkOptions,
+        url: clientConfig.wsEndpoint,
+        connectionParams: async () => {
+          const auth = await getAuth();
+          const csrf = await getCsrfToken();
+          if (!auth && !csrf) {
+            return;
+          }
+          return {
+            ...auth ? { [clientConfig.authHeader]: auth } : {},
+            ...csrf ? { [clientConfig.csrfHeader]: csrf } : {}
+          };
+        }
+      });
+      wsLink = new GraphQLWsLink(wsClient);
+      nuxtApp._apolloWsClients = nuxtApp._apolloWsClients || {};
+      nuxtApp._apolloWsClients[key] = wsClient;
+    }
+    let pusherLink = null;
+    if (process.client && clientConfig.pusher) {
+      pusherLink = new PusherLink({
+        pusher: new Pusher(clientConfig.pusher.pusherAppKey, {
+          wsHost: clientConfig.pusher.wsHost,
+          wsPort: clientConfig.pusher.wsPort,
+          forceTLS: clientConfig.pusher.forceTLS,
+          disableStats: true,
+          enabledTransports: ["ws", "wss"],
+          cluster: clientConfig.pusher.cluster,
+          channelAuthorization: {
+            endpoint: clientConfig.pusher.channelEndpoint,
+            headersProvider() {
+              const { token: csrfToken } = nuxtApp.$csrfToken();
+              const { token: authToken } = nuxtApp.$authToken();
+              return { "X-CSRF-Token": csrfToken.value, authorization: `Bearer ${authToken.value}` };
+            }
+          }
+        })
+      });
+    }
+    const errorLink = onError((err) => {
+      nuxtApp.callHook("apollo:error", err);
+    });
+    const link = pusherLink ? ApolloLink.from([
+      errorLink,
+      baseLink,
+      pusherLink,
+      httpEndLink
+    ]) : ApolloLink.from([
+      errorLink,
+      ...!wsLink ? [httpLink] : [
+        ...clientConfig?.websocketsOnly ? [wsLink] : [
+          split(
+            ({ query }) => {
+              const definition = getMainDefinition(query);
+              return definition.kind === "OperationDefinition" && definition.operation === "subscription";
+            },
+            wsLink,
+            httpLink
+          )
+        ]
+      ]
+    ]);
+    const cache = new InMemoryCache(clientConfig.inMemoryCacheOptions);
+    clients[key] = new ApolloClient({
+      link,
+      cache,
+      ...NuxtApollo.clientAwareness && { name: key },
+      ...process.server ? { ssrMode: true } : { ssrForceFetchDelay: 100 },
+      connectToDevTools: clientConfig.connectToDevTools || false,
+      defaultOptions: clientConfig?.defaultOptions
+    });
+    if (!clients?.default && !NuxtApollo?.clients?.default && key === Object.keys(NuxtApollo.clients)[0]) {
+      clients.default = clients[key];
+    }
+    const cacheKey = `_apollo:${key}`;
+    nuxtApp.hook("app:rendered", () => {
+      nuxtApp.payload.data[cacheKey] = cache.extract();
+    });
+    if (process.client && nuxtApp.payload.data[cacheKey]) {
+      cache.restore(destr(JSON.stringify(nuxtApp.payload.data[cacheKey])));
+    }
+  }
+  provideApolloClients(clients);
+  nuxtApp.vueApp.provide(ApolloClients, clients);
+  nuxtApp._apolloClients = clients;
+  const defaultClient = clients?.default;
+  return {
+    provide: {
+      apolloHelpers: useApollo(),
+      apollo: { clients, defaultClient }
+    }
+  };
+});

package/dist/runtime/pusher.d.ts

@@ -0,0 +1,10 @@
+export default PusherLink;
+declare class PusherLink extends ApolloLink {
+    constructor(options: any);
+    pusher: any;
+    request(operation: any, forward: any): Observable<any>;
+    subscribeToChannel(subscriptionChannel: any, event: string | undefined, observer: any): void;
+    unsubscribeFromChannel(subscriptionChannel: any): void;
+}
+import { ApolloLink } from '@apollo/client/core';
+import { Observable } from '@apollo/client/core';

package/dist/runtime/pusher.mjs

@@ -0,0 +1,100 @@
+import { ApolloLink, Observable } from '@apollo/client/core'
+
+// Inspired by https://github.com/rmosolgo/graphql-ruby/blob/master/javascript_client/src/subscriptions/PusherLink.ts
+class PusherLink extends ApolloLink {
+  constructor (options) {
+    super()
+
+    this.pusher = options.pusher
+  }
+
+  request (operation, forward) {
+    const subscribeObservable = new Observable((_observer) => {
+      //
+    })
+
+    // Capture the super method
+    const prevSubscribe =
+      subscribeObservable.subscribe.bind(subscribeObservable)
+
+    // Override subscribe to return an `unsubscribe` object, see
+    // https://github.com/apollographql/subscriptions-transport-ws/blob/master/src/client.ts#L182-L212
+    subscribeObservable.subscribe = (observerOrNext, onError, onComplete) => {
+      prevSubscribe(observerOrNext, onError, onComplete)
+
+      const observer = getObserver(observerOrNext, onError, onComplete)
+
+      let subscriptionChannel
+
+      forward(operation).subscribe({
+        next: (data) => {
+          // If the operation has the subscription channel, it's a subscription
+          subscriptionChannel =
+            data?.extensions?.lighthouse_subscriptions.channel ?? null
+          // No subscription found in the response, pipe data through
+          if (!subscriptionChannel) {
+            observer.next(data)
+            observer.complete()
+
+            return
+          }
+          const event = data?.extensions?.lighthouse_subscriptions.event ?? 'lighthouse-subscription'
+          this.subscribeToChannel(subscriptionChannel, event, observer)
+        }
+      })
+
+      // Return an object that will unsubscribe_if the query was a subscription
+      return {
+        closed: false,
+        unsubscribe: () => {
+          subscriptionChannel &&
+            this.unsubscribeFromChannel(subscriptionChannel)
+        }
+      }
+    }
+
+    return subscribeObservable
+  }
+
+  subscribeToChannel (subscriptionChannel, event = 'lighthouse-subscription', observer) {
+    this.pusher
+      .subscribe(subscriptionChannel)
+      .bind(event, (payload) => {
+        const { result } = payload
+        if (result) {
+          observer.next(result)
+        }
+        if (!payload.more) {
+          this.unsubscribeFromChannel(subscriptionChannel)
+
+          observer.complete()
+        }
+      })
+  }
+
+  unsubscribeFromChannel (subscriptionChannel) {
+    this.pusher.unsubscribe(subscriptionChannel)
+  }
+}
+
+// Turn `subscribe` arguments into an observer-like thing, see getObserver
+// https://github.com/apollographql/subscriptions-transport-ws/blob/master/src/client.ts#L329-L343
+function getObserver (observerOrNext, onError, onComplete) {
+  if (typeof observerOrNext === 'function') {
+    // Duck-type an observer
+    return {
+      next: v => observerOrNext(v),
+      error: e => onError && onError(e),
+      complete: () => onComplete && onComplete()
+    }
+  } else {
+    // Make an object that calls to the given object, with safety checks
+    return {
+      next: v => observerOrNext.next && observerOrNext.next(v),
+      error: e => observerOrNext.error && observerOrNext.error(e),
+      complete: () => observerOrNext.complete && observerOrNext.complete()
+    }
+  }
+}
+
+export default PusherLink

package/dist/runtime/ws.d.ts

@@ -0,0 +1,5 @@
+import type { Client, ClientOptions } from 'graphql-ws';
+export interface RestartableClient extends Client {
+    restart(): void;
+}
+export default function createRestartableClient(options: ClientOptions): RestartableClient;

package/dist/runtime/ws.mjs

@@ -0,0 +1,31 @@
+import { createClient } from "graphql-ws";
+export default function createRestartableClient(options) {
+  let restartRequested = false;
+  let restart = () => {
+    restartRequested = true;
+  };
+  const client = createClient({
+    ...options,
+    on: {
+      ...options.on,
+      opened: (socket) => {
+        options.on?.opened?.(socket);
+        restart = () => {
+          if (socket.readyState === WebSocket.OPEN) {
+            socket.close(4205, "Client Restart");
+          } else {
+            restartRequested = true;
+          }
+        };
+        if (restartRequested) {
+          restartRequested = false;
+          restart();
+        }
+      }
+    }
+  });
+  return {
+    ...client,
+    restart: () => restart()
+  };
+}

package/dist/types.d.ts

@@ -0,0 +1,10 @@
+
+import { ModuleOptions } from './module'
+
+declare module '@nuxt/schema' {
+  interface NuxtConfig { ['apollo']?: Partial<ModuleOptions> }
+  interface NuxtOptions { ['apollo']?: ModuleOptions }
+}
+
+
+export { ErrorResponse } from './module'

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@gambalabs/apollo",
+  "version": "6.0.0-alpha.10",
+  "license": "MIT",
+  "repository": "https://github.com/GambaLabs/apollo",
+  "homepage": "https://apollo.nuxtjs.org",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.ts",
+      "import": "./dist/module.mjs"
+    }
+  },
+  "main": "./dist/module.mjs",
+  "types": "./dist/module.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@apollo/client": "^3.8.7",
+    "@nuxt/kit": "^3.8.2",
+    "@rollup/plugin-graphql": "^2.0.4",
+    "@vue/apollo-composable": "4.0.0-beta.4",
+    "apollo-upload-client": "^18.0.1",
+    "crypto-hash": "^2.0.1",
+    "defu": "^6.1.3",
+    "destr": "^1.2.2",
+    "graphql": "^16.8.1",
+    "graphql-tag": "^2.12.6",
+    "graphql-ws": "^5.14.2",
+    "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",
+    "@nuxtjs/eslint-config-typescript": "^12.1.0",
+    "@types/node": "^18.18.13",
+    "eslint": "^8.54.0",
+    "nuxt": "^3.8.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "resolutions": {
+    "@nuxtjs/apollo": "link:."
+  },
+  "packageManager": "pnpm@7.29.1",
+  "scripts": {
+    "build": "nuxt-module-build",
+    "dev": "nuxi dev playground --dotenv .env --host",
+    "dev:build": "nuxi build playground",
+    "dev:prepare": "nuxt-module-build --stub && nuxi prepare playground",
+    "release": "standard-version --prerelease alpha && git push --follow-tags && pnpm publish --tag next"
+  }
+}