@apollo/client 4.0.0-alpha.0 → 4.0.0-alpha.2

package/__cjs/cache/core/types/Cache.d.cts

@@ -1,30 +1,23 @@
+import type { OperationVariables } from "@apollo/client/core";
 import type { Unmasked } from "@apollo/client/masking";
 import type { ApolloCache } from "../cache.cjs";
 import type { AllFieldsModifier, Modifiers } from "./common.cjs";
 import { DataProxy } from "./DataProxy.cjs";
 export declare namespace Cache {
-    type WatchCallback<TData = any> = (diff: Cache.DiffResult<TData>, lastDiff?: Cache.DiffResult<TData>) => void;
-    interface ReadOptions<TVariables = any, TData = any> extends DataProxy.Query<TVariables, TData> {
+    type WatchCallback<TData = unknown> = (diff: Cache.DiffResult<TData>, lastDiff?: Cache.DiffResult<TData>) => void;
+    interface ReadOptions<TVariables = OperationVariables, TData = unknown> extends DataProxy.Query<TVariables, TData> {
         rootId?: string;
         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"> {
+    }
+    interface WriteOptions<TData = unknown, TVariables = OperationVariables> extends Omit<DataProxy.Query<TVariables, TData>, "id">, Omit<DataProxy.WriteOptions<TData>, "data"> {
         dataId?: string;
-        result: Unmasked<TResult>;
+        result: Unmasked<TData>;
     }
-    interface DiffOptions<TData = any, TVariables = any> extends Omit<ReadOptions<TVariables, TData>, "rootId"> {
+    interface DiffOptions<TData = unknown, TVariables = OperationVariables> extends Omit<ReadOptions<TVariables, TData>, "rootId"> {
     }
-    interface WatchOptions<TData = any, TVariables = any> extends DiffOptions<TData, TVariables> {
+    interface WatchOptions<TData = unknown, TVariables = OperationVariables> extends DiffOptions<TData, TVariables> {
         watcher?: object;
         immediate?: boolean;
         callback: WatchCallback<TData>;
@@ -45,7 +38,7 @@ export declare namespace Cache {
         optimistic?: boolean;
         broadcast?: boolean;
     }
-    interface BatchOptions<TCache extends ApolloCache<any>, TUpdateResult = void> {
+    interface BatchOptions<TCache extends ApolloCache, TUpdateResult = void> {
         update(cache: TCache): TUpdateResult;
         optimistic?: string | boolean;
         removeOptimistic?: string;

package/__cjs/cache/core/types/DataProxy.d.cts

@@ -1,5 +1,6 @@
 import type { TypedDocumentNode } from "@graphql-typed-document-node/core";
 import type { DocumentNode } from "graphql";
+import type { OperationVariables } from "@apollo/client/core";
 import type { Unmasked } from "@apollo/client/masking";
 import type { DeepPartial, Reference } from "@apollo/client/utilities";
 import type { MissingFieldError } from "./common.cjs";
@@ -59,14 +60,6 @@ export declare namespace DataProxy {
          * readQuery method can be omitted. Defaults to false.
          */
         optimistic?: boolean;
-        /**
-        * Whether to canonize cache results before returning them. Canonization takes some extra time, but it speeds up future deep equality comparisons. Defaults to false.
-        * 
-        * @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 ReadFragmentOptions<TData, TVariables> extends Fragment<TVariables, TData> {
         /**
@@ -80,14 +73,6 @@ export declare namespace DataProxy {
          * readQuery method can be omitted. Defaults to false.
          */
         optimistic?: boolean;
-        /**
-        * Whether to canonize cache results before returning them. Canonization takes some extra time, but it speeds up future deep equality comparisons. Defaults to false.
-        * 
-        * @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<TData> {
         /**
@@ -112,13 +97,13 @@ export declare namespace DataProxy {
     }
     interface UpdateFragmentOptions<TData, TVariables> extends Omit<ReadFragmentOptions<TData, TVariables> & WriteFragmentOptions<TData, TVariables>, "data"> {
     }
-    type DiffResult<T> = {
-        result: T;
+    type DiffResult<TData> = {
+        result: TData;
         complete: true;
         missing?: never;
         fromOptimisticTransaction?: boolean;
     } | {
-        result: DeepPartial<T> | null;
+        result: DeepPartial<TData> | null;
         complete: false;
         missing?: MissingFieldError;
         fromOptimisticTransaction?: boolean;
@@ -134,22 +119,22 @@ export interface DataProxy {
     /**
      * Reads a GraphQL query from the root query id.
      */
-    readQuery<QueryType, TVariables = any>(options: DataProxy.ReadQueryOptions<QueryType, TVariables>, optimistic?: boolean): Unmasked<QueryType> | null;
+    readQuery<TData = unknown, TVariables = OperationVariables>(options: DataProxy.ReadQueryOptions<TData, TVariables>, optimistic?: boolean): Unmasked<TData> | 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): Unmasked<FragmentType> | null;
+    readFragment<TData = unknown, TVariables = OperationVariables>(options: DataProxy.ReadFragmentOptions<TData, TVariables>, optimistic?: boolean): Unmasked<TData> | null;
     /**
      * Writes a GraphQL query to the root query id.
      */
-    writeQuery<TData = any, TVariables = any>(options: DataProxy.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+    writeQuery<TData = unknown, TVariables = OperationVariables>(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;
+    writeFragment<TData = unknown, TVariables = OperationVariables>(options: DataProxy.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
 }
 //# sourceMappingURL=DataProxy.d.cts.map

package/__cjs/cache/inmemory/entityStore.cjs

@@ -81,7 +81,7 @@ class EntityStore {
         // then there are no fields to be merged, so we're done.
         if (!incoming)
             return;
-        (0, invariant_1.invariant)(typeof dataId === "string", 82);
+        (0, invariant_1.invariant)(typeof dataId === "string", 83);
         const merged = new utilities_1.DeepMerger(storeObjectReconciler).merge(existing, incoming);
         // Even if merged === existing, existing may have come from a lower
         // layer, so we always need to set this.data[dataId] on this level.
@@ -181,7 +181,7 @@ class EntityStore {
                             if (environment_1.__DEV__) {
                                 const checkReference = (ref) => {
                                     if (this.lookup(ref.__ref) === undefined) {
-                                        __DEV__ && invariant_1.invariant.warn(83, ref);
+                                        __DEV__ && invariant_1.invariant.warn(84, ref);
                                         return true;
                                     }
                                 };
@@ -210,7 +210,7 @@ class EntityStore {
                                             }
                                         }
                                         if (seenReference && someNonReference !== undefined) {
-                                            __DEV__ && invariant_1.invariant.warn(84, someNonReference);
+                                            __DEV__ && invariant_1.invariant.warn(85, someNonReference);
                                             break;
                                         }
                                     }
@@ -631,13 +631,11 @@ class Layer extends EntityStore {
             }
             : fromParent;
     }
-    getStorage() {
+    getStorage(...args) {
         let p = this.parent;
         while (p.parent)
             p = p.parent;
-        return p.getStorage.apply(p, 
-        // @ts-expect-error
-        arguments);
+        return p.getStorage(...args);
     }
 }
 // Represents a Layer permanently installed just above the Root, which allows