@apollo/client 3.13.9-rc.0 → 3.14.0-alpha.1

package/react/internal/cache/QueryReference.js

@@ -1,20 +1,39 @@
+import { __assign } from "tslib";
 import { equal } from "@wry/equality";
-import { filter } from "rxjs";
-import { createFulfilledPromise, createRejectedPromise, decoratePromise, } from "@apollo/client/utilities/internal";
-import { invariant } from "@apollo/client/utilities/invariant";
-const QUERY_REFERENCE_SYMBOL = Symbol.for("apollo.internal.queryRef");
-const PROMISE_SYMBOL = Symbol.for("apollo.internal.refPromise");
+import { createFulfilledPromise, createRejectedPromise, } from "../../../utilities/index.js";
+import { wrapPromiseWithState } from "../../../utilities/index.js";
+import { invariant } from "../../../utilities/globals/invariantWrappers.js";
+import { muteDeprecations } from "../../../utilities/deprecation/index.js";
+var QUERY_REFERENCE_SYMBOL = Symbol.for("apollo.internal.queryRef");
+var PROMISE_SYMBOL = Symbol.for("apollo.internal.refPromise");
 export function wrapQueryRef(internalQueryRef) {
-    return {
-        [QUERY_REFERENCE_SYMBOL]: internalQueryRef,
-        [PROMISE_SYMBOL]: internalQueryRef.promise,
-    };
+    var _a;
+    var ref = (_a = {
+            toPromise: function () {
+                // We avoid resolving this promise with the query data because we want to
+                // discourage using the server data directly from the queryRef. Instead,
+                // the data should be accessed through `useReadQuery`. When the server
+                // data is needed, its better to use `client.query()` directly.
+                //
+                // Here we resolve with the ref itself to make using this in React Router
+                // or TanStack Router `loader` functions a bit more ergonomic e.g.
+                //
+                // function loader() {
+                //   return { queryRef: await preloadQuery(query).toPromise() }
+                // }
+                return getWrappedPromise(ref).then(function () { return ref; });
+            }
+        },
+        _a[QUERY_REFERENCE_SYMBOL] = internalQueryRef,
+        _a[PROMISE_SYMBOL] = internalQueryRef.promise,
+        _a);
+    return ref;
 }
 export function assertWrappedQueryRef(queryRef) {
-    invariant(!queryRef || QUERY_REFERENCE_SYMBOL in queryRef, 27);
+    invariant(!queryRef || QUERY_REFERENCE_SYMBOL in queryRef, 93);
 }
 export function getWrappedPromise(queryRef) {
-    const internalQueryRef = unwrapQueryRef(queryRef);
+    var internalQueryRef = unwrapQueryRef(queryRef);
     return internalQueryRef.promise.status === "fulfilled" ?
         internalQueryRef.promise
         : queryRef[PROMISE_SYMBOL];
@@ -25,27 +44,23 @@ export function unwrapQueryRef(queryRef) {
 export function updateWrappedQueryRef(queryRef, promise) {
     queryRef[PROMISE_SYMBOL] = promise;
 }
-const OBSERVED_CHANGED_OPTIONS = [
+var OBSERVED_CHANGED_OPTIONS = [
+    "canonizeResults",
     "context",
     "errorPolicy",
     "fetchPolicy",
     "refetchWritePolicy",
     "returnPartialData",
 ];
-export class InternalQueryReference {
-    result;
-    key = {};
-    observable;
-    promise;
-    subscription;
-    listeners = new Set();
-    autoDisposeTimeoutId;
-    resolve;
-    reject;
-    references = 0;
-    softReferences = 0;
-    constructor(observable, options) {
+var InternalQueryReference = /** @class */ (function () {
+    function InternalQueryReference(observable, options) {
+        var _this = this;
+        this.key = {};
+        this.listeners = new Set();
+        this.references = 0;
+        this.softReferences = 0;
         this.handleNext = this.handleNext.bind(this);
+        this.handleError = this.handleError.bind(this);
         this.dispose = this.dispose.bind(this);
         this.observable = observable;
         if (options.onDispose) {
@@ -57,9 +72,10 @@ export class InternalQueryReference {
         // suspended resource does not use this queryRef in the given time. This
         // helps prevent memory leaks when a component has unmounted before the
         // query has finished loading.
-        const startDisposeTimer = () => {
-            if (!this.references) {
-                this.autoDisposeTimeoutId = setTimeout(this.dispose, options.autoDisposeTimeoutMs ?? 30_000);
+        var startDisposeTimer = function () {
+            var _a;
+            if (!_this.references) {
+                _this.autoDisposeTimeoutId = setTimeout(_this.dispose, (_a = options.autoDisposeTimeoutMs) !== null && _a !== void 0 ? _a : 30000);
             }
         };
         // We wait until the request has settled to ensure we don't dispose of the
@@ -67,54 +83,68 @@ export class InternalQueryReference {
         // promise in a pending state rendering the suspense boundary indefinitely.
         this.promise.then(startDisposeTimer, startDisposeTimer);
     }
-    get disposed() {
-        return this.subscription.closed;
-    }
-    get watchQueryOptions() {
-        return this.observable.options;
-    }
-    reinitialize() {
-        const { observable } = this;
-        const originalFetchPolicy = this.watchQueryOptions.fetchPolicy;
-        const avoidNetworkRequests = originalFetchPolicy === "no-cache" || originalFetchPolicy === "standby";
+    Object.defineProperty(InternalQueryReference.prototype, "disposed", {
+        get: function () {
+            return this.subscription.closed;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(InternalQueryReference.prototype, "watchQueryOptions", {
+        get: function () {
+            return this.observable.options;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    InternalQueryReference.prototype.reinitialize = function () {
+        var observable = this.observable;
+        var originalFetchPolicy = this.watchQueryOptions.fetchPolicy;
+        var avoidNetworkRequests = originalFetchPolicy === "no-cache" || originalFetchPolicy === "standby";
         try {
             if (avoidNetworkRequests) {
-                observable.applyOptions({ fetchPolicy: "standby" });
+                observable.silentSetOptions({ fetchPolicy: "standby" });
             }
             else {
-                observable.reset();
-                observable.applyOptions({ fetchPolicy: "cache-first" });
-            }
-            if (!avoidNetworkRequests) {
-                this.setResult();
+                muteDeprecations("resetLastResults", function () {
+                    return observable.resetLastResults();
+                });
+                observable.silentSetOptions({ fetchPolicy: "cache-first" });
             }
             this.subscribeToQuery();
+            if (avoidNetworkRequests) {
+                return;
+            }
+            observable.resetDiff();
+            this.setResult();
         }
         finally {
-            observable.applyOptions({ fetchPolicy: originalFetchPolicy });
+            observable.silentSetOptions({ fetchPolicy: originalFetchPolicy });
         }
-    }
-    retain() {
+    };
+    InternalQueryReference.prototype.retain = function () {
+        var _this = this;
         this.references++;
         clearTimeout(this.autoDisposeTimeoutId);
-        let disposed = false;
-        return () => {
+        var disposed = false;
+        return function () {
             if (disposed) {
                 return;
             }
             disposed = true;
-            this.references--;
-            setTimeout(() => {
-                if (!this.references) {
-                    this.dispose();
+            _this.references--;
+            setTimeout(function () {
+                if (!_this.references) {
+                    _this.dispose();
                 }
             });
         };
-    }
-    softRetain() {
+    };
+    InternalQueryReference.prototype.softRetain = function () {
+        var _this = this;
         this.softReferences++;
-        let disposed = false;
-        return () => {
+        var disposed = false;
+        return function () {
             // Tracking if this has already been called helps ensure that
             // multiple calls to this function won't decrement the reference
             // counter more than it should. Subsequent calls just result in a noop.
@@ -122,20 +152,23 @@ export class InternalQueryReference {
                 return;
             }
             disposed = true;
-            this.softReferences--;
-            setTimeout(() => {
-                if (!this.softReferences && !this.references) {
-                    this.dispose();
+            _this.softReferences--;
+            setTimeout(function () {
+                if (!_this.softReferences && !_this.references) {
+                    _this.dispose();
                 }
             });
         };
-    }
-    didChangeOptions(watchQueryOptions) {
-        return OBSERVED_CHANGED_OPTIONS.some((option) => option in watchQueryOptions &&
-            !equal(this.watchQueryOptions[option], watchQueryOptions[option]));
-    }
-    applyOptions(watchQueryOptions) {
-        const { fetchPolicy: currentFetchPolicy } = this.watchQueryOptions;
+    };
+    InternalQueryReference.prototype.didChangeOptions = function (watchQueryOptions) {
+        var _this = this;
+        return OBSERVED_CHANGED_OPTIONS.some(function (option) {
+            return option in watchQueryOptions &&
+                !equal(_this.watchQueryOptions[option], watchQueryOptions[option]);
+        });
+    };
+    InternalQueryReference.prototype.applyOptions = function (watchQueryOptions) {
+        var _a = this.watchQueryOptions, currentFetchPolicy = _a.fetchPolicy, currentCanonizeResults = _a.canonizeResults;
         // "standby" is used when `skip` is set to `true`. Detect when we've
         // enabled the query (i.e. `skip` is `false`) to execute a network request.
         if (currentFetchPolicy === "standby" &&
@@ -143,48 +176,45 @@ export class InternalQueryReference {
             this.initiateFetch(this.observable.reobserve(watchQueryOptions));
         }
         else {
-            this.observable.applyOptions(watchQueryOptions);
+            this.observable.silentSetOptions(watchQueryOptions);
+            if (currentCanonizeResults !== watchQueryOptions.canonizeResults) {
+                this.result = __assign(__assign({}, this.result), this.observable.getCurrentResult());
+                this.promise = createFulfilledPromise(this.result);
+            }
         }
         return this.promise;
-    }
-    listen(listener) {
+    };
+    InternalQueryReference.prototype.listen = function (listener) {
+        var _this = this;
         this.listeners.add(listener);
-        return () => {
-            this.listeners.delete(listener);
+        return function () {
+            _this.listeners.delete(listener);
         };
-    }
-    refetch(variables) {
+    };
+    InternalQueryReference.prototype.refetch = function (variables) {
         return this.initiateFetch(this.observable.refetch(variables));
-    }
-    fetchMore(options) {
+    };
+    InternalQueryReference.prototype.fetchMore = function (options) {
         return this.initiateFetch(this.observable.fetchMore(options));
-    }
-    dispose() {
+    };
+    InternalQueryReference.prototype.dispose = function () {
         this.subscription.unsubscribe();
-    }
-    onDispose() {
+        this.onDispose();
+    };
+    InternalQueryReference.prototype.onDispose = function () {
         // noop. overridable by options
-    }
-    handleNext(result) {
+    };
+    InternalQueryReference.prototype.handleNext = function (result) {
+        var _a;
         switch (this.promise.status) {
             case "pending": {
                 // Maintain the last successful `data` value if the next result does not
                 // have one.
-                // TODO: This can likely be removed once
-                // https://github.com/apollographql/apollo-client/issues/12667 is fixed
                 if (result.data === void 0) {
                     result.data = this.result.data;
-                    if (result.data) {
-                        result.dataState = "complete";
-                    }
-                }
-                if (this.shouldReject(result)) {
-                    this.reject?.(result.error);
-                }
-                else {
-                    this.result = result;
-                    this.resolve?.(result);
                 }
+                this.result = result;
+                (_a = this.resolve) === null || _a === void 0 ? void 0 : _a.call(this, result);
                 break;
             }
             default: {
@@ -200,32 +230,42 @@ export class InternalQueryReference {
                 if (result.data === void 0) {
                     result.data = this.result.data;
                 }
-                if (this.shouldReject(result)) {
-                    this.promise = createRejectedPromise(result.error);
-                    this.deliver(this.promise);
-                }
-                else {
-                    this.result = result;
-                    this.promise = createFulfilledPromise(result);
-                    this.deliver(this.promise);
-                }
+                this.result = result;
+                this.promise = createFulfilledPromise(result);
+                this.deliver(this.promise);
                 break;
             }
         }
-    }
-    deliver(promise) {
-        this.listeners.forEach((listener) => listener(promise));
-    }
-    initiateFetch(returnedPromise) {
+    };
+    InternalQueryReference.prototype.handleError = function (error) {
+        var _a;
+        this.subscription.unsubscribe();
+        this.subscription = this.observable.resubscribeAfterError(this.handleNext, this.handleError);
+        switch (this.promise.status) {
+            case "pending": {
+                (_a = this.reject) === null || _a === void 0 ? void 0 : _a.call(this, error);
+                break;
+            }
+            default: {
+                this.promise = createRejectedPromise(error);
+                this.deliver(this.promise);
+            }
+        }
+    };
+    InternalQueryReference.prototype.deliver = function (promise) {
+        this.listeners.forEach(function (listener) { return listener(promise); });
+    };
+    InternalQueryReference.prototype.initiateFetch = function (returnedPromise) {
+        var _this = this;
         this.promise = this.createPendingPromise();
-        this.promise.catch(() => { });
+        this.promise.catch(function () { });
         // If the data returned from the fetch is deeply equal to the data already
         // in the cache, `handleNext` will not be triggered leaving the promise we
         // created in a pending state forever. To avoid this situtation, we attempt
         // to resolve the promise if `handleNext` hasn't been run to ensure the
         // promise is resolved correctly.
         returnedPromise
-            .then(() => {
+            .then(function () {
             // In the case of `fetchMore`, this promise is resolved before a cache
             // result is emitted due to the fact that `fetchMore` sets a `no-cache`
             // fetch policy and runs `cache.batch` in its `.then` handler. Because
@@ -236,8 +276,9 @@ export class InternalQueryReference {
             // promise is checked.
             // See https://github.com/apollographql/apollo-client/issues/11315 for
             // more information
-            setTimeout(() => {
-                if (this.promise.status === "pending") {
+            setTimeout(function () {
+                var _a;
+                if (_this.promise.status === "pending") {
                     // Use the current result from the observable instead of the value
                     // resolved from the promise. This avoids issues in some cases where
                     // the raw resolved value should not be the emitted value, such as
@@ -246,44 +287,42 @@ export class InternalQueryReference {
                     //
                     // See the following for more information:
                     // https://github.com/apollographql/apollo-client/issues/11642
-                    this.result =
-                        this.observable.getCurrentResult();
-                    this.resolve?.(this.result);
+                    _this.result = _this.observable.getCurrentResult();
+                    (_a = _this.resolve) === null || _a === void 0 ? void 0 : _a.call(_this, _this.result);
                 }
             });
         })
-            .catch((error) => this.reject?.(error));
+            .catch(function (error) { var _a; return (_a = _this.reject) === null || _a === void 0 ? void 0 : _a.call(_this, error); });
         return returnedPromise;
-    }
-    subscribeToQuery() {
+    };
+    InternalQueryReference.prototype.subscribeToQuery = function () {
+        var _this = this;
         this.subscription = this.observable
-            .pipe(filter((result) => !equal(result, this.result)))
-            .subscribe(this.handleNext);
-        // call `onDispose` when the subscription is finalized, either because it is
-        // unsubscribed as a consequence of a `dispose` call or because the
-        // ObservableQuery completes because of a `ApolloClient.stop()` call.
-        this.subscription.add(this.onDispose);
-    }
-    setResult() {
-        const result = this.observable.getCurrentResult();
+            .filter(function (result) { return !equal(result.data, {}) && !equal(result, _this.result); })
+            .subscribe(this.handleNext, this.handleError);
+    };
+    InternalQueryReference.prototype.setResult = function () {
+        // Don't save this result as last result to prevent delivery of last result
+        // when first subscribing
+        var result = this.observable.getCurrentResult(false);
         if (equal(result, this.result)) {
             return;
         }
         this.result = result;
         this.promise =
-            result.data ?
+            (result.data &&
+                (!result.partial || this.watchQueryOptions.returnPartialData)) ?
                 createFulfilledPromise(result)
                 : this.createPendingPromise();
-    }
-    shouldReject(result) {
-        const { errorPolicy = "none" } = this.watchQueryOptions;
-        return result.error && errorPolicy === "none";
-    }
-    createPendingPromise() {
-        return decoratePromise(new Promise((resolve, reject) => {
-            this.resolve = resolve;
-            this.reject = reject;
+    };
+    InternalQueryReference.prototype.createPendingPromise = function () {
+        var _this = this;
+        return wrapPromiseWithState(new Promise(function (resolve, reject) {
+            _this.resolve = resolve;
+            _this.reject = reject;
         }));
-    }
-}
-//# sourceMappingURL=QueryReference.js.map
+    };
+    return InternalQueryReference;
+}());
+export { InternalQueryReference };
+//# sourceMappingURL=QueryReference.js.map