@gambalabs/apollo 6.0.0-alpha.17 → 6.0.0-alpha.20

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.d410709a.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.d410709a.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.d410709a.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.d410709a.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.17",
+  "version": "6.0.0-alpha.20",
   "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.17";
+const version = "6.0.0-alpha.20";
+
+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 {};