diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7e4197c57b3..d7e7d473256 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,53 @@
+## Apollo Client 3.2.0
+
+## Bug Fixes
+
+- Use `options.nextFetchPolicy` internally to restore original `FetchPolicy` after polling with `fetchPolicy: "network-only"`, so that polling does not interfere with normal query watching. `. This type has the same JavaScript representation but allows the APIs to infer the data and variable types instead of requiring you to specify types explicitly at the call site.
- cartItemsVar([...cartItems, productId])}>
+ cartItemsVar([...cartItemsVar(), productId])}>
Add to Cart
@@ -167,8 +166,6 @@ On click, this button updates the value of `cartItemsVar` to append the button's
Here's a `Cart` component that uses the `GET_CART_ITEMS` query and therefore refreshes automatically whenever the value of `cartItemsVar` changes:
-
-
```jsx:title=Cart.js
export const GET_CART_ITEMS = gql`
query GetCartItems {
@@ -199,7 +196,32 @@ export function Cart() {
}
```
-
+Alternatively, you can read directly from a reactive variable using the `useReactiveVar` hook introduced in Apollo Client 3.2.0:
+
+```jsx:title=Cart.js
+import { useReactiveVar } from '@apollo/client';
+
+export function Cart() {
+ const cartItems = useReactiveVar(cartItemsVar);
+
+ return (
+
+
+ {cartItems.length === 0 ? (
+
No items in your cart
+ ) : (
+
+ {cartItems.map(productId => (
+
+ )}
+
= query;
+
+ // The result and variables are being typed automatically, based on the query object we pass,
+ // and type inference is done based on the TypeDocumentNode object.
+ const result = await client.query({ query: typedQuery, variables: { testVar: 'foo' } });
+
+ // Just try to access it, if something will break, TS will throw an error
+ // during the test
+ result.data?.people.friends[0].id;
+ });
+
it('with a replacement of nested array (wq)', done => {
let count = 0;
const client = newClient();
diff --git a/src/__tests__/__snapshots__/exports.ts.snap b/src/__tests__/__snapshots__/exports.ts.snap
index 91326b9ce76..b1cf1084965 100644
--- a/src/__tests__/__snapshots__/exports.ts.snap
+++ b/src/__tests__/__snapshots__/exports.ts.snap
@@ -52,6 +52,7 @@ Array [
"useLazyQuery",
"useMutation",
"useQuery",
+ "useReactiveVar",
"useSubscription",
]
`;
@@ -173,6 +174,13 @@ Array [
]
`;
+exports[`exports of public entry points @apollo/client/link/persisted-queries 1`] = `
+Array [
+ "VERSION",
+ "createPersistedQueryLink",
+]
+`;
+
exports[`exports of public entry points @apollo/client/link/retry 1`] = `
Array [
"RetryLink",
@@ -216,6 +224,7 @@ Array [
"useLazyQuery",
"useMutation",
"useQuery",
+ "useReactiveVar",
"useSubscription",
]
`;
@@ -262,6 +271,7 @@ Array [
"useLazyQuery",
"useMutation",
"useQuery",
+ "useReactiveVar",
"useSubscription",
]
`;
diff --git a/src/__tests__/__snapshots__/mutationResults.ts.snap b/src/__tests__/__snapshots__/mutationResults.ts.snap
new file mode 100644
index 00000000000..ebcfff7bb25
--- /dev/null
+++ b/src/__tests__/__snapshots__/mutationResults.ts.snap
@@ -0,0 +1,40 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`mutation results should write results to cache according to errorPolicy 1`] = `Object {}`;
+
+exports[`mutation results should write results to cache according to errorPolicy 2`] = `
+Object {
+ "Person:{\\"name\\":\\"Jenn Creighton\\"}": Object {
+ "__typename": "Person",
+ "name": "Jenn Creighton",
+ },
+ "ROOT_MUTATION": Object {
+ "__typename": "Mutation",
+ "newPerson({\\"name\\":\\"Jenn Creighton\\"})": Object {
+ "__ref": "Person:{\\"name\\":\\"Jenn Creighton\\"}",
+ },
+ },
+}
+`;
+
+exports[`mutation results should write results to cache according to errorPolicy 3`] = `
+Object {
+ "Person:{\\"name\\":\\"Ellen Shapiro\\"}": Object {
+ "__typename": "Person",
+ "name": "Ellen Shapiro",
+ },
+ "Person:{\\"name\\":\\"Jenn Creighton\\"}": Object {
+ "__typename": "Person",
+ "name": "Jenn Creighton",
+ },
+ "ROOT_MUTATION": Object {
+ "__typename": "Mutation",
+ "newPerson({\\"name\\":\\"Ellen Shapiro\\"})": Object {
+ "__ref": "Person:{\\"name\\":\\"Ellen Shapiro\\"}",
+ },
+ "newPerson({\\"name\\":\\"Jenn Creighton\\"})": Object {
+ "__ref": "Person:{\\"name\\":\\"Jenn Creighton\\"}",
+ },
+ },
+}
+`;
diff --git a/src/__tests__/client.ts b/src/__tests__/client.ts
index 66653ce4319..f015f25f7bf 100644
--- a/src/__tests__/client.ts
+++ b/src/__tests__/client.ts
@@ -3172,6 +3172,96 @@ describe('@connection', () => {
});
});
+ itAsync('allows setting nextFetchPolicy in defaultOptions', (resolve, reject) => {
+ let networkCounter = 0;
+ let nextFetchPolicyCallCount = 0;
+
+ const client = new ApolloClient({
+ link: new ApolloLink(operation => new Observable(observer => {
+ observer.next({
+ data: {
+ count: networkCounter++,
+ },
+ });
+ observer.complete();
+ })),
+
+ cache: new InMemoryCache,
+
+ defaultOptions: {
+ watchQuery: {
+ nextFetchPolicy(fetchPolicy) {
+ expect(++nextFetchPolicyCallCount).toBe(1);
+ expect(this.query).toBe(query);
+ expect(fetchPolicy).toBe("cache-first");
+ // Usually options.nextFetchPolicy applies only once, but a
+ // nextFetchPolicy function can set this.nextFetchPolicy
+ // again to perform an additional transition.
+ this.nextFetchPolicy = fetchPolicy => {
+ ++nextFetchPolicyCallCount;
+ expect(fetchPolicy).toBe("cache-and-network");
+ return "cache-first";
+ };
+ return "cache-and-network";
+ },
+ },
+ },
+ });
+
+ const query = gql`
+ query {
+ count
+ }
+ `;
+
+ client.writeQuery({
+ query,
+ data: {
+ count: "initial",
+ },
+ });
+
+ const obs = client.watchQuery({ query });
+
+ subscribeAndCount(reject, obs, (handleCount, result) => {
+ if (handleCount === 1) {
+ expect(nextFetchPolicyCallCount).toBe(1);
+ expect(result.data).toEqual({ count: "initial" });
+ // Refetching makes a copy of the current options, which
+ // includes options.nextFetchPolicy, so the inner
+ // nextFetchPolicy function ends up getting called twice.
+ obs.refetch();
+ } else if (handleCount === 2) {
+ expect(result.data).toEqual({ count: "initial" });
+ expect(nextFetchPolicyCallCount).toBe(2);
+ } else if (handleCount === 3) {
+ expect(result.data).toEqual({ count: 0 });
+ expect(nextFetchPolicyCallCount).toBe(2);
+ client.writeQuery({
+ query,
+ data: {
+ count: "secondary",
+ },
+ });
+ } else if (handleCount === 4) {
+ expect(result.data).toEqual({ count: "secondary" });
+ expect(nextFetchPolicyCallCount).toBe(3);
+ } else if (handleCount === 5) {
+ expect(result.data).toEqual({ count: 1 });
+ expect(nextFetchPolicyCallCount).toBe(3);
+ client.cache.evict({ fieldName: "count" });
+ } else if (handleCount === 6) {
+ expect(result.data).toEqual({ count: 2 });
+ expect(nextFetchPolicyCallCount).toBe(3);
+ expect(obs.options.fetchPolicy).toBe("cache-first");
+ expect(obs.options.nextFetchPolicy).toBeUndefined();
+ setTimeout(resolve, 50);
+ } else {
+ reject("too many results");
+ }
+ });
+ });
+
itAsync('allows setting default options for query', (resolve, reject) => {
const errors = [{ message: 'failure', name: 'failure' }];
const link = mockSingleLink({
diff --git a/src/__tests__/exports.ts b/src/__tests__/exports.ts
index 5f896488d05..13e00747a14 100644
--- a/src/__tests__/exports.ts
+++ b/src/__tests__/exports.ts
@@ -8,6 +8,7 @@ import * as linkContext from "../link/context";
import * as linkCore from "../link/core";
import * as linkError from "../link/error";
import * as linkHTTP from "../link/http";
+import * as linkPersistedQueries from "../link/persisted-queries";
import * as linkRetry from "../link/retry";
import * as linkSchema from "../link/schema";
import * as linkUtils from "../link/utils";
@@ -47,6 +48,7 @@ describe('exports of public entry points', () => {
check("@apollo/client/link/core", linkCore);
check("@apollo/client/link/error", linkError);
check("@apollo/client/link/http", linkHTTP);
+ check("@apollo/client/link/persisted-queries", linkPersistedQueries);
check("@apollo/client/link/retry", linkRetry);
check("@apollo/client/link/schema", linkSchema);
check("@apollo/client/link/utils", linkUtils);
diff --git a/src/__tests__/mutationResults.ts b/src/__tests__/mutationResults.ts
index 9d87841f9fe..ed36c587cba 100644
--- a/src/__tests__/mutationResults.ts
+++ b/src/__tests__/mutationResults.ts
@@ -1,5 +1,6 @@
import { cloneDeep } from 'lodash';
import gql from 'graphql-tag';
+import { GraphQLError } from 'graphql';
import { ApolloClient } from '../core';
import { InMemoryCache } from '../cache';
@@ -306,6 +307,99 @@ describe('mutation results', () => {
});
});
+ itAsync("should write results to cache according to errorPolicy", async (resolve, reject) => {
+ const expectedFakeError = new GraphQLError("expected/fake error");
+
+ const client = new ApolloClient({
+ cache: new InMemoryCache({
+ typePolicies: {
+ Person: {
+ keyFields: ["name"],
+ },
+ },
+ }),
+
+ link: new ApolloLink(operation => new Observable(observer => {
+ observer.next({
+ errors: [
+ expectedFakeError,
+ ],
+ data: {
+ newPerson: {
+ __typename: "Person",
+ name: operation.variables.newName,
+ },
+ },
+ });
+ observer.complete();
+ })).setOnError(reject),
+ });
+
+ const mutation = gql`
+ mutation AddNewPerson($newName: String!) {
+ newPerson(name: $newName) {
+ name
+ }
+ }
+ `;
+
+ await client.mutate({
+ mutation,
+ variables: {
+ newName: "Hugh Willson",
+ },
+ }).then(() => {
+ reject("should have thrown for default errorPolicy");
+ }, error => {
+ expect(error.message).toBe(expectedFakeError.message);
+ });
+
+ expect(client.cache.extract()).toMatchSnapshot();
+
+ const ignoreErrorsResult = await client.mutate({
+ mutation,
+ errorPolicy: "ignore",
+ variables: {
+ newName: "Jenn Creighton",
+ },
+ });
+
+ expect(ignoreErrorsResult).toEqual({
+ data: {
+ newPerson: {
+ __typename: "Person",
+ name: "Jenn Creighton",
+ },
+ },
+ });
+
+ expect(client.cache.extract()).toMatchSnapshot();
+
+ const allErrorsResult = await client.mutate({
+ mutation,
+ errorPolicy: "all",
+ variables: {
+ newName: "Ellen Shapiro",
+ },
+ });
+
+ expect(allErrorsResult).toEqual({
+ data: {
+ newPerson: {
+ __typename: "Person",
+ name: "Ellen Shapiro",
+ },
+ },
+ errors: [
+ expectedFakeError,
+ ],
+ });
+
+ expect(client.cache.extract()).toMatchSnapshot();
+
+ resolve();
+ });
+
itAsync("should warn when the result fields don't match the query fields", (resolve, reject) => {
let handle: any;
let subscriptionHandle: Subscription;
diff --git a/src/__tests__/optimistic.ts b/src/__tests__/optimistic.ts
index 956b14d8da5..28a7e82d7e4 100644
--- a/src/__tests__/optimistic.ts
+++ b/src/__tests__/optimistic.ts
@@ -1334,7 +1334,7 @@ describe('optimistic mutation results', () => {
client.watchQuery({ query }) as any as ObservableInput,
).pipe(
map(value => stripSymbols(value.data.todoList.todos)),
- take(4),
+ take(5),
toArray(),
).toPromise();
@@ -1360,6 +1360,10 @@ describe('optimistic mutation results', () => {
expect(responses).toEqual([
defaultTodos,
+ [
+ customOptimisticResponse1.createTodo,
+ ...defaultTodos,
+ ],
[
customOptimisticResponse2.createTodo,
customOptimisticResponse1.createTodo,
@@ -1811,7 +1815,7 @@ describe('optimistic mutation results', () => {
client.watchQuery({ query }) as any as ObservableInput,
).pipe(
map(value => stripSymbols(value.data.todoList.todos)),
- take(4),
+ take(5),
toArray(),
).toPromise();
@@ -1833,6 +1837,10 @@ describe('optimistic mutation results', () => {
const defaultTodos = stripSymbols(result.data.todoList.todos);
expect(responses).toEqual([
defaultTodos,
+ [
+ customOptimisticResponse1.createTodo,
+ ...defaultTodos,
+ ],
[
customOptimisticResponse2.createTodo,
customOptimisticResponse1.createTodo,
@@ -1937,6 +1945,7 @@ describe('optimistic mutation results', () => {
expect(optimisticDiffs).toEqual([
{
complete: true,
+ fromOptimisticTransaction: true,
result: {
items: manualItems,
},
@@ -2099,12 +2108,14 @@ describe('optimistic mutation results', () => {
expect(optimisticDiffs).toEqual([
{
complete: true,
+ fromOptimisticTransaction: true,
result: {
items: manualItems,
},
},
{
complete: true,
+ fromOptimisticTransaction: true,
result: {
items: [...manualItems, optimisticItem],
},
diff --git a/src/cache/core/cache.ts b/src/cache/core/cache.ts
index 6babc4aeb58..19eb8dd6127 100644
--- a/src/cache/core/cache.ts
+++ b/src/cache/core/cache.ts
@@ -15,7 +15,7 @@ export abstract class ApolloCache implements DataProxy {
// required to implement
// core API
public abstract read(
- query: Cache.ReadOptions,
+ query: Cache.ReadOptions,
): T | null;
public abstract write(
write: Cache.WriteOptions,
@@ -104,7 +104,7 @@ export abstract class ApolloCache implements DataProxy {
* @param optimistic
*/
public readQuery(
- options: DataProxy.Query,
+ options: DataProxy.Query,
optimistic: boolean = false,
): QueryType | null {
return this.read({
@@ -120,7 +120,7 @@ export abstract class ApolloCache implements DataProxy {
private getFragmentDoc = wrap(getFragmentQueryDocument);
public readFragment(
- options: DataProxy.Fragment,
+ options: DataProxy.Fragment,
optimistic: boolean = false,
): FragmentType | null {
return this.read({
diff --git a/src/cache/core/types/Cache.ts b/src/cache/core/types/Cache.ts
index 21c2535538e..8a9af7c3ff1 100644
--- a/src/cache/core/types/Cache.ts
+++ b/src/cache/core/types/Cache.ts
@@ -4,15 +4,15 @@ import { Modifier, Modifiers } from './common';
export namespace Cache {
export type WatchCallback = (diff: Cache.DiffResult) => void;
- export interface ReadOptions
- extends DataProxy.Query {
+ export interface ReadOptions
+ extends DataProxy.Query {
rootId?: string;
previousResult?: any;
optimistic: boolean;
}
export interface WriteOptions
- extends DataProxy.Query {
+ extends DataProxy.Query {
dataId?: string;
result: TResult;
broadcast?: boolean;
diff --git a/src/cache/core/types/DataProxy.ts b/src/cache/core/types/DataProxy.ts
index 2e02ae6c42e..a256829d09f 100644
--- a/src/cache/core/types/DataProxy.ts
+++ b/src/cache/core/types/DataProxy.ts
@@ -1,15 +1,16 @@
import { DocumentNode } from 'graphql'; // eslint-disable-line import/no-extraneous-dependencies, import/no-unresolved
+import { TypedDocumentNode } from '@graphql-typed-document-node/core';
import { MissingFieldError } from './common';
export namespace DataProxy {
- export interface Query {
+ export interface Query {
/**
* The GraphQL query shape to be used constructed using the `gql` template
* string tag from `graphql-tag`. The query will be used to determine the
* shape of the data to be read.
*/
- query: DocumentNode;
+ query: DocumentNode | TypedDocumentNode;
/**
* Any variables that the GraphQL query may depend on.
@@ -24,7 +25,7 @@ export namespace DataProxy {
id?: string;
}
- export interface Fragment {
+ export interface Fragment {
/**
* The root id to be used. This id should take the same form as the
* value returned by your `dataIdFromObject` function. If a value with your
@@ -38,7 +39,7 @@ export namespace DataProxy {
* the shape of data to read. If you provide more than one fragment in this
* document then you must also specify `fragmentName` to select a single.
*/
- fragment: DocumentNode;
+ fragment: DocumentNode | TypedDocumentNode;
/**
* The name of the fragment in your GraphQL document to be used. If you do
@@ -54,7 +55,7 @@ export namespace DataProxy {
}
export interface WriteQueryOptions
- extends Query {
+ extends Query {
/**
* The data you will be writing to the store.
*/
@@ -66,7 +67,7 @@ export namespace DataProxy {
}
export interface WriteFragmentOptions
- extends Fragment {
+ extends Fragment {
/**
* The data you will be writing to the store.
*/
@@ -81,6 +82,7 @@ export namespace DataProxy {
result?: T;
complete?: boolean;
missing?: MissingFieldError[];
+ fromOptimisticTransaction?: boolean;
}
}
@@ -95,7 +97,7 @@ export interface DataProxy {
* Reads a GraphQL query from the root query id.
*/
readQuery(
- options: DataProxy.Query,
+ options: DataProxy.Query,
optimistic?: boolean,
): QueryType | null;
@@ -105,7 +107,7 @@ export interface DataProxy {
* provided to select the correct fragment.
*/
readFragment(
- options: DataProxy.Fragment,
+ options: DataProxy.Fragment,
optimistic?: boolean,
): FragmentType | null;
diff --git a/src/cache/core/types/common.ts b/src/cache/core/types/common.ts
index 7d58ebc3769..87fb2c066a5 100644
--- a/src/cache/core/types/common.ts
+++ b/src/cache/core/types/common.ts
@@ -7,6 +7,8 @@ import {
isReference,
} from '../../../utilities';
+import { StorageType } from '../../inmemory/policies';
+
// The Readonly type only really works for object types, since it marks
// all of the object's properties as readonly, but there are many cases when
// a generic type parameter like TExisting might be a string or some other
@@ -21,6 +23,7 @@ export class MissingFieldError {
public readonly message: string,
public readonly path: (string | number)[],
public readonly query: import('graphql').DocumentNode,
+ public readonly clientOnly: boolean,
public readonly variables?: Record,
) {}
}
@@ -54,12 +57,14 @@ export type CanReadFunction = (value: StoreValue) => boolean;
export type Modifier = (value: T, details: {
DELETE: any;
+ INVALIDATE: any;
fieldName: string;
storeFieldName: string;
readField: ReadFieldFunction;
canRead: CanReadFunction;
isReference: typeof isReference;
toReference: ToReferenceFunction;
+ storage: StorageType;
}) => T;
export type Modifiers = {
diff --git a/src/cache/inmemory/__tests__/__snapshots__/cache.ts.snap b/src/cache/inmemory/__tests__/__snapshots__/cache.ts.snap
index b03d1ba007a..b436838194b 100644
--- a/src/cache/inmemory/__tests__/__snapshots__/cache.ts.snap
+++ b/src/cache/inmemory/__tests__/__snapshots__/cache.ts.snap
@@ -227,3 +227,84 @@ Object {
},
}
`;
+
+exports[`InMemoryCache#modify should allow invalidation using details.INVALIDATE 1`] = `
+Object {
+ "Author:{\\"name\\":\\"Maria Dahvana Headley\\"}": Object {
+ "__typename": "Author",
+ "name": "Maria Dahvana Headley",
+ },
+ "Book:{\\"isbn\\":\\"0374110034\\"}": Object {
+ "__typename": "Book",
+ "author": Object {
+ "__ref": "Author:{\\"name\\":\\"Maria Dahvana Headley\\"}",
+ },
+ "isbn": "0374110034",
+ "title": "Beowulf: A New Translation",
+ },
+ "ROOT_QUERY": Object {
+ "__typename": "Query",
+ "currentlyReading": Object {
+ "__ref": "Book:{\\"isbn\\":\\"0374110034\\"}",
+ },
+ },
+}
+`;
+
+exports[`TypedDocumentNode should determine Data and Variables types of {write,read}{Query,Fragment} 1`] = `
+Object {
+ "Author:{\\"name\\":\\"John C. Mitchell\\"}": Object {
+ "__typename": "Author",
+ "name": "John C. Mitchell",
+ },
+ "Book:{\\"isbn\\":\\"0262133210\\"}": Object {
+ "__typename": "Book",
+ "author": Object {
+ "__ref": "Author:{\\"name\\":\\"John C. Mitchell\\"}",
+ },
+ "isbn": "0262133210",
+ "title": "Foundations for Programming Languages",
+ },
+ "ROOT_QUERY": Object {
+ "__typename": "Query",
+ "book({\\"isbn\\":\\"0262133210\\"})": Object {
+ "__ref": "Book:{\\"isbn\\":\\"0262133210\\"}",
+ },
+ },
+}
+`;
+
+exports[`TypedDocumentNode should determine Data and Variables types of {write,read}{Query,Fragment} 2`] = `
+Object {
+ "Author:{\\"name\\":\\"Harold Abelson\\"}": Object {
+ "__typename": "Author",
+ "name": "Harold Abelson",
+ },
+ "Author:{\\"name\\":\\"John C. Mitchell\\"}": Object {
+ "__typename": "Author",
+ "name": "John C. Mitchell",
+ },
+ "Book:{\\"isbn\\":\\"0262133210\\"}": Object {
+ "__typename": "Book",
+ "author": Object {
+ "__ref": "Author:{\\"name\\":\\"John C. Mitchell\\"}",
+ },
+ "isbn": "0262133210",
+ "title": "Foundations for Programming Languages",
+ },
+ "Book:{\\"isbn\\":\\"0262510871\\"}": Object {
+ "__typename": "Book",
+ "author": Object {
+ "__ref": "Author:{\\"name\\":\\"Harold Abelson\\"}",
+ },
+ "isbn": "0262510871",
+ "title": "Structure and Interpretation of Computer Programs",
+ },
+ "ROOT_QUERY": Object {
+ "__typename": "Query",
+ "book({\\"isbn\\":\\"0262133210\\"})": Object {
+ "__ref": "Book:{\\"isbn\\":\\"0262133210\\"}",
+ },
+ },
+}
+`;
diff --git a/src/cache/inmemory/__tests__/__snapshots__/fragmentMatcher.ts.snap b/src/cache/inmemory/__tests__/__snapshots__/fragmentMatcher.ts.snap
new file mode 100644
index 00000000000..0b0c04b9abf
--- /dev/null
+++ b/src/cache/inmemory/__tests__/__snapshots__/fragmentMatcher.ts.snap
@@ -0,0 +1,29 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`policies.fragmentMatches can infer fuzzy subtypes heuristically 1`] = `
+Object {
+ "ROOT_QUERY": Object {
+ "__typename": "Query",
+ "objects": Array [
+ Object {
+ "__typename": "E",
+ "c": "ce",
+ },
+ Object {
+ "__typename": "F",
+ "c": "cf",
+ },
+ Object {
+ "__typename": "G",
+ "c": "cg",
+ },
+ Object {
+ "__typename": "TooLong",
+ },
+ Object {
+ "__typename": "H",
+ },
+ ],
+ },
+}
+`;
diff --git a/src/cache/inmemory/__tests__/__snapshots__/policies.ts.snap b/src/cache/inmemory/__tests__/__snapshots__/policies.ts.snap
index afba80cb302..f26a0b9f885 100644
--- a/src/cache/inmemory/__tests__/__snapshots__/policies.ts.snap
+++ b/src/cache/inmemory/__tests__/__snapshots__/policies.ts.snap
@@ -830,3 +830,25 @@ Object {
},
}
`;
+
+exports[`type policies field policies read, merge, and modify functions can access options.storage 1`] = `
+Object {
+ "ROOT_QUERY": Object {
+ "__typename": "Query",
+ "mergeModify": 11,
+ "mergeRead": 1,
+ "mergeReadModify": 101,
+ },
+}
+`;
+
+exports[`type policies field policies read, merge, and modify functions can access options.storage 2`] = `
+Object {
+ "ROOT_QUERY": Object {
+ "__typename": "Query",
+ "mergeModify": 11,
+ "mergeRead": 1,
+ "mergeReadModify": 101,
+ },
+}
+`;
diff --git a/src/cache/inmemory/__tests__/cache.ts b/src/cache/inmemory/__tests__/cache.ts
index f877e68ba66..c5b707d6ffc 100644
--- a/src/cache/inmemory/__tests__/cache.ts
+++ b/src/cache/inmemory/__tests__/cache.ts
@@ -2,7 +2,8 @@ import gql, { disableFragmentWarnings } from 'graphql-tag';
import { stripSymbols } from '../../../utilities/testing/stripSymbols';
import { cloneDeep } from '../../../utilities/common/cloneDeep';
-import { makeReference, Reference, makeVar } from '../../../core';
+import { makeReference, Reference, makeVar, TypedDocumentNode, isReference } from '../../../core';
+import { Cache } from '../../../cache';
import { InMemoryCache, InMemoryCacheConfig } from '../inMemoryCache';
disableFragmentWarnings();
@@ -1644,6 +1645,104 @@ describe("InMemoryCache#modify", () => {
expect(resultAfterModify).toEqual({ a: 1, b: -1, c: 0 });
});
+ it("should allow invalidation using details.INVALIDATE", () => {
+ const cache = new InMemoryCache({
+ typePolicies: {
+ Book: {
+ keyFields: ["isbn"],
+ },
+ Author: {
+ keyFields: ["name"],
+ },
+ },
+ });
+
+ const query: TypedDocumentNode<{
+ currentlyReading: {
+ title: string;
+ isbn: string;
+ author: {
+ name: string;
+ },
+ },
+ }> = gql`
+ query {
+ currentlyReading {
+ title
+ isbn
+ author {
+ name
+ }
+ }
+ }
+ `;
+
+ const currentlyReading = {
+ __typename: "Book",
+ isbn: "0374110034",
+ title: "Beowulf: A New Translation",
+ author: {
+ __typename: "Author",
+ name: "Maria Dahvana Headley",
+ },
+ };
+
+ cache.writeQuery({
+ query,
+ data: {
+ currentlyReading,
+ }
+ });
+
+ function read() {
+ return cache.readQuery({ query })!;
+ }
+
+ const initialResult = read();
+
+ expect(cache.extract()).toMatchSnapshot();
+
+ expect(cache.modify({
+ id: cache.identify({
+ __typename: "Author",
+ name: "Maria Dahvana Headley",
+ }),
+ fields: {
+ name(_, { INVALIDATE }) {
+ return INVALIDATE;
+ },
+ },
+ })).toBe(false); // Nothing actually modified.
+
+ const resultAfterAuthorInvalidation = read();
+ expect(resultAfterAuthorInvalidation).not.toBe(initialResult);
+ expect(resultAfterAuthorInvalidation).toEqual(initialResult);
+
+ expect(cache.modify({
+ id: cache.identify({
+ __typename: "Book",
+ isbn: "0374110034",
+ }),
+ // Invalidate all fields of the Book entity.
+ fields(_, { INVALIDATE }) {
+ return INVALIDATE;
+ },
+ })).toBe(false); // Nothing actually modified.
+
+ const resultAfterBookInvalidation = read();
+ expect(resultAfterBookInvalidation).not.toBe(resultAfterAuthorInvalidation);
+ expect(resultAfterBookInvalidation).toEqual(resultAfterAuthorInvalidation);
+ expect(resultAfterBookInvalidation.currentlyReading.author).toEqual({
+ __typename: "Author",
+ name: "Maria Dahvana Headley",
+ });
+ expect(
+ resultAfterBookInvalidation.currentlyReading.author
+ ).toBe(
+ resultAfterAuthorInvalidation.currentlyReading.author
+ );
+ });
+
it("should allow deletion using details.DELETE", () => {
const cache = new InMemoryCache({
typePolicies: {
@@ -2495,4 +2594,259 @@ describe("ReactiveVar and makeVar", () => {
},
});
});
+
+ it("should broadcast only once for multiple reads of same variable", () => {
+ const nameVar = makeVar("Ben");
+ const cache = new InMemoryCache({
+ typePolicies: {
+ Query: {
+ fields: {
+ name() {
+ return nameVar();
+ },
+ },
+ },
+ },
+ });
+
+ // TODO This should not be necessary, but cache.readQuery currently
+ // returns null if we read a query before writing any queries.
+ cache.restore({
+ ROOT_QUERY: {}
+ });
+
+ const broadcast = cache["broadcastWatches"];
+ let broadcastCount = 0;
+ cache["broadcastWatches"] = function () {
+ ++broadcastCount;
+ return broadcast.apply(this, arguments);
+ };
+
+ const query = gql`
+ query {
+ name1: name
+ name2: name
+ }
+ `;
+
+ const watchDiffs: Cache.DiffResult[] = [];
+ cache.watch({
+ query,
+ optimistic: true,
+ callback(diff) {
+ watchDiffs.push(diff);
+ },
+ });
+
+ const benResult = cache.readQuery({ query });
+ expect(benResult).toEqual({
+ name1: "Ben",
+ name2: "Ben",
+ });
+
+ expect(watchDiffs).toEqual([]);
+
+ expect(broadcastCount).toBe(0);
+ nameVar("Jenn");
+ expect(broadcastCount).toBe(1);
+
+ const jennResult = cache.readQuery({ query });
+ expect(jennResult).toEqual({
+ name1: "Jenn",
+ name2: "Jenn",
+ });
+
+ expect(watchDiffs).toEqual([
+ {
+ complete: true,
+ result: {
+ name1: "Jenn",
+ name2: "Jenn",
+ },
+ },
+ ]);
+
+ expect(broadcastCount).toBe(1);
+ nameVar("Hugh");
+ expect(broadcastCount).toBe(2);
+
+ const hughResult = cache.readQuery({ query });
+ expect(hughResult).toEqual({
+ name1: "Hugh",
+ name2: "Hugh",
+ });
+
+ expect(watchDiffs).toEqual([
+ {
+ complete: true,
+ result: {
+ name1: "Jenn",
+ name2: "Jenn",
+ },
+ },
+ {
+ complete: true,
+ result: {
+ name1: "Hugh",
+ name2: "Hugh",
+ },
+ },
+ ]);
+ });
+});
+
+describe('TypedDocumentNode', () => {
+ type Book = {
+ isbn?: string;
+ title: string;
+ author: {
+ name: string;
+ };
+ };
+
+ const query: TypedDocumentNode<
+ { book: Book },
+ { isbn: string }
+ > = gql`query GetBook($isbn: String!) {
+ book(isbn: $isbn) {
+ title
+ author {
+ name
+ }
+ }
+ }`;
+
+ const fragment: TypedDocumentNode = gql`
+ fragment TitleAndAuthor on Book {
+ title
+ isbn
+ author {
+ name
+ }
+ }
+ `;
+
+ it('should determine Data and Variables types of {write,read}{Query,Fragment}', () => {
+ const cache = new InMemoryCache({
+ typePolicies: {
+ Query: {
+ fields: {
+ book(existing, { args, toReference }) {
+ return existing ?? (args && toReference({
+ __typename: "Book",
+ isbn: args.isbn,
+ }));
+ }
+ }
+ },
+
+ Book: {
+ keyFields: ["isbn"],
+ },
+
+ Author: {
+ keyFields: ["name"],
+ },
+ },
+ });
+
+ // We need to define these objects separately from calling writeQuery,
+ // because passing them directly to writeQuery will trigger excess property
+ // warnings due to the extra __typename and isbn fields. Internally, we
+ // almost never pass object literals to writeQuery or writeFragment, so
+ // excess property checks should not be a problem in practice.
+ const jcmAuthor = {
+ __typename: "Author",
+ name: "John C. Mitchell",
+ };
+
+ const ffplBook = {
+ __typename: "Book",
+ isbn: "0262133210",
+ title: "Foundations for Programming Languages",
+ author: jcmAuthor,
+ };
+
+ const ffplVariables = {
+ isbn: "0262133210",
+ };
+
+ cache.writeQuery({
+ query,
+ variables: ffplVariables,
+ data: {
+ book: ffplBook,
+ },
+ });
+
+ expect(cache.extract()).toMatchSnapshot();
+
+ const ffplQueryResult = cache.readQuery({
+ query,
+ variables: ffplVariables,
+ });
+
+ if (ffplQueryResult === null) throw new Error("null result");
+ expect(ffplQueryResult.book.isbn).toBeUndefined();
+ expect(ffplQueryResult.book.author.name).toBe(jcmAuthor.name);
+ expect(ffplQueryResult).toEqual({
+ book: {
+ __typename: "Book",
+ title: "Foundations for Programming Languages",
+ author: {
+ __typename: "Author",
+ name: "John C. Mitchell",
+ },
+ },
+ });
+
+ const sicpBook = {
+ __typename: "Book",
+ isbn: "0262510871",
+ title: "Structure and Interpretation of Computer Programs",
+ author: {
+ __typename: "Author",
+ name: "Harold Abelson",
+ },
+ };
+
+ const sicpRef = cache.writeFragment({
+ fragment,
+ data: sicpBook,
+ });
+
+ expect(isReference(sicpRef)).toBe(true);
+ expect(cache.extract()).toMatchSnapshot();
+
+ const ffplFragmentResult = cache.readFragment({
+ fragment,
+ id: cache.identify(ffplBook),
+ });
+ if (ffplFragmentResult === null) throw new Error("null result");
+ expect(ffplFragmentResult.title).toBe(ffplBook.title);
+ expect(ffplFragmentResult.author.name).toBe(ffplBook.author.name);
+ expect(ffplFragmentResult).toEqual(ffplBook);
+
+ // This uses the read function for the Query.book field.
+ const sicpReadResult = cache.readQuery({
+ query,
+ variables: {
+ isbn: sicpBook.isbn,
+ },
+ });
+ if (sicpReadResult === null) throw new Error("null result");
+ expect(sicpReadResult.book.isbn).toBeUndefined();
+ expect(sicpReadResult.book.title).toBe(sicpBook.title);
+ expect(sicpReadResult.book.author.name).toBe(sicpBook.author.name);
+ expect(sicpReadResult).toEqual({
+ book: {
+ __typename: "Book",
+ title: "Structure and Interpretation of Computer Programs",
+ author: {
+ __typename: "Author",
+ name: "Harold Abelson",
+ },
+ },
+ });
+ });
});
diff --git a/src/cache/inmemory/__tests__/entityStore.ts b/src/cache/inmemory/__tests__/entityStore.ts
index 3d97772502c..052c05218ca 100644
--- a/src/cache/inmemory/__tests__/entityStore.ts
+++ b/src/cache/inmemory/__tests__/entityStore.ts
@@ -1091,14 +1091,16 @@ describe('EntityStore', () => {
new MissingFieldError(
'Can\'t find field \'hobby\' on Author:{"name":"Ted Chiang"} object',
["authorOfBook", "hobby"],
- expect.anything(),
- expect.anything(),
+ expect.anything(), // query
+ false, // clientOnly
+ expect.anything(), // variables
),
new MissingFieldError(
'Can\'t find field \'publisherOfBook\' on ROOT_QUERY object',
["publisherOfBook"],
- expect.anything(),
- expect.anything(),
+ expect.anything(), // query
+ false, // clientOnly
+ expect.anything(), // variables
),
],
});
@@ -1674,8 +1676,9 @@ describe('EntityStore', () => {
new MissingFieldError(
"Dangling reference to missing Author:2 object",
["book", "author"],
- expect.anything(),
- expect.anything(),
+ expect.anything(), // query
+ false, // clientOnly
+ expect.anything(), // variables
),
];
@@ -1943,8 +1946,9 @@ describe('EntityStore', () => {
new MissingFieldError(
'Can\'t find field \'title\' on Book:{"isbn":"031648637X"} object',
["book", "title"],
- expect.anything(),
- expect.anything(),
+ expect.anything(), // query
+ false, // clientOnly
+ expect.anything(), // variables
),
],
});
diff --git a/src/cache/inmemory/__tests__/fragmentMatcher.ts b/src/cache/inmemory/__tests__/fragmentMatcher.ts
index 279a42ea902..d4062f64d97 100644
--- a/src/cache/inmemory/__tests__/fragmentMatcher.ts
+++ b/src/cache/inmemory/__tests__/fragmentMatcher.ts
@@ -1,6 +1,8 @@
import gql from 'graphql-tag';
import { InMemoryCache } from '../inMemoryCache';
+import { visit, FragmentDefinitionNode } from 'graphql';
+import { hasOwn } from '../helpers';
describe('fragment matching', () => {
it('can match exact types with or without possibleTypes', () => {
@@ -222,4 +224,340 @@ describe('fragment matching', () => {
cache.writeQuery({ query, data });
expect(cache.readQuery({ query })).toEqual(data);
});
+
+});
+
+describe("policies.fragmentMatches", () => {
+ const warnings: any[] = [];
+ const { warn } = console;
+
+ beforeEach(() => {
+ warnings.length = 0;
+ console.warn = function (message: any) {
+ warnings.push(message);
+ };
+ });
+
+ afterEach(() => {
+ console.warn = warn;
+ });
+
+ it("can infer fuzzy subtypes heuristically", () => {
+ const cache = new InMemoryCache({
+ possibleTypes: {
+ A: ["B", "C"],
+ B: ["D"],
+ C: ["[E-Z]"],
+ },
+ });
+
+ const fragments = gql`
+ fragment FragA on A { a }
+ fragment FragB on B { b }
+ fragment FragC on C { c }
+ fragment FragD on D { d }
+ fragment FragE on E { e }
+ fragment FragF on F { f }
+ `;
+
+ function checkTypes(
+ expected: Record>,
+ ) {
+ const checked = new Set();
+
+ visit(fragments, {
+ FragmentDefinition(frag) {
+ function check(typename: string, result: boolean) {
+ if (result !== cache.policies.fragmentMatches(frag, typename)) {
+ fail(`fragment ${
+ frag.name.value
+ } should${result ? "" : " not"} have matched typename ${typename}`);
+ }
+ }
+
+ const supertype = frag.typeCondition.name.value;
+ expect("ABCDEF".split("")).toContain(supertype);
+
+ if (hasOwn.call(expected, supertype)) {
+ Object.keys(expected[supertype]).forEach(subtype => {
+ check(subtype, expected[supertype][subtype]);
+ });
+
+ checked.add(frag);
+ }
+ },
+ });
+
+ return checked;
+ }
+
+ expect(checkTypes({
+ A: {
+ A: true,
+ B: true,
+ C: true,
+ D: true,
+ E: false,
+ F: false,
+ G: false,
+ },
+ B: {
+ A: false,
+ B: true,
+ C: false,
+ D: true,
+ E: false,
+ F: false,
+ G: false,
+ },
+ C: {
+ A: false,
+ B: false,
+ C: true,
+ D: false,
+ E: false,
+ F: false,
+ G: false,
+ },
+ D: {
+ A: false,
+ B: false,
+ C: false,
+ D: true,
+ E: false,
+ F: false,
+ G: false,
+ },
+ E: {
+ A: false,
+ B: false,
+ C: false,
+ D: false,
+ E: true,
+ F: false,
+ G: false,
+ },
+ F: {
+ A: false,
+ B: false,
+ C: false,
+ D: false,
+ E: false,
+ F: true,
+ G: false,
+ },
+ G: {
+ A: false,
+ B: false,
+ C: false,
+ D: false,
+ E: false,
+ F: false,
+ G: true,
+ },
+ }).size).toBe("ABCDEF".length);
+
+ cache.writeQuery({
+ query: gql`
+ query {
+ objects {
+ ...FragC
+ }
+ }
+ ${fragments}
+ `,
+ data: {
+ objects: [
+ { __typename: "E", c: "ce" },
+ { __typename: "F", c: "cf" },
+ { __typename: "G", c: "cg" },
+ // The /[E-Z]/ subtype pattern specified for the C supertype
+ // must match the entire subtype string.
+ { __typename: "TooLong", c: "nope" },
+ // The H typename matches the regular expression for C, but it
+ // does not pass the heuristic test of having all the fields
+ // expected if FragC matched.
+ { __typename: "H", h: "not c" },
+ ],
+ },
+ });
+
+ expect(warnings).toEqual([
+ "Inferring subtype E of supertype C",
+ "Inferring subtype F of supertype C",
+ "Inferring subtype G of supertype C",
+ // Note that TooLong is not inferred here.
+ ]);
+
+ expect(checkTypes({
+ A: {
+ A: true,
+ B: true,
+ C: true,
+ D: true,
+ E: true,
+ F: true,
+ G: true,
+ H: false,
+ },
+ B: {
+ A: false,
+ B: true,
+ C: false,
+ D: true,
+ E: false,
+ F: false,
+ G: false,
+ H: false,
+ },
+ C: {
+ A: false,
+ B: false,
+ C: true,
+ D: false,
+ E: true,
+ F: true,
+ G: true,
+ H: false,
+ },
+ D: {
+ A: false,
+ B: false,
+ C: false,
+ D: true,
+ E: false,
+ F: false,
+ G: false,
+ H: false,
+ },
+ E: {
+ A: false,
+ B: false,
+ C: false,
+ D: false,
+ E: true,
+ F: false,
+ G: false,
+ H: false,
+ },
+ F: {
+ A: false,
+ B: false,
+ C: false,
+ D: false,
+ E: false,
+ F: true,
+ G: false,
+ H: false,
+ },
+ G: {
+ A: false,
+ B: false,
+ C: false,
+ D: false,
+ E: false,
+ F: true,
+ G: true,
+ H: false,
+ },
+ }).size).toBe("ABCDEF".length);
+
+ expect(cache.extract()).toMatchSnapshot();
+
+ // Now add the TooLong subtype of C explicitly.
+ cache.policies.addPossibleTypes({
+ C: ["TooLong"],
+ });
+
+ expect(checkTypes({
+ A: {
+ A: true,
+ B: true,
+ C: true,
+ D: true,
+ E: true,
+ F: true,
+ G: true,
+ TooLong: true,
+ H: false,
+ },
+ B: {
+ A: false,
+ B: true,
+ C: false,
+ D: true,
+ E: false,
+ F: false,
+ G: false,
+ TooLong: false,
+ H: false,
+ },
+ C: {
+ A: false,
+ B: false,
+ C: true,
+ D: false,
+ E: true,
+ F: true,
+ G: true,
+ TooLong: true,
+ H: false,
+ },
+ D: {
+ A: false,
+ B: false,
+ C: false,
+ D: true,
+ E: false,
+ F: false,
+ G: false,
+ TooLong: false,
+ H: false,
+ },
+ E: {
+ A: false,
+ B: false,
+ C: false,
+ D: false,
+ E: true,
+ F: false,
+ G: false,
+ TooLong: false,
+ H: false,
+ },
+ F: {
+ A: false,
+ B: false,
+ C: false,
+ D: false,
+ E: false,
+ F: true,
+ G: false,
+ TooLong: false,
+ H: false,
+ },
+ G: {
+ A: false,
+ B: false,
+ C: false,
+ D: false,
+ E: false,
+ F: true,
+ G: true,
+ TooLong: false,
+ H: false,
+ },
+ H: {
+ A: false,
+ B: false,
+ C: false,
+ D: false,
+ E: false,
+ F: false,
+ G: false,
+ TooLong: false,
+ H: true,
+ },
+ }).size).toBe("ABCDEF".length);
+ });
});
diff --git a/src/cache/inmemory/__tests__/helpers.ts b/src/cache/inmemory/__tests__/helpers.ts
index 98c428b89be..3a518ff5027 100644
--- a/src/cache/inmemory/__tests__/helpers.ts
+++ b/src/cache/inmemory/__tests__/helpers.ts
@@ -1,6 +1,11 @@
-import { NormalizedCache, NormalizedCacheObject } from "../types";
+import {
+ NormalizedCache,
+ NormalizedCacheObject,
+ DiffQueryAgainstStoreOptions,
+} from "../types";
import { EntityStore } from "../entityStore";
import { InMemoryCache } from "../inMemoryCache";
+import { StoreReader } from "../readFromStore";
import { StoreWriter, WriteToStoreOptions } from "../writeToStore";
export function defaultNormalizedCacheFactory(
@@ -20,6 +25,16 @@ extends Omit {
store?: NormalizedCache;
}
+export function readQueryFromStore(
+ reader: StoreReader,
+ options: DiffQueryAgainstStoreOptions,
+) {
+ return reader.diffQueryAgainstStore({
+ ...options,
+ returnPartialData: false,
+ }).result;
+}
+
export function writeQueryToStore(
options: WriteQueryToStoreOptions,
): NormalizedCache {
diff --git a/src/cache/inmemory/__tests__/policies.ts b/src/cache/inmemory/__tests__/policies.ts
index 1c75e637635..4c7aef0ab35 100644
--- a/src/cache/inmemory/__tests__/policies.ts
+++ b/src/cache/inmemory/__tests__/policies.ts
@@ -2,12 +2,13 @@ import gql from "graphql-tag";
import { InMemoryCache } from "../inMemoryCache";
import { ReactiveVar, makeVar } from "../reactiveVars";
-import { Reference, StoreObject, ApolloClient, NetworkStatus } from "../../../core";
+import { Reference, StoreObject, ApolloClient, NetworkStatus, TypedDocumentNode } from "../../../core";
import { MissingFieldError } from "../..";
import { relayStylePagination } from "../../../utilities";
import { MockLink } from '../../../utilities/testing/mocking/mockLink';
import subscribeAndCount from '../../../utilities/testing/subscribeAndCount';
import { itAsync } from '../../../utilities/testing/itAsync';
+import { FieldPolicy, StorageType } from "../policies";
function reverse(s: string) {
return s.split("").reverse().join("");
@@ -736,8 +737,8 @@ describe("type policies", function () {
});
});
- it("can use stable storage in read functions", function () {
- const storageSet = new Set | null>();
+ it("can use options.storage in read functions", function () {
+ const storageSet = new Set>();
const cache = new InMemoryCache({
typePolicies: {
@@ -745,8 +746,8 @@ describe("type policies", function () {
fields: {
result(existing, { args, storage }) {
storageSet.add(storage);
- if (storage?.result) return storage.result;
- return storage!.result = compute();
+ if (storage.result) return storage.result;
+ return storage.result = compute();
},
},
},
@@ -840,9 +841,7 @@ describe("type policies", function () {
// Clear the cached results.
storageSet.forEach(storage => {
- if (storage) {
- delete storage.result;
- }
+ delete storage.result;
});
const result3 = cache.readQuery({
@@ -965,16 +964,16 @@ describe("type policies", function () {
fields: {
result: {
read(_, { storage }) {
- if (!storage!.jobName) {
- storage!.jobName = makeVar(undefined);
+ if (!storage.jobName) {
+ storage.jobName = makeVar(undefined);
}
- return storage!.jobName();
+ return storage.jobName();
},
merge(_, incoming: string, { storage }) {
- if (storage!.jobName) {
- storage!.jobName(incoming);
+ if (storage.jobName) {
+ storage.jobName(incoming);
} else {
- storage!.jobName = makeVar(incoming);
+ storage.jobName = makeVar(incoming);
}
},
},
@@ -1040,8 +1039,9 @@ describe("type policies", function () {
return new MissingFieldError(
`Can't find field 'result' on Job:{"name":"Job #${jobNumber}"} object`,
["jobs", jobNumber - 1, "result"],
- expect.anything(),
- expect.anything(),
+ expect.anything(), // query
+ false, // clientOnly
+ expect.anything(), // variables
);
}
@@ -1228,6 +1228,157 @@ describe("type policies", function () {
});
});
+ it("read, merge, and modify functions can access options.storage", function () {
+ const storageByFieldName = new Map();
+
+ function recordStorageOnce(fieldName: string, storage: StorageType) {
+ if (storageByFieldName.has(fieldName)) {
+ expect(storageByFieldName.get(fieldName)).toBe(storage);
+ } else {
+ storageByFieldName.set(fieldName, storage);
+ }
+ }
+
+ function makeFieldPolicy(): FieldPolicy {
+ return {
+ read(existing = 0, { fieldName, storage }) {
+ storage.readCount = (storage.readCount|0) + 1;
+ recordStorageOnce(fieldName, storage);
+ return existing;
+ },
+ merge(existing = 0, incoming, { fieldName, storage }) {
+ storage.mergeCount = (storage.mergeCount|0) + 1;
+ recordStorageOnce(fieldName, storage);
+ return existing + incoming;
+ },
+ };
+ };
+
+ const cache = new InMemoryCache({
+ typePolicies: {
+ Query: {
+ fields: {
+ mergeRead: makeFieldPolicy(),
+ mergeModify: makeFieldPolicy(),
+ mergeReadModify: makeFieldPolicy(),
+ },
+ },
+ },
+ });
+
+ const query: TypedDocumentNode<{
+ mergeRead: number;
+ mergeModify: number;
+ mergeReadModify: number;
+ }> = gql`
+ query {
+ mergeRead
+ mergeModify
+ mergeReadModify
+ }
+ `;
+
+ cache.writeQuery({
+ query,
+ data: {
+ mergeRead: 1,
+ mergeModify: 10,
+ mergeReadModify: 100,
+ },
+ });
+
+ expect(storageByFieldName.get("mergeRead")).toEqual({
+ mergeCount: 1,
+ });
+
+ expect(storageByFieldName.get("mergeModify")).toEqual({
+ mergeCount: 1,
+ });
+
+ expect(storageByFieldName.get("mergeReadModify")).toEqual({
+ mergeCount: 1,
+ });
+
+ expect(cache.readQuery({
+ query: gql`query { mergeRead mergeReadModify }`,
+ })).toEqual({
+ mergeRead: 1,
+ mergeReadModify: 100,
+ });
+
+ expect(storageByFieldName.get("mergeRead")).toEqual({
+ mergeCount: 1,
+ readCount: 1,
+ });
+
+ expect(storageByFieldName.get("mergeModify")).toEqual({
+ mergeCount: 1,
+ });
+
+ expect(storageByFieldName.get("mergeReadModify")).toEqual({
+ mergeCount: 1,
+ readCount: 1,
+ });
+
+ expect(cache.modify({
+ fields: {
+ mergeModify(value, { fieldName, storage }) {
+ storage.modifyCount = (storage.modifyCount|0) + 1;
+ recordStorageOnce(fieldName, storage);
+ return value + 1;
+ },
+ mergeReadModify(value, { fieldName, storage }) {
+ storage.modifyCount = (storage.modifyCount|0) + 1;
+ recordStorageOnce(fieldName, storage);
+ return value + 1;
+ },
+ },
+ })).toBe(true);
+
+ expect(cache.extract()).toMatchSnapshot();
+
+ expect(storageByFieldName.get("mergeRead")).toEqual({
+ mergeCount: 1,
+ readCount: 1,
+ });
+
+ expect(storageByFieldName.get("mergeModify")).toEqual({
+ mergeCount: 1,
+ modifyCount: 1,
+ });
+
+ expect(storageByFieldName.get("mergeReadModify")).toEqual({
+ mergeCount: 1,
+ readCount: 1,
+ modifyCount: 1,
+ });
+
+ expect(cache.readQuery({ query })).toEqual({
+ mergeRead: 1,
+ mergeModify: 11,
+ mergeReadModify: 101,
+ });
+
+ expect(storageByFieldName.get("mergeRead")).toEqual({
+ mergeCount: 1,
+ readCount: 2,
+ });
+
+ expect(storageByFieldName.get("mergeModify")).toEqual({
+ mergeCount: 1,
+ modifyCount: 1,
+ readCount: 1,
+ });
+
+ expect(storageByFieldName.get("mergeReadModify")).toEqual({
+ mergeCount: 1,
+ readCount: 2,
+ modifyCount: 1,
+ });
+
+ expect(cache.extract()).toMatchSnapshot();
+ });
+
it("merge functions can deduplicate items using readField", function () {
const cache = new InMemoryCache({
typePolicies: {
diff --git a/src/cache/inmemory/__tests__/readFromStore.ts b/src/cache/inmemory/__tests__/readFromStore.ts
index ce0a2bfb09a..fc1f02a9f8b 100644
--- a/src/cache/inmemory/__tests__/readFromStore.ts
+++ b/src/cache/inmemory/__tests__/readFromStore.ts
@@ -6,7 +6,8 @@ import { StoreObject } from '../types';
import { StoreReader } from '../readFromStore';
import { makeReference, InMemoryCache, Reference, isReference } from '../../../core';
import { Cache } from '../../core/types/Cache';
-import { defaultNormalizedCacheFactory } from './helpers';
+import { MissingFieldError } from '../../core/types/common';
+import { defaultNormalizedCacheFactory, readQueryFromStore } from './helpers';
import { withError } from './diffAgainstStore';
describe('reading from the store', () => {
@@ -32,7 +33,7 @@ describe('reading from the store', () => {
} as StoreObject,
});
- const queryResult = reader.readQueryFromStore({
+ const queryResult = readQueryFromStore(reader, {
store,
query: gql`
{
@@ -74,7 +75,7 @@ describe('reading from the store', () => {
it('rejects malformed queries', () => {
expect(() => {
- reader.readQueryFromStore({
+ readQueryFromStore(reader, {
store: defaultNormalizedCacheFactory(),
query: gql`
query {
@@ -89,7 +90,7 @@ describe('reading from the store', () => {
}).toThrowError(/2 operations/);
expect(() => {
- reader.readQueryFromStore({
+ readQueryFromStore(reader, {
store: defaultNormalizedCacheFactory(),
query: gql`
fragment x on y {
@@ -112,7 +113,7 @@ describe('reading from the store', () => {
ROOT_QUERY: result,
});
- const queryResult = reader.readQueryFromStore({
+ const queryResult = readQueryFromStore(reader, {
store,
query: gql`
query {
@@ -154,7 +155,7 @@ describe('reading from the store', () => {
},
});
- const result = reader.readQueryFromStore({
+ const result = readQueryFromStore(reader, {
store,
query,
variables,
@@ -187,7 +188,7 @@ describe('reading from the store', () => {
},
});
- const result = reader.readQueryFromStore({
+ const result = readQueryFromStore(reader, {
store,
query,
});
@@ -227,7 +228,7 @@ describe('reading from the store', () => {
},
});
- const result = reader.readQueryFromStore({
+ const result = readQueryFromStore(reader, {
store,
query,
variables,
@@ -262,7 +263,7 @@ describe('reading from the store', () => {
abcde: result.nestedObj,
});
- const queryResult = reader.readQueryFromStore({
+ const queryResult = readQueryFromStore(reader, {
store,
query: gql`
{
@@ -323,7 +324,7 @@ describe('reading from the store', () => {
abcdef: result.deepNestedObj as StoreObject,
});
- const queryResult = reader.readQueryFromStore({
+ const queryResult = readQueryFromStore(reader, {
store,
query: gql`
{
@@ -400,7 +401,7 @@ describe('reading from the store', () => {
ROOT_QUERY: result,
});
- const queryResult = reader.readQueryFromStore({
+ const queryResult = readQueryFromStore(reader, {
store,
query: gql`
{
@@ -451,7 +452,7 @@ describe('reading from the store', () => {
ROOT_QUERY: result,
});
- const queryResult = reader.readQueryFromStore({
+ const queryResult = readQueryFromStore(reader, {
store,
query: gql`
{
@@ -503,7 +504,7 @@ describe('reading from the store', () => {
abcde: result.nestedArray[1],
});
- const queryResult = reader.readQueryFromStore({
+ const queryResult = readQueryFromStore(reader, {
store,
query: gql`
{
@@ -544,7 +545,7 @@ describe('reading from the store', () => {
const store = defaultNormalizedCacheFactory({ ROOT_QUERY: result });
expect(() => {
- reader.readQueryFromStore({
+ readQueryFromStore(reader, {
store,
query: gql`
{
@@ -556,6 +557,74 @@ describe('reading from the store', () => {
}).toThrowError(/Can't find field 'missingField' on ROOT_QUERY object/);
});
+ it('distinguishes between missing @client and non-@client fields', () => {
+ const query = gql`
+ query {
+ normal {
+ present @client
+ missing
+ }
+ clientOnly @client {
+ present
+ missing
+ }
+ }
+ `;
+
+ const cache = new InMemoryCache({
+ typePolicies: {
+ Query: {
+ fields: {
+ normal() {
+ return { present: "here" };
+ },
+ clientOnly() {
+ return { present: "also here" };
+ },
+ },
+ },
+ },
+ });
+
+ const { result, complete, missing } = cache.diff({
+ query,
+ optimistic: true,
+ returnPartialData: true,
+ });
+
+ expect(complete).toBe(false);
+
+ expect(result).toEqual({
+ normal: {
+ present: "here",
+ },
+ clientOnly: {
+ present: "also here",
+ },
+ });
+
+ expect(missing).toEqual([
+ new MissingFieldError(
+ `Can't find field 'missing' on object {
+ "present": "here"
+}`,
+ ["normal", "missing"],
+ query,
+ false, // clientOnly
+ {}, // variables
+ ),
+ new MissingFieldError(
+ `Can't find field 'missing' on object {
+ "present": "also here"
+}`,
+ ["clientOnly", "missing"],
+ query,
+ true, // clientOnly
+ {}, // variables
+ ),
+ ]);
+ });
+
it('runs a nested query where the reference is null', () => {
const result: any = {
id: 'abcd',
@@ -571,7 +640,7 @@ describe('reading from the store', () => {
}) as StoreObject,
});
- const queryResult = reader.readQueryFromStore({
+ const queryResult = readQueryFromStore(reader, {
store,
query: gql`
{
@@ -606,7 +675,7 @@ describe('reading from the store', () => {
ROOT_QUERY: result,
});
- const queryResult = reader.readQueryFromStore({
+ const queryResult = readQueryFromStore(reader, {
store,
query: gql`
{
@@ -638,7 +707,7 @@ describe('reading from the store', () => {
ROOT_QUERY: result,
});
- const queryResult = reader.readQueryFromStore({
+ const queryResult = readQueryFromStore(reader, {
store,
query: gql`
{
@@ -693,7 +762,7 @@ describe('reading from the store', () => {
abcdef: data.deepNestedObj as StoreObject,
});
- const queryResult1 = reader.readQueryFromStore({
+ const queryResult1 = readQueryFromStore(reader, {
store,
rootId: 'abcde',
query: gql`
@@ -721,7 +790,7 @@ describe('reading from the store', () => {
},
});
- const queryResult2 = reader.readQueryFromStore({
+ const queryResult2 = readQueryFromStore(reader, {
store,
rootId: 'abcdef',
query: gql`
@@ -751,7 +820,7 @@ describe('reading from the store', () => {
},
});
- const queryResult = reader.readQueryFromStore({
+ const queryResult = readQueryFromStore(reader, {
store,
query: gql`
{
@@ -799,7 +868,7 @@ describe('reading from the store', () => {
},
});
- const queryResult = reader.readQueryFromStore({
+ const queryResult = readQueryFromStore(reader, {
store,
query: gql`
{
@@ -854,7 +923,7 @@ describe('reading from the store', () => {
});
expect(() => {
- reader.readQueryFromStore({
+ readQueryFromStore(reader, {
store,
query: gql`
{
@@ -870,7 +939,7 @@ describe('reading from the store', () => {
);
expect(
- reader.readQueryFromStore({
+ readQueryFromStore(reader, {
store,
query: gql`
{
diff --git a/src/cache/inmemory/__tests__/roundtrip.ts b/src/cache/inmemory/__tests__/roundtrip.ts
index bce2ff62c45..a83590f2e9f 100644
--- a/src/cache/inmemory/__tests__/roundtrip.ts
+++ b/src/cache/inmemory/__tests__/roundtrip.ts
@@ -6,7 +6,7 @@ import { EntityStore } from '../entityStore';
import { StoreReader } from '../readFromStore';
import { StoreWriter } from '../writeToStore';
import { InMemoryCache } from '../inMemoryCache';
-import { writeQueryToStore } from './helpers';
+import { writeQueryToStore, readQueryFromStore } from './helpers';
function assertDeeplyFrozen(value: any, stack: any[] = []) {
if (value !== null && typeof value === 'object' && stack.indexOf(value) < 0) {
@@ -43,17 +43,17 @@ function storeRoundtrip(query: DocumentNode, result: any, variables = {}) {
variables,
};
- const reconstructedResult = reader.readQueryFromStore(readOptions);
+ const reconstructedResult = readQueryFromStore(reader, readOptions);
expect(reconstructedResult).toEqual(result);
// Make sure the result is identical if we haven't written anything new
// to the store. https://github.com/apollographql/apollo-client/pull/3394
expect(store).toBeInstanceOf(EntityStore);
- expect(reader.readQueryFromStore(readOptions)).toBe(reconstructedResult);
+ expect(readQueryFromStore(reader, readOptions)).toBe(reconstructedResult);
- const immutableResult = reader.readQueryFromStore(readOptions);
+ const immutableResult = readQueryFromStore(reader, readOptions);
expect(immutableResult).toEqual(reconstructedResult);
- expect(reader.readQueryFromStore(readOptions)).toBe(immutableResult);
+ expect(readQueryFromStore(reader, readOptions)).toBe(immutableResult);
if (process.env.NODE_ENV !== 'production') {
try {
// Note: this illegal assignment will only throw in strict mode, but that's
@@ -80,7 +80,7 @@ function storeRoundtrip(query: DocumentNode, result: any, variables = {}) {
`,
});
- const deletedRootResult = reader.readQueryFromStore(readOptions);
+ const deletedRootResult = readQueryFromStore(reader, readOptions);
expect(deletedRootResult).toEqual(result);
if (deletedRootResult === reconstructedResult) {
diff --git a/src/cache/inmemory/__tests__/writeToStore.ts b/src/cache/inmemory/__tests__/writeToStore.ts
index 51ca52dcc32..668f299e29e 100644
--- a/src/cache/inmemory/__tests__/writeToStore.ts
+++ b/src/cache/inmemory/__tests__/writeToStore.ts
@@ -2326,6 +2326,19 @@ describe('writing to the store', () => {
});
});
+ it("should warn if it cannot identify the result object", () => {
+ const cache = new InMemoryCache;
+
+ expect(() => {
+ cache.writeFragment({
+ fragment: gql`fragment Count on Counter { count }`,
+ data: {
+ count: 1,
+ },
+ });
+ }).toThrowError(/Could not identify object/);
+ });
+
it('user objects should be able to have { __typename: "Subscription" }', () => {
const cache = new InMemoryCache({
typePolicies: {
diff --git a/src/cache/inmemory/entityStore.ts b/src/cache/inmemory/entityStore.ts
index 6f18eddada9..c2c135f08da 100644
--- a/src/cache/inmemory/entityStore.ts
+++ b/src/cache/inmemory/entityStore.ts
@@ -13,13 +13,12 @@ import {
} from '../../utilities';
import { NormalizedCache, NormalizedCacheObject } from './types';
import { hasOwn, fieldNameFromStoreName } from './helpers';
-import { Policies } from './policies';
+import { Policies, StorageType } from './policies';
import { Cache } from '../core/types/Cache';
import {
SafeReadonly,
Modifier,
Modifiers,
- ReadFieldFunction,
ReadFieldOptions,
ToReferenceFunction,
CanReadFunction,
@@ -27,6 +26,7 @@ import {
const DELETE: any = Object.create(null);
const delModifier: Modifier = () => DELETE;
+const INVALIDATE: any = Object.create(null);
export abstract class EntityStore implements NormalizedCache {
protected data: NormalizedCacheObject = Object.create(null);
@@ -127,16 +127,23 @@ export abstract class EntityStore implements NormalizedCache {
let needToMerge = false;
let allDeleted = true;
- const readField: ReadFieldFunction = (
- fieldNameOrOptions: string | ReadFieldOptions,
- from?: StoreObject | Reference,
- ) => this.policies.readField(
- typeof fieldNameOrOptions === "string" ? {
- fieldName: fieldNameOrOptions,
- from: from || makeReference(dataId),
- } : fieldNameOrOptions,
- { store: this },
- );
+ const sharedDetails = {
+ DELETE,
+ INVALIDATE,
+ isReference,
+ toReference: this.toReference,
+ canRead: this.canRead,
+ readField: (
+ fieldNameOrOptions: string | ReadFieldOptions,
+ from?: StoreObject | Reference,
+ ) => this.policies.readField(
+ typeof fieldNameOrOptions === "string" ? {
+ fieldName: fieldNameOrOptions,
+ from: from || makeReference(dataId),
+ } : fieldNameOrOptions,
+ { store: this },
+ ),
+ };
Object.keys(storeObject).forEach(storeFieldName => {
const fieldName = fieldNameFromStoreName(storeFieldName);
@@ -148,19 +155,20 @@ export abstract class EntityStore implements NormalizedCache {
if (modify) {
let newValue = modify === delModifier ? DELETE :
modify(maybeDeepFreeze(fieldValue), {
- DELETE,
+ ...sharedDetails,
fieldName,
storeFieldName,
- isReference,
- toReference: this.toReference,
- canRead: this.canRead,
- readField,
+ storage: this.getStorage(dataId, storeFieldName),
});
- if (newValue === DELETE) newValue = void 0;
- if (newValue !== fieldValue) {
- changedFields[storeFieldName] = newValue;
- needToMerge = true;
- fieldValue = newValue;
+ if (newValue === INVALIDATE) {
+ this.group.dirty(dataId, storeFieldName);
+ } else {
+ if (newValue === DELETE) newValue = void 0;
+ if (newValue !== fieldValue) {
+ changedFields[storeFieldName] = newValue;
+ needToMerge = true;
+ fieldValue = newValue;
+ }
}
}
if (fieldValue !== void 0) {
@@ -248,6 +256,11 @@ export abstract class EntityStore implements NormalizedCache {
}
}
+ public abstract getStorage(
+ idOrObj: string | StoreObject,
+ storeFieldName: string,
+ ): StorageType;
+
// Maps root entity IDs to the number of times they have been retained, minus
// the number of times they have been released. Retained entities keep other
// entities they reference (even indirectly) from being garbage collected.
@@ -467,6 +480,14 @@ export namespace EntityStore {
// Never remove the root layer.
return this;
}
+
+ public readonly storageTrie = new KeyTrie(canUseWeakMap);
+ public getStorage(
+ idOrObj: string | StoreObject,
+ storeFieldName: string,
+ ): StorageType {
+ return this.storageTrie.lookup(idOrObj, storeFieldName);
+ }
}
}
@@ -531,6 +552,13 @@ class Layer extends EntityStore {
...super.findChildRefIds(dataId),
} : fromParent;
}
+
+ public getStorage(
+ idOrObj: string | StoreObject,
+ storeFieldName: string,
+ ): StorageType {
+ return this.parent.getStorage(idOrObj, storeFieldName);
+ }
}
function storeObjectReconciler(
diff --git a/src/cache/inmemory/helpers.ts b/src/cache/inmemory/helpers.ts
index 9cdd09ae12c..47d9ee28e5c 100644
--- a/src/cache/inmemory/helpers.ts
+++ b/src/cache/inmemory/helpers.ts
@@ -1,4 +1,4 @@
-import { FieldNode } from 'graphql';
+import { FieldNode, SelectionSetNode } from 'graphql';
import { NormalizedCache } from './types';
import {
@@ -9,6 +9,8 @@ import {
isField,
DeepMerger,
ReconcilerFunction,
+ resultKeyNameFromField,
+ shouldInclude,
} from '../../utilities';
export const hasOwn = Object.prototype.hasOwnProperty;
@@ -22,12 +24,39 @@ export function getTypenameFromStoreObject(
: objectOrReference && objectOrReference.__typename;
}
-const FieldNamePattern = /^[_A-Za-z0-9]+/;
+export const TypeOrFieldNameRegExp = /^[_a-z][_0-9a-z]*/i;
+
export function fieldNameFromStoreName(storeFieldName: string): string {
- const match = storeFieldName.match(FieldNamePattern);
+ const match = storeFieldName.match(TypeOrFieldNameRegExp);
return match ? match[0] : storeFieldName;
}
+export function selectionSetMatchesResult(
+ selectionSet: SelectionSetNode,
+ result: Record,
+ variables?: Record,
+): boolean {
+ if (result && typeof result === "object") {
+ return Array.isArray(result)
+ ? result.every(item => selectionSetMatchesResult(selectionSet, item, variables))
+ : selectionSet.selections.every(field => {
+ if (isField(field) && shouldInclude(field, variables)) {
+ const key = resultKeyNameFromField(field);
+ return hasOwn.call(result, key) &&
+ (!field.selectionSet ||
+ selectionSetMatchesResult(field.selectionSet, result[key], variables));
+ }
+ // If the selection has been skipped with @skip(true) or
+ // @include(false), it should not count against the matching. If
+ // the selection is not a field, it must be a fragment (inline or
+ // named). We will determine if selectionSetMatchesResult for that
+ // fragment when we get to it, so for now we return true.
+ return true;
+ });
+ }
+ return false;
+}
+
// Invoking merge functions needs to happen after processSelectionSet has
// finished, but requires information that is more readily available
// during processSelectionSet, so processSelectionSet embeds special
diff --git a/src/cache/inmemory/inMemoryCache.ts b/src/cache/inmemory/inMemoryCache.ts
index 1260e83e1d2..aa988941e1d 100644
--- a/src/cache/inmemory/inMemoryCache.ts
+++ b/src/cache/inmemory/inMemoryCache.ts
@@ -110,13 +110,14 @@ export class InMemoryCache extends ApolloCache {
if (typeof options.rootId === 'string' && !store.has(options.rootId)) {
return null;
}
- return this.storeReader.readQueryFromStore({
+ return this.storeReader.diffQueryAgainstStore({
store,
query: options.query,
variables: options.variables,
rootId: options.rootId,
config: this.config,
- }) || null;
+ returnPartialData: false,
+ }).result || null;
}
public write(options: Cache.WriteOptions): Reference | undefined {
@@ -278,11 +279,14 @@ export class InMemoryCache extends ApolloCache {
}
};
+ let fromOptimisticTransaction = false;
+
if (typeof optimisticId === 'string') {
// Note that there can be multiple layers with the same optimisticId.
// When removeOptimistic(id) is called for that id, all matching layers
// will be removed, and the remaining layers will be reapplied.
this.optimisticData = this.optimisticData.addLayer(optimisticId, perform);
+ fromOptimisticTransaction = true;
} else if (optimisticId === null) {
// Ensure both this.data and this.optimisticData refer to the root
// (non-optimistic) layer of the cache during the transaction. Note
@@ -297,7 +301,7 @@ export class InMemoryCache extends ApolloCache {
}
// This broadcast does nothing if this.txCount > 0.
- this.broadcastWatches();
+ this.broadcastWatches(fromOptimisticTransaction);
}
public transformDocument(document: DocumentNode): DocumentNode {
@@ -316,14 +320,17 @@ export class InMemoryCache extends ApolloCache {
return document;
}
- protected broadcastWatches() {
+ protected broadcastWatches(fromOptimisticTransaction?: boolean) {
if (!this.txCount) {
- this.watches.forEach(c => this.maybeBroadcastWatch(c));
+ this.watches.forEach(c => this.maybeBroadcastWatch(c, fromOptimisticTransaction));
}
}
- private maybeBroadcastWatch = wrap((c: Cache.WatchOptions) => {
- return this.broadcastWatch.call(this, c);
+ private maybeBroadcastWatch = wrap((
+ c: Cache.WatchOptions,
+ fromOptimisticTransaction?: boolean,
+ ) => {
+ return this.broadcastWatch.call(this, c, !!fromOptimisticTransaction);
}, {
makeCacheKey: (c: Cache.WatchOptions) => {
// Return a cache key (thus enabling result caching) only if we're
@@ -354,7 +361,10 @@ export class InMemoryCache extends ApolloCache {
// simpler to check for changes after recomputing a result but before
// broadcasting it, but this wrapping approach allows us to skip both
// the recomputation and the broadcast, in most cases.
- private broadcastWatch(c: Cache.WatchOptions) {
+ private broadcastWatch(
+ c: Cache.WatchOptions,
+ fromOptimisticTransaction: boolean,
+ ) {
// First, invalidate any other maybeBroadcastWatch wrapper functions
// currently depending on this Cache.WatchOptions object (including
// the one currently calling broadcastWatch), so they will be included
@@ -372,10 +382,16 @@ export class InMemoryCache extends ApolloCache {
// changed since they were previously delivered.
this.watchDep(c);
- c.callback(this.diff({
+ const diff = this.diff({
query: c.query,
variables: c.variables,
optimistic: c.optimistic,
- }));
+ });
+
+ if (c.optimistic && fromOptimisticTransaction) {
+ diff.fromOptimisticTransaction = true;
+ }
+
+ c.callback(diff);
}
}
diff --git a/src/cache/inmemory/policies.ts b/src/cache/inmemory/policies.ts
index deb642f55c0..d36974b0845 100644
--- a/src/cache/inmemory/policies.ts
+++ b/src/cache/inmemory/policies.ts
@@ -29,6 +29,8 @@ import {
FieldValueToBeMerged,
isFieldValueToBeMerged,
storeValueIsStoreObject,
+ selectionSetMatchesResult,
+ TypeOrFieldNameRegExp,
} from './helpers';
import { cacheSlot } from './reactiveVars';
import { InMemoryCache } from './inMemoryCache';
@@ -102,7 +104,7 @@ export type FieldPolicy<
merge?: FieldMergeFunction | boolean;
};
-type StorageType = Record;
+export type StorageType = Record;
function argsFromFieldSpecifier(spec: FieldSpecifier) {
return spec.args !== void 0 ? spec.args :
@@ -138,7 +140,7 @@ export interface FieldFunctionOptions<
// A handy place to put field-specific data that you want to survive
// across multiple read function calls. Useful for field-level caching,
// if your read function does any expensive work.
- storage: StorageType | null;
+ storage: StorageType;
cache: InMemoryCache;
@@ -227,7 +229,6 @@ export class Policies {
private typePolicies: {
[__typename: string]: {
keyFn?: KeyFieldsFunction;
- subtypes?: Set;
fields?: {
[fieldName: string]: {
keyFn?: KeyArgsFunction;
@@ -238,6 +239,18 @@ export class Policies {
};
} = Object.create(null);
+ // Map from subtype names to sets of supertype names. Note that this
+ // representation inverts the structure of possibleTypes (whose keys are
+ // supertypes and whose values are arrays of subtypes) because it tends
+ // to be much more efficient to search upwards than downwards.
+ private supertypeMap = new Map>();
+
+ // Any fuzzy subtypes specified by possibleTypes will be converted to
+ // RegExp objects and recorded here. Every key of this map can also be
+ // found in supertypeMap. In many cases this Map will be empty, which
+ // means no fuzzy subtype checking will happen in fragmentMatches.
+ private fuzzySubtypes = new Map();
+
public readonly cache: InMemoryCache;
public readonly rootIdsByTypename: Record = Object.create(null);
@@ -407,8 +420,19 @@ export class Policies {
public addPossibleTypes(possibleTypes: PossibleTypesMap) {
(this.usingPossibleTypes as boolean) = true;
Object.keys(possibleTypes).forEach(supertype => {
- const subtypeSet = this.getSubtypeSet(supertype, true);
- possibleTypes[supertype].forEach(subtypeSet!.add, subtypeSet);
+ // Make sure all types have an entry in this.supertypeMap, even if
+ // their supertype set is empty, so we can return false immediately
+ // from policies.fragmentMatches for unknown supertypes.
+ this.getSupertypeSet(supertype, true);
+
+ possibleTypes[supertype].forEach(subtype => {
+ this.getSupertypeSet(subtype, true)!.add(supertype);
+ const match = subtype.match(TypeOrFieldNameRegExp);
+ if (!match || match[0] !== subtype) {
+ // TODO Don't interpret just any invalid typename as a RegExp.
+ this.fuzzySubtypes.set(subtype, new RegExp(subtype));
+ }
+ });
});
}
@@ -422,17 +446,6 @@ export class Policies {
}
}
- private getSubtypeSet(
- supertype: string,
- createIfMissing: boolean,
- ): Set | undefined {
- const policy = this.getTypePolicy(supertype, createIfMissing);
- if (policy) {
- return policy.subtypes || (
- createIfMissing ? policy.subtypes = new Set() : void 0);
- }
- }
-
private getFieldPolicy(
typename: string | undefined,
fieldName: string,
@@ -453,9 +466,22 @@ export class Policies {
}
}
+ private getSupertypeSet(
+ subtype: string,
+ createIfMissing: boolean,
+ ): Set | undefined {
+ let supertypeSet = this.supertypeMap.get(subtype);
+ if (!supertypeSet && createIfMissing) {
+ this.supertypeMap.set(subtype, supertypeSet = new Set());
+ }
+ return supertypeSet;
+ }
+
public fragmentMatches(
fragment: InlineFragmentNode | FragmentDefinitionNode,
typename: string | undefined,
+ result?: Record,
+ variables?: Record,
): boolean {
if (!fragment.typeCondition) return true;
@@ -464,20 +490,75 @@ export class Policies {
if (!typename) return false;
const supertype = fragment.typeCondition.name.value;
+ // Common case: fragment type condition and __typename are the same.
if (typename === supertype) return true;
- if (this.usingPossibleTypes) {
- const workQueue = [this.getSubtypeSet(supertype, false)];
+ if (this.usingPossibleTypes &&
+ this.supertypeMap.has(supertype)) {
+ const typenameSupertypeSet = this.getSupertypeSet(typename, true)!;
+ const workQueue = [typenameSupertypeSet];
+ const maybeEnqueue = (subtype: string) => {
+ const supertypeSet = this.getSupertypeSet(subtype, false);
+ if (supertypeSet &&
+ supertypeSet.size &&
+ workQueue.indexOf(supertypeSet) < 0) {
+ workQueue.push(supertypeSet);
+ }
+ };
+
+ // We need to check fuzzy subtypes only if we encountered fuzzy
+ // subtype strings in addPossibleTypes, and only while writing to
+ // the cache, since that's when selectionSetMatchesResult gives a
+ // strong signal of fragment matching. The StoreReader class calls
+ // policies.fragmentMatches without passing a result object, so
+ // needToCheckFuzzySubtypes is always false while reading.
+ let needToCheckFuzzySubtypes = !!(result && this.fuzzySubtypes.size);
+ let checkingFuzzySubtypes = false;
+
// It's important to keep evaluating workQueue.length each time through
// the loop, because the queue can grow while we're iterating over it.
for (let i = 0; i < workQueue.length; ++i) {
- const subtypes = workQueue[i];
- if (subtypes) {
- if (subtypes.has(typename)) return true;
- subtypes.forEach(subtype => {
- const subsubtypes = this.getSubtypeSet(subtype, false);
- if (subsubtypes && workQueue.indexOf(subsubtypes) < 0) {
- workQueue.push(subsubtypes);
+ const supertypeSet = workQueue[i];
+
+ if (supertypeSet.has(supertype)) {
+ if (!typenameSupertypeSet.has(supertype)) {
+ if (checkingFuzzySubtypes) {
+ invariant.warn(`Inferring subtype ${typename} of supertype ${supertype}`);
+ }
+ // Record positive results for faster future lookup.
+ // Unfortunately, we cannot safely cache negative results,
+ // because new possibleTypes data could always be added to the
+ // Policies class.
+ typenameSupertypeSet.add(supertype);
+ }
+ return true;
+ }
+
+ supertypeSet.forEach(maybeEnqueue);
+
+ if (needToCheckFuzzySubtypes &&
+ // Start checking fuzzy subtypes only after exhausting all
+ // non-fuzzy subtypes (after the final iteration of the loop).
+ i === workQueue.length - 1 &&
+ // We could wait to compare fragment.selectionSet to result
+ // after we verify the supertype, but this check is often less
+ // expensive than that search, and we will have to do the
+ // comparison anyway whenever we find a potential match.
+ selectionSetMatchesResult(fragment.selectionSet, result!, variables)) {
+ // We don't always need to check fuzzy subtypes (if no result
+ // was provided, or !this.fuzzySubtypes.size), but, when we do,
+ // we only want to check them once.
+ needToCheckFuzzySubtypes = false;
+ checkingFuzzySubtypes = true;
+
+ // If we find any fuzzy subtypes that match typename, extend the
+ // workQueue to search through the supertypes of those fuzzy
+ // subtypes. Otherwise the for-loop will terminate and we'll
+ // return false below.
+ this.fuzzySubtypes.forEach((regExp, fuzzyString) => {
+ const match = typename.match(regExp);
+ if (match && match[0] === typename) {
+ maybeEnqueue(fuzzyString);
}
});
}
@@ -528,8 +609,6 @@ export class Policies {
: fieldName + ":" + storeFieldName;
}
- private storageTrie = new KeyTrie(true);
-
public readField(
options: ReadFieldOptions,
context: ReadMergeModifyContext,
@@ -557,7 +636,7 @@ export class Policies {
objectOrReference,
options,
context,
- this.storageTrie.lookup(
+ context.store.getStorage(
isReference(objectOrReference)
? objectOrReference.__ref
: objectOrReference,
@@ -598,17 +677,6 @@ export class Policies {
const { merge } = this.getFieldPolicy(
incoming.__typename, fieldName, false)!;
- // If storage ends up null, that just means no options.storage object
- // has ever been created for a read function for this field before, so
- // there's nothing this merge function could do with options.storage
- // that would help the read function do its work. Most merge functions
- // will never need to worry about options.storage, but if you're reading
- // this comment then you probably have good reasons for wanting to know
- // esoteric details like these, you wizard, you.
- const storage = storageKeys
- ? this.storageTrie.lookupArray(storageKeys)
- : null;
-
incoming = merge!(existing, incoming.__value, makeFieldFunctionOptions(
this,
// Unlike options.readField for read functions, we do not fall
@@ -628,7 +696,9 @@ export class Policies {
field,
variables: context.variables },
context,
- storage,
+ storageKeys
+ ? context.store.getStorage(...storageKeys)
+ : Object.create(null),
)) as T;
}
@@ -695,7 +765,7 @@ function makeFieldFunctionOptions(
objectOrReference: StoreObject | Reference | undefined,
fieldSpec: FieldSpecifier,
context: ReadMergeModifyContext,
- storage: StorageType | null,
+ storage: StorageType,
): FieldFunctionOptions {
const storeFieldName = policies.getStoreFieldName(fieldSpec);
const fieldName = fieldNameFromStoreName(storeFieldName);
diff --git a/src/cache/inmemory/reactiveVars.ts b/src/cache/inmemory/reactiveVars.ts
index c702104aa59..f063bb03546 100644
--- a/src/cache/inmemory/reactiveVars.ts
+++ b/src/cache/inmemory/reactiveVars.ts
@@ -3,7 +3,12 @@ import { dep } from "optimism";
import { InMemoryCache } from "./inMemoryCache";
import { ApolloCache } from '../../core';
-export type ReactiveVar = (newValue?: T) => T;
+export interface ReactiveVar {
+ (newValue?: T): T;
+ onNextChange(listener: ReactiveListener): () => void;
+}
+
+export type ReactiveListener = (value: T) => any;
const varDep = dep>();
@@ -11,17 +16,34 @@ const varDep = dep>();
// called in Policies#readField.
export const cacheSlot = new Slot>();
+// A listener function could in theory cause another listener to be added
+// to the set while we're iterating over it, so it's important to commit
+// to the original elements of the set before we begin iterating. See
+// iterateObserversSafely for another example of this pattern.
+function consumeAndIterate(set: Set, callback: (item: T) => any) {
+ const items: T[] = [];
+ set.forEach(item => items.push(item));
+ set.clear();
+ items.forEach(callback);
+}
+
export function makeVar(value: T): ReactiveVar {
const caches = new Set>();
+ const listeners = new Set>();
- return function rv(newValue) {
+ const rv: ReactiveVar = function (newValue) {
if (arguments.length > 0) {
if (value !== newValue) {
value = newValue!;
+ // First, invalidate any fields with custom read functions that
+ // consumed this variable, so query results involving those fields
+ // will be recomputed the next time we read them.
varDep.dirty(rv);
- // Trigger broadcast for any caches that were previously involved
- // in reading this variable.
+ // Next, broadcast changes to any caches that have previously read
+ // from this variable.
caches.forEach(broadcast);
+ // Finally, notify any listeners added via rv.onNextChange.
+ consumeAndIterate(listeners, listener => listener(value));
}
} else {
// When reading from the variable, obtain the current cache from
@@ -34,12 +56,21 @@ export function makeVar(value: T): ReactiveVar {
return value;
};
+
+ rv.onNextChange = listener => {
+ listeners.add(listener);
+ return () => {
+ listeners.delete(listener);
+ };
+ };
+
+ return rv;
}
type Broadcastable = ApolloCache & {
// This method is protected in InMemoryCache, which we are ignoring, but
// we still want some semblance of type safety when we call it.
- broadcastWatches: InMemoryCache["broadcastWatches"];
+ broadcastWatches?: InMemoryCache["broadcastWatches"];
};
function broadcast(cache: Broadcastable) {
diff --git a/src/cache/inmemory/readFromStore.ts b/src/cache/inmemory/readFromStore.ts
index d0b343db628..1abafb40f30 100644
--- a/src/cache/inmemory/readFromStore.ts
+++ b/src/cache/inmemory/readFromStore.ts
@@ -1,8 +1,6 @@
import {
DocumentNode,
FieldNode,
- FragmentDefinitionNode,
- InlineFragmentNode,
SelectionSetNode,
} from 'graphql';
import { wrap, OptimisticWrapperFunction } from 'optimism';
@@ -10,7 +8,6 @@ import { invariant, InvariantError } from 'ts-invariant';
import {
isField,
- isInlineFragment,
resultKeyNameFromField,
Reference,
isReference,
@@ -26,11 +23,11 @@ import {
getQueryDefinition,
maybeDeepFreeze,
mergeDeepArray,
+ getFragmentFromSelection,
} from '../../utilities';
import { Cache } from '../core/types/Cache';
import {
DiffQueryAgainstStoreOptions,
- ReadQueryOptions,
NormalizedCache,
ReadMergeModifyContext,
} from './types';
@@ -47,6 +44,7 @@ interface ReadContext extends ReadMergeModifyContext {
policies: Policies;
fragmentMap: FragmentMap;
path: (string | number)[];
+ clientOnly: boolean;
};
export type ExecResult = {
@@ -62,6 +60,7 @@ function missingFromInvariant(
err.message,
context.path.slice(),
context.query,
+ context.clientOnly,
context.variables,
);
}
@@ -88,26 +87,6 @@ export class StoreReader {
this.config = { addTypename: true, ...config };
}
- /**
- * Resolves the result of a query solely from the store (i.e. never hits the server).
- *
- * @param {Store} store The {@link NormalizedCache} used by Apollo for the `data` portion of the
- * store.
- *
- * @param {DocumentNode} query The query document to resolve from the data available in the store.
- *
- * @param {Object} [variables] A map from the name of a variable to its value. These variables can
- * be referenced by the query document.
- */
- public readQueryFromStore(
- options: ReadQueryOptions,
- ): QueryType | undefined {
- return this.diffQueryAgainstStore({
- ...options,
- returnPartialData: false,
- }).result;
- }
-
/**
* Given a store and a query, return as much of the result as possible and
* identify if any data was missing from the store.
@@ -140,6 +119,7 @@ export class StoreReader {
varString: JSON.stringify(variables),
fragmentMap: createFragmentMap(getFragmentDefinitions(query)),
path: [],
+ clientOnly: false,
},
});
@@ -219,7 +199,7 @@ export class StoreReader {
};
}
- const { fragmentMap, variables, policies, store } = context;
+ const { variables, policies, store } = context;
const objectsToMerge: { [key: string]: any }[] = [];
const finalResult: ExecResult = { result: null };
const typename = store.getFieldValue(objectOrReference, "__typename");
@@ -260,6 +240,20 @@ export class StoreReader {
const resultName = resultKeyNameFromField(selection);
context.path.push(resultName);
+ // If this field has an @client directive, then the field and
+ // everything beneath it is client-only, meaning it will never be
+ // sent to the server.
+ const wasClientOnly = context.clientOnly;
+ // Once we enter a client-only subtree of the query, we can avoid
+ // repeatedly checking selection.directives.
+ context.clientOnly = wasClientOnly || !!(
+ // We don't use the hasDirectives helper here, because it looks
+ // for directives anywhere inside the AST node, whereas we only
+ // care about directives directly attached to this field.
+ selection.directives &&
+ selection.directives.some(d => d.name.value === "client")
+ );
+
if (fieldValue === void 0) {
if (!addTypenameToDocument.added(selection)) {
getMissing().push(
@@ -312,22 +306,17 @@ export class StoreReader {
objectsToMerge.push({ [resultName]: fieldValue });
}
+ context.clientOnly = wasClientOnly;
+
invariant(context.path.pop() === resultName);
} else {
- let fragment: InlineFragmentNode | FragmentDefinitionNode;
-
- if (isInlineFragment(selection)) {
- fragment = selection;
- } else {
- // This is a named fragment
- invariant(
- fragment = fragmentMap[selection.name.value],
- `No fragment named ${selection.name.value}`,
- );
- }
+ const fragment = getFragmentFromSelection(
+ selection,
+ context.fragmentMap,
+ );
- if (policies.fragmentMatches(fragment, typename)) {
+ if (fragment && policies.fragmentMatches(fragment, typename)) {
fragment.selectionSet.selections.forEach(workSet.add, workSet);
}
}
diff --git a/src/cache/inmemory/types.ts b/src/cache/inmemory/types.ts
index 9e83bf65932..bed9b7adb60 100644
--- a/src/cache/inmemory/types.ts
+++ b/src/cache/inmemory/types.ts
@@ -7,7 +7,7 @@ import {
Reference,
} from '../../utilities';
import { FieldValueGetter } from './entityStore';
-import { KeyFieldsFunction } from './policies';
+import { KeyFieldsFunction, StorageType } from './policies';
import {
Modifier,
Modifiers,
@@ -62,6 +62,11 @@ export interface NormalizedCache {
getFieldValue: FieldValueGetter;
toReference: ToReferenceFunction;
canRead: CanReadFunction;
+
+ getStorage(
+ idOrObj: string | StoreObject,
+ storeFieldName: string,
+ ): StorageType;
}
/**
diff --git a/src/cache/inmemory/writeToStore.ts b/src/cache/inmemory/writeToStore.ts
index fea1d64bf5c..1d05ba8e3f2 100644
--- a/src/cache/inmemory/writeToStore.ts
+++ b/src/cache/inmemory/writeToStore.ts
@@ -89,7 +89,7 @@ export class StoreWriter {
...variables,
};
- const objOrRef = this.processSelectionSet({
+ const ref = this.processSelectionSet({
result: result || Object.create(null),
dataId,
selectionSet: operationDefinition.selectionSet,
@@ -105,15 +105,14 @@ export class StoreWriter {
},
});
- const ref = isReference(objOrRef) ? objOrRef :
- dataId && makeReference(dataId) || void 0;
-
- if (ref) {
- // Any IDs written explicitly to the cache (including ROOT_QUERY,
- // most frequently) will be retained as reachable root IDs.
- store.retain(ref.__ref);
+ if (!isReference(ref)) {
+ throw new InvariantError(`Could not identify object ${JSON.stringify(result)}`);
}
+ // Any IDs written explicitly to the cache (including ROOT_QUERY,
+ // most frequently) will be retained as reachable root IDs.
+ store.retain(ref.__ref);
+
return ref;
}
@@ -246,7 +245,26 @@ export class StoreWriter {
context.fragmentMap,
);
- if (fragment && policies.fragmentMatches(fragment, typename)) {
+ if (fragment &&
+ // By passing result and context.variables, we enable
+ // policies.fragmentMatches to bend the rules when typename is
+ // not a known subtype of the fragment type condition, but the
+ // result object contains all the keys requested by the
+ // fragment, which strongly suggests the fragment probably
+ // matched. This fuzzy matching behavior must be enabled by
+ // including a regular expression string (such as ".*" or
+ // "Prefix.*" or ".*Suffix") in the possibleTypes array for
+ // specific supertypes; otherwise, all matching remains exact.
+ // Fuzzy matches are remembered by the Policies object and
+ // later used when reading from the cache. Since there is no
+ // incoming result object to check when reading, reading does
+ // not involve the same fuzzy inference, so the StoreReader
+ // class calls policies.fragmentMatches without passing result
+ // or context.variables. The flexibility of fuzzy matching
+ // allows existing clients to accommodate previously unknown
+ // __typename strings produced by server/schema changes, which
+ // would otherwise be breaking changes.
+ policies.fragmentMatches(fragment, typename, result, context.variables)) {
fragment.selectionSet.selections.forEach(workSet.add, workSet);
}
}
diff --git a/src/core/ApolloClient.ts b/src/core/ApolloClient.ts
index 6fd3ca69062..b4d58404ad7 100644
--- a/src/core/ApolloClient.ts
+++ b/src/core/ApolloClient.ts
@@ -277,7 +277,7 @@ export class ApolloClient implements DataProxy {
* a description of store reactivity.
*/
public watchQuery(
- options: WatchQueryOptions,
+ options: WatchQueryOptions,
): ObservableQuery {
if (this.defaultOptions.watchQuery) {
options = compact(this.defaultOptions.watchQuery, options);
@@ -305,7 +305,7 @@ export class ApolloClient implements DataProxy {
* server at all or just resolve from the cache, etc.
*/
public query(
- options: QueryOptions,
+ options: QueryOptions,
): Promise> {
if (this.defaultOptions.query) {
options = compact(this.defaultOptions.query, options);
@@ -347,7 +347,7 @@ export class ApolloClient implements DataProxy {
* {@link Observable} which either emits received data or an error.
*/
public subscribe(
- options: SubscriptionOptions,
+ options: SubscriptionOptions,
): Observable> {
return this.queryManager.startGraphQLSubscription(options);
}
@@ -362,7 +362,7 @@ export class ApolloClient implements DataProxy {
* optimistic results. Is `false` by default.
*/
public readQuery(
- options: DataProxy.Query,
+ options: DataProxy.Query,
optimistic: boolean = false,
): T | null {
return this.cache.readQuery(options, optimistic);
@@ -383,7 +383,7 @@ export class ApolloClient implements DataProxy {
* optimistic results. Is `false` by default.
*/
public readFragment(
- options: DataProxy.Fragment,
+ options: DataProxy.Fragment,
optimistic: boolean = false,
): T | null {
return this.cache.readFragment(options, optimistic);
diff --git a/src/core/ObservableQuery.ts b/src/core/ObservableQuery.ts
index 907a7d588a2..d4b31c4083f 100644
--- a/src/core/ObservableQuery.ts
+++ b/src/core/ObservableQuery.ts
@@ -1,4 +1,4 @@
-import { invariant, InvariantError } from 'ts-invariant';
+import { invariant } from 'ts-invariant';
import { equal } from '@wry/equality';
import { NetworkStatus, isNetworkRequestInFlight } from './networkStatus';
@@ -45,7 +45,7 @@ export class ObservableQuery<
TData = any,
TVariables = OperationVariables
> extends Observable> {
- public readonly options: WatchQueryOptions;
+ public readonly options: WatchQueryOptions;
public readonly queryId: string;
public readonly queryName?: string;
@@ -72,7 +72,7 @@ export class ObservableQuery<
}: {
queryManager: QueryManager;
queryInfo: QueryInfo;
- options: WatchQueryOptions;
+ options: WatchQueryOptions;
}) {
super((observer: Observer>) =>
this.onSubscribe(observer),
@@ -125,7 +125,7 @@ export class ObservableQuery<
});
}
- public getCurrentResult(): ApolloQueryResult {
+ public getCurrentResult(saveAsLastResult = true): ApolloQueryResult {
const { lastResult } = this;
const networkStatus =
@@ -146,7 +146,9 @@ export class ObservableQuery<
const { fetchPolicy = 'cache-first' } = this.options;
if (fetchPolicy === 'no-cache' ||
fetchPolicy === 'network-only') {
- result.partial = false;
+ // Similar to setting result.partial to false, but taking advantage
+ // of the falsiness of missing fields.
+ delete result.partial;
} else if (
!result.data ||
// If this.options.query has @client(always: true) fields, we cannot
@@ -159,24 +161,29 @@ export class ObservableQuery<
!this.queryManager.transform(this.options.query).hasForcedResolvers
) {
const diff = this.queryInfo.getDiff();
- result.partial = !diff.complete;
result.data = (
diff.complete ||
this.options.returnPartialData
) ? diff.result : void 0;
- // If the cache diff is complete, and we're using a FetchPolicy that
- // terminates after a complete cache read, we can assume the next
- // result we receive will have NetworkStatus.ready and !loading.
- if (diff.complete &&
- result.networkStatus === NetworkStatus.loading &&
- (fetchPolicy === 'cache-first' ||
- fetchPolicy === 'cache-only')) {
- result.networkStatus = NetworkStatus.ready;
- result.loading = false;
+ if (diff.complete) {
+ // If the diff is complete, and we're using a FetchPolicy that
+ // terminates after a complete cache read, we can assume the next
+ // result we receive will have NetworkStatus.ready and !loading.
+ if (result.networkStatus === NetworkStatus.loading &&
+ (fetchPolicy === 'cache-first' ||
+ fetchPolicy === 'cache-only')) {
+ result.networkStatus = NetworkStatus.ready;
+ result.loading = false;
+ }
+ delete result.partial;
+ } else {
+ result.partial = true;
}
}
- this.updateLastResult(result);
+ if (saveAsLastResult) {
+ this.updateLastResult(result);
+ }
return result;
}
@@ -216,15 +223,7 @@ export class ObservableQuery<
* the previous values of those variables will be used.
*/
public refetch(variables?: Partial): Promise> {
- let { fetchPolicy } = this.options;
- // early return if trying to read from cache during refetch
- if (fetchPolicy === 'cache-only') {
- return Promise.reject(new InvariantError(
- 'cache-only fetchPolicy option should not be used together with query refetch.',
- ));
- }
-
- const reobserveOptions: Partial> = {
+ const reobserveOptions: Partial> = {
// Always disable polling for refetches.
pollInterval: 0,
};
@@ -232,11 +231,12 @@ export class ObservableQuery<
// Unless the provided fetchPolicy always consults the network
// (no-cache, network-only, or cache-and-network), override it with
// network-only to force the refetch for this fetchQuery call.
+ const { fetchPolicy } = this.options;
if (fetchPolicy !== 'no-cache' &&
fetchPolicy !== 'cache-and-network') {
reobserveOptions.fetchPolicy = 'network-only';
// Go back to the original options.fetchPolicy after this refetch.
- reobserveOptions.nextFetchPolicy = fetchPolicy;
+ reobserveOptions.nextFetchPolicy = fetchPolicy || "cache-first";
}
if (variables && !equal(this.options.variables, variables)) {
@@ -254,7 +254,7 @@ export class ObservableQuery<
}
public fetchMore(
- fetchMoreOptions: FetchMoreQueryOptions &
+ fetchMoreOptions: FetchMoreQueryOptions &
FetchMoreOptions,
): Promise> {
const combinedOptions = {
@@ -276,36 +276,11 @@ export class ObservableQuery<
const qid = this.queryManager.generateQueryId();
+ // Simulate a loading result for the original query with
+ // result.networkStatus === NetworkStatus.fetchMore.
if (combinedOptions.notifyOnNetworkStatusChange) {
- const currentResult = this.getCurrentResult();
-
- // If we neglect to update queryInfo.networkStatus here,
- // getCurrentResult may return a loading:false result while
- // fetchMore is in progress, since getCurrentResult also consults
- // queryInfo.networkStatus. Note: setting queryInfo.networkStatus
- // to an in-flight status means that QueryInfo#shouldNotify will
- // return false while fetchMore is in progress, which is why we
- // call this.reobserve() explicitly in the .finally callback after
- // fetchMore (below), since the cache write will not automatically
- // trigger a notification, even though it does trigger a cache
- // broadcast. This is a good thing, because it means we won't see
- // intervening query notifications while fetchMore is pending.
this.queryInfo.networkStatus = NetworkStatus.fetchMore;
-
- // Simulate a loading result for the original query with
- // networkStatus === NetworkStatus.fetchMore.
- this.observer.next!({
- // Note that currentResult is an ApolloCurrentQueryResult,
- // whereas this.observer.next expects an ApolloQueryResult.
- // Fortunately, ApolloCurrentQueryResult is a subtype of
- // ApolloQueryResult (with additional .error and .partial fields),
- // so TypeScript has no problem with this sleight of hand.
- // TODO Consolidate these two types into a single type (most
- // likely just ApolloQueryResult) after AC3 is released.
- ...currentResult,
- loading: true,
- networkStatus: NetworkStatus.fetchMore,
- });
+ this.observe();
}
return this.queryManager.fetchQuery(
@@ -409,7 +384,7 @@ once, rather than every time you call fetchMore.`);
}
public setOptions(
- newOptions: Partial>,
+ newOptions: Partial>,
): Promise> {
return this.reobserve(newOptions);
}
@@ -459,22 +434,28 @@ once, rather than every time you call fetchMore.`);
}
let { fetchPolicy = 'cache-first' } = this.options;
+ const reobserveOptions: Partial> = {
+ fetchPolicy,
+ variables,
+ };
+
if (fetchPolicy !== 'cache-first' &&
fetchPolicy !== 'no-cache' &&
fetchPolicy !== 'network-only') {
- fetchPolicy = 'cache-and-network';
+ reobserveOptions.fetchPolicy = 'cache-and-network';
+ reobserveOptions.nextFetchPolicy = fetchPolicy;
}
- return this.reobserve({
- fetchPolicy,
- variables,
- }, NetworkStatus.setVariables);
+ return this.reobserve(
+ reobserveOptions,
+ NetworkStatus.setVariables,
+ );
}
public updateQuery(
mapFn: (
previousQueryResult: TData,
- options: Pick, "variables">,
+ options: Pick, "variables">,
) => TData,
): void {
const { queryManager } = this;
@@ -599,15 +580,25 @@ once, rather than every time you call fetchMore.`);
}
public reobserve(
- newOptions?: Partial>,
+ newOptions?: Partial>,
newNetworkStatus?: NetworkStatus,
): Promise> {
this.isTornDown = false;
return this.getReobserver().reobserve(newOptions, newNetworkStatus);
}
- private observer: Observer> = {
- next: result => {
+ // Pass the current result to this.observer.next without applying any
+ // fetch policies, bypassing the Reobserver.
+ private observe() {
+ // Passing false is important so that this.getCurrentResult doesn't
+ // save the fetchMore result as this.lastResult, causing it to be
+ // ignored due to the this.isDifferentFromLastResult check in
+ // this.observer.next.
+ this.observer.next(this.getCurrentResult(false));
+ }
+
+ private observer = {
+ next: (result: ApolloQueryResult) => {
if (this.lastError || this.isDifferentFromLastResult(result)) {
this.updateLastResult(result);
iterateObserversSafely(this.observers, 'next', result);
diff --git a/src/core/QueryInfo.ts b/src/core/QueryInfo.ts
index 333a22fbce6..e3c82e511c7 100644
--- a/src/core/QueryInfo.ts
+++ b/src/core/QueryInfo.ts
@@ -2,7 +2,7 @@ import { DocumentNode, GraphQLError } from 'graphql';
import { equal } from "@wry/equality";
import { Cache, ApolloCache } from '../cache';
-import { WatchQueryOptions } from './watchQueryOptions';
+import { WatchQueryOptions, ErrorPolicy } from './watchQueryOptions';
import { ObservableQuery } from './ObservableQuery';
import { QueryListener } from './types';
import { FetchResult } from '../link/core';
@@ -10,6 +10,7 @@ import {
ObservableSubscription,
isNonEmptyArray,
graphQLResultHasError,
+ canUseWeakMap,
} from '../utilities';
import {
NetworkStatus,
@@ -24,6 +25,30 @@ export type QueryStoreValue = Pick;
+const destructiveMethodCounts = new (
+ canUseWeakMap ? WeakMap : Map
+), number>();
+
+function wrapDestructiveCacheMethod(
+ cache: ApolloCache,
+ methodName: keyof ApolloCache,
+) {
+ const original = cache[methodName];
+ if (typeof original === "function") {
+ cache[methodName] = function () {
+ destructiveMethodCounts.set(
+ cache,
+ // The %1e15 allows the count to wrap around to 0 safely every
+ // quadrillion evictions, so there's no risk of overflow. To be
+ // clear, this is more of a pedantic principle than something
+ // that matters in any conceivable practical scenario.
+ (destructiveMethodCounts.get(cache)! + 1) % 1e15,
+ );
+ return original.apply(this, arguments);
+ };
+ }
+}
+
// A QueryInfo object represents a single query managed by the
// QueryManager, which tracks all QueryInfo objects by queryId in its
// this.queries Map. QueryInfo objects store the latest results and errors
@@ -46,7 +71,18 @@ export class QueryInfo {
networkError?: Error | null;
graphQLErrors?: ReadonlyArray;
- constructor(private cache: ApolloCache) {}
+ constructor(private cache: ApolloCache) {
+ // Track how often cache.evict is called, since we want eviction to
+ // override the feud-stopping logic in the markResult method, by
+ // causing shouldWrite to return true. Wrapping the cache.evict method
+ // is a bit of a hack, but it saves us from having to make eviction
+ // counting an official part of the ApolloCache API.
+ if (!destructiveMethodCounts.has(cache)) {
+ destructiveMethodCounts.set(cache, 0);
+ wrapDestructiveCacheMethod(cache, "evict");
+ wrapDestructiveCacheMethod(cache, "modify");
+ }
+ }
public init(query: {
document: DocumentNode;
@@ -112,7 +148,8 @@ export class QueryInfo {
setDiff(diff: Cache.DiffResult | null) {
const oldDiff = this.diff;
this.diff = diff;
- if (!this.dirty && diff?.result !== oldDiff?.result) {
+ if (!this.dirty &&
+ (diff && diff.result) !== (oldDiff && oldDiff.result)) {
this.dirty = true;
if (!this.notifyTimeout) {
this.notifyTimeout = setTimeout(() => this.notify(), 0);
@@ -134,7 +171,18 @@ export class QueryInfo {
if (oq) {
oq["queryInfo"] = this;
- this.listeners.add(this.oqListener = () => oq.reobserve());
+ this.listeners.add(this.oqListener = () => {
+ // If this.diff came from an optimistic transaction, deliver the
+ // current cache data to the ObservableQuery, but don't perform a
+ // full reobservation, since oq.reobserve might make a network
+ // request, and we don't want to trigger network requests for
+ // optimistic updates.
+ if (this.getDiff().fromOptimisticTransaction) {
+ oq["observe"]();
+ } else {
+ oq.reobserve();
+ }
+ });
} else {
delete this.oqListener;
}
@@ -204,8 +252,27 @@ export class QueryInfo {
}
}
- private lastWrittenResult?: FetchResult;
- private lastWrittenVars?: WatchQueryOptions["variables"];
+ private lastWrite?: {
+ result: FetchResult;
+ variables: WatchQueryOptions["variables"];
+ dmCount: number | undefined;
+ };
+
+ private shouldWrite(
+ result: FetchResult,
+ variables: WatchQueryOptions["variables"],
+ ) {
+ const { lastWrite } = this;
+ return !(
+ lastWrite &&
+ // If cache.evict has been called since the last time we wrote this
+ // data into the cache, there's a chance writing this result into
+ // the cache will repair what was evicted.
+ lastWrite.dmCount === destructiveMethodCounts.get(this.cache) &&
+ equal(variables, lastWrite.variables) &&
+ equal(result.data, lastWrite.result.data)
+ );
+ }
public markResult(
result: FetchResult,
@@ -221,23 +288,25 @@ export class QueryInfo {
this.diff = { result: result.data, complete: true };
} else if (allowCacheWrite) {
- const ignoreErrors =
- options.errorPolicy === 'ignore' ||
- options.errorPolicy === 'all';
- let writeWithErrors = !graphQLResultHasError(result);
- if (!writeWithErrors && ignoreErrors && result.data) {
- writeWithErrors = true;
- }
-
- if (writeWithErrors) {
+ if (shouldWriteResult(result, options.errorPolicy)) {
// Using a transaction here so we have a chance to read the result
// back from the cache before the watch callback fires as a result
// of writeQuery, so we can store the new diff quietly and ignore
// it when we receive it redundantly from the watch callback.
this.cache.performTransaction(cache => {
- if (this.lastWrittenResult &&
- equal(result.data, this.lastWrittenResult.data) &&
- equal(options.variables, this.lastWrittenVars)) {
+ if (this.shouldWrite(result, options.variables)) {
+ cache.writeQuery({
+ query: this.document!,
+ data: result.data as T,
+ variables: options.variables,
+ });
+
+ this.lastWrite = {
+ result,
+ variables: options.variables,
+ dmCount: destructiveMethodCounts.get(this.cache),
+ };
+ } else {
// If result is the same as the last result we received from
// the network (and the variables match too), avoid writing
// result into the cache again. The wisdom of skipping this
@@ -278,14 +347,6 @@ export class QueryInfo {
}
// If the previous this.diff was incomplete, fall through to
// re-reading the latest data with cache.diff, below.
- } else {
- cache.writeQuery({
- query: this.document!,
- data: result.data as T,
- variables: options.variables,
- });
- this.lastWrittenResult = result;
- this.lastWrittenVars = options.variables;
}
const diff = cache.diff({
@@ -311,7 +372,7 @@ export class QueryInfo {
});
} else {
- this.lastWrittenResult = this.lastWrittenVars = void 0;
+ this.lastWrite = void 0;
}
}
}
@@ -323,7 +384,7 @@ export class QueryInfo {
public markError(error: ApolloError) {
this.networkStatus = NetworkStatus.error;
- this.lastWrittenResult = this.lastWrittenVars = void 0;
+ this.lastWrite = void 0;
if (error.graphQLErrors) {
this.graphQLErrors = error.graphQLErrors;
@@ -336,3 +397,17 @@ export class QueryInfo {
return error;
}
}
+
+export function shouldWriteResult(
+ result: FetchResult,
+ errorPolicy: ErrorPolicy = "none",
+) {
+ const ignoreErrors =
+ errorPolicy === "ignore" ||
+ errorPolicy === "all";
+ let writeWithErrors = !graphQLResultHasError(result);
+ if (!writeWithErrors && ignoreErrors && result.data) {
+ writeWithErrors = true;
+ }
+ return writeWithErrors;
+}
diff --git a/src/core/QueryManager.ts b/src/core/QueryManager.ts
index 6966570b9d1..42fde4aefcb 100644
--- a/src/core/QueryManager.ts
+++ b/src/core/QueryManager.ts
@@ -39,7 +39,7 @@ import {
} from './types';
import { LocalState } from './LocalState';
-import { QueryInfo, QueryStoreValue } from './QueryInfo';
+import { QueryInfo, QueryStoreValue, shouldWriteResult } from './QueryInfo';
const { hasOwnProperty } = Object.prototype;
@@ -192,6 +192,7 @@ export class QueryManager {
result: { data: optimistic },
document: mutation,
variables: variables,
+ errorPolicy,
queryUpdatersById: generateUpdateQueriesInfo(),
update: updateWithProxyFn,
}, cache);
@@ -235,6 +236,7 @@ export class QueryManager {
result,
document: mutation,
variables,
+ errorPolicy,
queryUpdatersById: generateUpdateQueriesInfo(),
update: updateWithProxyFn,
}, self.cache);
@@ -333,7 +335,7 @@ export class QueryManager {
public fetchQuery(
queryId: string,
- options: WatchQueryOptions,
+ options: WatchQueryOptions,
networkStatus?: NetworkStatus,
): Promise> {
return this.fetchQueryObservable(
@@ -428,7 +430,7 @@ export class QueryManager {
}
public watchQuery(
- options: WatchQueryOptions,
+ options: WatchQueryOptions,
): ObservableQuery {
// assign variable default values if supplied
options = {
@@ -462,7 +464,7 @@ export class QueryManager {
}
public query(
- options: QueryOptions,
+ options: QueryOptions,
): Promise> {
invariant(
options.query,
@@ -588,6 +590,7 @@ export class QueryManager {
public startGraphQLSubscription({
query,
fetchPolicy,
+ errorPolicy,
variables,
context = {},
}: SubscriptionOptions): Observable> {
@@ -601,10 +604,10 @@ export class QueryManager {
variables,
false,
).map(result => {
- if (!fetchPolicy || fetchPolicy !== 'no-cache') {
+ if (fetchPolicy !== 'no-cache') {
// the subscription interface should handle not sending us results we no longer subscribe to.
// XXX I don't think we ever send in an object with errors, but we might in the future...
- if (!graphQLResultHasError(result)) {
+ if (shouldWriteResult(result, errorPolicy)) {
this.cache.write({
query,
result: result.data,
@@ -759,7 +762,7 @@ export class QueryManager {
private getResultsFromLink(
queryInfo: QueryInfo,
allowCacheWrite: boolean,
- options: Pick,
+ options: Pick,
| "variables"
| "context"
| "fetchPolicy"
@@ -817,7 +820,7 @@ export class QueryManager {
public fetchQueryObservable(
queryId: string,
- options: WatchQueryOptions,
+ options: WatchQueryOptions,
// The initial networkStatus for this fetch, most often
// NetworkStatus.loading, but also possibly fetchMore, poll, refetch,
// or setVariables.
@@ -909,7 +912,13 @@ export class QueryManager {
concast.cleanup(() => {
this.fetchCancelFns.delete(queryId);
- if (options.nextFetchPolicy) {
+ const { nextFetchPolicy } = options;
+ if (nextFetchPolicy) {
+ // The options.nextFetchPolicy transition should happen only once,
+ // but it should be possible for a nextFetchPolicy function to set
+ // this.nextFetchPolicy to perform an additional transition.
+ options.nextFetchPolicy = void 0;
+
// When someone chooses cache-and-network or network-only as their
// initial FetchPolicy, they often do not want future cache updates to
// trigger unconditional network requests, which is what repeatedly
@@ -920,9 +929,9 @@ export class QueryManager {
// The options.nextFetchPolicy option provides an easy way to update
// options.fetchPolicy after the intial network request, without
// having to call observableQuery.setOptions.
- options.fetchPolicy = options.nextFetchPolicy;
- // The options.nextFetchPolicy transition should happen only once.
- options.nextFetchPolicy = void 0;
+ options.fetchPolicy = typeof nextFetchPolicy === "function"
+ ? nextFetchPolicy.call(options, options.fetchPolicy || "cache-first")
+ : nextFetchPolicy;
}
});
@@ -931,7 +940,7 @@ export class QueryManager {
private fetchQueryByPolicy(
queryInfo: QueryInfo,
- options: WatchQueryOptions,
+ options: WatchQueryOptions,
// The initial networkStatus for this fetch, most often
// NetworkStatus.loading, but also possibly fetchMore, poll, refetch,
// or setVariables.
@@ -1072,6 +1081,7 @@ function markMutationResult(
result: FetchResult;
document: DocumentNode;
variables: any;
+ errorPolicy: ErrorPolicy;
queryUpdatersById: Record;
update:
((cache: ApolloCache, mutationResult: Object) => void) |
@@ -1080,7 +1090,7 @@ function markMutationResult(
cache: ApolloCache,
) {
// Incorporate the result from this mutation into the store
- if (!graphQLResultHasError(mutation.result)) {
+ if (shouldWriteResult(mutation.result, mutation.errorPolicy)) {
const cacheWrites: Cache.WriteOptions[] = [{
result: mutation.result.data,
dataId: 'ROOT_MUTATION',
diff --git a/src/core/Reobserver.ts b/src/core/Reobserver.ts
index e658985005a..e5cc8ed28bc 100644
--- a/src/core/Reobserver.ts
+++ b/src/core/Reobserver.ts
@@ -17,13 +17,13 @@ import { invariant } from 'ts-invariant';
export class Reobserver {
constructor(
private observer: Observer>,
- private options: WatchQueryOptions,
+ private options: WatchQueryOptions,
// Almost certainly just a wrapper function around
// QueryManager#fetchQueryObservable, but this small dose of
// indirection means the Reobserver doesn't have to know/assume
// anything about the QueryManager class.
private fetch: (
- options: WatchQueryOptions,
+ options: WatchQueryOptions,
newNetworkStatus?: NetworkStatus,
) => Concast>,
// If we're polling, there may be times when we should avoid fetching,
@@ -37,7 +37,7 @@ export class Reobserver {
private concast?: Concast>;
public reobserve(
- newOptions?: Partial>,
+ newOptions?: Partial>,
newNetworkStatus?: NetworkStatus,
): Promise> {
if (newOptions) {
@@ -66,7 +66,7 @@ export class Reobserver {
return (this.concast = concast).promise;
}
- public updateOptions(newOptions: Partial>) {
+ public updateOptions(newOptions: Partial>) {
Object.assign(this.options, compact(newOptions));
this.updatePolling();
return this;
@@ -133,6 +133,7 @@ export class Reobserver {
if (this.shouldFetch && this.shouldFetch()) {
this.reobserve({
fetchPolicy: "network-only",
+ nextFetchPolicy: this.options.fetchPolicy || "cache-first",
}, NetworkStatus.poll).then(poll, poll);
} else {
poll();
diff --git a/src/core/__tests__/ObservableQuery.ts b/src/core/__tests__/ObservableQuery.ts
index d2ec4b1d356..c220cb36895 100644
--- a/src/core/__tests__/ObservableQuery.ts
+++ b/src/core/__tests__/ObservableQuery.ts
@@ -1361,7 +1361,6 @@ describe('ObservableQuery', () => {
data: dataOne,
loading: false,
networkStatus: 7,
- partial: false,
});
resolve();
});
@@ -1406,7 +1405,6 @@ describe('ObservableQuery', () => {
data: dataOne,
loading: false,
networkStatus: NetworkStatus.ready,
- partial: false,
});
}).then(resolve, reject);
});
@@ -1502,7 +1500,7 @@ describe('ObservableQuery', () => {
const queryManager = mockQueryManager(reject, {
request: { query, variables },
result: { data: dataOne, errors: [error] },
- },
+ },
// FIXME: We shouldn't need a second mock, there should only be one network request
{
request: { query, variables },
@@ -1651,7 +1649,6 @@ describe('ObservableQuery', () => {
data: void 0,
loading: true,
networkStatus: 1,
- partial: false,
});
subscribeAndCount(reject, observable, (handleCount, subResult) => {
@@ -1659,7 +1656,6 @@ describe('ObservableQuery', () => {
expect(subResult).toEqual({
loading: true,
networkStatus: NetworkStatus.loading,
- partial: false,
});
} else if (handleCount === 2) {
expect(subResult).toEqual({
@@ -1696,7 +1692,6 @@ describe('ObservableQuery', () => {
data: undefined,
loading: true,
networkStatus: 1,
- partial: false,
});
subscribeAndCount(reject, observable, (handleCount, subResult) => {
@@ -1711,7 +1706,6 @@ describe('ObservableQuery', () => {
data,
loading,
networkStatus,
- partial: false,
});
} else if (handleCount === 2) {
expect(stripSymbols(subResult)).toEqual({
diff --git a/src/core/__tests__/QueryManager/index.ts b/src/core/__tests__/QueryManager/index.ts
index 02ef884f56e..a9adc0ac168 100644
--- a/src/core/__tests__/QueryManager/index.ts
+++ b/src/core/__tests__/QueryManager/index.ts
@@ -2288,6 +2288,112 @@ describe('QueryManager', () => {
});
});
+ itAsync("should disable feud-stopping logic after evict or modify", (resolve, reject) => {
+ const cache = new InMemoryCache({
+ typePolicies: {
+ Query: {
+ fields: {
+ info: {
+ merge: false,
+ },
+ },
+ },
+ },
+ });
+
+ const client = new ApolloClient({
+ cache,
+ link: new ApolloLink(operation => new Observable((observer: Observer) => {
+ observer.next!({ data: { info: { c: "see" }}});
+ observer.complete!();
+ })),
+ });
+
+ const query = gql`query { info { c } }`;
+
+ const obs = client.watchQuery({
+ query,
+ returnPartialData: true,
+ });
+
+ subscribeAndCount(reject, obs, (count, result) => {
+ if (count === 1) {
+ expect(result).toEqual({
+ loading: true,
+ networkStatus: NetworkStatus.loading,
+ data: {},
+ partial: true,
+ });
+
+ } else if (count === 2) {
+ expect(result).toEqual({
+ loading: false,
+ networkStatus: NetworkStatus.ready,
+ data: {
+ info: {
+ c: "see",
+ },
+ },
+ });
+
+ cache.evict({
+ fieldName: "info",
+ });
+
+ } else if (count === 3) {
+ expect(result).toEqual({
+ loading: true,
+ networkStatus: NetworkStatus.loading,
+ data: {},
+ partial: true,
+ });
+
+ } else if (count === 4) {
+ expect(result).toEqual({
+ loading: false,
+ networkStatus: NetworkStatus.ready,
+ data: {
+ info: {
+ c: "see",
+ },
+ },
+ });
+
+ cache.modify({
+ fields: {
+ info(_, { DELETE }) {
+ return DELETE;
+ },
+ },
+ });
+
+ } else if (count === 5) {
+ expect(result).toEqual({
+ loading: true,
+ networkStatus: NetworkStatus.loading,
+ data: {},
+ partial: true,
+ });
+
+ } else if (count === 6) {
+ expect(result).toEqual({
+ loading: false,
+ networkStatus: NetworkStatus.ready,
+ data: {
+ info: {
+ c: "see",
+ },
+ },
+ });
+
+ setTimeout(resolve, 100);
+
+ } else {
+ reject(new Error(`Unexpected ${JSON.stringify({count,result})}`));
+ }
+ });
+ });
+
itAsync('should not error when replacing unidentified data with a normalized ID', (resolve, reject) => {
const queryWithoutId = gql`
query {
diff --git a/src/core/__tests__/fetchPolicies.ts b/src/core/__tests__/fetchPolicies.ts
index abf78b225e1..5f1f0731982 100644
--- a/src/core/__tests__/fetchPolicies.ts
+++ b/src/core/__tests__/fetchPolicies.ts
@@ -3,6 +3,7 @@ import gql from 'graphql-tag';
import { ApolloClient, NetworkStatus } from '../../core';
import { ApolloLink } from '../../link/core';
import { InMemoryCache } from '../../cache';
+import { Observable } from '../../utilities';
import {
stripSymbols,
subscribeAndCount,
@@ -439,6 +440,62 @@ describe('cache-first', () => {
});
});
+describe('cache-only', () => {
+ itAsync('allows explicit refetch to happen', (resolve, reject) => {
+ let counter = 0;
+ const client = new ApolloClient({
+ cache: new InMemoryCache,
+ link: new ApolloLink(operation => new Observable(observer => {
+ observer.next({
+ data: {
+ count: ++counter,
+ },
+ });
+ observer.complete();
+ })),
+ });
+
+ const query = gql`query { counter }`;
+
+ const observable = client.watchQuery({
+ query,
+ nextFetchPolicy: 'cache-only',
+ });
+
+ subscribeAndCount(reject, observable, (count, result) => {
+ if (count === 1) {
+ expect(result).toEqual({
+ loading: false,
+ networkStatus: NetworkStatus.ready,
+ data: {
+ count: 1,
+ },
+ });
+
+ expect(observable.options.fetchPolicy).toBe('cache-only');
+
+ observable.refetch().catch(reject);
+
+ } else if (count === 2) {
+ expect(result).toEqual({
+ loading: false,
+ networkStatus: NetworkStatus.ready,
+ data: {
+ count: 2,
+ },
+ });
+
+ expect(observable.options.fetchPolicy).toBe('cache-only');
+
+ setTimeout(resolve, 50);
+
+ } else {
+ reject(`too many results (${count})`);
+ }
+ });
+ });
+});
+
describe('cache-and-network', function() {
itAsync('gives appropriate networkStatus for refetched queries', (resolve, reject) => {
const client = new ApolloClient({
diff --git a/src/core/types.ts b/src/core/types.ts
index a58cb921670..b139672fc52 100644
--- a/src/core/types.ts
+++ b/src/core/types.ts
@@ -6,6 +6,8 @@ import { QueryInfo } from './QueryInfo';
import { NetworkStatus } from './networkStatus';
import { Resolver } from './LocalState';
+export { TypedDocumentNode } from '@graphql-typed-document-node/core';
+
export type QueryListener = (queryInfo: QueryInfo) => void;
export type OperationVariables = Record;
diff --git a/src/core/watchQueryOptions.ts b/src/core/watchQueryOptions.ts
index d865367214f..e3b2ebe6602 100644
--- a/src/core/watchQueryOptions.ts
+++ b/src/core/watchQueryOptions.ts
@@ -1,4 +1,5 @@
import { DocumentNode } from 'graphql';
+import { TypedDocumentNode } from '@graphql-typed-document-node/core';
import { ApolloCache } from '../cache';
import { FetchResult } from '../link/core';
@@ -34,14 +35,14 @@ export type ErrorPolicy = 'none' | 'ignore' | 'all';
/**
* Common options shared across all query interfaces.
*/
-export interface QueryBaseOptions {
+export interface QueryBaseOptions {
/**
* A GraphQL document that consists of a single query to be sent down to the
* server.
*/
// TODO REFACTOR: rename this to document. Didn't do it yet because it's in a
// lot of tests.
- query: DocumentNode;
+ query: DocumentNode | TypedDocumentNode;
/**
* A map going from variable name to variable value, where the variables are used
@@ -63,8 +64,8 @@ export interface QueryBaseOptions