@apollo/client 4.0.0-alpha.16 → 4.0.0-alpha.17

package/__cjs/core/ObservableQuery.d.cts

@@ -152,6 +152,22 @@ export declare namespace ObservableQuery {
         */
         lastOwnDiff?: Cache.DiffResult<TData>;
     }
+    /**
+     * Promise returned by `reobserve` and `refetch` methods.
+     *
+     * By default, if the `ObservableQuery` is not interested in the result
+     * of this operation anymore, the network operation will be cancelled.
+     *
+     * This has an additional `retain` method that can be used to keep the
+     * network operation running until it is finished nonetheless.
+     */
+    interface ResultPromise<T> extends Promise<T> {
+        /**
+         * Kepp the network operation running until it is finished, even if
+         * `ObservableQuery` unsubscribed from the operation.
+         */
+        retain(): this;
+    }
 }
 export declare class ObservableQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables> implements Subscribable<ApolloQueryResult<MaybeMasked<TData>>>, InteropObservable<ApolloQueryResult<MaybeMasked<TData>>> {
     /**
@@ -217,7 +233,7 @@ export declare class ObservableQuery<TData = unknown, TVariables extends Operati
      * @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<QueryResult<TData>>;
+    refetch(variables?: Partial<TVariables>): ObservableQuery.ResultPromise<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/).
      */
@@ -280,7 +296,8 @@ export declare class ObservableQuery<TData = unknown, TVariables extends Operati
      * 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>>>;
+    reobserve(newOptions?: Partial<ObservableQuery.Options<TData, TVariables>>): ObservableQuery.ResultPromise<QueryResult<MaybeMasked<TData>>>;
+    private _reobserve;
     hasObservers(): boolean;
     private tearDownQuery;
     private transformDocument;

package/__cjs/core/QueryManager.cjs

@@ -850,20 +850,29 @@ class QueryManager {
             }
             const aqr = {
                 data: result.data,
+                dataState: result.data ? "complete" : "empty",
                 loading: false,
                 networkStatus: networkStatus_js_1.NetworkStatus.ready,
                 partial: !result.data,
             };
+            if ((0, internal_1.isExecutionPatchResult)(result) && result.hasNext) {
+                aqr.dataState = "streaming";
+                aqr.partial = true;
+            }
             // In the case we start multiple network requests simulatenously, we
             // want to ensure we properly set `data` if we're reporting on an old
             // result which will not be caught by the conditional above that ends up
             // throwing the markError result.
             if (hasErrors && errorPolicy === "none") {
                 aqr.data = void 0;
+                aqr.dataState = "empty";
             }
             if (hasErrors && errorPolicy !== "ignore") {
                 aqr.error = new errors_1.CombinedGraphQLErrors(result);
                 aqr.networkStatus = networkStatus_js_1.NetworkStatus.error;
+                if (aqr.data) {
+                    aqr.dataState = "complete";
+                }
             }
             return aqr;
         }), (0, rxjs_1.catchError)((error) => {
@@ -875,6 +884,7 @@ class QueryManager {
             }
             const aqr = {
                 data: undefined,
+                dataState: "empty",
                 loading: false,
                 networkStatus: networkStatus_js_1.NetworkStatus.ready,
                 partial: true,
@@ -1059,7 +1069,9 @@ class QueryManager {
                             if (result === true) {
                                 // The onQueryUpdated function requested the default refetching
                                 // behavior by returning true.
-                                result = oq.refetch();
+                                result = oq
+                                    .refetch()
+                                    .retain( /* create a persistent subscription on the query */);
                             }
                             // Record the result in the results Map, as long as onQueryUpdated
                             // did not return false to skip/ignore this result.
@@ -1093,7 +1105,9 @@ class QueryManager {
                 }
                 // Otherwise, we fall back to refetching.
                 if (!onQueryUpdated || result === true) {
-                    result = oq.refetch();
+                    result = oq
+                        .refetch()
+                        .retain( /* create a persistent subscription on the query */);
                 }
                 if (result !== false) {
                     results.set(oq, result);
@@ -1165,6 +1179,9 @@ class QueryManager {
                 return {
                     // TODO: Handle partial data
                     data: data,
+                    dataState: diff.complete ? "complete"
+                        : data ? "partial"
+                            : "empty",
                     loading: (0, networkStatus_js_1.isNetworkRequestInFlight)(networkStatus),
                     networkStatus,
                     partial: !diff.complete,