@apollo/client 3.13.4 → 4.0.0-alpha.0

package/core/QueryInfo.d.ts

@@ -1,13 +1,10 @@
-import type { DocumentNode, GraphQLFormattedError } from "graphql";
-import type { Cache } from "../cache/index.js";
-import type { WatchQueryOptions, ErrorPolicy } from "./watchQueryOptions.js";
+import type { DocumentNode } from "graphql";
+import type { Cache } from "@apollo/client/cache";
+import type { FetchResult } from "@apollo/client/link/core";
 import type { ObservableQuery } from "./ObservableQuery.js";
-import type { QueryListener } from "./types.js";
-import type { FetchResult } from "../link/core/index.js";
-import { NetworkStatus } from "./networkStatus.js";
-import type { ApolloError } from "../errors/index.js";
 import type { QueryManager } from "./QueryManager.js";
-export type QueryStoreValue = Pick<QueryInfo, "variables" | "networkStatus" | "networkError" | "graphQLErrors">;
+import type { QueryListener } from "./types.js";
+import type { ErrorPolicy, WatchQueryOptions } from "./watchQueryOptions.js";
 export declare const enum CacheWriteBehavior {
     FORBID = 0,
     OVERWRITE = 1,
@@ -19,16 +16,12 @@ export declare class QueryInfo {
     document: DocumentNode | null;
     lastRequestId: number;
     variables?: Record<string, any>;
-    networkStatus?: NetworkStatus;
-    networkError?: Error | null;
-    graphQLErrors?: ReadonlyArray<GraphQLFormattedError>;
     stopped: boolean;
     private cache;
     constructor(queryManager: QueryManager<any>, queryId?: string);
     init(query: {
         document: DocumentNode;
         variables: Record<string, any> | undefined;
-        networkStatus?: NetworkStatus;
         observableQuery?: ObservableQuery<any, any>;
         lastRequestId?: number;
     }): this;
@@ -54,8 +47,6 @@ export declare class QueryInfo {
     resetLastWrite(): void;
     private shouldWrite;
     markResult<T>(result: FetchResult<T>, document: DocumentNode, options: Pick<WatchQueryOptions, "variables" | "fetchPolicy" | "errorPolicy">, cacheWriteBehavior: CacheWriteBehavior): void;
-    markReady(): NetworkStatus;
-    markError(error: ApolloError): ApolloError;
 }
 export declare function shouldWriteResult<T>(result: FetchResult<T>, errorPolicy?: ErrorPolicy): boolean;
-//# sourceMappingURL=QueryInfo.d.ts.map
+//# sourceMappingURL=QueryInfo.d.ts.map

package/core/QueryInfo.js

@@ -1,13 +1,12 @@
-import { __assign } from "tslib";
 import { equal } from "@wry/equality";
-import { DeepMerger } from "../utilities/index.js";
-import { mergeIncrementalData } from "../utilities/index.js";
+import { graphQLResultHasError, isNonEmptyArray, } from "@apollo/client/utilities";
+import { mergeIncrementalData } from "@apollo/client/utilities";
+import { DeepMerger } from "@apollo/client/utilities";
+import { isNetworkRequestInFlight } from "./networkStatus.js";
 import { reobserveCacheFirst } from "./ObservableQuery.js";
-import { isNonEmptyArray, graphQLResultHasError, canUseWeakMap, } from "../utilities/index.js";
-import { NetworkStatus, isNetworkRequestInFlight } from "./networkStatus.js";
-var destructiveMethodCounts = new (canUseWeakMap ? WeakMap : Map)();
+const destructiveMethodCounts = new WeakMap();
 function wrapDestructiveCacheMethod(cache, methodName) {
-    var original = cache[methodName];
+    const original = cache[methodName];
     if (typeof original === "function") {
         // @ts-expect-error this is just too generic to be typed correctly
         cache[methodName] = function () {
@@ -40,17 +39,17 @@ function cancelNotifyTimeout(info) {
 // any field privacy or meaningful methods, which is why it still has so
 // many public fields. The effort to lock down and simplify the QueryInfo
 // interface is ongoing, and further improvements are welcome.
-var QueryInfo = /** @class */ (function () {
-    function QueryInfo(queryManager, queryId) {
-        if (queryId === void 0) { queryId = queryManager.generateQueryId(); }
+export class QueryInfo {
+    queryId;
+    listeners = new Set();
+    document = null;
+    lastRequestId = 1;
+    variables;
+    stopped = false;
+    cache;
+    constructor(queryManager, queryId = queryManager.generateQueryId()) {
         this.queryId = queryId;
-        this.listeners = new Set();
-        this.document = null;
-        this.lastRequestId = 1;
-        this.stopped = false;
-        this.dirty = false;
-        this.observableQuery = null;
-        var cache = (this.cache = queryManager.cache);
+        const cache = (this.cache = queryManager.cache);
         // Track how often cache.evict is called, since we want eviction to
         // override the feud-stopping logic in the markResult method, by
         // causing shouldWrite to return true. Wrapping the cache.evict method
@@ -63,13 +62,7 @@ var QueryInfo = /** @class */ (function () {
             wrapDestructiveCacheMethod(cache, "reset");
         }
     }
-    QueryInfo.prototype.init = function (query) {
-        var networkStatus = query.networkStatus || NetworkStatus.loading;
-        if (this.variables &&
-            this.networkStatus !== NetworkStatus.loading &&
-            !equal(this.variables, query.variables)) {
-            networkStatus = NetworkStatus.setVariables;
-        }
+    init(query) {
         if (!equal(query.variables, this.variables)) {
             this.lastDiff = void 0;
         }
@@ -77,8 +70,6 @@ var QueryInfo = /** @class */ (function () {
             document: query.document,
             variables: query.variables,
             networkError: null,
-            graphQLErrors: this.graphQLErrors || [],
-            networkStatus: networkStatus,
         });
         if (query.observableQuery) {
             this.setObservableQuery(query.observableQuery);
@@ -87,52 +78,51 @@ var QueryInfo = /** @class */ (function () {
             this.lastRequestId = query.lastRequestId;
         }
         return this;
-    };
-    QueryInfo.prototype.reset = function () {
+    }
+    dirty = false;
+    notifyTimeout;
+    reset() {
         cancelNotifyTimeout(this);
         this.dirty = false;
-    };
-    QueryInfo.prototype.resetDiff = function () {
+    }
+    resetDiff() {
         this.lastDiff = void 0;
-    };
-    QueryInfo.prototype.getDiff = function () {
-        var options = this.getDiffOptions();
+    }
+    getDiff() {
+        const options = this.getDiffOptions();
         if (this.lastDiff && equal(options, this.lastDiff.options)) {
             return this.lastDiff.diff;
         }
         this.updateWatch(this.variables);
-        var oq = this.observableQuery;
+        const oq = this.observableQuery;
         if (oq && oq.options.fetchPolicy === "no-cache") {
-            return { complete: false };
+            return { result: null, complete: false };
         }
-        var diff = this.cache.diff(options);
+        const diff = this.cache.diff(options);
         this.updateLastDiff(diff, options);
         return diff;
-    };
-    QueryInfo.prototype.updateLastDiff = function (diff, options) {
+    }
+    lastDiff;
+    updateLastDiff(diff, options) {
         this.lastDiff =
             diff ?
                 {
-                    diff: diff,
+                    diff,
                     options: options || this.getDiffOptions(),
                 }
                 : void 0;
-    };
-    QueryInfo.prototype.getDiffOptions = function (variables) {
-        var _a;
-        if (variables === void 0) { variables = this.variables; }
+    }
+    getDiffOptions(variables = this.variables) {
         return {
             query: this.document,
-            variables: variables,
+            variables,
             returnPartialData: true,
             optimistic: true,
-            canonizeResults: (_a = this.observableQuery) === null || _a === void 0 ? void 0 : _a.options.canonizeResults,
+            canonizeResults: this.observableQuery?.options.canonizeResults,
         };
-    };
-    QueryInfo.prototype.setDiff = function (diff) {
-        var _this = this;
-        var _a;
-        var oldDiff = this.lastDiff && this.lastDiff.diff;
+    }
+    setDiff(diff) {
+        const oldDiff = this.lastDiff && this.lastDiff.diff;
         // If we are trying to deliver an incomplete cache result, we avoid
         // reporting it if the query has errored, otherwise we let the broadcast try
         // and repair the partial result by refetching the query. This check avoids
@@ -142,19 +132,20 @@ var QueryInfo = /** @class */ (function () {
         //
         // See https://github.com/apollographql/apollo-client/issues/11400 for more
         // information on this issue.
-        if (diff && !diff.complete && ((_a = this.observableQuery) === null || _a === void 0 ? void 0 : _a.getLastError())) {
+        if (diff && !diff.complete && this.observableQuery?.getLastError()) {
             return;
         }
         this.updateLastDiff(diff);
         if (!this.dirty && !equal(oldDiff && oldDiff.result, diff && diff.result)) {
             this.dirty = true;
             if (!this.notifyTimeout) {
-                this.notifyTimeout = setTimeout(function () { return _this.notify(); }, 0);
+                this.notifyTimeout = setTimeout(() => this.notify(), 0);
             }
         }
-    };
-    QueryInfo.prototype.setObservableQuery = function (oq) {
-        var _this = this;
+    }
+    observableQuery = null;
+    oqListener;
+    setObservableQuery(oq) {
         if (oq === this.observableQuery)
             return;
         if (this.oqListener) {
@@ -163,8 +154,8 @@ var QueryInfo = /** @class */ (function () {
         this.observableQuery = oq;
         if (oq) {
             oq["queryInfo"] = this;
-            this.listeners.add((this.oqListener = function () {
-                var diff = _this.getDiff();
+            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
@@ -189,28 +180,28 @@ var QueryInfo = /** @class */ (function () {
         else {
             delete this.oqListener;
         }
-    };
-    QueryInfo.prototype.notify = function () {
-        var _this = this;
+    }
+    notify() {
         cancelNotifyTimeout(this);
         if (this.shouldNotify()) {
-            this.listeners.forEach(function (listener) { return listener(_this); });
+            this.listeners.forEach((listener) => listener(this));
         }
         this.dirty = false;
-    };
-    QueryInfo.prototype.shouldNotify = function () {
+    }
+    shouldNotify() {
         if (!this.dirty || !this.listeners.size) {
             return false;
         }
-        if (isNetworkRequestInFlight(this.networkStatus) && this.observableQuery) {
-            var fetchPolicy = this.observableQuery.options.fetchPolicy;
+        if (this.observableQuery &&
+            isNetworkRequestInFlight(this.observableQuery["networkStatus"])) {
+            const { fetchPolicy } = this.observableQuery.options;
             if (fetchPolicy !== "cache-only" && fetchPolicy !== "cache-and-network") {
                 return false;
             }
         }
         return true;
-    };
-    QueryInfo.prototype.stop = function () {
+    }
+    stop() {
         if (!this.stopped) {
             this.stopped = true;
             // Cancel the pending notify timeout
@@ -219,32 +210,39 @@ var QueryInfo = /** @class */ (function () {
             // Revert back to the no-op version of cancel inherited from
             // QueryInfo.prototype.
             this.cancel = QueryInfo.prototype.cancel;
-            var oq = this.observableQuery;
+            const oq = this.observableQuery;
             if (oq)
                 oq.stopPolling();
         }
-    };
+    }
     // This method is a no-op by default, until/unless overridden by the
     // updateWatch method.
-    QueryInfo.prototype.cancel = function () { };
-    QueryInfo.prototype.updateWatch = function (variables) {
-        var _this = this;
-        if (variables === void 0) { variables = this.variables; }
-        var oq = this.observableQuery;
+    cancel() { }
+    lastWatch;
+    updateWatch(variables = this.variables) {
+        const oq = this.observableQuery;
         if (oq && oq.options.fetchPolicy === "no-cache") {
             return;
         }
-        var watchOptions = __assign(__assign({}, this.getDiffOptions(variables)), { watcher: this, callback: function (diff) { return _this.setDiff(diff); } });
+        const watchOptions = {
+            // Although this.getDiffOptions returns Cache.DiffOptions instead of
+            // Cache.WatchOptions, all the overlapping options should be the same, so
+            // we can reuse getDiffOptions here, for consistency.
+            ...this.getDiffOptions(variables),
+            watcher: this,
+            callback: (diff) => this.setDiff(diff),
+        };
         if (!this.lastWatch || !equal(watchOptions, this.lastWatch)) {
             this.cancel();
             this.cancel = this.cache.watch((this.lastWatch = watchOptions));
         }
-    };
-    QueryInfo.prototype.resetLastWrite = function () {
+    }
+    lastWrite;
+    resetLastWrite() {
         this.lastWrite = void 0;
-    };
-    QueryInfo.prototype.shouldWrite = function (result, variables) {
-        var lastWrite = this.lastWrite;
+    }
+    shouldWrite(result, variables) {
+        const { lastWrite } = this;
         return !(lastWrite &&
             // If cache.evict has been called since the last time we wrote this
             // data into the cache, there's a chance writing this result into
@@ -252,16 +250,14 @@ var QueryInfo = /** @class */ (function () {
             lastWrite.dmCount === destructiveMethodCounts.get(this.cache) &&
             equal(variables, lastWrite.variables) &&
             equal(result.data, lastWrite.result.data));
-    };
-    QueryInfo.prototype.markResult = function (result, document, options, cacheWriteBehavior) {
-        var _this = this;
-        var merger = new DeepMerger();
-        var graphQLErrors = isNonEmptyArray(result.errors) ? result.errors.slice(0) : [];
+    }
+    markResult(result, document, options, cacheWriteBehavior) {
+        const merger = new 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();
         if ("incremental" in result && isNonEmptyArray(result.incremental)) {
-            var mergedData = mergeIncrementalData(this.getDiff().result, result);
+            const mergedData = mergeIncrementalData(this.getDiff().result, result);
             result.data = mergedData;
             // Detect the first chunk of a deferred query and merge it with existing
             // cache data. This ensures a `cache-first` fetch policy that returns
@@ -270,10 +266,9 @@ var QueryInfo = /** @class */ (function () {
             // initial deferred server data with existing cache data.
         }
         else if ("hasNext" in result && result.hasNext) {
-            var diff = this.getDiff();
+            const diff = this.getDiff();
             result.data = merger.merge(diff.result, result.data);
         }
-        this.graphQLErrors = graphQLErrors;
         if (options.fetchPolicy === "no-cache") {
             this.updateLastDiff({ result: result.data, complete: true }, this.getDiffOptions(options.variables));
         }
@@ -283,18 +278,18 @@ var QueryInfo = /** @class */ (function () {
                 // back from the cache before the watch callback fires as a result
                 // of writeQuery, so we can store the new diff quietly and ignore
                 // it when we receive it redundantly from the watch callback.
-                this.cache.performTransaction(function (cache) {
-                    if (_this.shouldWrite(result, options.variables)) {
+                this.cache.performTransaction((cache) => {
+                    if (this.shouldWrite(result, options.variables)) {
                         cache.writeQuery({
                             query: document,
                             data: result.data,
                             variables: options.variables,
                             overwrite: cacheWriteBehavior === 1 /* CacheWriteBehavior.OVERWRITE */,
                         });
-                        _this.lastWrite = {
-                            result: result,
+                        this.lastWrite = {
+                            result,
                             variables: options.variables,
-                            dmCount: destructiveMethodCounts.get(_this.cache),
+                            dmCount: destructiveMethodCounts.get(this.cache),
                         };
                     }
                     else {
@@ -330,34 +325,34 @@ var QueryInfo = /** @class */ (function () {
                         // mitigate the clobbering somehow, but that would make this
                         // particular cache write even less important, and thus
                         // skipping it would be even safer than it is today.
-                        if (_this.lastDiff && _this.lastDiff.diff.complete) {
+                        if (this.lastDiff && this.lastDiff.diff.complete) {
                             // Reuse data from the last good (complete) diff that we
                             // received, when possible.
-                            result.data = _this.lastDiff.diff.result;
+                            result.data = this.lastDiff.diff.result;
                             return;
                         }
                         // If the previous this.diff was incomplete, fall through to
                         // re-reading the latest data with cache.diff, below.
                     }
-                    var diffOptions = _this.getDiffOptions(options.variables);
-                    var diff = cache.diff(diffOptions);
+                    const diffOptions = this.getDiffOptions(options.variables);
+                    const diff = cache.diff(diffOptions);
                     // In case the QueryManager stops this QueryInfo before its
                     // results are delivered, it's important to avoid restarting the
                     // cache watch when markResult is called. We also avoid updating
                     // the watch if we are writing a result that doesn't match the current
                     // variables to avoid race conditions from broadcasting the wrong
                     // result.
-                    if (!_this.stopped && equal(_this.variables, options.variables)) {
+                    if (!this.stopped && equal(this.variables, options.variables)) {
                         // Any time we're about to update this.diff, we need to make
                         // sure we've started watching the cache.
-                        _this.updateWatch(options.variables);
+                        this.updateWatch(options.variables);
                     }
                     // If we're allowed to write to the cache, and we can read a
                     // complete result from the cache, update result.data to be the
                     // result from the cache, rather than the raw network result.
                     // Set without setDiff to avoid triggering a notify call, since
                     // we have other ways of notifying for this result.
-                    _this.updateLastDiff(diff, diffOptions);
+                    this.updateLastDiff(diff, diffOptions);
                     if (diff.complete) {
                         result.data = diff.result;
                     }
@@ -367,33 +362,14 @@ var QueryInfo = /** @class */ (function () {
                 this.lastWrite = void 0;
             }
         }
-    };
-    QueryInfo.prototype.markReady = function () {
-        this.networkError = null;
-        return (this.networkStatus = NetworkStatus.ready);
-    };
-    QueryInfo.prototype.markError = function (error) {
-        this.networkStatus = NetworkStatus.error;
-        this.lastWrite = void 0;
-        this.reset();
-        if (error.graphQLErrors) {
-            this.graphQLErrors = error.graphQLErrors;
-        }
-        if (error.networkError) {
-            this.networkError = error.networkError;
-        }
-        return error;
-    };
-    return QueryInfo;
-}());
-export { QueryInfo };
-export function shouldWriteResult(result, errorPolicy) {
-    if (errorPolicy === void 0) { errorPolicy = "none"; }
-    var ignoreErrors = errorPolicy === "ignore" || errorPolicy === "all";
-    var writeWithErrors = !graphQLResultHasError(result);
+    }
+}
+export function shouldWriteResult(result, errorPolicy = "none") {
+    const ignoreErrors = errorPolicy === "ignore" || errorPolicy === "all";
+    let writeWithErrors = !graphQLResultHasError(result);
     if (!writeWithErrors && ignoreErrors && result.data) {
         writeWithErrors = true;
     }
     return writeWithErrors;
 }
-//# sourceMappingURL=QueryInfo.js.map
+//# sourceMappingURL=QueryInfo.js.map