apollo-state-sync - API Reference (Users)
    Preparing search index...

    Class InMemoryCacheSyncedType

    Type for InMemoryCacheSynced class. Typed InMemoryCache augmented with custom fields. The first parameters of each of the cache operations are augmented with CacheSyncOptionsAugmentType.

    Hierarchy

    Implemented by

    Index
    constructor
    assumeImmutableResults config getMemoryInternals? makeVar onAfterBroadcast policies
    batch broadcastWatches diff evict extract fragmentMatches gc identify lookupFragment modify performTransaction read readFragment readQuery recordOptimisticTransaction release removeOptimistic reset resolvesClientField restore retain transformDocument transformForLink updateFragment updateQuery watch watchFragment write writeFragment writeQuery
    assumeImmutableResults: true
    config: InMemoryCacheConfig
    getMemoryInternals?: () => {
        addTypenameDocumentTransform: { cache: number }[];
        cache: { fragmentQueryDocuments: number | undefined };
        fragmentRegistry: {
            findFragmentSpreads: number | undefined;
            lookup: number | undefined;
            transform: number | undefined;
        };
        inMemoryCache: {
            executeSelectionSet: number
            | undefined;
            executeSubSelectedArray: number | undefined;
            maybeBroadcastWatch: number | undefined;
        };
    }

    This is not a stable API - it is used in development builds to expose information to the DevTools. Use at your own risk!

    This is an internal API and should not be used directly. This can be removed or changed at any time.

    makeVar: <T>(value: T) => ReactiveVar<T>
    onAfterBroadcast: (cb: () => void) => void

    Can be overridden by subclasses to delay calling the provided callback until after all broadcasts have been completed - e.g. in a cache scenario where many watchers are notified in parallel.

    policies: Policies

    • Executes multiple cache operations as a single batch, ensuring that watchers are only notified once after all operations complete. This is useful for improving performance when making multiple cache updates, as it prevents unnecessary re-renders or query refetches between individual operations.

      The batch method supports both optimistic and non-optimistic updates, and provides fine-grained control over which cache layer receives the updates and when watchers are notified.

      For usage instructions, see Interacting with cached data: cache.batch.

      Type Parameters

      • TUpdateResult

      Parameters

      Returns TUpdateResult

      The return value of the update function.

      cache.batch({
        update(cache) {
          cache.writeQuery({
            query: GET_TODOS,
            data: { todos: updatedTodos },
          });
          cache.evict({ id: "Todo:123" });
        },
      });

      // Optimistic update with a custom layer ID
      cache.batch({
        optimistic: "add-todo-optimistic",
        update(cache) {
          cache.modify({
            fields: {
              todos(existing = []) {
                return [...existing, newTodoRef];
              },
            },
          });
        },
      });

    • Parameters

      Returns void

    • Returns data read from the cache for a given query along with information about the cache result such as whether the result is complete and details about missing fields.

      Will return complete as true if it can fulfill the full cache result or false if not. When no data can be fulfilled from the cache, null is returned. When returnPartialData is true, non-null partial results are returned if it contains at least one field that can be fulfilled from the cache.

      Type Parameters

      Parameters

      Returns DiffResult<TData>

    • Exposes the cache's complete state, in a serializable format for later restoration.

      Parameters

      • Optionaloptimistic: boolean

      Returns NormalizedCacheObject

    • Parameters

      Returns string | undefined

    • Parameters

      • fragmentName: string

      Returns FragmentDefinitionNode | null

    • Parameters

      • update: (cache: InMemoryCache) => any
      • OptionaloptimisticId: string | null

      Returns any

    • Parameters

      Returns void

    • Parameters

      • idToRemove: string

      Returns void

    • Determines whether a @client field can be resolved by the cache. Used when LocalState does not have a local resolver that can resolve the field.

      Parameters

      • typename: string
      • fieldName: string

      Returns boolean

      Cache implementations should return true if a mechanism in the cache is expected to provide a value for the field. LocalState will set the value of the field to undefined in order for the cache to handle it.

      Cache implementations should return false to indicate that it cannot handle resolving the field (either because it doesn't have a mechanism to do so, or because the user hasn't provided enough information to resolve the field). Returning false will emit a warning and set the value of the field to null.

      A cache that doesn't implement resolvesClientField will be treated the same as returning false.

    • 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.

      Parameters

      Returns this

    • Parameters

      Returns DocumentNode

    • Parameters

      Returns DocumentNode

    Settings
    Member Visibility

    On This Page
    Constructors
    Properties
    Methods