@apollo/client 4.1.0-alpha.8 → 4.1.0-rc.0

package/cache/inmemory/policies.d.ts

@@ -1,5 +1,6 @@
 import type { FieldNode, FragmentDefinitionNode, InlineFragmentNode, SelectionSetNode } from "graphql";
 import type { OperationVariables } from "@apollo/client";
+import type { Incremental } from "@apollo/client/incremental";
 import type { Reference, StoreObject, StoreValue } from "@apollo/client/utilities";
 import { isReference } from "@apollo/client/utilities";
 import type { FragmentMap } from "@apollo/client/utilities/internal";
@@ -36,10 +37,10 @@ export type KeyArgsFunction = (args: Record<string, any> | null, context: {
     field: FieldNode | null;
     variables?: Record<string, any>;
 }) => KeySpecifier | false | ReturnType<IdGetter>;
-export type FieldPolicy<TExisting = any, TIncoming = TExisting, TReadResult = TIncoming, TOptions extends FieldFunctionOptions = FieldFunctionOptions> = {
+export type FieldPolicy<TExisting = any, TIncoming = TExisting, TReadResult = TIncoming, TReadOptions extends FieldReadFunctionOptions = FieldReadFunctionOptions, TMergeOptions extends FieldMergeFunctionOptions = FieldMergeFunctionOptions> = {
     keyArgs?: KeySpecifier | KeyArgsFunction | false;
-    read?: FieldReadFunction<TExisting, TReadResult, TOptions>;
-    merge?: FieldMergeFunction<TExisting, TIncoming, TOptions> | boolean;
+    read?: FieldReadFunction<TExisting, TReadResult, TReadOptions>;
+    merge?: FieldMergeFunction<TExisting, TIncoming, TMergeOptions> | boolean;
 };
 export type StorageType = Record<string, any>;
 export interface FieldFunctionOptions<TArgs = Record<string, any>, TVariables extends OperationVariables = Record<string, any>> {
@@ -56,9 +57,35 @@ export interface FieldFunctionOptions<TArgs = Record<string, any>, TVariables ex
     canRead: CanReadFunction;
     mergeObjects: MergeObjectsFunction;
 }
+export interface FieldReadFunctionOptions<TArgs = Record<string, any>, TVariables extends OperationVariables = Record<string, any>> extends FieldFunctionOptions<TArgs, TVariables> {
+}
+export interface FieldMergeFunctionOptions<TArgs = Record<string, any>, TVariables extends OperationVariables = Record<string, any>> extends FieldFunctionOptions<TArgs, TVariables> {
+    /**
+     * Any `extensions` provided when writing the cache.
+     */
+    extensions: Record<string, unknown> | undefined;
+    /**
+     * Details about the field when the `@stream` directive is used. Useful with
+     * custom merge functions to determine how to merge existing cache data with
+     * the incoming stream array.
+     *
+     * This field is only available in `merge` functions when the `@stream`
+     * directive is used on the field.
+     *
+     * > [!NOTE]
+     * > This field is not available when using the `Defer20220824Handler`
+     */
+    streamFieldInfo?: Incremental.StreamFieldInfo;
+    /**
+     * The same value as the `existing` argument, but preserves the `existing`
+     * value on refetches when `refetchWritePolicy` is `overwrite` (the default).
+     */
+    existingData: unknown;
+}
 type MergeObjectsFunction = <T extends StoreObject | Reference>(existing: T, incoming: T) => T;
-export type FieldReadFunction<TExisting = any, TReadResult = TExisting, TOptions extends FieldFunctionOptions = FieldFunctionOptions> = (existing: SafeReadonly<TExisting> | undefined, options: TOptions) => TReadResult | undefined;
-export type FieldMergeFunction<TExisting = any, TIncoming = TExisting, TOptions extends FieldFunctionOptions = FieldFunctionOptions> = (existing: SafeReadonly<TExisting> | undefined, incoming: SafeReadonly<TIncoming>, options: TOptions) => SafeReadonly<TExisting>;
+export type FieldReadFunction<TExisting = any, TReadResult = TExisting, TOptions extends FieldReadFunctionOptions = FieldReadFunctionOptions> = (existing: SafeReadonly<TExisting> | undefined, options: TOptions) => TReadResult | undefined;
+export type FieldMergeFunction<TExisting = any, TIncoming = TExisting, TOptions extends FieldMergeFunctionOptions = FieldMergeFunctionOptions> = (existing: SafeReadonly<TExisting> | undefined, incoming: SafeReadonly<TIncoming>, options: TOptions) => SafeReadonly<TExisting>;
+export declare const defaultStreamFieldMergeFn: FieldMergeFunction<Array<any>>;
 export type PossibleTypesMap = {
     [supertype: string]: string[];
 };
@@ -92,7 +119,7 @@ export declare class Policies {
     readField<V = StoreValue>(options: ReadFieldOptions, context: ReadMergeModifyContext): SafeReadonly<V> | undefined;
     getReadFunction(typename: string | undefined, fieldName: string): FieldReadFunction | undefined;
     getMergeFunction(parentTypename: string | undefined, fieldName: string, childTypename: string | undefined): FieldMergeFunction | undefined;
-    runMergeFunction(existing: StoreValue, incoming: StoreValue, { field, typename, merge }: MergeInfo, context: WriteContext, storage?: StorageType): any;
+    runMergeFunction(existing: StoreValue, incoming: StoreValue, { field, typename, merge, path }: MergeInfo, context: WriteContext, storage?: StorageType): any;
 }
 export declare function normalizeReadFieldOptions(readFieldArgs: any[], objectOrReference: StoreObject | Reference | undefined, variables?: ReadMergeModifyContext["variables"]): ReadFieldOptions;
 export {};

package/cache/inmemory/policies.js

@@ -1,6 +1,8 @@
+import { equal } from "@wry/equality";
 import { disableWarningsSlot } from "@apollo/client/masking";
 import { isReference } from "@apollo/client/utilities";
 import { __DEV__ } from "@apollo/client/utilities/environment";
+import { streamInfoSymbol } from "@apollo/client/utilities/internal";
 import { argumentsObjectFromField, getStoreKeyName, isArray, isNonNullObject, storeKeyNameFromField, stringifyForDisplay, } from "@apollo/client/utilities/internal";
 import { invariant, newInvariantError, } from "@apollo/client/utilities/invariant";
 import { defaultDataIdFromObject, fieldNameFromStoreName, hasOwn, selectionSetMatchesResult, storeValueIsStoreObject, TypeOrFieldNameRegExp, } from "./helpers.js";
@@ -17,6 +19,20 @@ const simpleKeyArgsFn = (_args, context) => context.fieldName;
 // merge:false in a field policy.
 const mergeTrueFn = (existing, incoming, { mergeObjects }) => mergeObjects(existing, incoming);
 const mergeFalseFn = (_, incoming) => incoming;
+export const defaultStreamFieldMergeFn = (existing, incoming, { streamFieldInfo, existingData }) => {
+    if (!existing && !existingData) {
+        return incoming;
+    }
+    const results = [];
+    const previous = existing ?? existingData;
+    const length = streamFieldInfo?.isLastChunk ?
+        incoming.length
+        : Math.max(previous.length, incoming.length);
+    for (let i = 0; i < length; i++) {
+        results[i] = incoming[i] === undefined ? previous[i] : incoming[i];
+    }
+    return results;
+};
 export class Policies {
     config;
     typePolicies = {};
@@ -204,7 +220,7 @@ export class Policies {
         const rootId = "ROOT_" + which.toUpperCase();
         const old = this.rootTypenamesById[rootId];
         if (typename !== old) {
-            invariant(!old || old === which, 102, which);
+            invariant(!old || old === which, 103, which);
             // First, delete any old __typename associated with this rootId from
             // rootIdsByTypename.
             if (old)
@@ -347,7 +363,7 @@ export class Policies {
                 if (supertypeSet.has(supertype)) {
                     if (!typenameSupertypeSet.has(supertype)) {
                         if (checkingFuzzySubtypes) {
-                            __DEV__ && invariant.warn(103, typename, supertype);
+                            __DEV__ && invariant.warn(104, typename, supertype);
                         }
                         // Record positive results for faster future lookup.
                         // Unfortunately, we cannot safely cache negative results,
@@ -476,7 +492,9 @@ export class Policies {
         }
         return merge;
     }
-    runMergeFunction(existing, incoming, { field, typename, merge }, context, storage) {
+    runMergeFunction(existing, incoming, { field, typename, merge, path }, context, storage) {
+        // Preserve the value in case `context.overwrite` is set.
+        const existingData = existing;
         if (merge === mergeTrueFn) {
             // Instead of going to the trouble of creating a full
             // FieldFunctionOptions object and calling mergeTrueFn, we can
@@ -494,7 +512,18 @@ export class Policies {
         if (context.overwrite) {
             existing = void 0;
         }
-        return merge(existing, incoming, makeFieldFunctionOptions(this, 
+        const streamInfo = context.extensions?.[streamInfoSymbol]
+            ?.deref()
+            ?.peekArray(path);
+        if (streamInfo) {
+            const { current, previous } = streamInfo;
+            if (previous &&
+                equal(previous.incoming, incoming) &&
+                equal(previous.streamFieldInfo, current)) {
+                return previous.result;
+            }
+        }
+        const result = merge(existing, incoming, makeMergeFieldFunctionOptions(this, 
         // Unlike options.readField for read functions, we do not fall
         // back to the current object if no foreignObjOrRef is provided,
         // because it's not clear what the current object should be for
@@ -511,7 +540,16 @@ export class Policies {
             fieldName: field.name.value,
             field,
             variables: context.variables,
-        }, context, storage || {}));
+            path,
+        }, context, storage || {}, existingData));
+        if (streamInfo) {
+            streamInfo.previous = {
+                incoming,
+                streamFieldInfo: streamInfo.current,
+                result,
+            };
+        }
+        return result;
     }
 }
 function makeFieldFunctionOptions(policies, objectOrReference, fieldSpec, context, storage) {
@@ -536,6 +574,26 @@ function makeFieldFunctionOptions(policies, objectOrReference, fieldSpec, contex
         mergeObjects: makeMergeObjectsFunction(context.store),
     };
 }
+function makeMergeFieldFunctionOptions(policies, objectOrReference, fieldSpec, context, storage, existingData) {
+    const options = {
+        ...makeFieldFunctionOptions(policies, objectOrReference, fieldSpec, context, storage),
+        extensions: context.extensions,
+        existingData,
+    };
+    const extensions = context.extensions;
+    if (extensions && streamInfoSymbol in extensions) {
+        const { [streamInfoSymbol]: streamInfo, ...otherExtensions } = extensions;
+        const streamFieldInfo = streamInfo?.deref()?.peekArray(fieldSpec.path);
+        if (streamFieldInfo) {
+            options.streamFieldInfo = streamFieldInfo.current;
+        }
+        // If the only key in `extensions` was the stream details key, we didn't
+        // receive any remote extensions, so we reset extensions back to undefined
+        options.extensions =
+            Object.keys(otherExtensions).length === 0 ? undefined : otherExtensions;
+    }
+    return options;
+}
 export function normalizeReadFieldOptions(readFieldArgs, objectOrReference, variables) {
     const { 0: fieldNameOrOptions, 1: from, length: argc } = readFieldArgs;
     let options;
@@ -557,7 +615,7 @@ export function normalizeReadFieldOptions(readFieldArgs, objectOrReference, vari
         }
     }
     if (__DEV__ && options.from === void 0) {
-        __DEV__ && invariant.warn(104, stringifyForDisplay(Array.from(readFieldArgs)));
+        __DEV__ && invariant.warn(105, stringifyForDisplay(Array.from(readFieldArgs)));
     }
     if (void 0 === options.variables) {
         options.variables = variables;
@@ -567,7 +625,7 @@ export function normalizeReadFieldOptions(readFieldArgs, objectOrReference, vari
 function makeMergeObjectsFunction(store) {
     return function mergeObjects(existing, incoming) {
         if (isArray(existing) || isArray(incoming)) {
-            throw newInvariantError(105);
+            throw newInvariantError(106);
         }
         // These dynamic checks are necessary because the parameters of a
         // custom merge function can easily have the any type, so the type