@apollo/client 4.1.0-alpha.5 → 4.1.0-alpha.7

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

@@ -10,9 +10,9 @@ import type { MissingTree } from "./types/common.cjs";
 export type Transaction = (c: ApolloCache) => void;
 export declare namespace ApolloCache {
     /**
-     * Acceptable values provided to the `from` option for `watchFragment`.
+     * Acceptable values provided to the `from` option.
      */
-    type WatchFragmentFromValue<TData> = StoreObject | Reference | FragmentType<NoInfer<TData>> | string | null;
+    type FromOptionValue<TData> = StoreObject | Reference | FragmentType<NoInfer<TData>> | string;
     /**
      * Watched fragment options.
      */
@@ -32,7 +32,7 @@ export declare namespace ApolloCache {
          *
          * @docGroup 1. Required options
          */
-        from: ApolloCache.WatchFragmentFromValue<TData> | Array<ApolloCache.WatchFragmentFromValue<TData>>;
+        from: ApolloCache.FromOptionValue<TData> | Array<ApolloCache.FromOptionValue<TData> | null> | null;
         /**
          * Any variables that the GraphQL fragment may depend on.
          *
@@ -182,19 +182,19 @@ export declare abstract class ApolloCache {
     optimistic: boolean): Unmasked<TData> | null;
     private fragmentWatches;
     watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloCache.WatchFragmentOptions<TData, TVariables> & {
-        from: Array<NonNullable<ApolloCache.WatchFragmentFromValue<TData>>>;
+        from: Array<ApolloCache.FromOptionValue<TData>>;
     }): ApolloCache.ObservableFragment<Array<Unmasked<TData>>>;
     watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloCache.WatchFragmentOptions<TData, TVariables> & {
         from: Array<null>;
     }): ApolloCache.ObservableFragment<Array<null>>;
     watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloCache.WatchFragmentOptions<TData, TVariables> & {
-        from: Array<ApolloCache.WatchFragmentFromValue<TData>>;
+        from: Array<ApolloCache.FromOptionValue<TData> | null>;
     }): ApolloCache.ObservableFragment<Array<Unmasked<TData> | null>>;
     watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloCache.WatchFragmentOptions<TData, TVariables> & {
         from: null;
     }): ApolloCache.ObservableFragment<null>;
     watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloCache.WatchFragmentOptions<TData, TVariables> & {
-        from: NonNullable<ApolloCache.WatchFragmentFromValue<TData>>;
+        from: ApolloCache.FromOptionValue<TData>;
     }): ApolloCache.ObservableFragment<Unmasked<TData>>;
     watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloCache.WatchFragmentOptions<TData, TVariables>): ApolloCache.ObservableFragment<Unmasked<TData> | null>;
     /**
@@ -208,7 +208,7 @@ export declare abstract class ApolloCache {
     /**
      * Read data from the cache for the specified fragment.
      */
-    readFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>({ fragment, variables, fragmentName, id, optimistic, returnPartialData, }: Cache.ReadFragmentOptions<TData, TVariables>): Unmasked<TData> | null;
+    readFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>({ fragment, variables, fragmentName, id, from, optimistic, returnPartialData, }: Cache.ReadFragmentOptions<TData, TVariables>): Unmasked<TData> | null;
     readFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: Cache.ReadFragmentOptions<TData, TVariables>, 
     /**
      * @deprecated Pass the `optimistic` argument as part of the first argument
@@ -226,9 +226,10 @@ export declare abstract class ApolloCache {
      * fragment to validate that the shape of the data you’re writing to the cache
      * is the same as the shape of the data required by the fragment.
      */
-    writeFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>({ data, fragment, fragmentName, variables, overwrite, id, broadcast, }: Cache.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    writeFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>({ data, fragment, fragmentName, variables, overwrite, id, from, broadcast, }: Cache.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
     updateQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: Cache.UpdateQueryOptions<TData, TVariables>, update: (data: Unmasked<TData> | null) => Unmasked<TData> | null | void): Unmasked<TData> | null;
     updateFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: Cache.UpdateFragmentOptions<TData, TVariables>, update: (data: Unmasked<TData> | null) => Unmasked<TData> | null | void): Unmasked<TData> | null;
+    private toCacheId;
     /**
     * @experimental
     * @internal

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

@@ -110,13 +110,7 @@ export declare namespace Cache {
          */
         optimistic?: boolean;
     }
-    interface ReadFragmentOptions<TData, TVariables extends OperationVariables> {
-        /**
-         * The root id to be used. This id should take the same form as the
-         * value returned by the `cache.identify` function. If a value with your
-         * id does not exist in the store, `null` will be returned.
-         */
-        id?: string;
+    type ReadFragmentOptions<TData, TVariables extends OperationVariables> = {
         /**
          * A GraphQL document created using the `gql` template string tag from
          * `graphql-tag` with one or more fragments which will be used to determine
@@ -147,7 +141,7 @@ export declare namespace Cache {
          * @defaultValue false
          */
         optimistic?: boolean;
-    }
+    } & Cache.CacheIdentifierOption<TData>;
     interface WriteQueryOptions<TData, TVariables extends OperationVariables> {
         /**
          * The GraphQL query shape to be used constructed using the `gql` template
@@ -181,13 +175,7 @@ export declare namespace Cache {
          */
         overwrite?: boolean;
     }
-    interface WriteFragmentOptions<TData, TVariables extends OperationVariables> {
-        /**
-         * The root id to be used. This id should take the same form as the
-         * value returned by the `cache.identify` function. If a value with your
-         * id does not exist in the store, `null` will be returned.
-         */
-        id?: string;
+    type WriteFragmentOptions<TData, TVariables extends OperationVariables> = {
         /**
          * A GraphQL document created using the `gql` template string
          * with one or more fragments which will be used to determine
@@ -221,11 +209,10 @@ export declare namespace Cache {
          * @defaultValue false
          */
         overwrite?: boolean;
-    }
+    } & Cache.CacheIdentifierOption<TData>;
     interface UpdateQueryOptions<TData, TVariables extends OperationVariables> extends Omit<ReadQueryOptions<TData, TVariables> & WriteQueryOptions<TData, TVariables>, "data"> {
     }
-    interface UpdateFragmentOptions<TData, TVariables extends OperationVariables> extends Omit<ReadFragmentOptions<TData, TVariables> & WriteFragmentOptions<TData, TVariables>, "data"> {
-    }
+    type UpdateFragmentOptions<TData, TVariables extends OperationVariables> = Omit<ReadFragmentOptions<TData, TVariables> & WriteFragmentOptions<TData, TVariables>, "data" | "id" | "from"> & Cache.CacheIdentifierOption<TData>;
     type DiffResult<TData> = {
         result: DataValue.Complete<TData>;
         complete: true;
@@ -237,5 +224,40 @@ export declare namespace Cache {
         missing?: MissingFieldError;
         fromOptimisticTransaction?: boolean;
     };
+    type CacheIdentifierOption<TData> = {
+        /**
+         * The root id to be used. This id should take the same form as the
+         * value returned by the `cache.identify` function. If a value with your
+         * id does not exist in the store, `null` will be returned.
+         */
+        id?: string;
+        /**
+         * An object containing a `__typename` and primary key fields
+         * (such as `id`) identifying the entity object from which the fragment will
+         * be retrieved, or a `{ __ref: "..." }` reference, or a `string` ID
+         * (uncommon).
+         *
+         * @remarks
+         * `from` is given precedence over `id` when both are provided.
+         */
+        from?: never;
+    } | {
+        /**
+         * The root id to be used. This id should take the same form as the
+         * value returned by the `cache.identify` function. If a value with your
+         * id does not exist in the store, `null` will be returned.
+         */
+        id?: never;
+        /**
+         * An object containing a `__typename` and primary key fields
+         * (such as `id`) identifying the entity object from which the fragment will
+         * be retrieved, or a `{ __ref: "..." }` reference, or a `string` ID
+         * (uncommon).
+         *
+         * @remarks
+         * `from` is given precedence over `id` when both are provided.
+         */
+        from?: ApolloCache.FromOptionValue<TData>;
+    };
 }
 //# sourceMappingURL=Cache.d.cts.map

package/__cjs/core/ApolloClient.cjs

@@ -295,11 +295,7 @@ class ApolloClient {
     }
     watchFragment(options) {
         const dataMasking = this.queryManager.dataMasking;
-        const observable = this.cache.watchFragment({
-            ...options,
-            fragment: this.transform(options.fragment, dataMasking),
-        });
-        const mask = (result) => {
+        const mask = (data) => {
             // The transform will remove fragment spreads from the fragment
             // document when dataMasking is enabled. The `mask` function
             // remains to apply warnings to fragments marked as
@@ -307,29 +303,17 @@ class ApolloClient {
             // in dev, we can skip the masking algorithm entirely for production.
             if (environment_1.__DEV__) {
                 if (dataMasking) {
-                    return {
-                        ...result,
-                        data: this.queryManager.maskFragment({
-                            ...options,
-                            data: result.data,
-                        }),
-                    };
+                    return this.queryManager.maskFragment({ ...options, data });
                 }
             }
-            return result;
+            return data;
         };
-        let currentResult;
-        let stableMaskedResult;
-        return Object.assign(observable.pipe((0, rxjs_1.map)(mask)), {
-            getCurrentResult: () => {
-                const result = observable.getCurrentResult();
-                if (result !== currentResult) {
-                    currentResult = result;
-                    stableMaskedResult = mask(currentResult);
-                }
-                return stableMaskedResult;
-            },
+        const observable = this.cache.watchFragment({
+            ...options,
+            fragment: this.transform(options.fragment, dataMasking),
+            [Symbol.for("apollo.transformData")]: mask,
         });
+        return observable;
     }
     readFragment(options, optimistic = false) {
         return this.cache.readFragment({ ...options, fragment: this.transform(options.fragment) }, optimistic);