@apollo/client 4.2.0-alpha.2 → 4.2.0-alpha.3

package/__cjs/version.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.build = exports.version = void 0;
-exports.version = "4.2.0-alpha.2";
+exports.version = "4.2.0-alpha.3";
 exports.build = "cjs";
 //# sourceMappingURL=version.cjs.map

package/core/ApolloClient.d.ts

@@ -28,6 +28,13 @@ export interface ReferenceToAvoidDroppingImportOnBuild {
 }
 export declare namespace ApolloClient {
     export type { DeclareDefaultOptions, DefaultOptions };
+    export namespace DocumentationTypes {
+        interface DefaultOptions {
+            watchQuery?: Partial<ApolloClient.WatchQueryOptions<any, any>>;
+            query?: Partial<ApolloClient.QueryOptions<any, any>>;
+            mutate?: Partial<ApolloClient.MutateOptions<any, any, any>>;
+        }
+    }
     export interface Options extends InternalTypes.DefaultOptionsParentObject {
         /**
          * 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/).
@@ -216,24 +223,118 @@ export declare namespace ApolloClient {
         */
         mutation: DocumentNode | TypedDocumentNode<TData, TVariables>;
     } & VariablesOption<NoInfer<TVariables>>;
-    export interface MutateResult<TData = unknown> {
-        /**
-        * The data returned from your mutation. Can be `undefined` if the `errorPolicy`
-        * is `all` or `ignore` and the server returns a GraphQL response with `errors`
-        * but not `data` or a network error is returned.
-        */
-        data: TData | undefined;
+    export namespace mutate {
+        interface DefaultOptions extends ApolloClient.DefaultOptions.Mutate.Calculated {
+        }
+        type ResultForOptions<TData, TVariables extends OperationVariables, TCache extends ApolloCache, TOptions extends Record<string, unknown> | MutateOptions<any, TVariables, TCache>> = LazyType<MutateResult<MaybeMasked<TData>, OptionWithFallback<TOptions, DefaultOptions, "errorPolicy"> & ErrorPolicy>>;
+        namespace Signatures {
+            interface Classic {
+                /**
+                * @deprecated Avoid manually specifying generics on `client.mutate`.
+                * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your mutation results.
+                *
+                *
+                * 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
+                * error. In some cases both `data` and `errors` might be undefined, for example
+                * when `errorPolicy` is set to `'ignore'`.
+                * 
+                * It takes options as an object with the following keys and values:
+                */
+                <TData = unknown, TVariables extends OperationVariables = OperationVariables, TCache extends ApolloCache = ApolloCache>(options: ApolloClient.MutateOptions<TData, TVariables, TCache>): Promise<ApolloClient.MutateResult<MaybeMasked<TData>>>;
+            }
+            interface Modern {
+                /**
+                * 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
+                * error. In some cases both `data` and `errors` might be undefined, for example
+                * when `errorPolicy` is set to `'ignore'`.
+                * 
+                * It takes options as an object with the following keys and values:
+                */
+                <TData, TVariables extends OperationVariables, TCache extends ApolloCache, TOptions extends ApolloClient.MutateOptions<NoInfer<TData>, NoInfer<TVariables>, TCache> & VariablesOption<TVariables & {
+                    [K in Exclude<keyof TOptions["variables"], keyof TVariables>]?: never;
+                }>>(options: TOptions & {
+                    mutation: TypedDocumentNode<TData, TVariables>;
+                }): Promise<ApolloClient.mutate.ResultForOptions<TData, TVariables, TCache, TOptions>>;
+            }
+            type Evaluated = SignatureStyle extends "classic" ? Classic : Modern;
+        }
         /**
-        * 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`.
+        * 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
+        * error. In some cases both `data` and `errors` might be undefined, for example
+        * when `errorPolicy` is set to `'ignore'`.
         * 
-        * For more information, see [Handling operation errors](https://www.apollographql.com/docs/react/data/error-handling/).
+        * It takes options as an object with the following keys and values:
         */
-        error?: ErrorLike;
+        interface Signature extends Signatures.Evaluated {
+        }
+    }
+    export type MutateResultMap<TData = unknown> = {
+        none: {
+            /**
+            * The data returned from your mutation. Can be `undefined` if the `errorPolicy`
+            * is `all` or `ignore` and the server returns a GraphQL response with `errors`
+            * but not `data` or a network error is returned.
+            */
+            data: TData;
+            /**
+            * 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?: never;
+        };
+        all: {
+            /**
+            * The data returned from your mutation. Can be `undefined` if the `errorPolicy`
+            * is `all` or `ignore` and the server returns a GraphQL response with `errors`
+            * but not `data` or a network error is returned.
+            */
+            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;
+        };
+        ignore: {
+            /**
+            * The data returned from your mutation. Can be `undefined` if the `errorPolicy`
+            * is `all` or `ignore` and the server returns a GraphQL response with `errors`
+            * but not `data` or a network error is returned.
+            */
+            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?: never;
+        };
+        undefined: {
+            /**
+            * The data returned from your mutation. Can be `undefined` if the `errorPolicy`
+            * is `all` or `ignore` and the server returns a GraphQL response with `errors`
+            * but not `data` or a network error is returned.
+            */
+            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;
+        };
+    };
+    export type MutateResult<TData = unknown, TErrorPolicy extends ErrorPolicy | undefined = undefined> = MutateResultMap<TData>[`${TErrorPolicy}`] & {
         /**
         * Custom extensions returned from the GraphQL server
         */
         extensions?: Record<string, unknown>;
-    }
+    };
     /**
      * Query options.
      */
@@ -271,7 +372,7 @@ export declare namespace ApolloClient {
         */
         fetchPolicy?: FetchPolicy;
     } & VariablesOption<NoInfer<TVariables>>;
-    export type QueryResultMap<TData = unknown, TErrorPolicy extends ErrorPolicy | undefined = undefined> = {
+    export type QueryResultMap<TData = unknown> = {
         none: {
             /**
             * An object containing the result of your GraphQL query after it completes.
@@ -349,7 +450,7 @@ export declare namespace ApolloClient {
             error?: ErrorLike;
         };
     };
-    export type QueryResult<TData = unknown, TErrorPolicy extends ErrorPolicy | undefined = undefined> = QueryResultMap<TData, TErrorPolicy>[`${TErrorPolicy}`];
+    export type QueryResult<TData = unknown, TErrorPolicy extends ErrorPolicy | undefined = undefined> = QueryResultMap<TData>[`${TErrorPolicy}`];
     export namespace query {
         interface DefaultOptions extends ApolloClient.DefaultOptions.Query.Calculated {
         }
@@ -827,6 +928,15 @@ export declare namespace ApolloClient {
          * server at all or just resolve from the cache, etc.
          */
         function query<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.QueryOptions<TData, TVariables>): Promise<ApolloClient.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
+         * error. In some cases both `data` and `errors` might be undefined, for example
+         * when `errorPolicy` is set to `'ignore'`.
+         *
+         * It takes options as an object with the following keys and values:
+         */
+        function mutate<TData = unknown, TVariables extends OperationVariables = OperationVariables, TCache extends ApolloCache = ApolloCache>(options: ApolloClient.MutateOptions<TData, TVariables, TCache>): Promise<ApolloClient.MutateResult<MaybeMasked<TData>>>;
     }
 }
 /**
@@ -940,14 +1050,14 @@ export declare class ApolloClient {
     */
     query: ApolloClient.query.Signature;
     /**
-     * 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
-     * error. In some cases both `data` and `errors` might be undefined, for example
-     * when `errorPolicy` is set to `'ignore'`.
-     *
-     * It takes options as an object with the following keys and values:
-     */
-    mutate<TData = unknown, TVariables extends OperationVariables = OperationVariables, TCache extends ApolloCache = ApolloCache>(options: ApolloClient.MutateOptions<TData, TVariables, TCache>): Promise<ApolloClient.MutateResult<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
+    * error. In some cases both `data` and `errors` might be undefined, for example
+    * when `errorPolicy` is set to `'ignore'`.
+    * 
+    * It takes options as an object with the following keys and values:
+    */
+    mutate: ApolloClient.mutate.Signature;
     /**
      * This subscribes to a graphql subscription according to the options specified and returns an
      * `Observable` which either emits received data or an error.

package/core/ApolloClient.js

@@ -247,14 +247,14 @@ export class ApolloClient {
         return this.queryManager.query(options);
     };
     /**
-     * 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
-     * error. In some cases both `data` and `errors` might be undefined, for example
-     * when `errorPolicy` is set to `'ignore'`.
-     *
-     * It takes options as an object with the following keys and values:
-     */
-    mutate(options) {
+    * 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
+    * error. In some cases both `data` and `errors` might be undefined, for example
+    * when `errorPolicy` is set to `'ignore'`.
+    * 
+    * It takes options as an object with the following keys and values:
+    */
+    mutate = (options) => {
         const optionsWithDefaults = mergeOptions(compact({
             fetchPolicy: "network-only",
             errorPolicy: "none",
@@ -266,7 +266,7 @@ export class ApolloClient {
         }
         checkDocument(optionsWithDefaults.mutation, OperationTypeNode.MUTATION);
         return this.queryManager.mutate(optionsWithDefaults);
-    }
+    };
     /**
      * This subscribes to a graphql subscription according to the options specified and returns an
      * `Observable` which either emits received data or an error.