@apollo/client 4.0.0-alpha.18 → 4.0.0-alpha.19

package/core/QueryManager.js

@@ -1,6 +1,7 @@
 import { Trie } from "@wry/trie";
 import { BREAK, Kind, OperationTypeNode, visit } from "graphql";
-import { catchError, concat, EMPTY, filter, from, lastValueFrom, map, materialize, mergeMap, mergeWith, Observable, of, share, shareReplay, Subject, tap, } from "rxjs";
+import { Observable } from "rxjs";
+import { catchError, concat, EMPTY, filter, finalize, from, lastValueFrom, map, materialize, mergeMap, mergeWith, of, share, shareReplay, Subject, tap, } from "rxjs";
 import { canonicalStringify } from "@apollo/client/cache";
 import { CombinedGraphQLErrors, graphQLResultHasProtocolErrors, registerLinkError, toErrorLike, } from "@apollo/client/errors";
 import { PROTOCOL_ERRORS_SYMBOL } from "@apollo/client/errors";
@@ -8,7 +9,7 @@ import { execute } from "@apollo/client/link";
 import { maskFragment, maskOperation } from "@apollo/client/masking";
 import { cacheSizes, DocumentTransform, print } from "@apollo/client/utilities";
 import { __DEV__ } from "@apollo/client/utilities/environment";
-import { AutoCleanedWeakCache, checkDocument, filterMap, getDefaultValues, getGraphQLErrorsFromResult, getOperationDefinition, getOperationName, graphQLResultHasError, hasDirectives, hasForcedResolvers, isDocumentNode, isExecutionPatchIncrementalResult, isExecutionPatchResult, isNonEmptyArray, isNonNullObject, makeUniqueId, mergeIncrementalData, onAnyEvent, removeDirectivesFromDocument, toQueryResult, } from "@apollo/client/utilities/internal";
+import { AutoCleanedWeakCache, checkDocument, filterMap, getDefaultValues, getGraphQLErrorsFromResult, getOperationDefinition, getOperationName, graphQLResultHasError, hasDirectives, hasForcedResolvers, isDocumentNode, isExecutionPatchIncrementalResult, isExecutionPatchResult, isNonEmptyArray, isNonNullObject, makeUniqueId, mergeIncrementalData, removeDirectivesFromDocument, toQueryResult, } from "@apollo/client/utilities/internal";
 import { invariant, newInvariantError, } from "@apollo/client/utilities/invariant";
 import { isNetworkRequestInFlight, NetworkStatus } from "./networkStatus.js";
 import { logMissingFieldErrors, ObservableQuery } from "./ObservableQuery.js";
@@ -139,7 +140,7 @@ export class QueryManager {
                 ...context,
                 optimisticResponse: isOptimistic ? optimisticResponse : void 0,
             }, variables, {}, false)
-                .pipe(validateDidEmitValue(), mergeMap((result) => {
+                .observable.pipe(validateDidEmitValue(), mergeMap((result) => {
                 const hasErrors = graphQLResultHasError(result);
                 if (hasErrors && errorPolicy === "none") {
                     throw new CombinedGraphQLErrors(result);
@@ -428,6 +429,7 @@ export class QueryManager {
     getDocumentInfo(document) {
         const { transformCache } = this;
         if (!transformCache.has(document)) {
+            const operationDefinition = getOperationDefinition(document);
             const cacheEntry = {
                 // TODO These three calls (hasClientExports, shouldForceResolvers, and
                 // usesNonreactiveDirective) are performing independent full traversals
@@ -445,7 +447,8 @@ export class QueryManager {
                     { name: "nonreactive" },
                     { name: "unmask" },
                 ], document),
-                defaultVars: getDefaultValues(getOperationDefinition(document)),
+                operationType: operationDefinition?.operation,
+                defaultVars: getDefaultValues(operationDefinition),
                 // Transform any mutation or subscription operations to query operations
                 // so we can read/write them from/to the cache.
                 asQuery: {
@@ -649,65 +652,68 @@ export class QueryManager {
         checkDocument(query, OperationTypeNode.SUBSCRIPTION);
         query = this.transform(query);
         variables = this.getVariables(query, variables);
-        const makeObservable = (variables) => this.getObservableFromLink(query, context, variables, extensions).pipe(map((rawResult) => {
-            if (fetchPolicy !== "no-cache") {
-                // the subscription interface should handle not sending us results we no longer subscribe to.
-                // XXX I don't think we ever send in an object with errors, but we might in the future...
-                if (shouldWriteResult(rawResult, errorPolicy)) {
-                    this.cache.write({
-                        query,
-                        result: rawResult.data,
-                        dataId: "ROOT_SUBSCRIPTION",
-                        variables: variables,
-                    });
-                }
-                this.broadcastQueries();
-            }
-            const result = {
-                data: rawResult.data ?? undefined,
-            };
-            if (graphQLResultHasError(rawResult)) {
-                result.error = new CombinedGraphQLErrors(rawResult);
-            }
-            else if (graphQLResultHasProtocolErrors(rawResult)) {
-                result.error = rawResult.extensions[PROTOCOL_ERRORS_SYMBOL];
-                // Don't emit protocol errors added by HttpLink
-                delete rawResult.extensions[PROTOCOL_ERRORS_SYMBOL];
-            }
-            if (rawResult.extensions &&
-                Object.keys(rawResult.extensions).length) {
-                result.extensions = rawResult.extensions;
-            }
-            if (result.error && errorPolicy === "none") {
-                result.data = undefined;
-            }
-            if (errorPolicy === "ignore") {
-                delete result.error;
-            }
-            return result;
-        }), catchError((error) => {
-            if (errorPolicy === "ignore") {
-                return of({ data: undefined });
-            }
-            return of({ data: undefined, error });
-        }), filter((result) => !!(result.data || result.error)));
-        if (this.getDocumentInfo(query).hasClientExports) {
-            if (__DEV__) {
-                invariant(this.localState, 89, getOperationName(query, "(anonymous)"));
-            }
-            const observablePromise = this.localState.getExportedVariables({
+        let restart;
+        if (__DEV__) {
+            invariant(
+                !this.getDocumentInfo(query).hasClientExports || this.localState,
+                89,
+                getOperationName(query, "(anonymous)")
+            );
+        }
+        const observable = (this.getDocumentInfo(query).hasClientExports ?
+            from(this.localState.getExportedVariables({
                 client: this.client,
                 document: query,
                 variables,
                 context,
-            }).then(makeObservable);
-            return new Observable((observer) => {
-                let sub = null;
-                observablePromise.then((observable) => (sub = observable.subscribe(observer)), observer.error);
-                return () => sub && sub.unsubscribe();
-            });
-        }
-        return makeObservable(variables);
+            }))
+            : of(variables)).pipe(mergeMap((variables) => {
+            const { observable, restart: res } = this.getObservableFromLink(query, context, variables, extensions);
+            restart = res;
+            return observable.pipe(map((rawResult) => {
+                if (fetchPolicy !== "no-cache") {
+                    // the subscription interface should handle not sending us results we no longer subscribe to.
+                    // XXX I don't think we ever send in an object with errors, but we might in the future...
+                    if (shouldWriteResult(rawResult, errorPolicy)) {
+                        this.cache.write({
+                            query,
+                            result: rawResult.data,
+                            dataId: "ROOT_SUBSCRIPTION",
+                            variables: variables,
+                        });
+                    }
+                    this.broadcastQueries();
+                }
+                const result = {
+                    data: rawResult.data ?? undefined,
+                };
+                if (graphQLResultHasError(rawResult)) {
+                    result.error = new CombinedGraphQLErrors(rawResult);
+                }
+                else if (graphQLResultHasProtocolErrors(rawResult)) {
+                    result.error = rawResult.extensions[PROTOCOL_ERRORS_SYMBOL];
+                    // Don't emit protocol errors added by HttpLink
+                    delete rawResult.extensions[PROTOCOL_ERRORS_SYMBOL];
+                }
+                if (rawResult.extensions &&
+                    Object.keys(rawResult.extensions).length) {
+                    result.extensions = rawResult.extensions;
+                }
+                if (result.error && errorPolicy === "none") {
+                    result.data = undefined;
+                }
+                if (errorPolicy === "ignore") {
+                    delete result.error;
+                }
+                return result;
+            }), catchError((error) => {
+                if (errorPolicy === "ignore") {
+                    return of({ data: undefined });
+                }
+                return of({ data: undefined, error });
+            }), filter((result) => !!(result.data || result.error)));
+        }));
+        return Object.assign(observable, { restart: () => restart?.() });
     }
     removeQuery(queryId) {
         // teardown all links
@@ -738,8 +744,8 @@ export class QueryManager {
     // Prefer context.queryDeduplication if specified.
     deduplication = context?.queryDeduplication ??
         this.queryDeduplication) {
-        let observable;
-        const { serverQuery, clientQuery } = this.getDocumentInfo(query);
+        let entry = {};
+        const { serverQuery, clientQuery, operationType } = this.getDocumentInfo(query);
         const operationName = getOperationName(query);
         const executeContext = {
             client: this.client,
@@ -759,29 +765,51 @@ export class QueryManager {
                 extensions,
             };
             context = operation.context;
+            function withRestart(source) {
+                return new Observable((observer) => {
+                    function subscribe() {
+                        return source.subscribe({
+                            next: observer.next.bind(observer),
+                            complete: observer.complete.bind(observer),
+                            error: observer.error.bind(observer),
+                        });
+                    }
+                    let subscription = subscribe();
+                    entry.restart ||= () => {
+                        subscription.unsubscribe();
+                        subscription = subscribe();
+                    };
+                    return () => {
+                        subscription.unsubscribe();
+                        entry.restart = undefined;
+                    };
+                });
+            }
             if (deduplication) {
                 const printedServerQuery = print(serverQuery);
                 const varJson = canonicalStringify(variables);
-                const entry = inFlightLinkObservables.lookup(printedServerQuery, varJson);
-                observable = entry.observable;
-                if (!observable) {
-                    observable = entry.observable = execute(link, operation, executeContext).pipe(onAnyEvent((event) => {
-                        if ((event.type !== "next" ||
-                            !("hasNext" in event.value) ||
-                            !event.value.hasNext) &&
-                            inFlightLinkObservables.peek(printedServerQuery, varJson) ===
-                                entry) {
+                entry = inFlightLinkObservables.lookup(printedServerQuery, varJson);
+                if (!entry.observable) {
+                    entry.observable = execute(link, operation, executeContext).pipe(withRestart, finalize(() => {
+                        if (inFlightLinkObservables.peek(printedServerQuery, varJson) ===
+                            entry) {
                             inFlightLinkObservables.remove(printedServerQuery, varJson);
                         }
-                    }), shareReplay({ refCount: true }));
+                    }), 
+                    // We don't want to replay the last emitted value for
+                    // subscriptions and instead opt to wait to receive updates until
+                    // the subscription emits new values.
+                    operationType === OperationTypeNode.SUBSCRIPTION ?
+                        share()
+                        : shareReplay({ refCount: true }));
                 }
             }
             else {
-                observable = execute(link, operation, executeContext);
+                entry.observable = execute(link, operation, executeContext).pipe(withRestart);
             }
         }
         else {
-            observable = of({ data: {} });
+            entry.observable = of({ data: {} });
         }
         if (clientQuery) {
             if (__DEV__) {
@@ -793,7 +821,7 @@ export class QueryManager {
                     operationName ?? "(anonymous)"
                 );
             }
-            observable = observable.pipe(mergeMap((result) => {
+            entry.observable = entry.observable.pipe(mergeMap((result) => {
                 return from(this.localState.execute({
                     client: this.client,
                     document: clientQuery,
@@ -803,11 +831,14 @@ export class QueryManager {
                 }));
             }));
         }
-        return observable.pipe(catchError((error) => {
-            error = toErrorLike(error);
-            registerLinkError(error);
-            throw error;
-        }));
+        return {
+            restart: () => entry.restart?.(),
+            observable: entry.observable.pipe(catchError((error) => {
+                error = toErrorLike(error);
+                registerLinkError(error);
+                throw error;
+            })),
+        };
     }
     getResultsFromLink(queryInfo, cacheWriteBehavior, options) {
         const requestId = (queryInfo.lastRequestId = this.generateRequestId());
@@ -816,7 +847,7 @@ export class QueryManager {
         // missing fragment definitions (for example) before sending this document
         // through the link chain.
         const linkDocument = this.cache.transformForLink(options.query);
-        return this.getObservableFromLink(linkDocument, options.context, options.variables).pipe(map((result) => {
+        return this.getObservableFromLink(linkDocument, options.context, options.variables).observable.pipe(map((result) => {
             const graphQLErrors = getGraphQLErrorsFromResult(result);
             const hasErrors = graphQLErrors.length > 0;
             // If we interrupted this request by calling getResultsFromLink again