@apollo/client 4.0.0-rc.4 → 4.0.0-rc.6

package/__cjs/cache/inmemory/writeToStore.d.cts

@@ -28,7 +28,7 @@ export declare class StoreWriter {
     private reader?;
     private fragments?;
     constructor(cache: InMemoryCache, reader?: StoreReader | undefined, fragments?: InMemoryCacheConfig["fragments"]);
-    writeToStore<TData = unknown, TVariables = OperationVariables>(store: NormalizedCache, { query, result, dataId, variables, overwrite, }: Cache.WriteOptions<TData, TVariables>): Reference | undefined;
+    writeToStore<TData = unknown, TVariables extends OperationVariables = OperationVariables>(store: NormalizedCache, { query, result, dataId, variables, overwrite, }: Cache.WriteOptions<TData, TVariables>): Reference | undefined;
     private processSelectionSet;
     private processFieldValue;
     private flattenFields;

package/__cjs/core/ApolloClient.cjs

@@ -9,6 +9,7 @@ const graphql_1 = require("graphql");
 const rxjs_1 = require("rxjs");
 const incremental_1 = require("@apollo/client/incremental");
 const link_1 = require("@apollo/client/link");
+const utilities_1 = require("@apollo/client/utilities");
 const environment_1 = require("@apollo/client/utilities/environment");
 const internal_1 = require("@apollo/client/utilities/internal");
 const invariant_1 = require("@apollo/client/utilities/invariant");
@@ -53,23 +54,24 @@ class ApolloClient {
      * Constructs an instance of `ApolloClient`.
      *
      * @example
+     *
      * ```js
-     * import { ApolloClient, InMemoryCache } from '@apollo/client';
+     * import { ApolloClient, InMemoryCache } from "@apollo/client";
      *
      * const cache = new InMemoryCache();
      *
      * const client = new ApolloClient({
      *   // Provide required constructor fields
      *   cache: cache,
-     *   uri: 'http://localhost:4000/',
+     *   uri: "http://localhost:4000/",
      *
      *   // Provide some optional constructor fields
-     *   name: 'react-web-client',
-     *   version: '1.3',
+     *   name: "react-web-client",
+     *   version: "1.3",
      *   queryDeduplication: false,
      *   defaultOptions: {
      *     watchQuery: {
-     *       fetchPolicy: 'cache-and-network',
+     *       fetchPolicy: "cache-and-network",
      *     },
      *   },
      * });
@@ -77,8 +79,8 @@ class ApolloClient {
      */
     constructor(options) {
         if (environment_1.__DEV__) {
-            (0, invariant_1.invariant)(options.cache, 66);
-            (0, invariant_1.invariant)(options.link, 67);
+            (0, invariant_1.invariant)(options.cache, 65);
+            (0, invariant_1.invariant)(options.link, 66);
         }
         const { cache, documentTransform, ssrMode = false, ssrForceFetchDelay = 0, queryDeduplication = true, defaultOptions, defaultContext, assumeImmutableResults = cache.assumeImmutableResults, localState, devtools, dataMasking, link, incrementalHandler = new incremental_1.NotImplementedHandler(), } = options;
         this.link = link;
@@ -189,6 +191,12 @@ class ApolloClient {
     /**
      * Call this method to terminate any active client processes, making it safe
      * to dispose of this `ApolloClient` instance.
+     *
+     * This method performs aggressive cleanup to prevent memory leaks:
+     *
+     * - Unsubscribes all active `ObservableQuery` instances by emitting a `completed` event
+     * - Rejects all currently running queries with "QueryManager stopped while query was in flight"
+     * - Removes all queryRefs from the suspense cache
      */
     stop() {
         this.queryManager.stop();
@@ -203,11 +211,11 @@ class ApolloClient {
      *
      * For example, suppose you call watchQuery on a GraphQL query that fetches a person's
      * first and last name and this person has a particular object identifier, provided by
-     * dataIdFromObject. Later, a different query fetches that same person's
+     * `cache.identify`. Later, a different query fetches that same person's
      * first and last name and the first name has now changed. Then, any observers associated
      * with the results of the first query will be updated with a new result object.
      *
-     * Note that if the cache does not change, the subscriber will *not* be notified.
+     * Note that if the cache does not change, the subscriber will _not_ be notified.
      *
      * See [here](https://medium.com/apollo-stack/the-concepts-of-graphql-bc68bd819be3#.3mb0cbcmc) for
      * a description of store reactivity.
@@ -232,13 +240,13 @@ class ApolloClient {
             options = (0, internal_1.mergeOptions)(this.defaultOptions.query, options);
         }
         if (environment_1.__DEV__) {
-            (0, invariant_1.invariant)(options.fetchPolicy !== "cache-and-network", 68);
-            (0, invariant_1.invariant)(options.fetchPolicy !== "standby", 69);
-            (0, invariant_1.invariant)(options.query, 70);
-            (0, invariant_1.invariant)(options.query.kind === "Document", 71);
-            (0, invariant_1.invariant)(!options.returnPartialData, 72);
-            (0, invariant_1.invariant)(!options.pollInterval, 73);
-            (0, invariant_1.invariant)(!options.notifyOnNetworkStatusChange, 74);
+            (0, invariant_1.invariant)(options.fetchPolicy !== "cache-and-network", 67);
+            (0, invariant_1.invariant)(options.fetchPolicy !== "standby", 68);
+            (0, invariant_1.invariant)(options.query, 69);
+            (0, invariant_1.invariant)(options.query.kind === "Document", 70);
+            (0, invariant_1.invariant)(!options.returnPartialData, 71);
+            (0, invariant_1.invariant)(!options.pollInterval, 72);
+            (0, invariant_1.invariant)(!options.notifyOnNetworkStatusChange, 73);
         }
         return this.queryManager.query(options);
     }
@@ -256,9 +264,9 @@ class ApolloClient {
             errorPolicy: "none",
         }, this.defaultOptions.mutate), options);
         if (environment_1.__DEV__) {
-            (0, invariant_1.invariant)(optionsWithDefaults.mutation, 75);
+            (0, invariant_1.invariant)(optionsWithDefaults.mutation, 74);
             (0, invariant_1.invariant)(optionsWithDefaults.fetchPolicy === "network-only" ||
-                optionsWithDefaults.fetchPolicy === "no-cache", 76);
+                optionsWithDefaults.fetchPolicy === "no-cache", 75);
         }
         (0, internal_1.checkDocument)(optionsWithDefaults.mutation, graphql_1.OperationTypeNode.MUTATION);
         return this.queryManager.mutate(optionsWithDefaults);
@@ -281,17 +289,8 @@ class ApolloClient {
         })));
         return Object.assign(mapped, { restart: observable.restart });
     }
-    /**
-     * Tries to read some data from the store in the shape of the provided
-     * GraphQL query without making a network request. This method will start at
-     * the root query. To start at a specific id returned by `dataIdFromObject`
-     * use `readFragment`.
-     *
-     * @param optimistic - Set to `true` to allow `readQuery` to return
-     * optimistic results. Is `false` by default.
-     */
     readQuery(options, optimistic = false) {
-        return this.cache.readQuery(options, optimistic);
+        return this.cache.readQuery({ ...options, query: this.transform(options.query) }, optimistic);
     }
     /**
      * Watches the cache store of the fragment according to the options specified
@@ -310,32 +309,37 @@ class ApolloClient {
      * to optimistic updates.
      */
     watchFragment(options) {
-        return this.cache.watchFragment({
+        const dataMasking = this.queryManager.dataMasking;
+        return this.cache
+            .watchFragment({
             ...options,
-            [Symbol.for("apollo.dataMasking")]: this.queryManager.dataMasking,
-        });
+            fragment: this.transform(options.fragment, dataMasking),
+        })
+            .pipe((0, rxjs_1.map)((result) => {
+            // The transform will remove fragment spreads from the fragment
+            // document when dataMasking is enabled. The `maskFragment` function
+            // remains to apply warnings to fragments marked as
+            // `@unmask(mode: "migrate")`. Since these warnings are only applied
+            // in dev, we can skip the masking algorithm entirely for production.
+            if (environment_1.__DEV__) {
+                if (dataMasking) {
+                    const data = this.queryManager.maskFragment({
+                        ...options,
+                        data: result.data,
+                    });
+                    return { ...result, data };
+                }
+            }
+            return result;
+        }));
     }
-    /**
-     * Tries to read some data from the store in the shape of the provided
-     * GraphQL fragment without making a network request. This method will read a
-     * GraphQL fragment from any arbitrary id that is currently cached, unlike
-     * `readQuery` which will only read from the root query.
-     *
-     * You must pass in a GraphQL document with a single fragment or a document
-     * with multiple fragments that represent what you are reading. If you pass
-     * in a document with multiple fragments then you must also specify a
-     * `fragmentName`.
-     *
-     * @param optimistic - Set to `true` to allow `readFragment` to return
-     * optimistic results. Is `false` by default.
-     */
     readFragment(options, optimistic = false) {
-        return this.cache.readFragment(options, optimistic);
+        return this.cache.readFragment({ ...options, fragment: this.transform(options.fragment) }, optimistic);
     }
     /**
      * Writes some data in the shape of the provided GraphQL query directly to
      * the store. This method will start at the root query. To start at a
-     * specific id returned by `dataIdFromObject` then use `writeFragment`.
+     * specific id returned by `cache.identify` then use `writeFragment`.
      */
     writeQuery(options) {
         const ref = this.cache.writeQuery(options);
@@ -378,7 +382,7 @@ class ApolloClient {
      * user session, and you now want to make sure that any references to data you
      * might have fetched while the user session was active is gone.
      *
-     * It is important to remember that `resetStore()` *will* refetch any active
+     * It is important to remember that `resetStore()` _will_ refetch any active
      * queries. This means that any components that might be mounted will execute
      * their queries again using your network interface. If you do not want to
      * re-execute any queries then you should make sure to stop watching any
@@ -430,13 +434,15 @@ class ApolloClient {
      *
      * `reFetchObservableQueries()` is useful if you want to bring the client back to proper state in case of a network outage
      *
-     * It is important to remember that `reFetchObservableQueries()` *will* refetch any active
+     * It is important to remember that `reFetchObservableQueries()` _will_ refetch any active
      * queries. This means that any components that might be mounted will execute
      * their queries again using your network interface. If you do not want to
      * re-execute any queries then you should make sure to stop watching any
      * active queries.
      * Takes optional parameter `includeStandby` which will include queries in standby-mode when refetching.
      *
+     * Note: `cache-only` queries are not refetched by this function.
+     *
      * @deprecated Please use `refetchObservableQueries` instead.
      */
     reFetchObservableQueries;
@@ -445,12 +451,14 @@ class ApolloClient {
      *
      * `refetchObservableQueries()` is useful if you want to bring the client back to proper state in case of a network outage
      *
-     * It is important to remember that `refetchObservableQueries()` *will* refetch any active
+     * It is important to remember that `refetchObservableQueries()` _will_ refetch any active
      * queries. This means that any components that might be mounted will execute
      * their queries again using your network interface. If you do not want to
      * re-execute any queries then you should make sure to stop watching any
      * active queries.
      * Takes optional parameter `includeStandby` which will include queries in standby-mode when refetching.
+     *
+     * Note: `cache-only` queries are not refetched by this function.
      */
     refetchObservableQueries(includeStandby) {
         return this.queryManager.refetchObservableQueries(includeStandby);
@@ -460,7 +468,7 @@ class ApolloClient {
      *
      * `refetchQueries()` is useful for use cases to imperatively refresh a selection of queries.
      *
-     * It is important to remember that `refetchQueries()` *will* refetch specified active
+     * It is important to remember that `refetchQueries()` _will_ refetch specified active
      * queries. This means that any components that might be mounted will execute
      * their queries again using your network interface. If you do not want to
      * re-execute any queries then you should make sure to stop watching any
@@ -483,13 +491,12 @@ class ApolloClient {
         // result.queries and result.results instead, you shouldn't have to worry
         // about preventing uncaught rejections for the Promise.all result.
         result.catch((error) => {
-            __DEV__ && invariant_1.invariant.debug(77, error);
+            __DEV__ && invariant_1.invariant.debug(76, error);
         });
         return result;
     }
     /**
-     * Get all currently active `ObservableQuery` objects, in a `Map` keyed by
-     * query ID strings.
+     * Get all currently active `ObservableQuery` objects, in a `Set`.
      *
      * An "active" query is one that has observers and a `fetchPolicy` other than
      * "standby" or "cache-only".
@@ -497,6 +504,9 @@ class ApolloClient {
      * You can include all `ObservableQuery` objects (including the inactive ones)
      * by passing "all" instead of "active", or you can include just a subset of
      * active queries by passing an array of query names or DocumentNode objects.
+     *
+     * Note: This method only returns queries that have active subscribers. Queries
+     * without subscribers are not tracked by the client.
      */
     getObservableQueries(include = "active") {
         return this.queryManager.getObservableQueries(include);
@@ -526,6 +536,13 @@ class ApolloClient {
     get defaultContext() {
         return this.queryManager.defaultContext;
     }
+    maskedFragmentTransform = new utilities_1.DocumentTransform(internal_1.removeMaskedFragmentSpreads);
+    transform(document, dataMasking = false) {
+        const transformed = this.queryManager.transform(document);
+        return dataMasking ?
+            this.maskedFragmentTransform.transformDocument(transformed)
+            : transformed;
+    }
     /**
      * @experimental
      * This is not a stable API - it is used in development builds to expose
@@ -534,75 +551,78 @@ class ApolloClient {
      * For more details, see [Memory Management](https://www.apollographql.com/docs/react/caching/memory-management/#measuring-cache-usage)
      *
      * @example
+     *
      * ```ts
-     * console.log(client.getMemoryInternals())
+     * console.log(client.getMemoryInternals());
      * ```
+     *
      * Logs output in the following JSON format:
      * @example
+     *
      * ```json
-     *{
-     *  limits:     {
-     *    canonicalStringify: 1000,
-     *    print: 2000,
-     *    'documentTransform.cache': 2000,
-     *    'queryManager.getDocumentInfo': 2000,
-     *    'PersistedQueryLink.persistedQueryHashes': 2000,
-     *    'fragmentRegistry.transform': 2000,
-     *    'fragmentRegistry.lookup': 1000,
-     *    'fragmentRegistry.findFragmentSpreads': 4000,
-     *    'cache.fragmentQueryDocuments': 1000,
-     *    'removeTypenameFromVariables.getVariableDefinitions': 2000,
-     *    'inMemoryCache.maybeBroadcastWatch': 5000,
-     *    'inMemoryCache.executeSelectionSet': 10000,
-     *    'inMemoryCache.executeSubSelectedArray': 5000
-     *  },
-     *  sizes: {
-     *    canonicalStringify: 4,
-     *    print: 14,
-     *    addTypenameDocumentTransform: [
-     *      {
-     *        cache: 14,
-     *      },
-     *    ],
-     *    queryManager: {
-     *      getDocumentInfo: 14,
-     *      documentTransforms: [
-     *        {
-     *          cache: 14,
-     *        },
-     *        {
-     *          cache: 14,
-     *        },
-     *      ],
-     *    },
-     *    fragmentRegistry: {
-     *      findFragmentSpreads: 34,
-     *      lookup: 20,
-     *      transform: 14,
-     *    },
-     *    cache: {
-     *      fragmentQueryDocuments: 22,
-     *    },
-     *    inMemoryCache: {
-     *      executeSelectionSet: 4345,
-     *      executeSubSelectedArray: 1206,
-     *      maybeBroadcastWatch: 32,
-     *    },
-     *    links: [
-     *      {
-     *        PersistedQueryLink: {
-     *          persistedQueryHashes: 14,
-     *        },
-     *      },
-     *      {
-     *        removeTypenameFromVariables: {
-     *          getVariableDefinitions: 14,
-     *        },
-     *      },
-     *    ],
-     *  },
+     * {
+     *   "limits": {
+     *     "canonicalStringify": 1000,
+     *     "print": 2000,
+     *     "documentTransform.cache": 2000,
+     *     "queryManager.getDocumentInfo": 2000,
+     *     "PersistedQueryLink.persistedQueryHashes": 2000,
+     *     "fragmentRegistry.transform": 2000,
+     *     "fragmentRegistry.lookup": 1000,
+     *     "fragmentRegistry.findFragmentSpreads": 4000,
+     *     "cache.fragmentQueryDocuments": 1000,
+     *     "removeTypenameFromVariables.getVariableDefinitions": 2000,
+     *     "inMemoryCache.maybeBroadcastWatch": 5000,
+     *     "inMemoryCache.executeSelectionSet": 10000,
+     *     "inMemoryCache.executeSubSelectedArray": 5000
+     *   },
+     *   "sizes": {
+     *     "canonicalStringify": 4,
+     *     "print": 14,
+     *     "addTypenameDocumentTransform": [
+     *       {
+     *         "cache": 14
+     *       }
+     *     ],
+     *     "queryManager": {
+     *       "getDocumentInfo": 14,
+     *       "documentTransforms": [
+     *         {
+     *           "cache": 14
+     *         },
+     *         {
+     *           "cache": 14
+     *         }
+     *       ]
+     *     },
+     *     "fragmentRegistry": {
+     *       "findFragmentSpreads": 34,
+     *       "lookup": 20,
+     *       "transform": 14
+     *     },
+     *     "cache": {
+     *       "fragmentQueryDocuments": 22
+     *     },
+     *     "inMemoryCache": {
+     *       "executeSelectionSet": 4345,
+     *       "executeSubSelectedArray": 1206,
+     *       "maybeBroadcastWatch": 32
+     *     },
+     *     "links": [
+     *       {
+     *         "PersistedQueryLink": {
+     *           "persistedQueryHashes": 14
+     *         }
+     *       },
+     *       {
+     *         "removeTypenameFromVariables": {
+     *           "getVariableDefinitions": 14
+     *         }
+     *       }
+     *     ]
+     *   }
      * }
-     *```
+     * ```
      */
     getMemoryInternals;
 }