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

package/__cjs/core/ObservableQuery.d.cts

@@ -1,44 +1,167 @@
+import type { DocumentNode } from "graphql";
 import type { InteropObservable, Observer, Subscribable, Subscription } from "rxjs";
 import type { Observable } from "rxjs";
 import type { MissingFieldError } from "@apollo/client/cache";
 import type { MissingTree } from "@apollo/client/cache";
 import type { MaybeMasked, Unmasked } from "@apollo/client/masking";
-import { NetworkStatus } from "./networkStatus.cjs";
 import type { QueryInfo } from "./QueryInfo.cjs";
 import type { QueryManager } from "./QueryManager.cjs";
-import type { ApolloQueryResult, ErrorLike, OperationVariables, TypedDocumentNode } from "./types.cjs";
-import type { FetchMoreQueryOptions, SubscribeToMoreOptions, UpdateQueryMapFn, WatchQueryOptions } from "./watchQueryOptions.cjs";
-export interface FetchMoreOptions<TData = any, TVariables = OperationVariables> {
+import type { ApolloQueryResult, DefaultContext, ErrorLike, OperationVariables, QueryResult, TypedDocumentNode } from "./types.cjs";
+import type { ErrorPolicy, FetchMoreQueryOptions, NextFetchPolicyContext, RefetchWritePolicy, SubscribeToMoreOptions, UpdateQueryMapFn, WatchQueryFetchPolicy, WatchQueryOptions } from "./watchQueryOptions.cjs";
+export interface FetchMoreOptions<TData = unknown, TVariables = OperationVariables> {
     updateQuery?: (previousQueryResult: TData, options: {
         fetchMoreResult?: TData;
         variables?: TVariables;
     }) => TData;
 }
-export declare class ObservableQuery<TData = any, TVariables extends OperationVariables = OperationVariables> implements Subscribable<ApolloQueryResult<MaybeMasked<TData>>>, InteropObservable<ApolloQueryResult<MaybeMasked<TData>>> {
-    readonly options: WatchQueryOptions<TVariables, TData>;
+export declare namespace ObservableQuery {
+    type Options<TData = unknown, TVariables extends OperationVariables = OperationVariables> = {
+        /**
+        * Specifies how the query interacts with the Apollo Client cache during execution (for example, whether it checks the cache for results before sending a request to the server).
+        * 
+        * For details, see [Setting a fetch policy](https://www.apollographql.com/docs/react/data/queries/#setting-a-fetch-policy).
+        * 
+        * The default value is `cache-first`.
+        * 
+        * @docGroup
+        * 
+        * 3. Caching options
+        */
+        fetchPolicy: WatchQueryFetchPolicy;
+        /**
+        * Specifies the `FetchPolicy` to be used after this query has completed.
+        * 
+        * @docGroup
+        * 
+        * 3. Caching options
+        */
+        nextFetchPolicy?: WatchQueryFetchPolicy | ((this: WatchQueryOptions<TVariables, TData>, currentFetchPolicy: WatchQueryFetchPolicy, context: NextFetchPolicyContext<TData, TVariables>) => WatchQueryFetchPolicy);
+        /**
+        * Defaults to the initial value of options.fetchPolicy, but can be explicitly configured to specify the WatchQueryFetchPolicy to revert back to whenever variables change (unless nextFetchPolicy intervenes).
+        * 
+        * @docGroup
+        * 
+        * 3. Caching options
+        */
+        initialFetchPolicy: WatchQueryFetchPolicy;
+        /**
+        * Specifies whether a `NetworkStatus.refetch` operation should merge incoming field data with existing data, or overwrite the existing data. Overwriting is probably preferable, but merging is currently the default behavior, for backwards compatibility with Apollo Client 3.x.
+        * 
+        * @docGroup
+        * 
+        * 3. Caching options
+        */
+        refetchWritePolicy?: RefetchWritePolicy;
+        /**
+        * Specifies how the query 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 query result includes error details but not partial results.
+        * 
+        * @docGroup
+        * 
+        * 1. Operation options
+        */
+        errorPolicy?: ErrorPolicy;
+        /**
+        * If you're using [Apollo Link](https://www.apollographql.com/docs/react/api/link/introduction/), this object is the initial value of the `context` object that's passed along your link chain.
+        * 
+        * @docGroup
+        * 
+        * 2. Networking options
+        */
+        context?: DefaultContext;
+        /**
+        * Specifies the interval (in milliseconds) at which the query polls for updated results.
+        * 
+        * The default value is `0` (no polling).
+        * 
+        * @docGroup
+        * 
+        * 2. Networking options
+        */
+        pollInterval?: number;
+        /**
+        * If `true`, the in-progress query's associated component re-renders whenever the network status changes or a network error occurs.
+        * 
+        * The default value is `true`.
+        * 
+        * @docGroup
+        * 
+        * 2. Networking options
+        */
+        notifyOnNetworkStatusChange?: boolean;
+        /**
+        * If `true`, the query can return partial results from the cache if the cache doesn't contain results for all queried fields.
+        * 
+        * The default value is `false`.
+        * 
+        * @docGroup
+        * 
+        * 3. Caching options
+        */
+        returnPartialData?: boolean;
+        /**
+        * A callback function that's called whenever a refetch attempt occurs while polling. If the function returns `true`, the refetch is skipped and not reattempted until the next poll interval.
+        * 
+        * @docGroup
+        * 
+        * 2. Networking options
+        */
+        skipPollAttempt?: () => boolean;
+        /**
+        * A GraphQL query string parsed into an AST with the gql template literal.
+        * 
+        * @docGroup
+        * 
+        * 1. Operation options
+        */
+        query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+        /**
+        * An object containing all of the GraphQL variables your query requires to execute.
+        * 
+        * Each key in the object corresponds to a variable name, and that key's value corresponds to the variable value.
+        * 
+        * @docGroup
+        * 
+        * 1. Operation options
+        */
+        variables: TVariables;
+    };
+}
+export declare class ObservableQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables> implements Subscribable<ApolloQueryResult<MaybeMasked<TData>>>, InteropObservable<ApolloQueryResult<MaybeMasked<TData>>> {
+    /**
+     * @internal
+     * A slot used by the `useQuery` hook to indicate that `client.watchQuery`
+     * should not register the query immediately, but instead wait for the query to
+     * be started registered with the `QueryManager` when `useSyncExternalStore`
+     * actively subscribes to it.
+     */
+    private static inactiveOnCreation;
+    readonly options: ObservableQuery.Options<TData, TVariables>;
     readonly queryId: string;
     readonly queryName?: string;
     get query(): TypedDocumentNode<TData, TVariables>;
     /**
      * An object containing the variables that were provided for the query.
      */
-    get variables(): TVariables | undefined;
+    get variables(): TVariables;
     private subject;
     private readonly observable;
-    private initialResult;
     private isTornDown;
     private queryManager;
     private subscriptions;
     private waitForOwnResult;
     private last?;
-    private lastQuery?;
+    private lastQuery;
     private queryInfo;
     private linkSubscription?;
     private linkObservable?;
     private pollingInfo?;
     private networkStatus;
     constructor({ queryManager, queryInfo, options, }: {
-        queryManager: QueryManager<any>;
+        queryManager: QueryManager;
         queryInfo: QueryInfo;
         options: WatchQueryOptions<TVariables, TData>;
     });
@@ -48,6 +171,7 @@ export declare class ObservableQuery<TData = any, TVariables extends OperationVa
     ["@@observable"]: () => Subscribable<ApolloQueryResult<MaybeMasked<TData>>>;
     /** @internal */
     resetDiff(): void;
+    private getInitialResult;
     private getCurrentFullResult;
     getCurrentResult(saveAsLastResult?: boolean): ApolloQueryResult<MaybeMasked<TData>>;
     isDifferentFromLastResult(newResult: ApolloQueryResult<TData>, variables?: TVariables): boolean | undefined;
@@ -62,7 +186,7 @@ export declare class ObservableQuery<TData = any, TVariables extends OperationVa
      * @param variables - The new set of variables. If there are missing variables,
      * the previous values of those variables will be used.
      */
-    refetch(variables?: Partial<TVariables>): Promise<ApolloQueryResult<MaybeMasked<TData>>>;
+    refetch(variables?: Partial<TVariables>): Promise<QueryResult<TData>>;
     /**
      * A function that helps you fetch the next set of results for a [paginated list field](https://www.apollographql.com/docs/react/pagination/core-api/).
      */
@@ -71,15 +195,15 @@ export declare class ObservableQuery<TData = any, TVariables extends OperationVa
             fetchMoreResult: Unmasked<TFetchData>;
             variables: TFetchVars;
         }) => Unmasked<TData>;
-    }): Promise<ApolloQueryResult<MaybeMasked<TFetchData>>>;
+    }): Promise<QueryResult<TFetchData>>;
     /**
      * A function that enables you to execute a [subscription](https://www.apollographql.com/docs/react/data/subscriptions/), usually to subscribe to specific fields that were included in the query.
      *
      * This function returns _another_ function that you can call to terminate the subscription.
      */
     subscribeToMore<TSubscriptionData = TData, TSubscriptionVariables extends OperationVariables = TVariables>(options: SubscribeToMoreOptions<TData, TSubscriptionVariables, TSubscriptionData, TVariables>): () => void;
-    setOptions(newOptions: Partial<WatchQueryOptions<TVariables, TData>>): Promise<ApolloQueryResult<MaybeMasked<TData>>>;
-    silentSetOptions(newOptions: Partial<WatchQueryOptions<TVariables, TData>>): void;
+    /** @internal */
+    silentSetOptions(newOptions: Partial<ObservableQuery.Options<TData, TVariables>>): void;
     /**
      * Update the variables of this observable query, and fetch the new results
      * if they've changed. Most users should prefer `refetch` instead of
@@ -98,7 +222,7 @@ export declare class ObservableQuery<TData = any, TVariables extends OperationVa
      * @param variables - The new set of variables. If there are missing variables,
      * the previous values of those variables will be used.
      */
-    setVariables(variables: TVariables): Promise<ApolloQueryResult<MaybeMasked<TData>>>;
+    setVariables(variables: TVariables): Promise<QueryResult<TData>>;
     /**
      * A function that enables you to update the query's cached result without executing a followup GraphQL operation.
      *
@@ -116,8 +240,13 @@ export declare class ObservableQuery<TData = any, TVariables extends OperationVa
     private applyNextFetchPolicy;
     private fetch;
     private updatePolling;
+    private cancelPolling;
     private updateLastResult;
-    reobserve(newOptions?: Partial<WatchQueryOptions<TVariables, TData>>, newNetworkStatus?: NetworkStatus): Promise<ApolloQueryResult<MaybeMasked<TData>>>;
+    /**
+     * Reevaluate the query, optionally against new options. New options will be
+     * merged with the current options when given.
+     */
+    reobserve(newOptions?: Partial<ObservableQuery.Options<TData, TVariables>>): Promise<QueryResult<MaybeMasked<TData>>>;
     private observe;
     private reportResult;
     private reportError;
@@ -125,7 +254,17 @@ export declare class ObservableQuery<TData = any, TVariables extends OperationVa
     private tearDownQuery;
     private transformDocument;
     private maskResult;
+    private dirty;
+    private notifyTimeout?;
+    /** @internal */
+    protected resetNotifications(): void;
+    private cancelNotifyTimeout;
+    /** @internal */
+    protected scheduleNotify(): void;
+    /** @internal */
+    protected notify(): void;
+    private reobserveCacheFirst;
+    private getVariablesWithDefaults;
 }
-export declare function reobserveCacheFirst<TData, TVars extends OperationVariables>(obsQuery: ObservableQuery<TData, TVars>): Promise<ApolloQueryResult<MaybeMasked<TData_1>>>;
 export declare function logMissingFieldErrors(missing: MissingFieldError | MissingTree | undefined): void;
 //# sourceMappingURL=ObservableQuery.d.cts.map

package/__cjs/core/QueryInfo.cjs

@@ -6,8 +6,6 @@ const equality_1 = require("@wry/equality");
 const utilities_1 = require("@apollo/client/utilities");
 const utilities_2 = require("@apollo/client/utilities");
 const utilities_3 = require("@apollo/client/utilities");
-const networkStatus_js_1 = require("./networkStatus.cjs");
-const ObservableQuery_js_1 = require("./ObservableQuery.cjs");
 const destructiveMethodCounts = new WeakMap();
 function wrapDestructiveCacheMethod(cache, methodName) {
     const original = cache[methodName];
@@ -25,12 +23,6 @@ function wrapDestructiveCacheMethod(cache, methodName) {
         };
     }
 }
-function cancelNotifyTimeout(info) {
-    if (info["notifyTimeout"]) {
-        clearTimeout(info["notifyTimeout"]);
-        info["notifyTimeout"] = void 0;
-    }
-}
 // A QueryInfo object represents a single query managed by the
 // QueryManager, which tracks all QueryInfo objects by queryId in its
 // this.queries Map. QueryInfo objects store the latest results and errors
@@ -45,11 +37,11 @@ function cancelNotifyTimeout(info) {
 // interface is ongoing, and further improvements are welcome.
 class QueryInfo {
     queryId;
-    listeners = new Set();
     document = null;
     lastRequestId = 1;
     variables;
     stopped = false;
+    cancelWatch;
     cache;
     constructor(queryManager, queryId = queryManager.generateQueryId()) {
         this.queryId = queryId;
@@ -69,26 +61,15 @@ class QueryInfo {
     init(query) {
         if (!(0, equality_1.equal)(query.variables, this.variables)) {
             this.lastDiff = void 0;
+            // Ensure we don't continue to receive cache updates for old variables
+            this.cancel();
         }
         Object.assign(this, {
             document: query.document,
             variables: query.variables,
-            networkError: null,
         });
-        if (query.observableQuery) {
-            this.setObservableQuery(query.observableQuery);
-        }
-        if (query.lastRequestId) {
-            this.lastRequestId = query.lastRequestId;
-        }
         return this;
     }
-    dirty = false;
-    notifyTimeout;
-    reset() {
-        cancelNotifyTimeout(this);
-        this.dirty = false;
-    }
     resetDiff() {
         this.lastDiff = void 0;
     }
@@ -122,7 +103,6 @@ class QueryInfo {
             variables,
             returnPartialData: true,
             optimistic: true,
-            canonizeResults: this.observableQuery?.options.canonizeResults,
         };
     }
     setDiff(diff) {
@@ -140,88 +120,34 @@ class QueryInfo {
             return;
         }
         this.updateLastDiff(diff);
-        if (!this.dirty && !(0, equality_1.equal)(oldDiff && oldDiff.result, diff && diff.result)) {
-            this.dirty = true;
-            if (!this.notifyTimeout) {
-                this.notifyTimeout = setTimeout(() => this.notify(), 0);
-            }
+        if (!(0, equality_1.equal)(oldDiff && oldDiff.result, diff && diff.result)) {
+            this.observableQuery?.["scheduleNotify"]();
         }
     }
     observableQuery = null;
-    oqListener;
     setObservableQuery(oq) {
         if (oq === this.observableQuery)
             return;
-        if (this.oqListener) {
-            this.listeners.delete(this.oqListener);
-        }
         this.observableQuery = oq;
         if (oq) {
             oq["queryInfo"] = this;
-            this.listeners.add((this.oqListener = () => {
-                const diff = this.getDiff();
-                if (diff.fromOptimisticTransaction) {
-                    // If this diff came from an optimistic transaction, deliver the
-                    // current cache data to the ObservableQuery, but don't perform a
-                    // reobservation, since oq.reobserveCacheFirst might make a network
-                    // request, and we never want to trigger network requests in the
-                    // middle of optimistic updates.
-                    oq["observe"]();
-                }
-                else {
-                    // Otherwise, make the ObservableQuery "reobserve" the latest data
-                    // using a temporary fetch policy of "cache-first", so complete cache
-                    // results have a chance to be delivered without triggering additional
-                    // network requests, even when options.fetchPolicy is "network-only"
-                    // or "cache-and-network". All other fetch policies are preserved by
-                    // this method, and are handled by calling oq.reobserve(). If this
-                    // reobservation is spurious, isDifferentFromLastResult still has a
-                    // chance to catch it before delivery to ObservableQuery subscribers.
-                    (0, ObservableQuery_js_1.reobserveCacheFirst)(oq);
-                }
-            }));
-        }
-        else {
-            delete this.oqListener;
         }
     }
-    notify() {
-        cancelNotifyTimeout(this);
-        if (this.shouldNotify()) {
-            this.listeners.forEach((listener) => listener(this));
-        }
-        this.dirty = false;
-    }
-    shouldNotify() {
-        if (!this.dirty || !this.listeners.size) {
-            return false;
-        }
-        if (this.observableQuery &&
-            (0, networkStatus_js_1.isNetworkRequestInFlight)(this.observableQuery["networkStatus"])) {
-            const { fetchPolicy } = this.observableQuery.options;
-            if (fetchPolicy !== "cache-only" && fetchPolicy !== "cache-and-network") {
-                return false;
-            }
-        }
-        return true;
-    }
     stop() {
         if (!this.stopped) {
             this.stopped = true;
             // Cancel the pending notify timeout
-            this.reset();
+            this.observableQuery?.["resetNotifications"]();
             this.cancel();
-            // Revert back to the no-op version of cancel inherited from
-            // QueryInfo.prototype.
-            this.cancel = QueryInfo.prototype.cancel;
             const oq = this.observableQuery;
             if (oq)
                 oq.stopPolling();
         }
     }
-    // This method is a no-op by default, until/unless overridden by the
-    // updateWatch method.
-    cancel() { }
+    cancel() {
+        this.cancelWatch?.();
+        this.cancelWatch = void 0;
+    }
     lastWatch;
     updateWatch(variables = this.variables) {
         const oq = this.observableQuery;
@@ -238,7 +164,7 @@ class QueryInfo {
         };
         if (!this.lastWatch || !(0, equality_1.equal)(watchOptions, this.lastWatch)) {
             this.cancel();
-            this.cancel = this.cache.watch((this.lastWatch = watchOptions));
+            this.cancelWatch = this.cache.watch((this.lastWatch = watchOptions));
         }
     }
     lastWrite;
@@ -259,7 +185,7 @@ class QueryInfo {
         const merger = new utilities_3.DeepMerger();
         // Cancel the pending notify timeout (if it exists) to prevent extraneous network
         // requests. To allow future notify timeouts, diff and dirty are reset as well.
-        this.reset();
+        this.observableQuery?.["resetNotifications"]();
         if ("incremental" in result && (0, utilities_1.isNonEmptyArray)(result.incremental)) {
             const mergedData = (0, utilities_2.mergeIncrementalData)(this.getDiff().result, result);
             result.data = mergedData;