@apollo/client 4.0.0-rc.1 → 4.0.0-rc.10

package/__cjs/core/types.d.cts

@@ -6,51 +6,111 @@ import type { ClientAwarenessLink } from "@apollo/client/link/client-awareness";
 import type { Unmasked } from "@apollo/client/masking";
 import type { DeepPartial, HKT } from "@apollo/client/utilities";
 import type { ApplyHKTImplementationWithDefault, IsAny } from "@apollo/client/utilities/internal";
-import type { NetworkStatus } from "./networkStatus.cjs";
+import type { ApolloClient } from "./ApolloClient.cjs";
 import type { ObservableQuery } from "./ObservableQuery.cjs";
-import type { QueryOptions } from "./watchQueryOptions.cjs";
 export type { TypedDocumentNode } from "@graphql-typed-document-node/core";
-export type MethodKeys<T> = {
-    [P in keyof T]: T[P] extends Function ? P : never;
-}[keyof T];
 export interface TypeOverrides {
 }
 declare namespace OverridableTypes {
-    export interface Defaults {
+    interface Defaults {
+        Complete: Complete;
         Streaming: Streaming;
+        Partial: Partial;
+    }
+    interface Complete extends HKT {
+        arg1: unknown;
+        return: this["arg1"];
     }
     interface Streaming extends HKT {
         arg1: unknown;
         return: this["arg1"];
     }
-    export {};
+    interface Partial extends HKT {
+        arg1: unknown;
+        return: DeepPartial<this["arg1"]>;
+    }
+}
+export declare namespace DataValue {
+    /**
+     * Returns a representation of `TData` in it's "complete" state.
+     *
+     * @defaultValue `TData` if no overrides are provided.
+     *
+     * @example
+     * You can override this type globally - this example shows how to override it
+     * with `DeepPartial<TData>`:
+     *
+     * ```ts
+     * import { HKT, DeepPartial } from "@apollo/client/utilities";
+     *
+     * type CompleteOverride<TData> =
+     *   TData extends { _complete?: infer _Complete } ? _Complete : TData;
+     *
+     * interface CompleteOverrideHKT extends HKT {
+     *   return: CompleteOverride<this["arg1"]>;
+     * }
+     *
+     * declare module "@apollo/client" {
+     *   export interface TypeOverrides {
+     *     Complete: CompleteOverrideHKT;
+     *   }
+     * }
+     * ```
+     */
+    type Complete<TData> = ApplyHKTImplementationWithDefault<TypeOverrides, "Complete", OverridableTypes.Defaults, TData>;
+    /**
+     * Returns a representation of `TData` while it is streaming.
+     *
+     * @defaultValue `TData` if no overrides are provided.
+     *
+     * @example
+     * You can override this type globally - this example shows how to override it
+     * with `DeepPartial<TData>`:
+     *
+     * ```ts
+     * import { HKT, DeepPartial } from "@apollo/client/utilities";
+     *
+     * type StreamingOverride<TData> = DeepPartial<TData>;
+     *
+     * interface StreamingOverrideHKT extends HKT {
+     *   return: StreamingOverride<this["arg1"]>;
+     * }
+     *
+     * declare module "@apollo/client" {
+     *   export interface TypeOverrides {
+     *     Streaming: StreamingOverrideHKT;
+     *   }
+     * }
+     * ```
+     */
+    type Streaming<TData> = ApplyHKTImplementationWithDefault<TypeOverrides, "Streaming", OverridableTypes.Defaults, TData>;
+    /**
+     * Returns a representation of `TData` while it is partial.
+     *
+     * @defaultValue `DeepPartial<TData>` if no overrides are provided.
+     *
+     * @example
+     * You can override this type globally - this example shows how to override it
+     * with `DeepPartial<TData>`:
+     *
+     * ```ts
+     * import { HKT, DeepPartial } from "@apollo/client/utilities";
+     *
+     * type PartialOverride<TData> = DeepPartial<Complete<TData>>;
+     *
+     * interface PartialOverrideHKT extends HKT {
+     *   return: PartialOverride<this["arg1"]>;
+     * }
+     *
+     * declare module "@apollo/client" {
+     *   export interface TypeOverrides {
+     *     Partial: PartialOverrideHKT;
+     *   }
+     * }
+     * ```
+     */
+    type Partial<TData> = ApplyHKTImplementationWithDefault<TypeOverrides, "Partial", OverridableTypes.Defaults, TData>;
 }
-/**
- * Returns a representation of `TData` while it is streaming.
- *
- * @defaultValue `TData` if no overrides are provided.
- *
- * @example
- * You can override this type globally - this example shows how to override it
- * with `DeepPartial<TData>`:
- *
- * ```ts
- * import { HKT, DeepPartial } from "@apollo/client/utilities";
- *
- * type StreamingOverride<TData> = DeepPartial<TData>;
- *
- * interface StreamingOverrideHKT extends HKT {
- *   return: StreamingOverride<this["arg1"]>;
- * }
- *
- * declare module "@apollo/client" {
- *   export interface TypeOverrides {
- *     Streaming: StreamingOverrideHKT;
- *   }
- * }
- * ```
- */
-export type Streaming<TData> = ApplyHKTImplementationWithDefault<TypeOverrides, "Streaming", OverridableTypes.Defaults, TData>;
 export interface DefaultContext extends Record<string, any> {
     /**
      * Indicates whether `queryDeduplication` was enabled for the request.
@@ -65,12 +125,14 @@ export interface DefaultContext extends Record<string, any> {
  *
  * Apollo Client uses several types of errors throughout the client which can be
  * narrowed using `instanceof`:
+ *
  * - `CombinedGraphQLErrors` - `errors` returned from a GraphQL result
  * - `CombinedProtocolErrors` - Transport-level errors from multipart subscriptions.
  * - `ServerParseError` - A JSON-parse error when parsing the server response.
  * - `ServerError` - A non-200 server response.
  *
  * @example
+ *
  * ```ts
  * import { CombinedGraphQLErrors } from "@apollo/client";
  *
@@ -79,7 +141,7 @@ export interface DefaultContext extends Record<string, any> {
  * } catch (error) {
  *   // Use `instanceof` to check for more specific types of errors.
  *   if (error instanceof CombinedGraphQLErrors) {
- *     error.errors.map(graphQLError => console.log(graphQLError.message));
+ *     error.errors.map((graphQLError) => console.log(graphQLError.message));
  *   } else {
  *     console.error(errors);
  *   }
@@ -93,67 +155,112 @@ export interface ErrorLike {
 }
 export type OnQueryUpdated<TResult> = (observableQuery: ObservableQuery<any>, diff: Cache.DiffResult<any>, lastDiff: Cache.DiffResult<any> | undefined) => boolean | TResult;
 export type RefetchQueryDescriptor = string | DocumentNode;
-export type InternalRefetchQueryDescriptor = RefetchQueryDescriptor | QueryOptions;
+export type InternalRefetchQueryDescriptor = RefetchQueryDescriptor | ApolloClient.QueryOptions;
 type RefetchQueriesIncludeShorthand = "all" | "active";
 export type RefetchQueriesInclude = RefetchQueryDescriptor[] | RefetchQueriesIncludeShorthand;
 export type InternalRefetchQueriesInclude = InternalRefetchQueryDescriptor[] | RefetchQueriesIncludeShorthand;
-export interface RefetchQueriesOptions<TCache extends ApolloCache, TResult> {
-    updateCache?: (cache: TCache) => void;
-    include?: RefetchQueriesInclude;
-    optimistic?: boolean;
-    onQueryUpdated?: OnQueryUpdated<TResult> | null;
-}
-export type RefetchQueriesPromiseResults<TResult> = IsAny<TResult> extends true ? any[] : TResult extends boolean ? QueryResult<any>[] : TResult extends PromiseLike<infer U> ? U[] : TResult[];
-export interface RefetchQueriesResult<TResult> extends Promise<RefetchQueriesPromiseResults<TResult>> {
-    queries: ObservableQuery<any>[];
-    results: InternalRefetchQueriesResult<TResult>[];
-}
-export interface InternalRefetchQueriesOptions<TCache extends ApolloCache, TResult> extends Omit<RefetchQueriesOptions<TCache, TResult>, "include"> {
+export type RefetchQueriesPromiseResults<TResult> = IsAny<TResult> extends true ? any[] : TResult extends boolean ? ApolloClient.QueryResult<any>[] : TResult extends PromiseLike<infer U> ? U[] : TResult[];
+export interface InternalRefetchQueriesOptions<TCache extends ApolloCache, TResult> extends Omit<ApolloClient.RefetchQueriesOptions<TCache, TResult>, "include"> {
     include?: InternalRefetchQueriesInclude;
     removeOptimistic?: string;
 }
-export type InternalRefetchQueriesResult<TResult> = TResult extends boolean ? Promise<QueryResult<any>> : TResult;
+export type InternalRefetchQueriesResult<TResult> = TResult extends boolean ? Promise<ApolloClient.QueryResult<any>> : TResult;
 export type InternalRefetchQueriesMap<TResult> = Map<ObservableQuery<any>, InternalRefetchQueriesResult<TResult>>;
 export type OperationVariables = Record<string, any>;
-export type ApolloQueryResult<TData, TStates extends DataState<TData>["dataState"] = DataState<TData>["dataState"]> = {
-    /**
-     * The single Error object that is passed to onError and useQuery hooks, and is often thrown during manual `client.query` calls.
-     * This will contain both a NetworkError field and any GraphQLErrors.
-     * See https://www.apollographql.com/docs/react/data/error-handling/ for more information.
-     */
-    error?: ErrorLike;
-    loading: boolean;
-    networkStatus: NetworkStatus;
-    /**
-     * Describes whether `data` is a complete or partial result. This flag is only
-     * set when `returnPartialData` is `true` in query options.
-     *
-     * @deprecated This field will be removed in a future version of Apollo Client.
-     */
-    partial: boolean;
-} & GetDataState<TData, TStates>;
 export type DataState<TData> = {
-    data: TData;
     /**
-    * Describes the completeness of `data`. - `empty`: No data could be fulfilled from the cache or the result is incomplete. `data` is `undefined`. - `partial`: Some data could be fulfilled from the cache but `data` is incomplete. This is only possible when `returnPartialData` is `true`. - `streaming`: `data` is incomplete as a result of a deferred query and the result is still streaming in. - `complete`: `data` is a fully satisfied query result fulfilled either from the cache or network.
+    * An object containing the result of your GraphQL query after it completes.
+    * 
+    * This value might be `undefined` if a query results in one or more errors (depending on the query's `errorPolicy`).
+    * 
+    * @docGroup 1. Operation data
+    */
+    data: DataValue.Complete<TData>;
+    /**
+    * Describes the completeness of `data`.
+    * 
+    * - `empty`: No data could be fulfilled from the cache or the result is
+    *   incomplete. `data` is `undefined`.
+    * - `partial`: Some data could be fulfilled from the cache but `data` is
+    *   incomplete. This is only possible when `returnPartialData` is `true`.
+    * - `streaming`: `data` is incomplete as a result of a deferred query and
+    *   the result is still streaming in.
+    * - `complete`: `data` is a fully satisfied query result fulfilled
+    *   either from the cache or network.
+    * 
+    * @docGroup 1. Operation data
     */
     dataState: "complete";
 } | {
-    data: Streaming<TData>;
     /**
-    * Describes the completeness of `data`. - `empty`: No data could be fulfilled from the cache or the result is incomplete. `data` is `undefined`. - `partial`: Some data could be fulfilled from the cache but `data` is incomplete. This is only possible when `returnPartialData` is `true`. - `streaming`: `data` is incomplete as a result of a deferred query and the result is still streaming in. - `complete`: `data` is a fully satisfied query result fulfilled either from the cache or network.
+    * An object containing the result of your GraphQL query after it completes.
+    * 
+    * This value might be `undefined` if a query results in one or more errors (depending on the query's `errorPolicy`).
+    * 
+    * @docGroup 1. Operation data
+    */
+    data: DataValue.Streaming<TData>;
+    /**
+    * Describes the completeness of `data`.
+    * 
+    * - `empty`: No data could be fulfilled from the cache or the result is
+    *   incomplete. `data` is `undefined`.
+    * - `partial`: Some data could be fulfilled from the cache but `data` is
+    *   incomplete. This is only possible when `returnPartialData` is `true`.
+    * - `streaming`: `data` is incomplete as a result of a deferred query and
+    *   the result is still streaming in.
+    * - `complete`: `data` is a fully satisfied query result fulfilled
+    *   either from the cache or network.
+    * 
+    * @docGroup 1. Operation data
     */
     dataState: "streaming";
 } | {
-    data: DeepPartial<TData>;
     /**
-    * Describes the completeness of `data`. - `empty`: No data could be fulfilled from the cache or the result is incomplete. `data` is `undefined`. - `partial`: Some data could be fulfilled from the cache but `data` is incomplete. This is only possible when `returnPartialData` is `true`. - `streaming`: `data` is incomplete as a result of a deferred query and the result is still streaming in. - `complete`: `data` is a fully satisfied query result fulfilled either from the cache or network.
+    * An object containing the result of your GraphQL query after it completes.
+    * 
+    * This value might be `undefined` if a query results in one or more errors (depending on the query's `errorPolicy`).
+    * 
+    * @docGroup 1. Operation data
+    */
+    data: DataValue.Partial<TData>;
+    /**
+    * Describes the completeness of `data`.
+    * 
+    * - `empty`: No data could be fulfilled from the cache or the result is
+    *   incomplete. `data` is `undefined`.
+    * - `partial`: Some data could be fulfilled from the cache but `data` is
+    *   incomplete. This is only possible when `returnPartialData` is `true`.
+    * - `streaming`: `data` is incomplete as a result of a deferred query and
+    *   the result is still streaming in.
+    * - `complete`: `data` is a fully satisfied query result fulfilled
+    *   either from the cache or network.
+    * 
+    * @docGroup 1. Operation data
     */
     dataState: "partial";
 } | {
+    /**
+    * An object containing the result of your GraphQL query after it completes.
+    * 
+    * This value might be `undefined` if a query results in one or more errors (depending on the query's `errorPolicy`).
+    * 
+    * @docGroup 1. Operation data
+    */
     data: undefined;
     /**
-    * Describes the completeness of `data`. - `empty`: No data could be fulfilled from the cache or the result is incomplete. `data` is `undefined`. - `partial`: Some data could be fulfilled from the cache but `data` is incomplete. This is only possible when `returnPartialData` is `true`. - `streaming`: `data` is incomplete as a result of a deferred query and the result is still streaming in. - `complete`: `data` is a fully satisfied query result fulfilled either from the cache or network.
+    * Describes the completeness of `data`.
+    * 
+    * - `empty`: No data could be fulfilled from the cache or the result is
+    *   incomplete. `data` is `undefined`.
+    * - `partial`: Some data could be fulfilled from the cache but `data` is
+    *   incomplete. This is only possible when `returnPartialData` is `true`.
+    * - `streaming`: `data` is incomplete as a result of a deferred query and
+    *   the result is still streaming in.
+    * - `complete`: `data` is a fully satisfied query result fulfilled
+    *   either from the cache or network.
+    * 
+    * @docGroup 1. Operation data
     */
     dataState: "empty";
 };
@@ -165,19 +272,7 @@ export type GetDataState<TData, TState extends DataState<TData>["dataState"]> =
  * has been normalized into a plain GraphQL result. When the result is
  * still `streaming`, some fields might not yet be available.
  */
-export type NormalizedExecutionResult<TData = Record<string, unknown>, TExtensions = Record<string, unknown>> = Omit<FormattedExecutionResult<TData, TExtensions>, "data"> & ({
-    data: TData;
-    /**
-    * Describes the completeness of `data`. - `empty`: No data could be fulfilled from the cache or the result is incomplete. `data` is `undefined`. - `partial`: Some data could be fulfilled from the cache but `data` is incomplete. This is only possible when `returnPartialData` is `true`. - `streaming`: `data` is incomplete as a result of a deferred query and the result is still streaming in. - `complete`: `data` is a fully satisfied query result fulfilled either from the cache or network.
-    */
-    dataState: "complete";
-} | {
-    data: Streaming<TData>;
-    /**
-    * Describes the completeness of `data`. - `empty`: No data could be fulfilled from the cache or the result is incomplete. `data` is `undefined`. - `partial`: Some data could be fulfilled from the cache but `data` is incomplete. This is only possible when `returnPartialData` is `true`. - `streaming`: `data` is incomplete as a result of a deferred query and the result is still streaming in. - `complete`: `data` is a fully satisfied query result fulfilled either from the cache or network.
-    */
-    dataState: "streaming";
-});
+export type NormalizedExecutionResult<TData = Record<string, unknown>, TExtensions = Record<string, unknown>> = Omit<FormattedExecutionResult<TData, TExtensions>, "data"> & GetDataState<TData, "streaming" | "complete">;
 export type MutationQueryReducer<T> = (previousResult: Record<string, any>, options: {
     mutationResult: NormalizedExecutionResult<Unmasked<T>>;
     queryName: string | undefined;
@@ -188,80 +283,26 @@ export type MutationQueryReducersMap<T = {
 }> = {
     [queryName: string]: MutationQueryReducer<T>;
 };
-export type MutationUpdaterFunction<TData, TVariables, TCache extends ApolloCache> = (cache: TCache, result: FormattedExecutionResult<Unmasked<TData>>, options: {
+export type MutationUpdaterFunction<TData, TVariables extends OperationVariables, TCache extends ApolloCache> = (cache: TCache, result: FormattedExecutionResult<Unmasked<TData>>, options: {
     context?: DefaultContext;
     variables?: TVariables;
 }) => void;
-export interface MutateResult<TData = unknown> {
-    /**
-    * The data returned from your mutation. Can be `undefined` if `ignoreResults` is `true`.
-    */
-    data: TData | undefined;
-    /**
-    * If the mutation produces one or more errors, this object contains either an array of `graphQLErrors` or a single `networkError`. Otherwise, this value is `undefined`.
-    * 
-    * For more information, see [Handling operation errors](https://www.apollographql.com/docs/react/data/error-handling/).
-    */
-    error?: ErrorLike;
-    /**
-    * Custom extensions returned from the GraphQL server
-    */
-    extensions?: Record<string, unknown>;
-}
-export interface SubscribeResult<TData = unknown> {
-    /**
-    * The data returned from your mutation. Can be `undefined` if `ignoreResults` is `true`.
-    */
-    data: TData | undefined;
-    /**
-    * If the mutation produces one or more errors, this object contains either an array of `graphQLErrors` or a single `networkError`. Otherwise, this value is `undefined`.
-    * 
-    * For more information, see [Handling operation errors](https://www.apollographql.com/docs/react/data/error-handling/).
-    */
-    error?: ErrorLike;
-    /**
-    * Custom extensions returned from the GraphQL server
-    */
-    extensions?: Record<string, unknown>;
-}
-export interface QueryResult<TData = unknown> {
-    /**
-    * An object containing the result of your GraphQL query after it completes.
-    * 
-    * This value might be `undefined` if a query results in one or more errors (depending on the query's `errorPolicy`).
-    * 
-    * @docGroup
-    * 
-    * 1. Operation data
-    */
-    data: TData | undefined;
-    /**
-    * If the query produces one or more errors, this object contains either an array of `graphQLErrors` or a single `networkError`. Otherwise, this value is `undefined`.
-    * 
-    * For more information, see [Handling operation errors](https://www.apollographql.com/docs/react/data/error-handling/).
-    * 
-    * @docGroup
-    * 
-    * 1. Operation data
-    */
-    error?: ErrorLike;
-}
 export declare namespace QueryNotification {
-    type NewNetworkStatus<TData> = NextNotification<{
+    type NewNetworkStatus = NextNotification<{
         resetError?: boolean;
     }> & {
         source: "newNetworkStatus";
     };
-    type SetResult<TData> = NextNotification<ApolloQueryResult<TData>> & {
+    type SetResult<TData> = NextNotification<ObservableQuery.Result<TData>> & {
         source: "setResult";
     };
-    type FromNetwork<TData> = ObservableNotification<ApolloQueryResult<TData>> & {
+    type FromNetwork<TData> = ObservableNotification<ObservableQuery.Result<TData>> & {
         source: "network";
     };
-    type FromCache<TData> = NextNotification<ApolloQueryResult<TData>> & {
+    type FromCache<TData> = NextNotification<ObservableQuery.Result<TData>> & {
         source: "cache";
     };
-    type Value<TData> = FromCache<TData> | FromNetwork<TData> | NewNetworkStatus<TData> | SetResult<TData>;
+    type Value<TData> = FromCache<TData> | FromNetwork<TData> | NewNetworkStatus | SetResult<TData>;
 }
 /** Observable created by initiating a subscription operation. */
 export interface SubscriptionObservable<T> extends Observable<T> {