@apollo/client 3.13.9-rc.0 → 3.13.9

package/core/ApolloClient.d.ts

@@ -1,22 +1,20 @@
-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 { 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 { ObservableQuery } from "./ObservableQuery.js";
-import type { DefaultContext, MutateResult, OperationVariables, QueryResult, RefetchQueriesInclude, RefetchQueriesOptions, RefetchQueriesResult, SubscribeResult, SubscriptionObservable } from "./types.js";
-import type { MutationOptions, QueryOptions, SubscriptionOptions, WatchQueryOptions } from "./watchQueryOptions.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";
 export interface DefaultOptions {
     watchQuery?: Partial<WatchQueryOptions<any, any>>;
     query?: Partial<QueryOptions<any, any>>;
     mutate?: Partial<MutationOptions<any, any, any>>;
 }
-interface DevtoolsOptions {
+export 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.
      *
@@ -30,19 +28,32 @@ interface DevtoolsOptions {
      */
     name?: string;
 }
-export interface ApolloClientOptions {
+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>;
     /**
      * 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;
+    cache: ApolloCache<TCacheShape>;
     /**
      * The time interval (in milliseconds) before Apollo Client force-fetches queries after a server-side render.
      *
@@ -81,15 +92,19 @@ export interface ApolloClientOptions {
      * @defaultValue `false`
      */
     assumeImmutableResults?: boolean;
-    localState?: LocalState;
+    resolvers?: Resolvers | Resolvers[];
+    typeDefs?: string | string[] | DocumentNode | DocumentNode[];
+    fragmentMatcher?: FragmentMatcher;
     /**
-    *
-    */
-    clientAwareness?: ClientAwarenessLink.ClientAwarenessOptions;
+     * 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;
     /**
-    *
-    */
-    enhancedClientAwareness?: ClientAwarenessLink.EnhancedClientAwarenessOptions;
+     * 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;
     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.
@@ -103,42 +118,32 @@ export interface ApolloClientOptions {
      * @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 implements DataProxy {
+export declare class ApolloClient<TCacheShape> implements DataProxy {
     link: ApolloLink;
-    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;
+    cache: ApolloCache<TCacheShape>;
+    disableNetworkFetches: 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`.
      *
@@ -165,7 +170,7 @@ export declare class ApolloClient implements DataProxy {
      * });
      * ```
      */
-    constructor(options: ApolloClientOptions);
+    constructor(options: ApolloClientOptions<TCacheShape>);
     private connectToDevTools;
     /**
      * The `DocumentTransform` used to modify GraphQL documents before a request
@@ -173,12 +178,6 @@ export declare class ApolloClient 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.
@@ -203,7 +202,7 @@ export declare class ApolloClient implements DataProxy {
      * See [here](https://medium.com/apollo-stack/the-concepts-of-graphql-bc68bd819be3#.3mb0cbcmc) for
      * a description of store reactivity.
      */
-    watchQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: WatchQueryOptions<TVariables, TData>): ObservableQuery<TData, TVariables>;
+    watchQuery<T = any, TVariables extends OperationVariables = OperationVariables>(options: WatchQueryOptions<TVariables, T>): ObservableQuery<T, TVariables>;
     /**
      * This resolves a single query according to the options specified and
      * returns a `Promise` which is either resolved with the resulting data
@@ -213,7 +212,7 @@ export declare class ApolloClient 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<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: QueryOptions<TVariables, TData>): Promise<QueryResult<MaybeMasked<TData>>>;
+    query<T = any, TVariables extends OperationVariables = OperationVariables>(options: QueryOptions<TVariables, T>): Promise<ApolloQueryResult<MaybeMasked<T>>>;
     /**
      * 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
@@ -222,12 +221,12 @@ export declare class ApolloClient implements DataProxy {
      *
      * It takes options as an object with the following keys and values:
      */
-    mutate<TData = unknown, TVariables extends OperationVariables = OperationVariables, TCache extends ApolloCache = ApolloCache>(options: MutationOptions<TData, TVariables, TCache>): Promise<MutateResult<MaybeMasked<TData>>>;
+    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>>>;
     /**
      * This subscribes to a graphql subscription according to the options specified and returns an
      * `Observable` which either emits received data or an error.
      */
-    subscribe<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: SubscriptionOptions<TVariables, TData>): SubscriptionObservable<SubscribeResult<MaybeMasked<TData>>>;
+    subscribe<T = any, TVariables extends OperationVariables = OperationVariables>(options: SubscriptionOptions<TVariables, T>): Observable<FetchResult<MaybeMasked<T>>>;
     /**
      * 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
@@ -237,7 +236,7 @@ export declare class ApolloClient implements DataProxy {
      * @param optimistic - Set to `true` to allow `readQuery` to return
      * optimistic results. Is `false` by default.
      */
-    readQuery<TData = unknown, TVariables = OperationVariables>(options: DataProxy.Query<TVariables, TData>, optimistic?: boolean): Unmasked<TData> | null;
+    readQuery<T = any, TVariables = OperationVariables>(options: DataProxy.Query<TVariables, T>, optimistic?: boolean): Unmasked<T> | null;
     /**
      * Watches the cache store of the fragment according to the options specified
      * and returns an `Observable`. We can subscribe to this
@@ -254,7 +253,7 @@ export declare class ApolloClient implements DataProxy {
      * the cache to identify the fragment and optionally specify whether to react
      * to optimistic updates.
      */
-    watchFragment<TData = unknown, TVariables = OperationVariables>(options: WatchFragmentOptions<TData, TVariables>): Observable<WatchFragmentResult<TData>>;
+    watchFragment<TFragmentData = unknown, TVariables = OperationVariables>(options: WatchFragmentOptions<TFragmentData, TVariables>): Observable<WatchFragmentResult<TFragmentData>>;
     /**
      * 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
@@ -269,13 +268,13 @@ export declare class ApolloClient implements DataProxy {
      * @param optimistic - Set to `true` to allow `readFragment` to return
      * optimistic results. Is `false` by default.
      */
-    readFragment<T = unknown, TVariables = OperationVariables>(options: DataProxy.Fragment<TVariables, T>, optimistic?: boolean): Unmasked<T> | null;
+    readFragment<T = any, 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 = unknown, TVariables = OperationVariables>(options: DataProxy.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+    writeQuery<TData = any, 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
@@ -287,9 +286,9 @@ export declare class ApolloClient implements DataProxy {
      * in a document with multiple fragments then you must also specify a
      * `fragmentName`.
      */
-    writeFragment<TData = unknown, TVariables = OperationVariables>(options: DataProxy.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    writeFragment<TData = any, TVariables = OperationVariables>(options: DataProxy.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
     __actionHookForDevTools(cb: () => any): void;
-    __requestRaw(payload: GraphQLRequest): Observable<FetchResult<unknown>>;
+    __requestRaw(payload: GraphQLRequest): Observable<FormattedExecutionResult>;
     /**
      * 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
@@ -306,7 +305,7 @@ export declare class ApolloClient implements DataProxy {
      * re-execute any queries then you should make sure to stop watching any
      * active queries.
      */
-    resetStore(): Promise<QueryResult<any>[] | null>;
+    resetStore(): Promise<ApolloQueryResult<any>[] | null>;
     /**
      * Remove all data from the store. Unlike `resetStore`, `clearStore` will
      * not refetch any active queries.
@@ -336,7 +335,7 @@ export declare class ApolloClient implements DataProxy {
      * active queries.
      * Takes optional parameter `includeStandby` which will include queries in standby-mode when refetching.
      */
-    reFetchObservableQueries(includeStandby?: boolean): Promise<QueryResult<any>[]>;
+    reFetchObservableQueries(includeStandby?: boolean): Promise<ApolloQueryResult<any>[]>;
     /**
      * Refetches specified active queries. Similar to "reFetchObservableQueries()" but with a specific list of queries.
      *
@@ -348,7 +347,7 @@ export declare class ApolloClient implements DataProxy {
      * re-execute any queries then you should make sure to stop watching any
      * active queries.
      */
-    refetchQueries<TCache extends ApolloCache = ApolloCache, TResult = Promise<QueryResult<any>>>(options: RefetchQueriesOptions<TCache, TResult>): RefetchQueriesResult<TResult>;
+    refetchQueries<TCache extends ApolloCache<any> = ApolloCache<TCacheShape>, TResult = Promise<ApolloQueryResult<any>>>(options: RefetchQueriesOptions<TCache, TResult>): RefetchQueriesResult<TResult>;
     /**
      * Get all currently active `ObservableQuery` objects, in a `Map` keyed by
      * query ID strings.
@@ -360,11 +359,11 @@ export declare class ApolloClient 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): Set<ObservableQuery<any>>;
+    getObservableQueries(include?: RefetchQueriesInclude): Map<string, ObservableQuery<any>>;
     /**
      * Exposes the cache's complete state, in a serializable format for later restoration.
      */
-    extract(optimistic?: boolean): unknown;
+    extract(optimistic?: boolean): TCacheShape;
     /**
      * Replaces existing state in the cache (if any) with the values expressed by
      * `serializedState`.
@@ -372,7 +371,23 @@ export declare class ApolloClient implements DataProxy {
      * Called when hydrating a cache (server side rendering, or offline storage),
      * and also (potentially) during hot reloads.
      */
-    restore(serializedState: unknown): ApolloCache;
+    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;
     /**
      * Define a new ApolloLink (or link chain) that Apollo Client will use.
      */
@@ -394,6 +409,7 @@ export declare class ApolloClient implements DataProxy {
      * ```json
      *{
      *  limits:     {
+     *    parser: 1000,
      *    canonicalStringify: 1000,
      *    print: 2000,
      *    'documentTransform.cache': 2000,
@@ -409,6 +425,7 @@ export declare class ApolloClient implements DataProxy {
      *    'inMemoryCache.executeSubSelectedArray': 5000
      *  },
      *  sizes: {
+     *    parser: 26,
      *    canonicalStringify: 4,
      *    print: 14,
      *    addTypenameDocumentTransform: [
@@ -458,5 +475,4 @@ export declare class ApolloClient implements DataProxy {
      */
     getMemoryInternals?: typeof getApolloClientMemoryInternals;
 }
-export {};
-//# sourceMappingURL=ApolloClient.d.ts.map
+//# sourceMappingURL=ApolloClient.d.ts.map