@apollo/client 3.9.0-alpha.4 → 3.9.0-beta.0

package/cache/core/cache.d.ts

@@ -2,6 +2,7 @@ import type { DocumentNode } from "graphql";
 import type { StoreObject, Reference } from "../../utilities/index.js";
 import type { DataProxy } from "./types/DataProxy.js";
 import type { Cache } from "./types/Cache.js";
+import { getApolloCacheMemoryInternals } from "../../utilities/caching/getMemoryInternals.js";
 export type Transaction<T> = (c: ApolloCache<T>) => void;
 export declare abstract class ApolloCache<TSerialized> implements DataProxy {
     readonly assumeImmutableResults: boolean;
@@ -11,7 +12,17 @@ export declare abstract class ApolloCache<TSerialized> implements DataProxy {
     abstract watch<TData = any, TVariables = any>(watch: Cache.WatchOptions<TData, TVariables>): () => void;
     abstract reset(options?: Cache.ResetOptions): Promise<void>;
     abstract evict(options: Cache.EvictOptions): boolean;
+    /**
+     * Replaces existing state in the cache (if any) with the values expressed by
+     * `serializedState`.
+     *
+     * Called when hydrating a cache (server side rendering, or offline storage),
+     * and also (potentially) during hot reloads.
+     */
     abstract restore(serializedState: TSerialized): ApolloCache<TSerialized>;
+    /**
+     * Exposes the cache's complete state, in a serializable format for later restoration.
+     */
     abstract extract(optimistic?: boolean): TSerialized;
     abstract removeOptimistic(id: string): void;
     batch<U>(options: Cache.BatchOptions<this, U>): U;
@@ -29,5 +40,13 @@ export declare abstract class ApolloCache<TSerialized> implements DataProxy {
     writeFragment<TData = any, TVariables = any>({ id, data, fragment, fragmentName, ...options }: Cache.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
     updateQuery<TData = any, TVariables = any>(options: Cache.UpdateQueryOptions<TData, TVariables>, update: (data: TData | null) => TData | null | void): TData | null;
     updateFragment<TData = any, TVariables = any>(options: Cache.UpdateFragmentOptions<TData, TVariables>, update: (data: TData | null) => TData | null | void): TData | null;
+    /**
+     * @experimental
+     * @internal
+     * This is not a stable API - it is used in development builds to expose
+     * information to the DevTools.
+     * Use at your own risk!
+     */
+    getMemoryInternals?: typeof getApolloCacheMemoryInternals;
 }
 //# sourceMappingURL=cache.d.ts.map

package/cache/core/cache.js

@@ -1,17 +1,29 @@
 import { __assign, __rest } from "tslib";
 import { wrap } from "optimism";
-import { getFragmentQueryDocument } from "../../utilities/index.js";
-var ApolloCache = (function () {
+import { cacheSizes, getFragmentQueryDocument, } from "../../utilities/index.js";
+import { WeakCache } from "@wry/caches";
+import { getApolloCacheMemoryInternals } from "../../utilities/caching/getMemoryInternals.js";
+var ApolloCache = /** @class */ (function () {
     function ApolloCache() {
         this.assumeImmutableResults = false;
-        this.getFragmentDoc = wrap(getFragmentQueryDocument);
+        // Make sure we compute the same (===) fragment query document every
+        // time we receive the same fragment in readFragment.
+        this.getFragmentDoc = wrap(getFragmentQueryDocument, {
+            max: cacheSizes["cache.fragmentQueryDocuments"] ||
+                1000 /* defaultCacheSizes["cache.fragmentQueryDocuments"] */,
+            cache: WeakCache,
+        });
     }
+    // Transactional API
+    // The batch method is intended to replace/subsume both performTransaction
+    // and recordOptimisticTransaction, but performTransaction came first, so we
+    // provide a default batch implementation that's just another way of calling
+    // performTransaction. Subclasses of ApolloCache (such as InMemoryCache) can
+    // override the batch method to do more interesting things with its options.
     ApolloCache.prototype.batch = function (options) {
         var _this = this;
-        var optimisticId = typeof options.optimistic === "string"
-            ? options.optimistic
-            : options.optimistic === false
-                ? null
+        var optimisticId = typeof options.optimistic === "string" ? options.optimistic
+            : options.optimistic === false ? null
                 : void 0;
         var updateResult;
         this.performTransaction(function () { return (updateResult = options.update(_this)); }, optimisticId);
@@ -20,9 +32,14 @@ var ApolloCache = (function () {
     ApolloCache.prototype.recordOptimisticTransaction = function (transaction, optimisticId) {
         this.performTransaction(transaction, optimisticId);
     };
+    // Optional API
+    // Called once per input document, allowing the cache to make static changes
+    // to the query, such as adding __typename fields.
     ApolloCache.prototype.transformDocument = function (document) {
         return document;
     };
+    // Called before each ApolloLink request, allowing the cache to make dynamic
+    // changes to the query, such as filling in missing fragment definitions.
     ApolloCache.prototype.transformForLink = function (document) {
         return document;
     };
@@ -35,6 +52,7 @@ var ApolloCache = (function () {
     ApolloCache.prototype.modify = function (options) {
         return false;
     };
+    // DataProxy API
     ApolloCache.prototype.readQuery = function (options, optimistic) {
         if (optimistic === void 0) { optimistic = !!options.optimistic; }
         return this.read(__assign(__assign({}, options), { rootId: options.id || "ROOT_QUERY", optimistic: optimistic }));
@@ -85,4 +103,7 @@ var ApolloCache = (function () {
     return ApolloCache;
 }());
 export { ApolloCache };
+if (globalThis.__DEV__ !== false) {
+    ApolloCache.prototype.getMemoryInternals = getApolloCacheMemoryInternals;
+}
 //# sourceMappingURL=cache.js.map

package/cache/core/cache.js.map

@@ -1 +1 @@
-{"version":3,"file":"cache.js","sourceRoot":"","sources":["../../../src/cache/core/cache.ts"],"names":[],"mappings":"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","sourcesContent":["import type { DocumentNode } from \"graphql\";\nimport { wrap } from \"optimism\";\n\nimport type { StoreObject, Reference } from \"../../utilities/index.js\";\nimport { getFragmentQueryDocument } from \"../../utilities/index.js\";\nimport type { DataProxy } from \"./types/DataProxy.js\";\nimport type { Cache } from \"./types/Cache.js\";\n\nexport type Transaction<T> = (c: ApolloCache<T>) => void;\n\nexport abstract class ApolloCache<TSerialized> implements DataProxy {\n  public readonly assumeImmutableResults: boolean = false;\n\n  // required to implement\n  // core API\n  public abstract read<TData = any, TVariables = any>(\n    query: Cache.ReadOptions<TVariables, TData>\n  ): TData | null;\n  public abstract write<TData = any, TVariables = any>(\n    write: Cache.WriteOptions<TData, TVariables>\n  ): Reference | undefined;\n  public abstract diff<T>(query: Cache.DiffOptions): Cache.DiffResult<T>;\n  public abstract watch<TData = any, TVariables = any>(\n    watch: Cache.WatchOptions<TData, TVariables>\n  ): () => void;\n\n  // Empty the cache and restart all current watches (unless\n  // options.discardWatches is true).\n  public abstract reset(options?: Cache.ResetOptions): Promise<void>;\n\n  // Remove whole objects from the cache by passing just options.id, or\n  // specific fields by passing options.field and/or options.args. If no\n  // options.args are provided, all fields matching options.field (even\n  // those with arguments) will be removed. Returns true iff any data was\n  // removed from the cache.\n  public abstract evict(options: Cache.EvictOptions): boolean;\n\n  // initializer / offline / ssr API\n  /**\n   * Replaces existing state in the cache (if any) with the values expressed by\n   * `serializedState`.\n   *\n   * Called when hydrating a cache (server side rendering, or offline storage),\n   * and also (potentially) during hot reloads.\n   */\n  public abstract restore(\n    serializedState: TSerialized\n  ): ApolloCache<TSerialized>;\n\n  /**\n   * Exposes the cache's complete state, in a serializable format for later restoration.\n   */\n  public abstract extract(optimistic?: boolean): TSerialized;\n\n  // Optimistic API\n\n  public abstract removeOptimistic(id: string): void;\n\n  // Transactional API\n\n  // The batch method is intended to replace/subsume both performTransaction\n  // and recordOptimisticTransaction, but performTransaction came first, so we\n  // provide a default batch implementation that's just another way of calling\n  // performTransaction. Subclasses of ApolloCache (such as InMemoryCache) can\n  // override the batch method to do more interesting things with its options.\n  public batch<U>(options: Cache.BatchOptions<this, U>): U {\n    const optimisticId =\n      typeof options.optimistic === \"string\"\n        ? options.optimistic\n        : options.optimistic === false\n        ? null\n        : void 0;\n    let updateResult: U;\n    this.performTransaction(\n      () => (updateResult = options.update(this)),\n      optimisticId\n    );\n    return updateResult!;\n  }\n\n  public abstract performTransaction(\n    transaction: Transaction<TSerialized>,\n    // Although subclasses may implement recordOptimisticTransaction\n    // however they choose, the default implementation simply calls\n    // performTransaction with a string as the second argument, allowing\n    // performTransaction to handle both optimistic and non-optimistic\n    // (broadcast-batching) transactions. Passing null for optimisticId is\n    // also allowed, and indicates that performTransaction should apply\n    // the transaction non-optimistically (ignoring optimistic data).\n    optimisticId?: string | null\n  ): void;\n\n  public recordOptimisticTransaction(\n    transaction: Transaction<TSerialized>,\n    optimisticId: string\n  ) {\n    this.performTransaction(transaction, optimisticId);\n  }\n\n  // Optional API\n\n  // Called once per input document, allowing the cache to make static changes\n  // to the query, such as adding __typename fields.\n  public transformDocument(document: DocumentNode): DocumentNode {\n    return document;\n  }\n\n  // Called before each ApolloLink request, allowing the cache to make dynamic\n  // changes to the query, such as filling in missing fragment definitions.\n  public transformForLink(document: DocumentNode): DocumentNode {\n    return document;\n  }\n\n  public identify(object: StoreObject | Reference): string | undefined {\n    return;\n  }\n\n  public gc(): string[] {\n    return [];\n  }\n\n  public modify<Entity extends Record<string, any> = Record<string, any>>(\n    options: Cache.ModifyOptions<Entity>\n  ): boolean {\n    return false;\n  }\n\n  // DataProxy API\n  /**\n   *\n   * @param options\n   * @param optimistic\n   */\n  public readQuery<QueryType, TVariables = any>(\n    options: Cache.ReadQueryOptions<QueryType, TVariables>,\n    optimistic = !!options.optimistic\n  ): QueryType | null {\n    return this.read({\n      ...options,\n      rootId: options.id || \"ROOT_QUERY\",\n      optimistic,\n    });\n  }\n\n  // Make sure we compute the same (===) fragment query document every\n  // time we receive the same fragment in readFragment.\n  private getFragmentDoc = wrap(getFragmentQueryDocument);\n\n  public readFragment<FragmentType, TVariables = any>(\n    options: Cache.ReadFragmentOptions<FragmentType, TVariables>,\n    optimistic = !!options.optimistic\n  ): FragmentType | null {\n    return this.read({\n      ...options,\n      query: this.getFragmentDoc(options.fragment, options.fragmentName),\n      rootId: options.id,\n      optimistic,\n    });\n  }\n\n  public writeQuery<TData = any, TVariables = any>({\n    id,\n    data,\n    ...options\n  }: Cache.WriteQueryOptions<TData, TVariables>): Reference | undefined {\n    return this.write(\n      Object.assign(options, {\n        dataId: id || \"ROOT_QUERY\",\n        result: data,\n      })\n    );\n  }\n\n  public writeFragment<TData = any, TVariables = any>({\n    id,\n    data,\n    fragment,\n    fragmentName,\n    ...options\n  }: Cache.WriteFragmentOptions<TData, TVariables>): Reference | undefined {\n    return this.write(\n      Object.assign(options, {\n        query: this.getFragmentDoc(fragment, fragmentName),\n        dataId: id,\n        result: data,\n      })\n    );\n  }\n\n  public updateQuery<TData = any, TVariables = any>(\n    options: Cache.UpdateQueryOptions<TData, TVariables>,\n    update: (data: TData | null) => TData | null | void\n  ): TData | null {\n    return this.batch({\n      update(cache) {\n        const value = cache.readQuery<TData, TVariables>(options);\n        const data = update(value);\n        if (data === void 0 || data === null) return value;\n        cache.writeQuery<TData, TVariables>({ ...options, data });\n        return data;\n      },\n    });\n  }\n\n  public updateFragment<TData = any, TVariables = any>(\n    options: Cache.UpdateFragmentOptions<TData, TVariables>,\n    update: (data: TData | null) => TData | null | void\n  ): TData | null {\n    return this.batch({\n      update(cache) {\n        const value = cache.readFragment<TData, TVariables>(options);\n        const data = update(value);\n        if (data === void 0 || data === null) return value;\n        cache.writeFragment<TData, TVariables>({ ...options, data });\n        return data;\n      },\n    });\n  }\n}\n"]}
+{"version":3,"file":"cache.js","sourceRoot":"","sources":["../../../src/cache/core/cache.ts"],"names":[],"mappings":"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","sourcesContent":["import type { DocumentNode } from \"graphql\";\nimport { wrap } from \"optimism\";\n\nimport type { StoreObject, Reference } from \"../../utilities/index.js\";\nimport {\n  cacheSizes,\n  defaultCacheSizes,\n  getFragmentQueryDocument,\n} from \"../../utilities/index.js\";\nimport type { DataProxy } from \"./types/DataProxy.js\";\nimport type { Cache } from \"./types/Cache.js\";\nimport { WeakCache } from \"@wry/caches\";\nimport { getApolloCacheMemoryInternals } from \"../../utilities/caching/getMemoryInternals.js\";\n\nexport type Transaction<T> = (c: ApolloCache<T>) => void;\n\nexport abstract class ApolloCache<TSerialized> implements DataProxy {\n  public readonly assumeImmutableResults: boolean = false;\n\n  // required to implement\n  // core API\n  public abstract read<TData = any, TVariables = any>(\n    query: Cache.ReadOptions<TVariables, TData>\n  ): TData | null;\n  public abstract write<TData = any, TVariables = any>(\n    write: Cache.WriteOptions<TData, TVariables>\n  ): Reference | undefined;\n  public abstract diff<T>(query: Cache.DiffOptions): Cache.DiffResult<T>;\n  public abstract watch<TData = any, TVariables = any>(\n    watch: Cache.WatchOptions<TData, TVariables>\n  ): () => void;\n\n  // Empty the cache and restart all current watches (unless\n  // options.discardWatches is true).\n  public abstract reset(options?: Cache.ResetOptions): Promise<void>;\n\n  // Remove whole objects from the cache by passing just options.id, or\n  // specific fields by passing options.field and/or options.args. If no\n  // options.args are provided, all fields matching options.field (even\n  // those with arguments) will be removed. Returns true iff any data was\n  // removed from the cache.\n  public abstract evict(options: Cache.EvictOptions): boolean;\n\n  // initializer / offline / ssr API\n  /**\n   * Replaces existing state in the cache (if any) with the values expressed by\n   * `serializedState`.\n   *\n   * Called when hydrating a cache (server side rendering, or offline storage),\n   * and also (potentially) during hot reloads.\n   */\n  public abstract restore(\n    serializedState: TSerialized\n  ): ApolloCache<TSerialized>;\n\n  /**\n   * Exposes the cache's complete state, in a serializable format for later restoration.\n   */\n  public abstract extract(optimistic?: boolean): TSerialized;\n\n  // Optimistic API\n\n  public abstract removeOptimistic(id: string): void;\n\n  // Transactional API\n\n  // The batch method is intended to replace/subsume both performTransaction\n  // and recordOptimisticTransaction, but performTransaction came first, so we\n  // provide a default batch implementation that's just another way of calling\n  // performTransaction. Subclasses of ApolloCache (such as InMemoryCache) can\n  // override the batch method to do more interesting things with its options.\n  public batch<U>(options: Cache.BatchOptions<this, U>): U {\n    const optimisticId =\n      typeof options.optimistic === \"string\" ? options.optimistic\n      : options.optimistic === false ? null\n      : void 0;\n    let updateResult: U;\n    this.performTransaction(\n      () => (updateResult = options.update(this)),\n      optimisticId\n    );\n    return updateResult!;\n  }\n\n  public abstract performTransaction(\n    transaction: Transaction<TSerialized>,\n    // Although subclasses may implement recordOptimisticTransaction\n    // however they choose, the default implementation simply calls\n    // performTransaction with a string as the second argument, allowing\n    // performTransaction to handle both optimistic and non-optimistic\n    // (broadcast-batching) transactions. Passing null for optimisticId is\n    // also allowed, and indicates that performTransaction should apply\n    // the transaction non-optimistically (ignoring optimistic data).\n    optimisticId?: string | null\n  ): void;\n\n  public recordOptimisticTransaction(\n    transaction: Transaction<TSerialized>,\n    optimisticId: string\n  ) {\n    this.performTransaction(transaction, optimisticId);\n  }\n\n  // Optional API\n\n  // Called once per input document, allowing the cache to make static changes\n  // to the query, such as adding __typename fields.\n  public transformDocument(document: DocumentNode): DocumentNode {\n    return document;\n  }\n\n  // Called before each ApolloLink request, allowing the cache to make dynamic\n  // changes to the query, such as filling in missing fragment definitions.\n  public transformForLink(document: DocumentNode): DocumentNode {\n    return document;\n  }\n\n  public identify(object: StoreObject | Reference): string | undefined {\n    return;\n  }\n\n  public gc(): string[] {\n    return [];\n  }\n\n  public modify<Entity extends Record<string, any> = Record<string, any>>(\n    options: Cache.ModifyOptions<Entity>\n  ): boolean {\n    return false;\n  }\n\n  // DataProxy API\n  public readQuery<QueryType, TVariables = any>(\n    options: Cache.ReadQueryOptions<QueryType, TVariables>,\n    optimistic = !!options.optimistic\n  ): QueryType | null {\n    return this.read({\n      ...options,\n      rootId: options.id || \"ROOT_QUERY\",\n      optimistic,\n    });\n  }\n\n  // Make sure we compute the same (===) fragment query document every\n  // time we receive the same fragment in readFragment.\n  private getFragmentDoc = wrap(getFragmentQueryDocument, {\n    max:\n      cacheSizes[\"cache.fragmentQueryDocuments\"] ||\n      defaultCacheSizes[\"cache.fragmentQueryDocuments\"],\n    cache: WeakCache,\n  });\n\n  public readFragment<FragmentType, TVariables = any>(\n    options: Cache.ReadFragmentOptions<FragmentType, TVariables>,\n    optimistic = !!options.optimistic\n  ): FragmentType | null {\n    return this.read({\n      ...options,\n      query: this.getFragmentDoc(options.fragment, options.fragmentName),\n      rootId: options.id,\n      optimistic,\n    });\n  }\n\n  public writeQuery<TData = any, TVariables = any>({\n    id,\n    data,\n    ...options\n  }: Cache.WriteQueryOptions<TData, TVariables>): Reference | undefined {\n    return this.write(\n      Object.assign(options, {\n        dataId: id || \"ROOT_QUERY\",\n        result: data,\n      })\n    );\n  }\n\n  public writeFragment<TData = any, TVariables = any>({\n    id,\n    data,\n    fragment,\n    fragmentName,\n    ...options\n  }: Cache.WriteFragmentOptions<TData, TVariables>): Reference | undefined {\n    return this.write(\n      Object.assign(options, {\n        query: this.getFragmentDoc(fragment, fragmentName),\n        dataId: id,\n        result: data,\n      })\n    );\n  }\n\n  public updateQuery<TData = any, TVariables = any>(\n    options: Cache.UpdateQueryOptions<TData, TVariables>,\n    update: (data: TData | null) => TData | null | void\n  ): TData | null {\n    return this.batch({\n      update(cache) {\n        const value = cache.readQuery<TData, TVariables>(options);\n        const data = update(value);\n        if (data === void 0 || data === null) return value;\n        cache.writeQuery<TData, TVariables>({ ...options, data });\n        return data;\n      },\n    });\n  }\n\n  public updateFragment<TData = any, TVariables = any>(\n    options: Cache.UpdateFragmentOptions<TData, TVariables>,\n    update: (data: TData | null) => TData | null | void\n  ): TData | null {\n    return this.batch({\n      update(cache) {\n        const value = cache.readFragment<TData, TVariables>(options);\n        const data = update(value);\n        if (data === void 0 || data === null) return value;\n        cache.writeFragment<TData, TVariables>({ ...options, data });\n        return data;\n      },\n    });\n  }\n\n  /**\n   * @experimental\n   * @internal\n   * This is not a stable API - it is used in development builds to expose\n   * information to the DevTools.\n   * Use at your own risk!\n   */\n  public getMemoryInternals?: typeof getApolloCacheMemoryInternals;\n}\n\nif (__DEV__) {\n  ApolloCache.prototype.getMemoryInternals = getApolloCacheMemoryInternals;\n}\n"]}

package/cache/core/types/Cache.d.ts

@@ -8,6 +8,13 @@ export declare namespace Cache {
         previousResult?: any;
         optimistic: boolean;
         returnPartialData?: boolean;
+        /**
+         * @deprecated
+         * Using `canonizeResults` can result in memory leaks so we generally do not
+         * recommend using this option anymore.
+         * A future version of Apollo Client will contain a similar feature without
+         * the risk of memory leaks.
+         */
         canonizeResults?: boolean;
     }
     interface WriteOptions<TResult = any, TVariables = any> extends Omit<DataProxy.Query<TVariables, TResult>, "id">, Omit<DataProxy.WriteOptions<TResult>, "data"> {
@@ -41,7 +48,7 @@ export declare namespace Cache {
         update(cache: TCache): TUpdateResult;
         optimistic?: string | boolean;
         removeOptimistic?: string;
-        onWatchUpdated?: (this: TCache, watch: Cache.WatchOptions, diff: Cache.DiffResult<any>, lastDiff: Cache.DiffResult<any> | undefined) => any;
+        onWatchUpdated?: (this: TCache, watch: Cache.WatchOptions, diff: Cache.DiffResult<any>, lastDiff?: Cache.DiffResult<any> | undefined) => any;
     }
     export import DiffResult = DataProxy.DiffResult;
     export import ReadQueryOptions = DataProxy.ReadQueryOptions;

package/cache/core/types/Cache.js.map

@@ -1 +1 @@
-{"version":3,"file":"Cache.js","sourceRoot":"","sources":["../../../../src/cache/core/types/Cache.ts"],"names":[],"mappings":"AAIA,MAAM,KAAW,KAAK,CAuGrB;AAvGD,WAAiB,KAAK;AAuGtB,CAAC,EAvGgB,KAAK,KAAL,KAAK,QAuGrB","sourcesContent":["import { DataProxy } from \"./DataProxy.js\";\nimport type { AllFieldsModifier, Modifiers } from \"./common.js\";\nimport type { ApolloCache } from \"../cache.js\";\n\nexport namespace Cache {\n  export type WatchCallback<TData = any> = (\n    diff: Cache.DiffResult<TData>,\n    lastDiff?: Cache.DiffResult<TData>\n  ) => void;\n\n  export interface ReadOptions<TVariables = any, TData = any>\n    extends DataProxy.Query<TVariables, TData> {\n    rootId?: string;\n    previousResult?: any;\n    optimistic: boolean;\n    returnPartialData?: boolean;\n    canonizeResults?: boolean;\n  }\n\n  export interface WriteOptions<TResult = any, TVariables = any>\n    extends Omit<DataProxy.Query<TVariables, TResult>, \"id\">,\n      Omit<DataProxy.WriteOptions<TResult>, \"data\"> {\n    dataId?: string;\n    result: TResult;\n  }\n\n  export interface DiffOptions<TData = any, TVariables = any>\n    extends Omit<ReadOptions<TVariables, TData>, \"rootId\"> {\n    // The DiffOptions interface is currently just an alias for\n    // ReadOptions, though DiffOptions used to be responsible for\n    // declaring the returnPartialData option.\n  }\n\n  export interface WatchOptions<TData = any, TVariables = any>\n    extends DiffOptions<TData, TVariables> {\n    watcher?: object;\n    immediate?: boolean;\n    callback: WatchCallback<TData>;\n    lastDiff?: DiffResult<TData>;\n  }\n\n  export interface EvictOptions {\n    id?: string;\n    fieldName?: string;\n    args?: Record<string, any>;\n    broadcast?: boolean;\n  }\n\n  // Although you can call cache.reset() without options, its behavior can be\n  // configured by passing a Cache.ResetOptions object.\n  export interface ResetOptions {\n    discardWatches?: boolean;\n  }\n\n  export interface ModifyOptions<\n    Entity extends Record<string, any> = Record<string, any>,\n  > {\n    id?: string;\n    fields: Modifiers<Entity> | AllFieldsModifier<Entity>;\n    optimistic?: boolean;\n    broadcast?: boolean;\n  }\n\n  export interface BatchOptions<\n    TCache extends ApolloCache<any>,\n    TUpdateResult = void,\n  > {\n    // Same as the first parameter of performTransaction, except the cache\n    // argument will have the subclass type rather than ApolloCache.\n    update(cache: TCache): TUpdateResult;\n\n    // Passing a string for this option creates a new optimistic layer, with the\n    // given string as its layer.id, just like passing a string for the\n    // optimisticId parameter of performTransaction. Passing true is the same as\n    // passing undefined to performTransaction (running the batch operation\n    // against the current top layer of the cache), and passing false is the\n    // same as passing null (running the operation against root/non-optimistic\n    // cache data).\n    optimistic?: string | boolean;\n\n    // If you specify the ID of an optimistic layer using this option, that\n    // layer will be removed as part of the batch transaction, triggering at\n    // most one broadcast for both the transaction and the removal of the layer.\n    // Note: this option is needed because calling cache.removeOptimistic during\n    // the transaction function may not be not safe, since any modifications to\n    // cache layers may be discarded after the transaction finishes.\n    removeOptimistic?: string;\n\n    // If you want to find out which watched queries were invalidated during\n    // this batch operation, pass this optional callback function. Returning\n    // false from the callback will prevent broadcasting this result.\n    onWatchUpdated?: (\n      this: TCache,\n      watch: Cache.WatchOptions,\n      diff: Cache.DiffResult<any>,\n      lastDiff: Cache.DiffResult<any> | undefined\n    ) => any;\n  }\n\n  export import DiffResult = DataProxy.DiffResult;\n  export import ReadQueryOptions = DataProxy.ReadQueryOptions;\n  export import ReadFragmentOptions = DataProxy.ReadFragmentOptions;\n  export import WriteQueryOptions = DataProxy.WriteQueryOptions;\n  export import WriteFragmentOptions = DataProxy.WriteFragmentOptions;\n  export import UpdateQueryOptions = DataProxy.UpdateQueryOptions;\n  export import UpdateFragmentOptions = DataProxy.UpdateFragmentOptions;\n  export import Fragment = DataProxy.Fragment;\n}\n"]}
+{"version":3,"file":"Cache.js","sourceRoot":"","sources":["../../../../src/cache/core/types/Cache.ts"],"names":[],"mappings":"AAIA,MAAM,KAAW,KAAK,CA8GrB;AA9GD,WAAiB,KAAK;AA8GtB,CAAC,EA9GgB,KAAK,KAAL,KAAK,QA8GrB","sourcesContent":["import { DataProxy } from \"./DataProxy.js\";\nimport type { AllFieldsModifier, Modifiers } from \"./common.js\";\nimport type { ApolloCache } from \"../cache.js\";\n\nexport namespace Cache {\n  export type WatchCallback<TData = any> = (\n    diff: Cache.DiffResult<TData>,\n    lastDiff?: Cache.DiffResult<TData>\n  ) => void;\n\n  export interface ReadOptions<TVariables = any, TData = any>\n    extends DataProxy.Query<TVariables, TData> {\n    rootId?: string;\n    previousResult?: any;\n    optimistic: boolean;\n    returnPartialData?: boolean;\n    /**\n     * @deprecated\n     * Using `canonizeResults` can result in memory leaks so we generally do not\n     * recommend using this option anymore.\n     * A future version of Apollo Client will contain a similar feature without\n     * the risk of memory leaks.\n     */\n    canonizeResults?: boolean;\n  }\n\n  export interface WriteOptions<TResult = any, TVariables = any>\n    extends Omit<DataProxy.Query<TVariables, TResult>, \"id\">,\n      Omit<DataProxy.WriteOptions<TResult>, \"data\"> {\n    dataId?: string;\n    result: TResult;\n  }\n\n  export interface DiffOptions<TData = any, TVariables = any>\n    extends Omit<ReadOptions<TVariables, TData>, \"rootId\"> {\n    // The DiffOptions interface is currently just an alias for\n    // ReadOptions, though DiffOptions used to be responsible for\n    // declaring the returnPartialData option.\n  }\n\n  export interface WatchOptions<TData = any, TVariables = any>\n    extends DiffOptions<TData, TVariables> {\n    watcher?: object;\n    immediate?: boolean;\n    callback: WatchCallback<TData>;\n    lastDiff?: DiffResult<TData>;\n  }\n\n  export interface EvictOptions {\n    id?: string;\n    fieldName?: string;\n    args?: Record<string, any>;\n    broadcast?: boolean;\n  }\n\n  // Although you can call cache.reset() without options, its behavior can be\n  // configured by passing a Cache.ResetOptions object.\n  export interface ResetOptions {\n    discardWatches?: boolean;\n  }\n\n  export interface ModifyOptions<\n    Entity extends Record<string, any> = Record<string, any>,\n  > {\n    id?: string;\n    fields: Modifiers<Entity> | AllFieldsModifier<Entity>;\n    optimistic?: boolean;\n    broadcast?: boolean;\n  }\n\n  export interface BatchOptions<\n    TCache extends ApolloCache<any>,\n    TUpdateResult = void,\n  > {\n    // Same as the first parameter of performTransaction, except the cache\n    // argument will have the subclass type rather than ApolloCache.\n    update(cache: TCache): TUpdateResult;\n\n    // Passing a string for this option creates a new optimistic layer, with the\n    // given string as its layer.id, just like passing a string for the\n    // optimisticId parameter of performTransaction. Passing true is the same as\n    // passing undefined to performTransaction (running the batch operation\n    // against the current top layer of the cache), and passing false is the\n    // same as passing null (running the operation against root/non-optimistic\n    // cache data).\n    optimistic?: string | boolean;\n\n    // If you specify the ID of an optimistic layer using this option, that\n    // layer will be removed as part of the batch transaction, triggering at\n    // most one broadcast for both the transaction and the removal of the layer.\n    // Note: this option is needed because calling cache.removeOptimistic during\n    // the transaction function may not be not safe, since any modifications to\n    // cache layers may be discarded after the transaction finishes.\n    removeOptimistic?: string;\n\n    // If you want to find out which watched queries were invalidated during\n    // this batch operation, pass this optional callback function. Returning\n    // false from the callback will prevent broadcasting this result.\n    onWatchUpdated?: (\n      this: TCache,\n      watch: Cache.WatchOptions,\n      diff: Cache.DiffResult<any>,\n      lastDiff?: Cache.DiffResult<any> | undefined\n    ) => any;\n  }\n\n  export import DiffResult = DataProxy.DiffResult;\n  export import ReadQueryOptions = DataProxy.ReadQueryOptions;\n  export import ReadFragmentOptions = DataProxy.ReadFragmentOptions;\n  export import WriteQueryOptions = DataProxy.WriteQueryOptions;\n  export import WriteFragmentOptions = DataProxy.WriteFragmentOptions;\n  export import UpdateQueryOptions = DataProxy.UpdateQueryOptions;\n  export import UpdateFragmentOptions = DataProxy.UpdateFragmentOptions;\n  export import Fragment = DataProxy.Fragment;\n}\n"]}

package/cache/core/types/DataProxy.d.ts

@@ -4,29 +4,111 @@ import type { MissingFieldError } from "./common.js";
 import type { Reference } from "../../../utilities/index.js";
 export declare namespace DataProxy {
     interface Query<TVariables, TData> {
+        /**
+         * The GraphQL query shape to be used constructed using the `gql` template
+         * string tag from `graphql-tag`. The query will be used to determine the
+         * shape of the data to be read.
+         */
         query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+        /**
+         * Any variables that the GraphQL query may depend on.
+         */
         variables?: TVariables;
+        /**
+         * The root id to be used. Defaults to "ROOT_QUERY", which is the ID of the
+         * root query object. This property makes writeQuery capable of writing data
+         * to any object in the cache.
+         */
         id?: string;
     }
     interface Fragment<TVariables, TData> {
+        /**
+         * The root id to be used. This id should take the same form as the
+         * value returned by your `dataIdFromObject` function. If a value with your
+         * id does not exist in the store, `null` will be returned.
+         */
         id?: string;
+        /**
+         * A GraphQL document created using the `gql` template string tag from
+         * `graphql-tag` with one or more fragments which will be used to determine
+         * the shape of data to read. If you provide more than one fragment in this
+         * document then you must also specify `fragmentName` to select a single.
+         */
         fragment: DocumentNode | TypedDocumentNode<TData, TVariables>;
+        /**
+         * The name of the fragment in your GraphQL document to be used. If you do
+         * not provide a `fragmentName` and there is only one fragment in your
+         * `fragment` document then that fragment will be used.
+         */
         fragmentName?: string;
+        /**
+         * Any variables that your GraphQL fragments depend on.
+         */
         variables?: TVariables;
     }
     interface ReadQueryOptions<TData, TVariables> extends Query<TVariables, TData> {
+        /**
+         * Whether to return incomplete data rather than null.
+         * Defaults to false.
+         */
         returnPartialData?: boolean;
+        /**
+         * Whether to read from optimistic or non-optimistic cache data. If
+         * this named option is provided, the optimistic parameter of the
+         * readQuery method can be omitted. Defaults to false.
+         */
         optimistic?: boolean;
+        /**
+        /**
+         * @deprecated
+         * Using `canonizeResults` can result in memory leaks so we generally do not
+         * recommend using this option anymore.
+         * A future version of Apollo Client will contain a similar feature without
+         * the risk of memory leaks.
+         *
+         * Whether to canonize cache results before returning them. Canonization
+         * takes some extra time, but it speeds up future deep equality comparisons.
+         * Defaults to false.
+         */
         canonizeResults?: boolean;
     }
     interface ReadFragmentOptions<TData, TVariables> extends Fragment<TVariables, TData> {
+        /**
+         * Whether to return incomplete data rather than null.
+         * Defaults to false.
+         */
         returnPartialData?: boolean;
+        /**
+         * Whether to read from optimistic or non-optimistic cache data. If
+         * this named option is provided, the optimistic parameter of the
+         * readQuery method can be omitted. Defaults to false.
+         */
         optimistic?: boolean;
+        /**
+         * @deprecated
+         * Using `canonizeResults` can result in memory leaks so we generally do not
+         * recommend using this option anymore.
+         * A future version of Apollo Client will contain a similar feature.
+         *
+         * Whether to canonize cache results before returning them. Canonization
+         * takes some extra time, but it speeds up future deep equality comparisons.
+         * Defaults to false.
+         */
         canonizeResults?: boolean;
     }
     interface WriteOptions<TData> {
+        /**
+         * The data you will be writing to the store.
+         */
         data: TData;
+        /**
+         * Whether to notify query watchers (default: true).
+         */
         broadcast?: boolean;
+        /**
+         * When true, ignore existing field data rather than merging it with
+         * incoming data (default: false).
+         */
         overwrite?: boolean;
     }
     interface WriteQueryOptions<TData, TVariables> extends Query<TVariables, TData>, WriteOptions<TData> {
@@ -44,10 +126,32 @@ export declare namespace DataProxy {
         fromOptimisticTransaction?: boolean;
     };
 }
+/**
+ * A proxy to the normalized data living in our store. This interface allows a
+ * user to read and write denormalized data which feels natural to the user
+ * whilst in the background this data is being converted into the normalized
+ * store format.
+ */
 export interface DataProxy {
+    /**
+     * Reads a GraphQL query from the root query id.
+     */
     readQuery<QueryType, TVariables = any>(options: DataProxy.ReadQueryOptions<QueryType, TVariables>, optimistic?: boolean): QueryType | null;
+    /**
+     * Reads a GraphQL fragment from any arbitrary id. If there is more than
+     * one fragment in the provided document then a `fragmentName` must be
+     * provided to select the correct fragment.
+     */
     readFragment<FragmentType, TVariables = any>(options: DataProxy.ReadFragmentOptions<FragmentType, TVariables>, optimistic?: boolean): FragmentType | null;
+    /**
+     * Writes a GraphQL query to the root query id.
+     */
     writeQuery<TData = any, TVariables = any>(options: DataProxy.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+    /**
+     * Writes a GraphQL fragment to any arbitrary id. If there is more than
+     * one fragment in the provided document then a `fragmentName` must be
+     * provided to select the correct fragment.
+     */
     writeFragment<TData = any, TVariables = any>(options: DataProxy.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
 }
 //# sourceMappingURL=DataProxy.d.ts.map

package/cache/core/types/DataProxy.js.map

@@ -1 +1 @@
-{"version":3,"file":"DataProxy.js","sourceRoot":"","sources":["../../../../src/cache/core/types/DataProxy.ts"],"names":[],"mappings":"","sourcesContent":["import type { DocumentNode } from \"graphql\"; // ignore-comment eslint-disable-line import/no-extraneous-dependencies, import/no-unresolved\nimport type { TypedDocumentNode } from \"@graphql-typed-document-node/core\";\n\nimport type { MissingFieldError } from \"./common.js\";\nimport type { Reference } from \"../../../utilities/index.js\";\n\nexport namespace DataProxy {\n  export interface Query<TVariables, TData> {\n    /**\n     * The GraphQL query shape to be used constructed using the `gql` template\n     * string tag from `graphql-tag`. The query will be used to determine the\n     * shape of the data to be read.\n     */\n    query: DocumentNode | TypedDocumentNode<TData, TVariables>;\n\n    /**\n     * Any variables that the GraphQL query may depend on.\n     */\n    variables?: TVariables;\n\n    /**\n     * The root id to be used. Defaults to \"ROOT_QUERY\", which is the ID of the\n     * root query object. This property makes writeQuery capable of writing data\n     * to any object in the cache.\n     */\n    id?: string;\n  }\n\n  export interface Fragment<TVariables, TData> {\n    /**\n     * The root id to be used. This id should take the same form as the\n     * value returned by your `dataIdFromObject` function. If a value with your\n     * id does not exist in the store, `null` will be returned.\n     */\n    id?: string;\n\n    /**\n     * A GraphQL document created using the `gql` template string tag from\n     * `graphql-tag` with one or more fragments which will be used to determine\n     * the shape of data to read. If you provide more than one fragment in this\n     * document then you must also specify `fragmentName` to select a single.\n     */\n    fragment: DocumentNode | TypedDocumentNode<TData, TVariables>;\n\n    /**\n     * The name of the fragment in your GraphQL document to be used. If you do\n     * not provide a `fragmentName` and there is only one fragment in your\n     * `fragment` document then that fragment will be used.\n     */\n    fragmentName?: string;\n\n    /**\n     * Any variables that your GraphQL fragments depend on.\n     */\n    variables?: TVariables;\n  }\n\n  export interface ReadQueryOptions<TData, TVariables>\n    extends Query<TVariables, TData> {\n    /**\n     * Whether to return incomplete data rather than null.\n     * Defaults to false.\n     */\n    returnPartialData?: boolean;\n    /**\n     * Whether to read from optimistic or non-optimistic cache data. If\n     * this named option is provided, the optimistic parameter of the\n     * readQuery method can be omitted. Defaults to false.\n     */\n    optimistic?: boolean;\n    /**\n     * Whether to canonize cache results before returning them. Canonization\n     * takes some extra time, but it speeds up future deep equality comparisons.\n     * Defaults to false.\n     */\n    canonizeResults?: boolean;\n  }\n\n  export interface ReadFragmentOptions<TData, TVariables>\n    extends Fragment<TVariables, TData> {\n    /**\n     * Whether to return incomplete data rather than null.\n     * Defaults to false.\n     */\n    returnPartialData?: boolean;\n    /**\n     * Whether to read from optimistic or non-optimistic cache data. If\n     * this named option is provided, the optimistic parameter of the\n     * readQuery method can be omitted. Defaults to false.\n     */\n    optimistic?: boolean;\n    /**\n     * Whether to canonize cache results before returning them. Canonization\n     * takes some extra time, but it speeds up future deep equality comparisons.\n     * Defaults to false.\n     */\n    canonizeResults?: boolean;\n  }\n\n  export interface WriteOptions<TData> {\n    /**\n     * The data you will be writing to the store.\n     */\n    data: TData;\n    /**\n     * Whether to notify query watchers (default: true).\n     */\n    broadcast?: boolean;\n    /**\n     * When true, ignore existing field data rather than merging it with\n     * incoming data (default: false).\n     */\n    overwrite?: boolean;\n  }\n\n  export interface WriteQueryOptions<TData, TVariables>\n    extends Query<TVariables, TData>,\n      WriteOptions<TData> {}\n\n  export interface WriteFragmentOptions<TData, TVariables>\n    extends Fragment<TVariables, TData>,\n      WriteOptions<TData> {}\n\n  export interface UpdateQueryOptions<TData, TVariables>\n    extends Omit<\n      ReadQueryOptions<TData, TVariables> &\n        WriteQueryOptions<TData, TVariables>,\n      \"data\"\n    > {}\n\n  export interface UpdateFragmentOptions<TData, TVariables>\n    extends Omit<\n      ReadFragmentOptions<TData, TVariables> &\n        WriteFragmentOptions<TData, TVariables>,\n      \"data\"\n    > {}\n\n  export type DiffResult<T> = {\n    result?: T;\n    complete?: boolean;\n    missing?: MissingFieldError[];\n    fromOptimisticTransaction?: boolean;\n  };\n}\n\n/**\n * A proxy to the normalized data living in our store. This interface allows a\n * user to read and write denormalized data which feels natural to the user\n * whilst in the background this data is being converted into the normalized\n * store format.\n */\nexport interface DataProxy {\n  /**\n   * Reads a GraphQL query from the root query id.\n   */\n  readQuery<QueryType, TVariables = any>(\n    options: DataProxy.ReadQueryOptions<QueryType, TVariables>,\n    optimistic?: boolean\n  ): QueryType | null;\n\n  /**\n   * Reads a GraphQL fragment from any arbitrary id. If there is more than\n   * one fragment in the provided document then a `fragmentName` must be\n   * provided to select the correct fragment.\n   */\n  readFragment<FragmentType, TVariables = any>(\n    options: DataProxy.ReadFragmentOptions<FragmentType, TVariables>,\n    optimistic?: boolean\n  ): FragmentType | null;\n\n  /**\n   * Writes a GraphQL query to the root query id.\n   */\n  writeQuery<TData = any, TVariables = any>(\n    options: DataProxy.WriteQueryOptions<TData, TVariables>\n  ): Reference | undefined;\n\n  /**\n   * Writes a GraphQL fragment to any arbitrary id. If there is more than\n   * one fragment in the provided document then a `fragmentName` must be\n   * provided to select the correct fragment.\n   */\n  writeFragment<TData = any, TVariables = any>(\n    options: DataProxy.WriteFragmentOptions<TData, TVariables>\n  ): Reference | undefined;\n}\n"]}
+{"version":3,"file":"DataProxy.js","sourceRoot":"","sources":["../../../../src/cache/core/types/DataProxy.ts"],"names":[],"mappings":"","sourcesContent":["import type { DocumentNode } from \"graphql\"; // ignore-comment eslint-disable-line import/no-extraneous-dependencies, import/no-unresolved\nimport type { TypedDocumentNode } from \"@graphql-typed-document-node/core\";\n\nimport type { MissingFieldError } from \"./common.js\";\nimport type { Reference } from \"../../../utilities/index.js\";\n\nexport namespace DataProxy {\n  export interface Query<TVariables, TData> {\n    /**\n     * The GraphQL query shape to be used constructed using the `gql` template\n     * string tag from `graphql-tag`. The query will be used to determine the\n     * shape of the data to be read.\n     */\n    query: DocumentNode | TypedDocumentNode<TData, TVariables>;\n\n    /**\n     * Any variables that the GraphQL query may depend on.\n     */\n    variables?: TVariables;\n\n    /**\n     * The root id to be used. Defaults to \"ROOT_QUERY\", which is the ID of the\n     * root query object. This property makes writeQuery capable of writing data\n     * to any object in the cache.\n     */\n    id?: string;\n  }\n\n  export interface Fragment<TVariables, TData> {\n    /**\n     * The root id to be used. This id should take the same form as the\n     * value returned by your `dataIdFromObject` function. If a value with your\n     * id does not exist in the store, `null` will be returned.\n     */\n    id?: string;\n\n    /**\n     * A GraphQL document created using the `gql` template string tag from\n     * `graphql-tag` with one or more fragments which will be used to determine\n     * the shape of data to read. If you provide more than one fragment in this\n     * document then you must also specify `fragmentName` to select a single.\n     */\n    fragment: DocumentNode | TypedDocumentNode<TData, TVariables>;\n\n    /**\n     * The name of the fragment in your GraphQL document to be used. If you do\n     * not provide a `fragmentName` and there is only one fragment in your\n     * `fragment` document then that fragment will be used.\n     */\n    fragmentName?: string;\n\n    /**\n     * Any variables that your GraphQL fragments depend on.\n     */\n    variables?: TVariables;\n  }\n\n  export interface ReadQueryOptions<TData, TVariables>\n    extends Query<TVariables, TData> {\n    /**\n     * Whether to return incomplete data rather than null.\n     * Defaults to false.\n     */\n    returnPartialData?: boolean;\n    /**\n     * Whether to read from optimistic or non-optimistic cache data. If\n     * this named option is provided, the optimistic parameter of the\n     * readQuery method can be omitted. Defaults to false.\n     */\n    optimistic?: boolean;\n    /**\n    /**\n     * @deprecated\n     * Using `canonizeResults` can result in memory leaks so we generally do not\n     * recommend using this option anymore.\n     * A future version of Apollo Client will contain a similar feature without\n     * the risk of memory leaks.\n     *\n     * Whether to canonize cache results before returning them. Canonization\n     * takes some extra time, but it speeds up future deep equality comparisons.\n     * Defaults to false.\n     */\n    canonizeResults?: boolean;\n  }\n\n  export interface ReadFragmentOptions<TData, TVariables>\n    extends Fragment<TVariables, TData> {\n    /**\n     * Whether to return incomplete data rather than null.\n     * Defaults to false.\n     */\n    returnPartialData?: boolean;\n    /**\n     * Whether to read from optimistic or non-optimistic cache data. If\n     * this named option is provided, the optimistic parameter of the\n     * readQuery method can be omitted. Defaults to false.\n     */\n    optimistic?: boolean;\n    /**\n     * @deprecated\n     * Using `canonizeResults` can result in memory leaks so we generally do not\n     * recommend using this option anymore.\n     * A future version of Apollo Client will contain a similar feature.\n     *\n     * Whether to canonize cache results before returning them. Canonization\n     * takes some extra time, but it speeds up future deep equality comparisons.\n     * Defaults to false.\n     */\n    canonizeResults?: boolean;\n  }\n\n  export interface WriteOptions<TData> {\n    /**\n     * The data you will be writing to the store.\n     */\n    data: TData;\n    /**\n     * Whether to notify query watchers (default: true).\n     */\n    broadcast?: boolean;\n    /**\n     * When true, ignore existing field data rather than merging it with\n     * incoming data (default: false).\n     */\n    overwrite?: boolean;\n  }\n\n  export interface WriteQueryOptions<TData, TVariables>\n    extends Query<TVariables, TData>,\n      WriteOptions<TData> {}\n\n  export interface WriteFragmentOptions<TData, TVariables>\n    extends Fragment<TVariables, TData>,\n      WriteOptions<TData> {}\n\n  export interface UpdateQueryOptions<TData, TVariables>\n    extends Omit<\n      ReadQueryOptions<TData, TVariables> &\n        WriteQueryOptions<TData, TVariables>,\n      \"data\"\n    > {}\n\n  export interface UpdateFragmentOptions<TData, TVariables>\n    extends Omit<\n      ReadFragmentOptions<TData, TVariables> &\n        WriteFragmentOptions<TData, TVariables>,\n      \"data\"\n    > {}\n\n  export type DiffResult<T> = {\n    result?: T;\n    complete?: boolean;\n    missing?: MissingFieldError[];\n    fromOptimisticTransaction?: boolean;\n  };\n}\n\n/**\n * A proxy to the normalized data living in our store. This interface allows a\n * user to read and write denormalized data which feels natural to the user\n * whilst in the background this data is being converted into the normalized\n * store format.\n */\nexport interface DataProxy {\n  /**\n   * Reads a GraphQL query from the root query id.\n   */\n  readQuery<QueryType, TVariables = any>(\n    options: DataProxy.ReadQueryOptions<QueryType, TVariables>,\n    optimistic?: boolean\n  ): QueryType | null;\n\n  /**\n   * Reads a GraphQL fragment from any arbitrary id. If there is more than\n   * one fragment in the provided document then a `fragmentName` must be\n   * provided to select the correct fragment.\n   */\n  readFragment<FragmentType, TVariables = any>(\n    options: DataProxy.ReadFragmentOptions<FragmentType, TVariables>,\n    optimistic?: boolean\n  ): FragmentType | null;\n\n  /**\n   * Writes a GraphQL query to the root query id.\n   */\n  writeQuery<TData = any, TVariables = any>(\n    options: DataProxy.WriteQueryOptions<TData, TVariables>\n  ): Reference | undefined;\n\n  /**\n   * Writes a GraphQL fragment to any arbitrary id. If there is more than\n   * one fragment in the provided document then a `fragmentName` must be\n   * provided to select the correct fragment.\n   */\n  writeFragment<TData = any, TVariables = any>(\n    options: DataProxy.WriteFragmentOptions<TData, TVariables>\n  ): Reference | undefined;\n}\n"]}

package/cache/core/types/common.d.ts

@@ -37,6 +37,10 @@ declare const _invalidateModifier: unique symbol;
 export interface InvalidateModifier {
     [_invalidateModifier]: true;
 }
+declare const _ignoreModifier: unique symbol;
+export interface IgnoreModifier {
+    [_ignoreModifier]: true;
+}
 export type ModifierDetails = {
     DELETE: DeleteModifier;
     INVALIDATE: InvalidateModifier;
@@ -49,7 +53,7 @@ export type ModifierDetails = {
     storage: StorageType;
 };
 export type Modifier<T> = (value: T, details: ModifierDetails) => T | DeleteModifier | InvalidateModifier;
-type StoreObjectValueMaybeReference<StoreVal> = StoreVal extends Array<infer Item extends Record<string, any>> ? ReadonlyArray<AsStoreObject<Item> | Reference> : StoreVal extends Record<string, any> ? AsStoreObject<StoreVal> | Reference : StoreVal;
+type StoreObjectValueMaybeReference<StoreVal> = StoreVal extends Array<Record<string, any>> ? StoreVal extends Array<infer Item> ? Item extends Record<string, any> ? ReadonlyArray<AsStoreObject<Item> | Reference> : never : never : StoreVal extends Record<string, any> ? AsStoreObject<StoreVal> | Reference : StoreVal;
 export type AllFieldsModifier<Entity extends Record<string, any>> = Modifier<Entity[keyof Entity] extends infer Value ? StoreObjectValueMaybeReference<Exclude<Value, undefined>> : never>;
 export type Modifiers<T extends Record<string, any> = Record<string, unknown>> = Partial<{
     [FieldName in keyof T]: Modifier<StoreObjectValueMaybeReference<Exclude<T[FieldName], undefined>>>;

package/cache/core/types/common.js

@@ -1,8 +1,9 @@
 import { __extends } from "tslib";
-var MissingFieldError = (function (_super) {
+var MissingFieldError = /** @class */ (function (_super) {
     __extends(MissingFieldError, _super);
     function MissingFieldError(message, path, query, variables) {
         var _a;
+        // 'Error' breaks prototype chain here
         var _this = _super.call(this, message) || this;
         _this.message = message;
         _this.path = path;
@@ -17,6 +18,8 @@ var MissingFieldError = (function (_super) {
         else {
             _this.missing = _this.path;
         }
+        // We're not using `Object.setPrototypeOf` here as it isn't fully supported
+        // on Android (see issue #3236).
         _this.__proto__ = MissingFieldError.prototype;
         return _this;
     }

package/cache/core/types/common.js.map

@@ -1 +1 @@
-{"version":3,"file":"common.js","sourceRoot":"","sources":["../../../../src/cache/core/types/common.ts"],"names":[],"mappings":";AA2BA;IAAuC,qCAAK;IAC1C,2BACkB,OAAe,EACf,IAA0C,EAC1C,KAAmB,EACnB,SAA+B;;QAJjD,YAOE,kBAAM,OAAO,CAAC,SAcf;QApBiB,aAAO,GAAP,OAAO,CAAQ;QACf,UAAI,GAAJ,IAAI,CAAsC;QAC1C,WAAK,GAAL,KAAK,CAAc;QACnB,eAAS,GAAT,SAAS,CAAsB;QAK/C,IAAI,KAAK,CAAC,OAAO,CAAC,KAAI,CAAC,IAAI,CAAC,EAAE;YAC5B,KAAI,CAAC,OAAO,GAAG,KAAI,CAAC,OAAO,CAAC;YAC5B,KAAK,IAAI,CAAC,GAAG,KAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC,EAAE;gBAC9C,KAAI,CAAC,OAAO,aAAK,GAAC,KAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAG,KAAI,CAAC,OAAO,KAAE,CAAC;aACjD;SACF;aAAM;YACL,KAAI,CAAC,OAAO,GAAG,KAAI,CAAC,IAAI,CAAC;SAC1B;QAIA,KAAY,CAAC,SAAS,GAAG,iBAAiB,CAAC,SAAS,CAAC;;IACxD,CAAC;IAGH,wBAAC;AAAD,CAAC,AAzBD,CAAuC,KAAK,GAyB3C","sourcesContent":["import type { DocumentNode, FieldNode } from \"graphql\";\n\nimport type {\n  Reference,\n  StoreObject,\n  StoreValue,\n  isReference,\n  AsStoreObject,\n} from \"../../../utilities/index.js\";\n\nimport type { StorageType } from \"../../inmemory/policies.js\";\n\n// The Readonly<T> type only really works for object types, since it marks\n// all of the object's properties as readonly, but there are many cases when\n// a generic type parameter like TExisting might be a string or some other\n// primitive type, in which case we need to avoid wrapping it with Readonly.\n// SafeReadonly<string> collapses to just string, which makes string\n// assignable to SafeReadonly<any>, whereas string is not assignable to\n// Readonly<any>, somewhat surprisingly.\nexport type SafeReadonly<T> = T extends object ? Readonly<T> : T;\n\nexport type MissingTree =\n  | string\n  | {\n      readonly [key: string]: MissingTree;\n    };\n\nexport class MissingFieldError extends Error {\n  constructor(\n    public readonly message: string,\n    public readonly path: MissingTree | Array<string | number>,\n    public readonly query: DocumentNode,\n    public readonly variables?: Record<string, any>\n  ) {\n    // 'Error' breaks prototype chain here\n    super(message);\n\n    if (Array.isArray(this.path)) {\n      this.missing = this.message;\n      for (let i = this.path.length - 1; i >= 0; --i) {\n        this.missing = { [this.path[i]]: this.missing };\n      }\n    } else {\n      this.missing = this.path;\n    }\n\n    // We're not using `Object.setPrototypeOf` here as it isn't fully supported\n    // on Android (see issue #3236).\n    (this as any).__proto__ = MissingFieldError.prototype;\n  }\n\n  public readonly missing: MissingTree;\n}\n\nexport interface FieldSpecifier {\n  typename?: string;\n  fieldName: string;\n  field?: FieldNode;\n  args?: Record<string, any>;\n  variables?: Record<string, any>;\n}\n\nexport interface ReadFieldOptions extends FieldSpecifier {\n  from?: StoreObject | Reference;\n}\n\nexport interface ReadFieldFunction {\n  <V = StoreValue>(options: ReadFieldOptions): SafeReadonly<V> | undefined;\n  <V = StoreValue>(\n    fieldName: string,\n    from?: StoreObject | Reference\n  ): SafeReadonly<V> | undefined;\n}\n\nexport type ToReferenceFunction = (\n  objOrIdOrRef: StoreObject | string | Reference,\n  mergeIntoStore?: boolean\n) => Reference | undefined;\n\nexport type CanReadFunction = (value: StoreValue) => boolean;\n\ndeclare const _deleteModifier: unique symbol;\nexport interface DeleteModifier {\n  [_deleteModifier]: true;\n}\ndeclare const _invalidateModifier: unique symbol;\nexport interface InvalidateModifier {\n  [_invalidateModifier]: true;\n}\n\nexport type ModifierDetails = {\n  DELETE: DeleteModifier;\n  INVALIDATE: InvalidateModifier;\n  fieldName: string;\n  storeFieldName: string;\n  readField: ReadFieldFunction;\n  canRead: CanReadFunction;\n  isReference: typeof isReference;\n  toReference: ToReferenceFunction;\n  storage: StorageType;\n};\n\nexport type Modifier<T> = (\n  value: T,\n  details: ModifierDetails\n) => T | DeleteModifier | InvalidateModifier;\n\ntype StoreObjectValueMaybeReference<StoreVal> = StoreVal extends Array<\n  infer Item extends Record<string, any>\n>\n  ? ReadonlyArray<AsStoreObject<Item> | Reference>\n  : StoreVal extends Record<string, any>\n  ? AsStoreObject<StoreVal> | Reference\n  : StoreVal;\n\nexport type AllFieldsModifier<Entity extends Record<string, any>> = Modifier<\n  Entity[keyof Entity] extends infer Value\n    ? StoreObjectValueMaybeReference<Exclude<Value, undefined>>\n    : never\n>;\n\nexport type Modifiers<T extends Record<string, any> = Record<string, unknown>> =\n  Partial<{\n    [FieldName in keyof T]: Modifier<\n      StoreObjectValueMaybeReference<Exclude<T[FieldName], undefined>>\n    >;\n  }>;\n"]}
+{"version":3,"file":"common.js","sourceRoot":"","sources":["../../../../src/cache/core/types/common.ts"],"names":[],"mappings":";AA2BA;IAAuC,qCAAK;IAC1C,2BACkB,OAAe,EACf,IAA0C,EAC1C,KAAmB,EACnB,SAA+B;;QAE/C,sCAAsC;QACtC,YAAA,MAAK,YAAC,OAAO,CAAC,SAAC;QANC,aAAO,GAAP,OAAO,CAAQ;QACf,UAAI,GAAJ,IAAI,CAAsC;QAC1C,WAAK,GAAL,KAAK,CAAc;QACnB,eAAS,GAAT,SAAS,CAAsB;QAK/C,IAAI,KAAK,CAAC,OAAO,CAAC,KAAI,CAAC,IAAI,CAAC,EAAE,CAAC;YAC7B,KAAI,CAAC,OAAO,GAAG,KAAI,CAAC,OAAO,CAAC;YAC5B,KAAK,IAAI,CAAC,GAAG,KAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;gBAC/C,KAAI,CAAC,OAAO,aAAK,GAAC,KAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAG,KAAI,CAAC,OAAO,KAAE,CAAC;YAClD,CAAC;QACH,CAAC;aAAM,CAAC;YACN,KAAI,CAAC,OAAO,GAAG,KAAI,CAAC,IAAI,CAAC;QAC3B,CAAC;QAED,2EAA2E;QAC3E,gCAAgC;QAC/B,KAAY,CAAC,SAAS,GAAG,iBAAiB,CAAC,SAAS,CAAC;;IACxD,CAAC;IAGH,wBAAC;AAAD,CAAC,AAzBD,CAAuC,KAAK,GAyB3C","sourcesContent":["import type { DocumentNode, FieldNode } from \"graphql\";\n\nimport type {\n  Reference,\n  StoreObject,\n  StoreValue,\n  isReference,\n  AsStoreObject,\n} from \"../../../utilities/index.js\";\n\nimport type { StorageType } from \"../../inmemory/policies.js\";\n\n// The Readonly<T> type only really works for object types, since it marks\n// all of the object's properties as readonly, but there are many cases when\n// a generic type parameter like TExisting might be a string or some other\n// primitive type, in which case we need to avoid wrapping it with Readonly.\n// SafeReadonly<string> collapses to just string, which makes string\n// assignable to SafeReadonly<any>, whereas string is not assignable to\n// Readonly<any>, somewhat surprisingly.\nexport type SafeReadonly<T> = T extends object ? Readonly<T> : T;\n\nexport type MissingTree =\n  | string\n  | {\n      readonly [key: string]: MissingTree;\n    };\n\nexport class MissingFieldError extends Error {\n  constructor(\n    public readonly message: string,\n    public readonly path: MissingTree | Array<string | number>,\n    public readonly query: DocumentNode,\n    public readonly variables?: Record<string, any>\n  ) {\n    // 'Error' breaks prototype chain here\n    super(message);\n\n    if (Array.isArray(this.path)) {\n      this.missing = this.message;\n      for (let i = this.path.length - 1; i >= 0; --i) {\n        this.missing = { [this.path[i]]: this.missing };\n      }\n    } else {\n      this.missing = this.path;\n    }\n\n    // We're not using `Object.setPrototypeOf` here as it isn't fully supported\n    // on Android (see issue #3236).\n    (this as any).__proto__ = MissingFieldError.prototype;\n  }\n\n  public readonly missing: MissingTree;\n}\n\nexport interface FieldSpecifier {\n  typename?: string;\n  fieldName: string;\n  field?: FieldNode;\n  args?: Record<string, any>;\n  variables?: Record<string, any>;\n}\n\nexport interface ReadFieldOptions extends FieldSpecifier {\n  from?: StoreObject | Reference;\n}\n\nexport interface ReadFieldFunction {\n  <V = StoreValue>(options: ReadFieldOptions): SafeReadonly<V> | undefined;\n  <V = StoreValue>(\n    fieldName: string,\n    from?: StoreObject | Reference\n  ): SafeReadonly<V> | undefined;\n}\n\nexport type ToReferenceFunction = (\n  objOrIdOrRef: StoreObject | string | Reference,\n  mergeIntoStore?: boolean\n) => Reference | undefined;\n\nexport type CanReadFunction = (value: StoreValue) => boolean;\n\ndeclare const _deleteModifier: unique symbol;\nexport interface DeleteModifier {\n  [_deleteModifier]: true;\n}\ndeclare const _invalidateModifier: unique symbol;\nexport interface InvalidateModifier {\n  [_invalidateModifier]: true;\n}\ndeclare const _ignoreModifier: unique symbol;\nexport interface IgnoreModifier {\n  [_ignoreModifier]: true;\n}\n\nexport type ModifierDetails = {\n  DELETE: DeleteModifier;\n  INVALIDATE: InvalidateModifier;\n  fieldName: string;\n  storeFieldName: string;\n  readField: ReadFieldFunction;\n  canRead: CanReadFunction;\n  isReference: typeof isReference;\n  toReference: ToReferenceFunction;\n  storage: StorageType;\n};\n\nexport type Modifier<T> = (\n  value: T,\n  details: ModifierDetails\n) => T | DeleteModifier | InvalidateModifier;\n\ntype StoreObjectValueMaybeReference<StoreVal> =\n  StoreVal extends Array<Record<string, any>> ?\n    StoreVal extends Array<infer Item> ?\n      Item extends Record<string, any> ?\n        ReadonlyArray<AsStoreObject<Item> | Reference>\n      : never\n    : never\n  : StoreVal extends Record<string, any> ? AsStoreObject<StoreVal> | Reference\n  : StoreVal;\n\nexport type AllFieldsModifier<Entity extends Record<string, any>> = Modifier<\n  Entity[keyof Entity] extends infer Value ?\n    StoreObjectValueMaybeReference<Exclude<Value, undefined>>\n  : never\n>;\n\nexport type Modifiers<T extends Record<string, any> = Record<string, unknown>> =\n  Partial<{\n    [FieldName in keyof T]: Modifier<\n      StoreObjectValueMaybeReference<Exclude<T[FieldName], undefined>>\n    >;\n  }>;\n"]}

package/cache/inmemory/entityStore.d.ts

@@ -4,6 +4,7 @@ import type { NormalizedCache, NormalizedCacheObject } from "./types.js";
 import type { Policies, StorageType } from "./policies.js";
 import type { Cache } from "../core/types/Cache.js";
 import type { SafeReadonly, Modifier, Modifiers, ToReferenceFunction, CanReadFunction } from "../core/types/common.js";
+import type { DocumentNode, FieldNode, SelectionSetNode } from "graphql";
 export declare abstract class EntityStore implements NormalizedCache {
     readonly policies: Policies;
     readonly group: CacheGroup;
@@ -30,6 +31,14 @@ export declare abstract class EntityStore implements NormalizedCache {
     gc(): string[];
     private refs;
     findChildRefIds(dataId: string): Record<string, true>;
+    /** overload for `InMemoryCache.maybeBroadcastWatch` */
+    makeCacheKey(document: DocumentNode, callback: Cache.WatchCallback<any>, details: string): object;
+    /** overload for `StoreReader.executeSelectionSet` */
+    makeCacheKey(selectionSet: SelectionSetNode, parent: string | StoreObject, varString: string | undefined, canonizeResults: boolean): object;
+    /** overload for `StoreReader.executeSubSelectedArray` */
+    makeCacheKey(field: FieldNode, array: readonly any[], varString: string | undefined): object;
+    /** @deprecated This is only meant for internal usage,
+     * in your own code please use a `Trie` instance instead. */
     makeCacheKey(...args: any[]): object;
     getFieldValue: <T = StoreValue>(objectOrReference: StoreObject | Reference | undefined, storeFieldName: string) => SafeReadonly<T>;
     canRead: CanReadFunction;
@@ -76,7 +85,7 @@ declare class Layer extends EntityStore {
 declare class Stump extends Layer {
     constructor(root: EntityStore.Root);
     removeLayer(): this;
-    merge(): any;
+    merge(older: string | StoreObject, newer: string | StoreObject): void;
 }
 export declare function supportsResultCaching(store: any): store is EntityStore;
 export {};