@apollo/client 3.13.7 → 3.13.9-rc.0

package/core/ApolloClient.d.ts

@@ -1,20 +1,22 @@
-import type { DocumentNode, FormattedExecutionResult } from "graphql";
-import type { FetchResult, GraphQLRequest } from "../link/core/index.js";
-import { ApolloLink } from "../link/core/index.js";
-import type { ApolloCache, DataProxy, Reference } from "../cache/index.js";
-import type { DocumentTransform } from "../utilities/index.js";
-import type { Observable } from "../utilities/index.js";
-import type { UriFunction } from "../link/http/index.js";
+import type { Observable } from "rxjs";
+import type { ApolloCache, DataProxy, Reference } from "@apollo/client/cache";
+import type { WatchFragmentOptions, WatchFragmentResult } from "@apollo/client/cache";
+import type { Incremental } from "@apollo/client/incremental";
+import type { ApolloLink, FetchResult, GraphQLRequest } from "@apollo/client/link";
+import type { ClientAwarenessLink } from "@apollo/client/link/client-awareness";
+import type { LocalState } from "@apollo/client/local-state";
+import type { MaybeMasked, Unmasked } from "@apollo/client/masking";
+import type { DocumentTransform } from "@apollo/client/utilities";
+import { getApolloClientMemoryInternals } from "@apollo/client/utilities/internal";
 import type { ObservableQuery } from "./ObservableQuery.js";
-import type { ApolloQueryResult, DefaultContext, OperationVariables, Resolvers, RefetchQueriesOptions, RefetchQueriesResult, RefetchQueriesInclude } from "./types.js";
-import type { QueryOptions, WatchQueryOptions, MutationOptions, SubscriptionOptions } from "./watchQueryOptions.js";
-import type { FragmentMatcher } from "./LocalState.js";
+import type { DefaultContext, MutateResult, OperationVariables, QueryResult, RefetchQueriesInclude, RefetchQueriesOptions, RefetchQueriesResult, SubscribeResult, SubscriptionObservable } from "./types.js";
+import type { MutationOptions, QueryOptions, SubscriptionOptions, WatchQueryOptions } from "./watchQueryOptions.js";
 export interface DefaultOptions {
     watchQuery?: Partial<WatchQueryOptions<any, any>>;
     query?: Partial<QueryOptions<any, any>>;
     mutate?: Partial<MutationOptions<any, any, any>>;
 }
-export interface DevtoolsOptions {
+interface DevtoolsOptions {
     /**
      * If `true`, the [Apollo Client Devtools](https://www.apollographql.com/docs/react/development-testing/developer-tooling/#apollo-client-devtools) browser extension can connect to this `ApolloClient` instance.
      *
@@ -28,32 +30,19 @@ export interface DevtoolsOptions {
      */
     name?: string;
 }
-export interface ApolloClientOptions<TCacheShape> {
-    /**
-     * The URI of the GraphQL endpoint that Apollo Client will communicate with.
-     *
-     * One of `uri` or `link` is **required**. If you provide both, `link` takes precedence.
-     */
-    uri?: string | UriFunction;
-    credentials?: string;
-    /**
-     * An object representing headers to include in every HTTP request, such as `{Authorization: 'Bearer 1234'}`
-     *
-     * This value will be ignored when using the `link` option.
-     */
-    headers?: Record<string, string>;
+export interface ApolloClientOptions {
     /**
      * You can provide an `ApolloLink` instance to serve as Apollo Client's network layer. For more information, see [Advanced HTTP networking](https://www.apollographql.com/docs/react/networking/advanced-http-networking/).
      *
      * One of `uri` or `link` is **required**. If you provide both, `link` takes precedence.
      */
-    link?: ApolloLink;
+    link: ApolloLink;
     /**
      * The cache that Apollo Client should use to store query results locally. The recommended cache is `InMemoryCache`, which is provided by the `@apollo/client` package.
      *
      * For more information, see [Configuring the cache](https://www.apollographql.com/docs/react/caching/cache-configuration/).
      */
-    cache: ApolloCache<TCacheShape>;
+    cache: ApolloCache;
     /**
      * The time interval (in milliseconds) before Apollo Client force-fetches queries after a server-side render.
      *
@@ -92,19 +81,15 @@ export interface ApolloClientOptions<TCacheShape> {
      * @defaultValue `false`
      */
     assumeImmutableResults?: boolean;
-    resolvers?: Resolvers | Resolvers[];
-    typeDefs?: string | string[] | DocumentNode | DocumentNode[];
-    fragmentMatcher?: FragmentMatcher;
+    localState?: LocalState;
     /**
-     * A custom name (e.g., `iOS`) that identifies this particular client among your set of clients. Apollo Server and Apollo Studio use this property as part of the [client awareness](https://www.apollographql.com/docs/apollo-server/monitoring/metrics#identifying-distinct-clients) feature.
-     */
-    name?: string;
+    *
+    */
+    clientAwareness?: ClientAwarenessLink.ClientAwarenessOptions;
     /**
-     * A custom version that identifies the current version of this particular client (e.g., `1.2`). Apollo Server and Apollo Studio use this property as part of the [client awareness](https://www.apollographql.com/docs/apollo-server/monitoring/metrics#identifying-distinct-clients) feature.
-     *
-     * This is **not** the version of Apollo Client that you are using, but rather any version string that helps you differentiate between versions of your client.
-     */
-    version?: string;
+    *
+    */
+    enhancedClientAwareness?: ClientAwarenessLink.EnhancedClientAwarenessOptions;
     documentTransform?: DocumentTransform;
     /**
      * Configuration used by the [Apollo Client Devtools extension](https://www.apollographql.com/docs/react/development-testing/developer-tooling/#apollo-client-devtools) for this client.
@@ -118,32 +103,42 @@ export interface ApolloClientOptions<TCacheShape> {
      * @defaultValue false
      */
     dataMasking?: boolean;
+    /**
+     * Determines the strategy used to parse incremental chunks from `@defer`
+     * queries.
+     */
+    incrementalHandler?: Incremental.Handler<any>;
 }
-import { mergeOptions } from "../utilities/index.js";
-import { getApolloClientMemoryInternals } from "../utilities/caching/getMemoryInternals.js";
-import type { WatchFragmentOptions, WatchFragmentResult } from "../cache/core/cache.js";
-import type { MaybeMasked, Unmasked } from "../masking/index.js";
-export { mergeOptions };
 /**
  * This is the primary Apollo Client class. It is used to send GraphQL documents (i.e. queries
  * and mutations) to a GraphQL spec-compliant server over an `ApolloLink` instance,
  * receive results from the server and cache the results in a store. It also delivers updates
  * to GraphQL queries through `Observable` instances.
  */
-export declare class ApolloClient<TCacheShape> implements DataProxy {
+export declare class ApolloClient implements DataProxy {
     link: ApolloLink;
-    cache: ApolloCache<TCacheShape>;
-    disableNetworkFetches: boolean;
+    cache: ApolloCache;
+    /**
+     * @deprecated `disableNetworkFetches` has been renamed to `prioritizeCacheValues`.
+     */
+    disableNetworkFetches: never;
+    set prioritizeCacheValues(value: boolean);
+    /**
+     * Whether to prioritize cache values over network results when `query` or `watchQuery` is called.
+     * This will essentially turn a `"network-only"` or `"cache-and-network"` fetchPolicy into a `"cache-first"` fetchPolicy,
+     * but without influencing the `fetchPolicy` of the created `ObservableQuery` long-term.
+     *
+     * This can e.g. be used to prioritize the cache during the first render after SSR.
+     */
+    get prioritizeCacheValues(): boolean;
     version: string;
     queryDeduplication: boolean;
     defaultOptions: DefaultOptions;
-    readonly typeDefs: ApolloClientOptions<TCacheShape>["typeDefs"];
     readonly devtoolsConfig: DevtoolsOptions;
     private queryManager;
     private devToolsHookCb?;
     private resetStoreCallbacks;
     private clearStoreCallbacks;
-    private localState;
     /**
      * Constructs an instance of `ApolloClient`.
      *
@@ -170,7 +165,7 @@ export declare class ApolloClient<TCacheShape> implements DataProxy {
      * });
      * ```
      */
-    constructor(options: ApolloClientOptions<TCacheShape>);
+    constructor(options: ApolloClientOptions);
     private connectToDevTools;
     /**
      * The `DocumentTransform` used to modify GraphQL documents before a request
@@ -178,6 +173,12 @@ export declare class ApolloClient<TCacheShape> implements DataProxy {
      * default document transform.
      */
     get documentTransform(): DocumentTransform;
+    /**
+     * The configured `LocalState` instance used to enable the use of `@client`
+     * fields.
+     */
+    get localState(): LocalState | undefined;
+    set localState(localState: LocalState);
     /**
      * Call this method to terminate any active client processes, making it safe
      * to dispose of this `ApolloClient` instance.
@@ -202,7 +203,7 @@ export declare class ApolloClient<TCacheShape> implements DataProxy {
      * See [here](https://medium.com/apollo-stack/the-concepts-of-graphql-bc68bd819be3#.3mb0cbcmc) for
      * a description of store reactivity.
      */
-    watchQuery<T = any, TVariables extends OperationVariables = OperationVariables>(options: WatchQueryOptions<TVariables, T>): ObservableQuery<T, TVariables>;
+    watchQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: WatchQueryOptions<TVariables, TData>): ObservableQuery<TData, TVariables>;
     /**
      * This resolves a single query according to the options specified and
      * returns a `Promise` which is either resolved with the resulting data
@@ -212,7 +213,7 @@ export declare class ApolloClient<TCacheShape> implements DataProxy {
      * describe how this query should be treated e.g. whether it should hit the
      * server at all or just resolve from the cache, etc.
      */
-    query<T = any, TVariables extends OperationVariables = OperationVariables>(options: QueryOptions<TVariables, T>): Promise<ApolloQueryResult<MaybeMasked<T>>>;
+    query<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: QueryOptions<TVariables, TData>): Promise<QueryResult<MaybeMasked<TData>>>;
     /**
      * This resolves a single mutation according to the options specified and returns a
      * Promise which is either resolved with the resulting data or rejected with an
@@ -221,12 +222,12 @@ export declare class ApolloClient<TCacheShape> implements DataProxy {
      *
      * It takes options as an object with the following keys and values:
      */
-    mutate<TData = any, TVariables extends OperationVariables = OperationVariables, TContext extends Record<string, any> = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>>(options: MutationOptions<TData, TVariables, TContext>): Promise<FetchResult<MaybeMasked<TData>>>;
+    mutate<TData = unknown, TVariables extends OperationVariables = OperationVariables, TCache extends ApolloCache = ApolloCache>(options: MutationOptions<TData, TVariables, TCache>): Promise<MutateResult<MaybeMasked<TData>>>;
     /**
      * This subscribes to a graphql subscription according to the options specified and returns an
      * `Observable` which either emits received data or an error.
      */
-    subscribe<T = any, TVariables extends OperationVariables = OperationVariables>(options: SubscriptionOptions<TVariables, T>): Observable<FetchResult<MaybeMasked<T>>>;
+    subscribe<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: SubscriptionOptions<TVariables, TData>): SubscriptionObservable<SubscribeResult<MaybeMasked<TData>>>;
     /**
      * Tries to read some data from the store in the shape of the provided
      * GraphQL query without making a network request. This method will start at
@@ -236,7 +237,7 @@ export declare class ApolloClient<TCacheShape> implements DataProxy {
      * @param optimistic - Set to `true` to allow `readQuery` to return
      * optimistic results. Is `false` by default.
      */
-    readQuery<T = any, TVariables = OperationVariables>(options: DataProxy.Query<TVariables, T>, optimistic?: boolean): Unmasked<T> | null;
+    readQuery<TData = unknown, TVariables = OperationVariables>(options: DataProxy.Query<TVariables, TData>, optimistic?: boolean): Unmasked<TData> | null;
     /**
      * Watches the cache store of the fragment according to the options specified
      * and returns an `Observable`. We can subscribe to this
@@ -253,7 +254,7 @@ export declare class ApolloClient<TCacheShape> implements DataProxy {
      * the cache to identify the fragment and optionally specify whether to react
      * to optimistic updates.
      */
-    watchFragment<TFragmentData = unknown, TVariables = OperationVariables>(options: WatchFragmentOptions<TFragmentData, TVariables>): Observable<WatchFragmentResult<TFragmentData>>;
+    watchFragment<TData = unknown, TVariables = OperationVariables>(options: WatchFragmentOptions<TData, TVariables>): Observable<WatchFragmentResult<TData>>;
     /**
      * Tries to read some data from the store in the shape of the provided
      * GraphQL fragment without making a network request. This method will read a
@@ -268,13 +269,13 @@ export declare class ApolloClient<TCacheShape> implements DataProxy {
      * @param optimistic - Set to `true` to allow `readFragment` to return
      * optimistic results. Is `false` by default.
      */
-    readFragment<T = any, TVariables = OperationVariables>(options: DataProxy.Fragment<TVariables, T>, optimistic?: boolean): Unmasked<T> | null;
+    readFragment<T = unknown, TVariables = OperationVariables>(options: DataProxy.Fragment<TVariables, T>, optimistic?: boolean): Unmasked<T> | null;
     /**
      * Writes some data in the shape of the provided GraphQL query directly to
      * the store. This method will start at the root query. To start at a
      * specific id returned by `dataIdFromObject` then use `writeFragment`.
      */
-    writeQuery<TData = any, TVariables = OperationVariables>(options: DataProxy.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+    writeQuery<TData = unknown, TVariables = OperationVariables>(options: DataProxy.WriteQueryOptions<TData, TVariables>): Reference | undefined;
     /**
      * Writes some data in the shape of the provided GraphQL fragment directly to
      * the store. This method will write to a GraphQL fragment from any arbitrary
@@ -286,9 +287,9 @@ export declare class ApolloClient<TCacheShape> implements DataProxy {
      * in a document with multiple fragments then you must also specify a
      * `fragmentName`.
      */
-    writeFragment<TData = any, TVariables = OperationVariables>(options: DataProxy.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    writeFragment<TData = unknown, TVariables = OperationVariables>(options: DataProxy.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
     __actionHookForDevTools(cb: () => any): void;
-    __requestRaw(payload: GraphQLRequest): Observable<FormattedExecutionResult>;
+    __requestRaw(payload: GraphQLRequest): Observable<FetchResult<unknown>>;
     /**
      * Resets your entire store by clearing out your cache and then re-executing
      * all of your active queries. This makes it so that you may guarantee that
@@ -305,7 +306,7 @@ export declare class ApolloClient<TCacheShape> implements DataProxy {
      * re-execute any queries then you should make sure to stop watching any
      * active queries.
      */
-    resetStore(): Promise<ApolloQueryResult<any>[] | null>;
+    resetStore(): Promise<QueryResult<any>[] | null>;
     /**
      * Remove all data from the store. Unlike `resetStore`, `clearStore` will
      * not refetch any active queries.
@@ -335,7 +336,7 @@ export declare class ApolloClient<TCacheShape> implements DataProxy {
      * active queries.
      * Takes optional parameter `includeStandby` which will include queries in standby-mode when refetching.
      */
-    reFetchObservableQueries(includeStandby?: boolean): Promise<ApolloQueryResult<any>[]>;
+    reFetchObservableQueries(includeStandby?: boolean): Promise<QueryResult<any>[]>;
     /**
      * Refetches specified active queries. Similar to "reFetchObservableQueries()" but with a specific list of queries.
      *
@@ -347,7 +348,7 @@ export declare class ApolloClient<TCacheShape> implements DataProxy {
      * re-execute any queries then you should make sure to stop watching any
      * active queries.
      */
-    refetchQueries<TCache extends ApolloCache<any> = ApolloCache<TCacheShape>, TResult = Promise<ApolloQueryResult<any>>>(options: RefetchQueriesOptions<TCache, TResult>): RefetchQueriesResult<TResult>;
+    refetchQueries<TCache extends ApolloCache = ApolloCache, TResult = Promise<QueryResult<any>>>(options: RefetchQueriesOptions<TCache, TResult>): RefetchQueriesResult<TResult>;
     /**
      * Get all currently active `ObservableQuery` objects, in a `Map` keyed by
      * query ID strings.
@@ -359,11 +360,11 @@ export declare class ApolloClient<TCacheShape> implements DataProxy {
      * by passing "all" instead of "active", or you can include just a subset of
      * active queries by passing an array of query names or DocumentNode objects.
      */
-    getObservableQueries(include?: RefetchQueriesInclude): Map<string, ObservableQuery<any>>;
+    getObservableQueries(include?: RefetchQueriesInclude): Set<ObservableQuery<any>>;
     /**
      * Exposes the cache's complete state, in a serializable format for later restoration.
      */
-    extract(optimistic?: boolean): TCacheShape;
+    extract(optimistic?: boolean): unknown;
     /**
      * Replaces existing state in the cache (if any) with the values expressed by
      * `serializedState`.
@@ -371,23 +372,7 @@ export declare class ApolloClient<TCacheShape> implements DataProxy {
      * Called when hydrating a cache (server side rendering, or offline storage),
      * and also (potentially) during hot reloads.
      */
-    restore(serializedState: TCacheShape): ApolloCache<TCacheShape>;
-    /**
-     * Add additional local resolvers.
-     */
-    addResolvers(resolvers: Resolvers | Resolvers[]): void;
-    /**
-     * Set (override existing) local resolvers.
-     */
-    setResolvers(resolvers: Resolvers | Resolvers[]): void;
-    /**
-     * Get all registered local resolvers.
-     */
-    getResolvers(): Resolvers;
-    /**
-     * Set a custom local state fragment matcher.
-     */
-    setLocalStateFragmentMatcher(fragmentMatcher: FragmentMatcher): void;
+    restore(serializedState: unknown): ApolloCache;
     /**
      * Define a new ApolloLink (or link chain) that Apollo Client will use.
      */
@@ -409,7 +394,6 @@ export declare class ApolloClient<TCacheShape> implements DataProxy {
      * ```json
      *{
      *  limits:     {
-     *    parser: 1000,
      *    canonicalStringify: 1000,
      *    print: 2000,
      *    'documentTransform.cache': 2000,
@@ -425,7 +409,6 @@ export declare class ApolloClient<TCacheShape> implements DataProxy {
      *    'inMemoryCache.executeSubSelectedArray': 5000
      *  },
      *  sizes: {
-     *    parser: 26,
      *    canonicalStringify: 4,
      *    print: 14,
      *    addTypenameDocumentTransform: [
@@ -475,4 +458,5 @@ export declare class ApolloClient<TCacheShape> implements DataProxy {
      */
     getMemoryInternals?: typeof getApolloClientMemoryInternals;
 }
-//# sourceMappingURL=ApolloClient.d.ts.map
+export {};
+//# sourceMappingURL=ApolloClient.d.ts.map