@apollo/client 4.1.0-alpha.8 → 4.1.0-rc.0

package/__cjs/core/ApolloClient.d.cts

@@ -7,7 +7,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 { VariablesOption } from "@apollo/client/utilities/internal";
+import type { VariablesOption, variablesUnknownSymbol } from "@apollo/client/utilities/internal";
 import { getApolloClientMemoryInternals } from "@apollo/client/utilities/internal";
 import type { ObservableQuery } from "./ObservableQuery.cjs";
 import type { DefaultContext, ErrorLike, InternalRefetchQueriesInclude, InternalRefetchQueriesResult, MutationQueryReducersMap, MutationUpdaterFunction, NormalizedExecutionResult, OnQueryUpdated, OperationVariables, RefetchQueriesInclude, RefetchQueriesPromiseResults, SubscriptionObservable, TypedDocumentNode } from "./types.cjs";
@@ -482,6 +482,21 @@ export declare namespace ApolloClient {
         * @docGroup 1. Operation options
         */
         query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+        /**
+        * @internal This API is meant for framework integrations only.
+        * Do not use for everyday use.
+        *
+        * Indicates that the variables are unknown at the time of query creation.
+        * This option can only be set when `fetchPolicy` is `'standby'`.
+        * Setting this to `true` will prevent `client.refetchQueries` from refetching
+        * this query before it has left the `'standby'` state, either by setting a
+        * `fetchPolicy`, or by calling `observableQuery.refetch()` explicitly.
+        *
+        * Changing this option after the query has been created will have no effect.
+        * 
+        * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+        */
+        [variablesUnknownSymbol]?: boolean;
     } & VariablesOption<NoInfer<TVariables>>;
     namespace Base {
         interface ReadQueryOptions<TData, TVariables extends OperationVariables> {
@@ -608,6 +623,11 @@ export declare namespace ApolloClient {
              * @defaultValue false
              */
             overwrite?: boolean;
+            /**
+             * GraphQL extensions for the write operation. Any provided `extensions`
+             * are available in `merge` functions.
+             */
+            extensions?: Record<string, unknown>;
         }
     }
     type WriteQueryOptions<TData, TVariables extends OperationVariables> = Base.WriteQueryOptions<TData, TVariables> & VariablesOption<TVariables>;

package/__cjs/core/ObservableQuery.cjs

@@ -31,6 +31,7 @@ const empty = {
 class ObservableQuery {
     options;
     queryName;
+    variablesUnknown = false;
     /**
     * @internal will be read and written from `QueryInfo`
     * 
@@ -82,6 +83,10 @@ class ObservableQuery {
         const { fetchPolicy = defaultFetchPolicy, 
         // Make sure we don't store "standby" as the initialFetchPolicy.
         initialFetchPolicy = fetchPolicy === "standby" ? defaultFetchPolicy : (fetchPolicy), } = options;
+        if (options[internal_1.variablesUnknownSymbol]) {
+            (0, invariant_1.invariant)(fetchPolicy === "standby", 80);
+            this.variablesUnknown = true;
+        }
         this.lastQuery = transformedQuery;
         this.options = {
             ...options,
@@ -383,7 +388,7 @@ class ObservableQuery {
             const queryDef = (0, internal_1.getQueryDefinition)(this.query);
             const vars = queryDef.variableDefinitions;
             if (!vars || !vars.some((v) => v.variable.name.value === "variables")) {
-                __DEV__ && invariant_1.invariant.warn(80, variables, queryDef.name?.value || queryDef);
+                __DEV__ && invariant_1.invariant.warn(81, variables, queryDef.name?.value || queryDef);
             }
         }
         if (variables && !(0, equality_1.equal)(this.variables, variables)) {
@@ -399,7 +404,7 @@ class ObservableQuery {
     fetchMore({ query, variables, context, errorPolicy, updateQuery, }) {
         (0, invariant_1.invariant)(
             this.options.fetchPolicy !== "cache-only",
-            81,
+            82,
             (0, internal_1.getOperationName)(this.query, "(anonymous)")
         );
         const combinedOptions = {
@@ -433,7 +438,7 @@ class ObservableQuery {
         let wasUpdated = false;
         const isCached = this.options.fetchPolicy !== "no-cache";
         if (!isCached) {
-            (0, invariant_1.invariant)(updateQuery, 82);
+            (0, invariant_1.invariant)(updateQuery, 83);
         }
         const { finalize, pushNotification } = this.pushOperation(networkStatus_js_1.NetworkStatus.fetchMore);
         pushNotification({
@@ -442,13 +447,14 @@ class ObservableQuery {
             value: {},
         }, { shouldEmit: 3 /* EmitBehavior.networkStatusChange */ });
         const { promise, operator } = getTrackingOperatorPromise();
-        const { observable } = this.queryManager.fetchObservableWithInfo(combinedOptions, { networkStatus: networkStatus_js_1.NetworkStatus.fetchMore });
+        const { observable } = this.queryManager.fetchObservableWithInfo(combinedOptions, { networkStatus: networkStatus_js_1.NetworkStatus.fetchMore, exposeExtensions: true });
         const subscription = observable
             .pipe(operator, (0, rxjs_1.filter)((notification) => notification.kind === "N" && notification.source === "network"))
             .subscribe({
             next: (notification) => {
                 wasUpdated = false;
                 const fetchMoreResult = notification.value;
+                const extensions = fetchMoreResult[internal_1.extensionsSymbol];
                 if ((0, utilities_1.isNetworkRequestSettled)(notification.value.networkStatus)) {
                     finalize();
                 }
@@ -469,6 +475,7 @@ class ObservableQuery {
                                     variables: this.variables,
                                     returnPartialData: true,
                                     optimistic: false,
+                                    extensions,
                                 }, (previous) => updateQuery(previous, {
                                     fetchMoreResult: fetchMoreResult.data,
                                     variables: combinedOptions.variables,
@@ -484,6 +491,7 @@ class ObservableQuery {
                                     query: combinedOptions.query,
                                     variables: combinedOptions.variables,
                                     data: fetchMoreResult.data,
+                                    extensions,
                                 });
                             }
                         },
@@ -606,7 +614,7 @@ class ObservableQuery {
                         onError(error);
                     }
                     else {
-                        invariant_1.invariant.error(83, error);
+                        invariant_1.invariant.error(84, error);
                     }
                     return;
                 }
@@ -850,7 +858,7 @@ class ObservableQuery {
                 if (!this.didWarnCacheOnlyPolling &&
                     pollInterval &&
                     fetchPolicy === "cache-only") {
-                    __DEV__ && invariant_1.invariant.warn(84, (0, internal_1.getOperationName)(this.query, "(anonymous)"));
+                    __DEV__ && invariant_1.invariant.warn(85, (0, internal_1.getOperationName)(this.query, "(anonymous)"));
                     this.didWarnCacheOnlyPolling = true;
                 }
             }
@@ -925,6 +933,10 @@ class ObservableQuery {
         const oldVariables = this.variables;
         const oldFetchPolicy = this.options.fetchPolicy;
         const mergedOptions = (0, internal_1.compact)(this.options, newOptions || {});
+        // This request will hit the network, so even if there are no variables,
+        // we now know that's intentional. (see #12996)
+        // Even if that happens only once, we want `variablesUnknown` to stay false permanently.
+        this.variablesUnknown &&= mergedOptions.fetchPolicy === "standby";
         const options = useDisposableObservable ?
             // Disposable Observable fetches receive a shallow copy of this.options
             // (merged with newOptions), leaving this.options unmodified.
@@ -1194,7 +1206,9 @@ class ObservableQuery {
         // "fetchMore" having priority over "polling" or "loading" network statuses
         // as for now we just take the "latest" operation that is still active,
         // as that lines up best with previous behavior[]
-        const operation = Array.from(this.activeOperations.values()).findLast((operation) => isEqualQuery(operation, this) && operation.override !== undefined);
+        const operation = Array.from(this.activeOperations.values())
+            .reverse()
+            .find((operation) => isEqualQuery(operation, this) && operation.override !== undefined);
         return operation?.override ?? baseNetworkStatus;
     }
     abortActiveOperations() {
@@ -1339,7 +1353,7 @@ class ObservableQuery {
 exports.ObservableQuery = ObservableQuery;
 function logMissingFieldErrors(missing) {
     if (environment_1.__DEV__ && missing) {
-        __DEV__ && invariant_1.invariant.debug(85, missing);
+        __DEV__ && invariant_1.invariant.debug(86, missing);
     }
 }
 function isEqualQuery(a, b) {