@apollo/client 3.13.4 → 4.0.0-alpha.1

package/react/internal/cache/QueryReference.js

@@ -1,38 +1,37 @@
-import { __assign } from "tslib";
 import { equal } from "@wry/equality";
-import { createFulfilledPromise, createRejectedPromise, } from "../../../utilities/index.js";
-import { wrapPromiseWithState } from "../../../utilities/index.js";
-import { invariant } from "../../../utilities/globals/invariantWrappers.js";
-var QUERY_REFERENCE_SYMBOL = Symbol.for("apollo.internal.queryRef");
-var PROMISE_SYMBOL = Symbol.for("apollo.internal.refPromise");
+import { filter } from "rxjs";
+import { CombinedGraphQLErrors } from "@apollo/client/core";
+import { createFulfilledPromise, createRejectedPromise, } from "@apollo/client/utilities";
+import { wrapPromiseWithState } from "@apollo/client/utilities";
+import { invariant } from "@apollo/client/utilities/invariant";
+const QUERY_REFERENCE_SYMBOL = Symbol.for("apollo.internal.queryRef");
+const PROMISE_SYMBOL = Symbol.for("apollo.internal.refPromise");
 export function wrapQueryRef(internalQueryRef) {
-    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; });
-            }
+    const ref = {
+        toPromise() {
+            // 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(() => ref);
         },
-        _a[QUERY_REFERENCE_SYMBOL] = internalQueryRef,
-        _a[PROMISE_SYMBOL] = internalQueryRef.promise,
-        _a);
+        [QUERY_REFERENCE_SYMBOL]: internalQueryRef,
+        [PROMISE_SYMBOL]: internalQueryRef.promise,
+    };
     return ref;
 }
 export function assertWrappedQueryRef(queryRef) {
-    invariant(!queryRef || QUERY_REFERENCE_SYMBOL in queryRef, 69);
+    invariant(!queryRef || QUERY_REFERENCE_SYMBOL in queryRef, 30);
 }
 export function getWrappedPromise(queryRef) {
-    var internalQueryRef = unwrapQueryRef(queryRef);
+    const internalQueryRef = unwrapQueryRef(queryRef);
     return internalQueryRef.promise.status === "fulfilled" ?
         internalQueryRef.promise
         : queryRef[PROMISE_SYMBOL];
@@ -43,7 +42,7 @@ export function unwrapQueryRef(queryRef) {
 export function updateWrappedQueryRef(queryRef, promise) {
     queryRef[PROMISE_SYMBOL] = promise;
 }
-var OBSERVED_CHANGED_OPTIONS = [
+const OBSERVED_CHANGED_OPTIONS = [
     "canonizeResults",
     "context",
     "errorPolicy",
@@ -51,15 +50,20 @@ var OBSERVED_CHANGED_OPTIONS = [
     "refetchWritePolicy",
     "returnPartialData",
 ];
-var InternalQueryReference = /** @class */ (function () {
-    function InternalQueryReference(observable, options) {
-        var _this = this;
-        this.key = {};
-        this.listeners = new Set();
-        this.references = 0;
-        this.softReferences = 0;
+export class InternalQueryReference {
+    result;
+    key = {};
+    observable;
+    promise;
+    subscription;
+    listeners = new Set();
+    autoDisposeTimeoutId;
+    resolve;
+    reject;
+    references = 0;
+    softReferences = 0;
+    constructor(observable, options) {
         this.handleNext = this.handleNext.bind(this);
-        this.handleError = this.handleError.bind(this);
         this.dispose = this.dispose.bind(this);
         this.observable = observable;
         if (options.onDispose) {
@@ -71,10 +75,9 @@ var InternalQueryReference = /** @class */ (function () {
         // 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.
-        var startDisposeTimer = function () {
-            var _a;
-            if (!_this.references) {
-                _this.autoDisposeTimeoutId = setTimeout(_this.dispose, (_a = options.autoDisposeTimeoutMs) !== null && _a !== void 0 ? _a : 30000);
+        const startDisposeTimer = () => {
+            if (!this.references) {
+                this.autoDisposeTimeoutId = setTimeout(this.dispose, options.autoDisposeTimeoutMs ?? 30_000);
             }
         };
         // We wait until the request has settled to ensure we don't dispose of the
@@ -82,24 +85,16 @@ var InternalQueryReference = /** @class */ (function () {
         // promise in a pending state rendering the suspense boundary indefinitely.
         this.promise.then(startDisposeTimer, startDisposeTimer);
     }
-    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";
+    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";
         try {
             if (avoidNetworkRequests) {
                 observable.silentSetOptions({ fetchPolicy: "standby" });
@@ -118,30 +113,28 @@ var InternalQueryReference = /** @class */ (function () {
         finally {
             observable.silentSetOptions({ fetchPolicy: originalFetchPolicy });
         }
-    };
-    InternalQueryReference.prototype.retain = function () {
-        var _this = this;
+    }
+    retain() {
         this.references++;
         clearTimeout(this.autoDisposeTimeoutId);
-        var disposed = false;
-        return function () {
+        let disposed = false;
+        return () => {
             if (disposed) {
                 return;
             }
             disposed = true;
-            _this.references--;
-            setTimeout(function () {
-                if (!_this.references) {
-                    _this.dispose();
+            this.references--;
+            setTimeout(() => {
+                if (!this.references) {
+                    this.dispose();
                 }
             });
         };
-    };
-    InternalQueryReference.prototype.softRetain = function () {
-        var _this = this;
+    }
+    softRetain() {
         this.softReferences++;
-        var disposed = false;
-        return function () {
+        let disposed = false;
+        return () => {
             // 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.
@@ -149,23 +142,20 @@ var InternalQueryReference = /** @class */ (function () {
                 return;
             }
             disposed = true;
-            _this.softReferences--;
-            setTimeout(function () {
-                if (!_this.softReferences && !_this.references) {
-                    _this.dispose();
+            this.softReferences--;
+            setTimeout(() => {
+                if (!this.softReferences && !this.references) {
+                    this.dispose();
                 }
             });
         };
-    };
-    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;
+    }
+    didChangeOptions(watchQueryOptions) {
+        return OBSERVED_CHANGED_OPTIONS.some((option) => option in watchQueryOptions &&
+            !equal(this.watchQueryOptions[option], watchQueryOptions[option]));
+    }
+    applyOptions(watchQueryOptions) {
+        const { fetchPolicy: currentFetchPolicy, canonizeResults: currentCanonizeResults, } = this.watchQueryOptions;
         // "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" &&
@@ -175,34 +165,32 @@ var InternalQueryReference = /** @class */ (function () {
         else {
             this.observable.silentSetOptions(watchQueryOptions);
             if (currentCanonizeResults !== watchQueryOptions.canonizeResults) {
-                this.result = __assign(__assign({}, this.result), this.observable.getCurrentResult());
+                this.result = { ...this.result, ...this.observable.getCurrentResult() };
                 this.promise = createFulfilledPromise(this.result);
             }
         }
         return this.promise;
-    };
-    InternalQueryReference.prototype.listen = function (listener) {
-        var _this = this;
+    }
+    listen(listener) {
         this.listeners.add(listener);
-        return function () {
-            _this.listeners.delete(listener);
+        return () => {
+            this.listeners.delete(listener);
         };
-    };
-    InternalQueryReference.prototype.refetch = function (variables) {
+    }
+    refetch(variables) {
         return this.initiateFetch(this.observable.refetch(variables));
-    };
-    InternalQueryReference.prototype.fetchMore = function (options) {
+    }
+    fetchMore(options) {
         return this.initiateFetch(this.observable.fetchMore(options));
-    };
-    InternalQueryReference.prototype.dispose = function () {
+    }
+    dispose() {
         this.subscription.unsubscribe();
         this.onDispose();
-    };
-    InternalQueryReference.prototype.onDispose = function () {
+    }
+    onDispose() {
         // noop. overridable by options
-    };
-    InternalQueryReference.prototype.handleNext = function (result) {
-        var _a;
+    }
+    handleNext(result) {
         switch (this.promise.status) {
             case "pending": {
                 // Maintain the last successful `data` value if the next result does not
@@ -210,8 +198,13 @@ var InternalQueryReference = /** @class */ (function () {
                 if (result.data === void 0) {
                     result.data = this.result.data;
                 }
-                this.result = result;
-                (_a = this.resolve) === null || _a === void 0 ? void 0 : _a.call(this, result);
+                if (this.shouldReject(result)) {
+                    this.reject?.(result.error);
+                }
+                else {
+                    this.result = result;
+                    this.resolve?.(result);
+                }
                 break;
             }
             default: {
@@ -227,42 +220,32 @@ var InternalQueryReference = /** @class */ (function () {
                 if (result.data === void 0) {
                     result.data = this.result.data;
                 }
-                this.result = result;
-                this.promise = createFulfilledPromise(result);
-                this.deliver(this.promise);
-                break;
-            }
-        }
-    };
-    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);
+                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);
+                }
                 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;
+    }
+    deliver(promise) {
+        this.listeners.forEach((listener) => listener(promise));
+    }
+    initiateFetch(returnedPromise) {
         this.promise = this.createPendingPromise();
-        this.promise.catch(function () { });
+        this.promise.catch(() => { });
         // 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(function () {
+            .then(() => {
             // 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
@@ -273,9 +256,8 @@ var InternalQueryReference = /** @class */ (function () {
             // promise is checked.
             // See https://github.com/apollographql/apollo-client/issues/11315 for
             // more information
-            setTimeout(function () {
-                var _a;
-                if (_this.promise.status === "pending") {
+            setTimeout(() => {
+                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
@@ -284,42 +266,46 @@ var InternalQueryReference = /** @class */ (function () {
                     //
                     // See the following for more information:
                     // https://github.com/apollographql/apollo-client/issues/11642
-                    _this.result = _this.observable.getCurrentResult();
-                    (_a = _this.resolve) === null || _a === void 0 ? void 0 : _a.call(_this, _this.result);
+                    this.result = this.observable.getCurrentResult();
+                    this.resolve?.(this.result);
                 }
             });
         })
-            .catch(function (error) { var _a; return (_a = _this.reject) === null || _a === void 0 ? void 0 : _a.call(_this, error); });
+            .catch((error) => this.reject?.(error));
         return returnedPromise;
-    };
-    InternalQueryReference.prototype.subscribeToQuery = function () {
-        var _this = this;
+    }
+    subscribeToQuery() {
         this.subscription = this.observable
-            .filter(function (result) { return !equal(result.data, {}) && !equal(result, _this.result); })
-            .subscribe(this.handleNext, this.handleError);
-    };
-    InternalQueryReference.prototype.setResult = function () {
+            .pipe(filter((result) => !equal(result, this.result)))
+            .subscribe(this.handleNext);
+    }
+    setResult() {
         // Don't save this result as last result to prevent delivery of last result
         // when first subscribing
-        var result = this.observable.getCurrentResult(false);
+        const result = this.observable.getCurrentResult(false);
         if (equal(result, this.result)) {
             return;
         }
         this.result = result;
         this.promise =
-            (result.data &&
-                (!result.partial || this.watchQueryOptions.returnPartialData)) ?
+            result.data ?
                 createFulfilledPromise(result)
                 : this.createPendingPromise();
-    };
-    InternalQueryReference.prototype.createPendingPromise = function () {
-        var _this = this;
-        return wrapPromiseWithState(new Promise(function (resolve, reject) {
-            _this.resolve = resolve;
-            _this.reject = reject;
+    }
+    shouldReject(result) {
+        const { errorPolicy } = this.watchQueryOptions;
+        // TODO: Determine if we still want the behavior of always rejecting
+        // "network" errors (any error that isn't a CombinedGraphQLErrors).
+        return (result.error &&
+            (!(result.error instanceof CombinedGraphQLErrors) ||
+                errorPolicy === "none" ||
+                errorPolicy === undefined));
+    }
+    createPendingPromise() {
+        return wrapPromiseWithState(new Promise((resolve, reject) => {
+            this.resolve = resolve;
+            this.reject = reject;
         }));
-    };
-    return InternalQueryReference;
-}());
-export { InternalQueryReference };
-//# sourceMappingURL=QueryReference.js.map
+    }
+}
+//# sourceMappingURL=QueryReference.js.map