@apollo/client 4.3.0-alpha.4 → 4.3.0-alpha.6

package/__cjs/core/ApolloClient.d.cts

@@ -8,7 +8,7 @@ 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 { DocumentTransform } from "@apollo/client/utilities";
-import type { LazyType, OptionWithFallback, SignatureStyle, VariablesOption, variablesUnknownSymbol } from "@apollo/client/utilities/internal";
+import type { LazyType, OptionWithFallback, Prettify, SignatureStyle, VariablesOption, variablesUnknownSymbol } from "@apollo/client/utilities/internal";
 import { getApolloClientMemoryInternals } from "@apollo/client/utilities/internal";
 import type { DeclareDefaultOptions, DefaultOptions } from "./defaultOptions.cjs";
 import type { ObservableQuery } from "./ObservableQuery.cjs";
@@ -232,7 +232,20 @@ export declare namespace ApolloClient {
     export namespace mutate {
         interface DefaultOptions extends ApolloClient.DefaultOptions.Mutate.Calculated {
         }
-        type ResultForOptions<TData, TVariables extends OperationVariables, TCache extends Cache.Implementation, TOptions extends Record<string, unknown> | MutateOptions<any, TVariables, TCache>> = LazyType<MutateResult<MaybeMasked<TData>, OptionWithFallback<TOptions, DefaultOptions, "errorPolicy"> & ErrorPolicy>>;
+        type OptionsFor<TData, TVariables extends OperationVariables, TCache extends Cache.Implementation, TOptions extends {
+            variables?: unknown;
+        }> = MutateOptions<NoInfer<TData>, NoInfer<TVariables>, TCache> & {
+            variables?: Prettify<TVariables & {
+                [K in keyof TOptions["variables"]]: K extends keyof TVariables ? TVariables[K] : never;
+            }>;
+        } & (Exclude<keyof TOptions, keyof MutateOptions<any, any, any>> extends (infer InvalidOptionNames extends string) ? [
+            InvalidOptionNames
+        ] extends [never] ? unknown : {
+            [K in InvalidOptionNames]: never;
+        } : never);
+        type ResultForOptions<TData, TErrorPolicy extends ErrorPolicy | undefined = undefined> = LazyType<MutateResult<MaybeMasked<TData>, OptionWithFallback<{
+            errorPolicy: TErrorPolicy;
+        }, DefaultOptions, "errorPolicy"> & ErrorPolicy>>;
         namespace Signatures {
             interface Classic {
                 /**
@@ -271,11 +284,21 @@ export declare namespace ApolloClient {
                 * 
                 * It takes options as an object with the following keys and values:
                 */
-                <TData, TVariables extends OperationVariables, TOptions extends ApolloClient.MutateOptions<NoInfer<TData>, NoInfer<TVariables>, Cache.Implementation> & VariablesOption<TVariables & {
-                    [K in Exclude<keyof TOptions["variables"], keyof TVariables>]?: never;
-                }>>(options: TOptions & {
+                <TData, TVariables extends OperationVariables, TOptions extends Omit<ApolloClient.MutateOptions<NoInfer<TData>, any, Cache.Implementation>, "variables"> & {
+                    variables?: unknown;
+                }, TErrorPolicy extends ErrorPolicy | undefined = undefined>(options: TOptions & ApolloClient.mutate.OptionsFor<TData, TVariables, Cache.Implementation, TOptions> & {
                     mutation: TypedDocumentNode<TData, TVariables>;
-                }): Promise<ApolloClient.mutate.ResultForOptions<TData, TVariables, Cache.Implementation, TOptions>>;
+                    /**
+                    * Specifies how the mutation handles a response that returns both GraphQL errors and partial results.
+                    * 
+                    * For details, see [GraphQL error policies](https://www.apollographql.com/docs/react/data/error-handling/#graphql-error-policies).
+                    * 
+                    * The default value is `none`, meaning that the mutation result includes error details but _not_ partial results.
+                    * 
+                    * @docGroup 1. Operation options
+                    */
+                    errorPolicy?: TErrorPolicy;
+                }): Promise<ApolloClient.mutate.ResultForOptions<TData, TErrorPolicy>>;
             }
             type Evaluated = SignatureStyle extends "classic" ? Classic : Modern;
         }
@@ -473,7 +496,18 @@ export declare namespace ApolloClient {
     export namespace query {
         interface DefaultOptions extends ApolloClient.DefaultOptions.Query.Calculated {
         }
-        type ResultForOptions<TData, TVariables extends OperationVariables, TOptions extends Record<string, unknown> | QueryOptions<any, TVariables>> = LazyType<QueryResult<MaybeMasked<TData>, OptionWithFallback<TOptions, DefaultOptions, "errorPolicy"> & ErrorPolicy>>;
+        type OptionsFor<TData, TVariables extends OperationVariables, TOptions extends {
+            variables?: unknown;
+        }> = QueryOptions<NoInfer<TData>, NoInfer<TVariables>> & {
+            variables?: Prettify<TVariables & {
+                [K in keyof TOptions["variables"]]: K extends keyof TVariables ? TVariables[K] : never;
+            }>;
+        } & (Exclude<keyof TOptions, keyof QueryOptions<any, any>> extends (infer InvalidOptionNames extends string) ? [
+            InvalidOptionNames
+        ] extends [never] ? unknown : {
+            [K in InvalidOptionNames]: never;
+        } : never);
+        type ResultForOptions<TData, TVariables extends OperationVariables, TOptions extends Record<string, unknown> | Omit<QueryOptions<any, any>, "variables">> = LazyType<QueryResult<MaybeMasked<TData>, OptionWithFallback<TOptions, DefaultOptions, "errorPolicy"> & ErrorPolicy>>;
         namespace Signatures {
             interface Classic {
                 /**
@@ -515,9 +549,9 @@ export declare namespace ApolloClient {
                 * describe how this query should be treated e.g. whether it should hit the
                 * server at all or just resolve from the cache, etc.
                 */
-                <TData, TVariables extends OperationVariables, TOptions extends ApolloClient.QueryOptions<NoInfer<TData>, NoInfer<TVariables>> & VariablesOption<TVariables & {
-                    [K in Exclude<keyof TOptions["variables"], keyof TVariables>]?: never;
-                }>>(options: TOptions & {
+                <TData, TVariables extends OperationVariables, TOptions extends Omit<ApolloClient.QueryOptions<NoInfer<TData>, any>, "variables"> & {
+                    variables?: unknown;
+                }>(options: TOptions & ApolloClient.query.OptionsFor<TData, TVariables, TOptions> & {
                     query: TypedDocumentNode<TData, TVariables>;
                 }): Promise<ApolloClient.query.ResultForOptions<TData, TVariables, TOptions>>;
             }

package/__cjs/core/ObservableQuery.cjs

@@ -12,6 +12,7 @@ const utilities_1 = require("@apollo/client/utilities");
 const environment_1 = require("@apollo/client/utilities/environment");
 const internal_1 = require("@apollo/client/utilities/internal");
 const invariant_1 = require("@apollo/client/utilities/invariant");
+const dataStateErrorCache_js_1 = require("./dataStateErrorCache.cjs");
 const networkStatus_js_1 = require("./networkStatus.cjs");
 const { assign, hasOwnProperty } = Object;
 const uninitialized = {
@@ -213,12 +214,13 @@ class ObservableQuery {
     * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
     */
     getCacheDiff({ optimistic = true } = {}) {
-        return this.cache.diff({
+        return (0, internal_1.toDiffWithDataState)(this.cache.diff({
             query: this.query,
             variables: this.variables,
             returnPartialData: true,
             optimistic,
-        });
+            [internal_1.handleIncrementalSymbol]: undefined,
+        }));
     }
     getInitialResult(initialFetchPolicy) {
         let fetchPolicy = initialFetchPolicy || this.options.fetchPolicy;
@@ -228,16 +230,18 @@ class ObservableQuery {
         }
         const cacheResult = () => {
             const diff = this.getCacheDiff();
+            let { dataState } = diff;
             // TODO: queryInfo.getDiff should handle this since cache.diff returns a
             // null when returnPartialData is false
             const data = this.options.returnPartialData || diff.complete ?
                 diff.result ?? undefined
                 : undefined;
+            if (data === undefined) {
+                dataState = "empty";
+            }
             return this.maskResult({
                 data,
-                dataState: diff.complete ? "complete"
-                    : data === undefined ? "empty"
-                        : "partial",
+                dataState,
                 loading: !diff.complete,
                 networkStatus: diff.complete ? networkStatus_js_1.NetworkStatus.ready : networkStatus_js_1.NetworkStatus.loading,
                 partial: !diff.complete,
@@ -886,6 +890,7 @@ class ObservableQuery {
             if (this.pollingInfo) {
                 if (!(0, utilities_1.isNetworkRequestInFlight)(this.networkStatus) &&
                     !this.options.skipPollAttempt?.()) {
+                    this._lastWrite = undefined;
                     this._reobserve({
                         // Most fetchPolicy options don't make sense to use in a polling context, as
                         // users wouldn't want to be polling the cache directly. However, network-only and
@@ -1162,9 +1167,7 @@ class ObservableQuery {
                     kind: "N",
                     value: {
                         data: diff.result,
-                        dataState: diff.complete ? "complete"
-                            : diff.result ? "partial"
-                                : "empty",
+                        dataState: diff.dataState,
                         networkStatus: networkStatus_js_1.NetworkStatus.ready,
                         loading: false,
                         error: undefined,
@@ -1260,19 +1263,55 @@ class ObservableQuery {
         });
     }
     operator = (0, internal_1.filterMap)((notification) => {
-        const { query, variables, meta } = notification;
+        const { query, meta } = notification;
         if (notification.source === "setResult") {
-            return { query, variables, result: notification.value, meta };
+            return {
+                query,
+                variables: this.variables,
+                result: notification.value,
+                meta,
+            };
+        }
+        if (notification.kind === "C") {
+            return;
         }
-        if (notification.kind === "C" || !isEqualQuery(notification, this)) {
+        const resolvedVariables = "resolvedVariables" in notification ?
+            notification.resolvedVariables
+            : undefined;
+        // Usually we prefer to drop notifications that don't match this query
+        // but this breaks when used with `@export` queries that resolve variables
+        // after the request is initiated. `notification.resolvedVariables` gives us
+        // the variables the query actually resolved with during evaluation in
+        // QueryManager (which is the variables value after `@export` variables have
+        // been applied), but we need to update this query with those resolved
+        // variables maybe in the middle of a request (updating is handled below).
+        // When we update this.variables to the resolved variables, this causes
+        // isEqualQuery(notification, this) to fail for future notifications since
+        // the notification.variables holds the stale variables value. In this case,
+        // we want to allow the notification through only if the current variables
+        // value matches the resolved variables.
+        //
+        // Note: the check for matching resolved variables typically kicks in for
+        // multi-emission fetches (such as defer, or cache-and-network, etc).
+        if (notification.query !== this.query) {
             return;
         }
+        if (!(0, equality_1.equal)(resolvedVariables, this.variables)) {
+            if (!(0, equality_1.equal)(notification.variables, this.variables)) {
+                return;
+            }
+            if (resolvedVariables) {
+                this.options.variables = resolvedVariables;
+                this.resubscribeCache();
+            }
+        }
+        const variables = this.variables;
         let result;
         const previous = this.subject.getValue();
         if (notification.source === "cache") {
             result = notification.value;
             if (result.networkStatus === networkStatus_js_1.NetworkStatus.ready &&
-                result.partial &&
+                result.dataState === "partial" &&
                 (!this.options.returnPartialData ||
                     previous.result.networkStatus === networkStatus_js_1.NetworkStatus.error) &&
                 this.options.fetchPolicy !== "cache-only") {
@@ -1287,7 +1326,9 @@ class ObservableQuery {
             result =
                 notification.kind === "E" ?
                     {
-                        ...(isEqualQuery(previous, notification) ?
+                        ...((isEqualQuery(previous, notification) ||
+                            (resolvedVariables &&
+                                (0, equality_1.equal)(resolvedVariables, previous.variables))) ?
                             previous.result
                             : { data: undefined, dataState: "empty", partial: true }),
                         error: notification.error,
@@ -1296,7 +1337,8 @@ class ObservableQuery {
                     }
                     : notification.value;
             if (notification.kind === "E" && result.dataState === "streaming") {
-                result.dataState = "complete";
+                result.dataState =
+                    dataStateErrorCache_js_1.dataStateErrorCache.get(notification.error) ?? "complete";
             }
             if (result.error) {
                 meta.shouldEmit = 1 /* EmitBehavior.force */;