React Apollo 4.0.0 is dependent on @apollo/client >= 3. If you are using apollo-client 2.x and are not ready to update to @apollo/client, please use React Apollo 3.x.

The react-apollo package has been fully removed. Please use @apollo/client or @apollo/react-X packages directly.

Due to changes made in Apollo Client, the previous SSR testing pattern of:

  return getDataFromTree(app).then(() => {
    const markup = ReactDOM.renderToString(app);
    expect(markup).toMatch(/Waldo/);
  });

will no longer work (ReactDOM.renderToString(app) will just return the initial loading state of the component under test). Instead, we can leverage the markup returned when getDataFromTree's Promise resolves:

  return getDataFromTree(app).then((markup) => {
    expect(markup).toMatch(/Waldo/);
  });

We are no longer building UMD versions of React Apollo.

Make sure SSR is fully disabled when using ssr: false and ssrMode: true.

Fixed MockLink's broken newData function handling.

Fixed an issue that prevented networkStatus from changing ready at the end of pagination.

Calling startPolling or stopPolling after a component has unmounted is now a no-op (instead of throwing an exception). Polling is automatically stopped when a component is unmounted, so it doesn't need to be called manually.

Allow ignoreResults to be controlled through graphql and withMutation options.

Be a bit more defensive when it comes to accessing the internal ObservableQuery instance, to avoid attempting to use it after a component has unmounted.

A fix has been applied to prevent an unchanging loading state when an error occurs after a refetch, that is the same as the previous error.

Add back in the removed ChildDataProps and ChildMutateProps types.

Make sure onCompleted is called each time a useLazyQuery based query completes, after the execution function is called.

Change the default query data state from {} to undefined. This change aligns all parts of the React Apollo query cycle so that data is always undefined if there is no data, instead of data being converted into an empty object. This change impacts the initial query response, initial SSR response, data value when errors occur, data value when skipping, etc. All of these areas are now aligned to only ever return a value for data if there really is a value to return (instead of making it seem like there is one by converting to {}).

Adds support for the skip option when using useSubscription.

Makes sure refetch, fetchMore, updateQuery, startPolling, stopPolling, and subscribeToMore maintain a stable identity when they're passed back alongside query results.

Fixed problematic re-renders that were caused by using fetchMore.updateQuery with notifyOnNetworkStatusChange set to true. When notifyOnNetworkStatusChange is true, re-renders will now wait until updateQuery has completed, to make sure the updated data is used during the render.

Add client to the useMutation result.

Prevent inline onError and onCompleted callbacks from being part of the internal memoization that's used to decide when certain after render units of functionality are run, when using useQuery. This fixes issues related to un-necessary component cleanup, like error disappearing from results when it should be present.

useLazyQuery's execution function can now be called multiple times in a row, and will properly submit network requests each time called, when using a fetch policy of network-only.

SSR enhancements to support network-only and cache-and-network fetch policies, along with changes to ensure disabled SSR queries are not fired.

Remove void from the MutationFunction's returned Promise types.

Prevent duplicate onCompleted calls during the same query execution cycle.

Make sure polling is stopped when a component is unmounted.

Documentation fixes.

Documentation updates.

Dedupe onError callback calls and ensure refetch sets loading state properly.

Add missing useLazyQuery export to the react-apollo (all) package.

Remove void from being one of the MutationTuple mutate function possible generics. This will make it easier to properly destructure results returned by the mutate function Promise.

Export MockedProviderProps and MockedProviderState from @apollo/react-testing.

Add @types/react as a peer dep, to address potential TS compilation errors when using ApolloProvider.

Make sure error's are maintained after re-renders, when they should be.

This major release includes a large refactoring of the existing React Apollo codebase, to introduce new improvements, changes, features and bug fixes. The biggest new features are:

Provides new useQuery, useLazyQuery, useMutation, useSubscription, and useApolloClient hooks, following React's Hooks API.

Maintains support for React Apollo's graphql HOC and render proper components.

Introduces a new monorepo structure, with separately published packages, making it easier to use just the parts of React Apollo you're interested in:

• @apollo/react-common
• @apollo/react-hooks
• @apollo/react-components
• @apollo/react-hoc
• @apollo/react-ssr
• @apollo/react-testing

Thorough codebase pruning and cleaning to reduce the overall React Apollo bundle size.

And more!

Consult the Hooks migration guide for more details around upgrading. For more information regarding how to use the new hooks, please consult the updated React Apollo docs (all docs have been updated to be hooks first).

The minimum supported React version is now 16.8.

The [email protected] package preserves most of the functionality of [email protected] by re-exporting existing components and functions from @apollo/react-components and @apollo/react-hoc. If you want to use Hooks, Components, or HOC directly, import the new @apollo/react-hooks, @apollo/react-components, and/or @apollo/react-hoc packages instead.

React Apollo testing utilities are no longer available as part of the react-apollo package. They should now be imported from the new @apollo/react-testing package.

The deprecated walkTree function has been removed (9b24d756).

The deprecated GraphqlQueryControls and MutationFunc types have been removed (ade881f0).

Preact is no longer supported (b742ae63).

Various Typescript type changes. Since we've introduced a third way of managing data with React (Hooks), we had to rework many of the existing exported types to better align with the Hooks way of doing things. Base types are used to hold common properties across Hooks, Components and the graphql HOC, and these types are then extended when needed to provide properties that are specific to a certain React paradigm (30edb1b0 and

catchAsyncError, wrap, and compose utilities have been removed (2c3a262, 7de864e, and e6089a7).

Previously, compose was imported then exported directly from lodash using flowRight. To keep using compose, install the lodash.flowright package, then update your compose imports as:

  import compose from 'lodash.flowright';

Render prop components (Query, Mutation and Subscription) can no longer be extended. In other words, this is no longer possible:

  class SomeQuery extends Query<SomeData, SomeVariables> {}

All class based render prop components have been converted to functional components, so they could then just wrap their hook based equivalents (useQuery, useMutation, useSubscription).

While we recommend switching over to use the new hooks as soon as possible, if you're looking for a stop gap you can consider typing a Query component in a similar fashion, like:

  export const SomeQuery = () => (
    <Query<SomeData, SomeVariables> query={SOME_QUERY} ...>
      {({ data }) => {
        return <div> ... things happen... </div>;
      }}
    </Query>
  );

Make sure MockedProvider is using the proper CJS/ESM bundle, when referencing ApolloProvider.

Adjust the ApolloContext definition to play a bit more nicely with React.createContext types.

The result of a mutation is now made available to the wrapped component, when using the graphql HOC.

Check equality of stringified variables in the MockLink to improve debugging experience used by MockedProvider.

Removed leftover [email protected] peer dep.

Stop setting optional input to null, when using the graphql HOC.

Fix typescript error caused by query being mandatory in the fetchMore signature.

Fixes an issue that caused the Query component to get stuck in an always loading state, caused by receiving an error (meaning subsequent valid responses couldn't be handled). The Query component can now handle an error in a response, then continue to handle a valid response afterwards.

Reorder Subscription component code to avoid setting state on unmounted component.

Fix component stuck in loading state for network-only fetch policy.

Both the Query component and graphql HOC now accept a returnPartialData prop. This is an important new feature, that should help address a lot of open Apollo Client / React Apollo issues, so we'll explain it here with an example. Before this release, if you run a query that looks like:

  const GET_MEMBER = gql`
    query GetMember($id: ID!) {
      member(id: $id) {
        id
        name
      }
    }
  `;

in one component, the results are cached, then you run a superset query like the following in another component:

  const GET_MEMBER_WITH_PLANS = gql`
    query GetMemberWithPlans($id: ID!) {
      member(id: $id) {
        id
        name
        plans {
          id
          title
          duration
        }
      }
    }
  `;

Apollo Client will not re-use the partial data that was cached from the first query, when it preps and displays the second component. It can't find a cache hit for the full second query, so it fires the full query over the network.

With this release, if you set a returnPartialData prop to true on the second component, the data available to that component will be automatically pre-loaded with the parts of the query that can be found in the cache, before the full query is fired over the network. This means you can do things like showing partial data in your components, while the rest of the data is being loaded over the network.

Export the Apollo Context provider (ApolloContext).

Documentation updates.

Fixes Could not find "client" in the context of ApolloConsumer errors when using MockedProvider.

Ensure Query components using a fetchPolicy of no-cache have their data preserved when the components tree is re-rendered.

MockedProvider now accepts a childProps prop that can be used to pass props down to a child component.

onCompleted callbacks now use a destructuring-friendly type definition.

@connection directives are now properly stripped from MockedResponse's, when using MockedProvider.

MockedProvider has been updated to stop setting a default resolvers value of {}, which means by default Apollo Client 2.5 local resolver functionality is not enabled when mocking with MockedProvider. This allows @client fields to be passed through the mocked link chain, like people were used to before AC 2.5. When using this default mode you will see a dev only warning message about this like:

Found @client directives in query but no client resolvers were specified. You can now pass apollo-link-state resolvers to the ApolloClient constructor.

This message can be safely ignored. If you want to use MockedProvider with AC 2.5's new local resolver functionality, you can pass your local resolver map into the MockedProvider resolvers prop.

Improvements to the graphql HOC generics for fetchMore and refetch.

The ApolloProvider / ApolloConsumer implementations have been refactored to use React 16.3's new context API.

All dependencies and devDependencies have been updated to their latest versions, and related Typescript changes have been applied.

Fixed an infinite loop caused by using setState in the onError / onCompleted callbacks of the Query component.

Fixed an issue that prevented good results from showing up in a Query component, after an error was received, variables were adjusted, and then the good data was fetched.

Fixed an issue that prevented Query component updates from firing (under certain circumstances) due to the internal lastResult value (that's used to help prevent unnecessary re-renders) not being updated.

Add examples/rollup to enable application-level bundle measurement and demonstrate Rollup configuration best practices.

Bundle size reductions inspired by examples/rollup app.

Export Context type from types.ts instead of walkTree.ts, to reenable import { Context } from 'react-apollo' (which has been broken since 2.4.0).

Make sure MockedProvider enables Apollo Client 2.5's local state handling, and allow custom / mocked resolvers to be passed in as props, and used with the created test ApolloClient instance.

Ready to be used with Apollo Client 2.5 and its new local state management features, as well as many overall code improvements to help reduce the React Apollo bundle size.

A function can now be set as a MockedResponse result when using MockedProvider, such that every time the mocked result is returned, the function is run to calculate the result. This opens up new testing possibilities, like being able to verify if a mocked result was actually requested and received by a test.

Adds a onSubscriptionComplete prop to the Subscription component, that can be passed a callback to be called when the subscription observable is completed.

During server-side rendering, ObservableQuery objects created in previous rendering passes will now be preserved in later passes (within the same getDataFromTree or getMarkupFromTree call), so that errors can be handled properly when using the errorPolicy: "all" option.

The walkTree function has been deprecated, since there's no way to make its behavior consistent with the latest versions of React. To save bundle size, walkTree is no longer exported from react-apollo, though you can still access it as follows:

  import { walkTree } from 'react-apollo/walkTree';

Invoke onCompleted/onError even if Mutation unmounts.

Update the typescript example app to use the raw Query component directly, with generics, to avoid generating the extra object that's created (in the compiled code) when extending the Query component as a class.

Use new ApolloClient#stop method to dispose of MockedProvider client instance.

The apollo-client peer dependency version constraint has been updated to require the latest version, 2.4.12. Although this update is recommended, and we believe it is backwards compatible with other [email protected] versions, we decided to bump the minor version of react-apollo (to 2.4.0) because of this new apollo-client version requirement.

Invoke onCompleted/onError even if Mutation unmounts.

Drop react 14.x support, since the 14.x release line is 2 years old now, and react-apollo is no longer tested against it.

Add react-dom as a peer dependency (since it's used by getDataFromTree and renderToStringWithData).

This package no longer imports react-dom/server unconditionally at the top level, making react-apollo safer to use in environments like React Native that are neither browser-like nor Node-like, and thus struggle to import react-dom/server and its dependencies. Additionally, the React Native bundler has been instructed to ignore all react-dom/server dependencies within react-apollo, so react-dom will not be bundled in React Native apps simply because they import react-apollo.

Restore original getDataFromTree(tree, context) API, and introduce a new alternative called getMarkupFromTree to enable custom rendering functions:

  export default function getDataFromTree(
    tree: React.ReactNode,
    context: { [key: string]: any } = {},
  ) {
    return getMarkupFromTree({
      tree,
      context,
      renderFunction: renderToStaticMarkup,
    });
  }

  export type GetMarkupFromTreeOptions = {
    tree: React.ReactNode;
    context?: { [key: string]: any };
    renderFunction?: typeof renderToStaticMarkup;
  };

  export function getMarkupFromTree({
    tree,
    context = {},
    renderFunction = renderToStaticMarkup,
  }: GetMarkupFromTreeOptions): Promise<string> {...}

Version 2.3.0 was published incorrectly, breaking nested react-apollo/... imports. This problem was fixed in version 2.3.1 by running npm publish from the lib/ directory, as intended.

Reimplement getDataFromTree using ReactDOM.renderToStaticMarkup to make asynchronous server-side rendering compatible with Although the rendering function used by getDataFromTree defaults to renderToStaticMarkup, any suitable rendering function can be passed as the optional second argument to getDataFromTree, which now returns a Promise<string> that resolves to The HTML rendered in the final pass, which means calling renderToString after getDataFromTree may not be necessary anymore.

Fix networkStatus to reflect the loading state correctly for partial refetching.

Make sure the TVariables generic is passed to ObservableQuery.

The Subscription component now accepts a fetchPolicy prop.

lodash.isequal was improperly set as a dev dependency for MockLink / MockedProvider. It is now a dependency.

Typings: added context to MutationOptions.

Typings: more MutationOptions changes/fixes.

Remove allowSyntheticDefaultImports use. Typescript's allowSyntheticDefaultImports compiler option is something we'd like to start using, but we jumped the gun a bit by introducing it in https://github.com/apollographql/react-apollo/commit/9a96519d390783dfd9a431dc2dbaa476a24f7b80. Including it means that anyone who wants to use Typescript with React Apollo would have to also include it in their own local tsconfig.json, to be able to handle default imports properly. This is because we're also using Typescript's es2015 module option, which means allowSyntheticDefaultImports has to be enabled explicitly. We've switched back to using a combination of import * as X and require syntax, to work with default imports. We'll re-introduce allowSyntheticDefaultImports use in React Apollo 3.

Replace the lodash dependency with lodash.flowright (since that's the only non-dev lodash function we're dependent on). Dev lodash dependencies have also been updated to use their individual module equivalent.

Removed rollup-plugin-babel-minify as it's no longer being used.

Small getDataFromTree.ts logic adjustment to avoid unnecessary calls when a falsy element is encountered.

graphql 14 updates.

All example apps (included in the repo) have been updated to work with the latest version of React Apollo.

Mutation errors are now properly returned as a render prop, when using a default errorPolicy of all.

<Mutation /> refetchQueries triggered by name (string) will now use the correct variables.

Fix lodash typings.

Added query, mutation, and subscription higher order components

Added prop-types validation to the <Query />, <Subscription /> and <ApolloConsumer /> component #1587

Added <Mutation /> component #1520

Added back in support for browser / main bundles #1578

add component name in unhandled error message #1362

Added notifyOnNetworkStatusChange to QueryOpts and MutationOpts Typesccript definitions #1034

Added variables types with Typescript #997

Address deprecation warnings coming from graphql-tag graphql-tag#54

Add apollo-client ^0.10.0 to dependency range

Add react-dom to peerDependencies because since React 15.4 it is no longer "secretly" included. (ref: https://github.com/facebook/react/releases/tag/v15.4.0)

bad build

Refactored and removed old graphql implementation in favor of new components

Removed QueryRecycler!! :yay:

Aded <Subscription /> to the public API

HoC props result-mapping function now receives prior return value as second argument.

Rollback importing non esm packages. Fixes the previous broken version #1621

Stricter type checking in the codebase. #1617

Beta release of all 2.1 features!

Resubscribe after error for Query #1580

Change package to produce ES2015 as module and commonjs for main #1576

Make Query component work with getDataFromTree by defining fetchData [#1579]

NEW FEATURES

• Added <Query /> component #1398
• Add <ApolloConsumer /> component #1399 #1484
• Added support for Preact when using getDataFromTree #1561

BREAKING CHANGES [Removal of deprecated code]

• Remove deprecated operationOptions.options.skip, use operationOptions.skip instead
• Remove deprecated options.updateQueries, use options.update instead #1485

BREAKING CHANGES [TypeScript and Flow only]

• typescript - graphql parameterized types streamlined for a) full typing; and b) ease of use; and c) consistency. New parameterized is: graphql<TProps,TData, TGraphQLVariables, TChildProps> where none are required and full typing only requires the first three params (TChildProps can be derived). #1402
• Rename type ProviderProps to ApolloProviderProps #1467
• Rename getDataFromTree type QueryResult to QueryTreeResult #1467
• Rename type QueryProps to GraphqlQueryControls #1467 #1478

Fixes and Improvements

• Fixed bug where link error prevents future requests
• Fixed stack traces on non chrome browsers #1568
• Fixed bug #1412 where the MockedProvider ignored variables when doing matching. This is potentially breaking because tests could break for which the variables don't match #1501
• Update all dependencies, scripts' usage, prettier and typescript setup #1402
• Tests are now linted and verified valid typescript #1402
• Typescript - updated types for consistency and potential to pass through all types e.g. TProps, TData, TGraphQLVariables #1402
• Typescript - added ChildDataProps and ChildMutateProps for optional stronger typed usage version of ChildProps #1402
• Typescript - fix graphql HOC inference #1402
• Made prettier solely responsible for formatting, removed all formatting linting rules from tslint #1452
• Convert Query.test to tsx and parameterize types for Query #1462
• Remove copied shallowEqual code and delegate to fbjs #1465
• Update rollup configurations, refine package exports #1467
• Removed unused gzip script #1468
• Minify umd and ensure umd name consistency #1469
• Converted test/test-utils/test-utils.test.js to test/test-utils.test.tsx #1475
• Updates to examples/typescript #1471
• Mutation test cleanup #1480
• Removed react-native from the test suite #1451
• Add client to Query's QueryResult #1488
• Disregard falsy elements when walking tree in SSR #1495
• Removed the key variables from the render prop result in the <Query /> #1497
• Added <Subscription /> component #1483
• Render callback should be typed with TData #1519

rolled back on the lodash-es changes from errors reported on slack

Use lodash-es to allow lodash functions to be used in ES modules #1344

turn back on flow checking

upgraded required apollo-client for bugfix for subscriptions

upgraded flow support to 0.59.0 :tada: #1354

skip null / undefined items on SSR if present #1355

Correctly provide the generic cache type to ApolloProvider #1319

Correctly initializes component state as null (not undefined) #1300

BREAKING: removed cleanupApolloState as it is no longer needed!

Exported getDataFromTree on the client

Removed redux from peer dependencies. Issue #1223 PR #1224

Support arrays being returned from render in SSR #1158

Support passing an updater function to setState in SSR mode #1263

upgrade to Apollo Client 2.0

remove direct dependencies on Apollo Client, graphql-tag

Made OptionProps.data's TResult partial #1231

upgrade to react-16

Made ChildProps.data non-optional #1143

MockNetworkInterface match mock requests regardless of variable order #973

Allow to pass removeTypenames to MockedProvider #1001

Support apollo-client 2.0

Replace string refs with callback refs #908

Feature: Add support for flow typecheck to work out of the box (without any configuration)

Feature: You can now supply a client in options object passed to the graphql high oder component. PR #729

Feature: Enhanced typescript definitions to allow for more valid type checking of graphql HOC PR #695

Feature: Flow types: PR #695

Feature: Support tree shaking and smaller (marginally) bundles via rollup PR #691

Perf: Removed unneeded usage of shouldComponentUpdate PR #661 inspired by PR #653

Perf: Removed unneeded usage of shouldComponentUpdate in Provider PR #669

Chore: remove unused immutable prop PR #539

Chore: Include React 16 alpha in dependency version range PR #647

Pass cached data to the child component along with the error. PR #548

Switch graphql-tag dependency to 2.0.0. This isn't really a breaking change because we only export gql from react-apollo.

Exposed createBatchingNetworkInterface from apollo-client so that it can be imported from react-apollo just like createNetworkInterface. PR #618

ApolloProvider now won't put its store on context unless it was given. PR #550

MockedProvider now accepts a store prop to be passed to ApolloProvider so that react-redux store is not overwritten

Make sure that all queries resolve or reject if an error was thrown when server side rendering. PR #488

ApolloProvider now changes its client and store when those props change. PR #479

Update dependency to Apollo Client 1.0.0-rc.1 PR #520

Make sure that the cached rendered element has the correct type before returning it. PR #505

Move constructor initializing of props to componentWillMount. PR #506 (Issue #509).

Make sure ApolloClient and gql are exported from browser bundle PR #501

Make apollo-client and graphql-tag dependencies and re-export them from this package PR #490

Print errors to console if they are not handled by component PR #476

Update Apollo Client to 0.9.0 and bump a lot of other dependencies PR #484

Remove @types/chai dev dependency which called a reference to the chai types in the production build. PR #471

Feature: [typescript] Add better typings to graphql HOC Issue #379

Update apollo-client peerDependency to 0.8.0 PR #438

Bug: Issue #404 fix issue with network errors thrown when changing variables.

Feature: Allow access to withApollo's wrapped instance thanks to {withRef: true} option Issue #331.

Feature: Add an alias option to the graphql function to allow customizing the display name of the wrapped component (Issue #354).

Chore: PR #403 move react-dom to be an optional dependency for better react-native builds.

Same as 0.8.0, but properly built

Update typings dependency from typed-grapqhl to @types/graphql PR #393

Chore: PR #390 gets rid of warning during queries test.

Chore: PR #391 gets rid of warnings during redux test.

Feature: PR #389 added a shouldResubscribe option to allow subscriptions to automatically resubscribe when props change.

Identical to 0.7.2 because 0.7.3 contained breaking change (updated typings)

Chore: PR #390 gets rid of warning during queries test.

Chore: PR #391 gets rid of warnings during redux test.

Feature: PR #389 added a shouldResubscribe option to allow subscriptions to automatically resubscribe when props change.

Bug: fix issue where changing variables while unskipping didn't result in the variables actually changing - Issue #374

Bug: fix issue with no longer passing errors to components w/ `[email protected]` - Issue #378

// old
import { getDataFromTree, renderToStringWithData } from 'react-apollo/server';

// new
import { getDataFromTree, renderToStringWithData } from 'react-apollo';

Feature: Better packaging PR #306

Feature: Add networkStatus prop to connected componentsIssue #322

Feature: Pass component display name as watchQuery metadata for experimental devtools PR #363

Feature: Removed use of createFragment and bumped AC version PR #357

Bug: fix issue with Redux's connect and SSR - Issue #350

// old -- we attempted to get the state out of your apollo provider for your
renderToStringWithData(component).then({ markup, initialState });

// new -- you must get it yourself
renderToStringWithData(component).then((markup) => {
  const initialState = client.store.getState()[client.reduxRootKey];

  // ...
});

This release refactors the server side rendering and data access code, hopefully making it easier to contribute to in the future and fixing a few bugs along the way:

Bug: Fix bug in SSR in React Production mode Issue #237

Bug: Fix issue fetching multiple levels of queries Issue #250

Bug: Fix issue with Stateless components in SSR Issue #297

Feature: Refactored to collect data in one place Issue 264

Feature: Added test utilities and examples to library.

Bug: Fix issue with usage in TypeScript projects caused by 'compose' re-export. PR #291

Bug: Fix issue with forceFetch during SSR PR #293

Full support for both Apollo Client 0.4.21 and 0.5.0. PR #277

Bug: Fix issue with SSR queries running twice when a mutation wraps a query #274

Bug: Fix issue with changing outer props and not changing variables, ultimately caused by https://github.com/apollostack/apollo-client/pull/694

Bug: Fix and test some subtle bugs around skipping and subscriptions. #260

Feature: Remove nested imports for apollo-client. Making local development eaiser. #234

Feature: Move types to dev deps #251

Feature: New method for skipping queries which bypasses HOC internals #253

Feature: Integrated subscriptions! #256

Feature: Refactor loading state managment to use apollo-client fully. Reduces library size by ~50% #211

Feature: Upgraded to typescript 2.0 #217

Feature: Allow usage of redux key or selector #226

Bug: Passing immutable to ApolloProvider breaks ssr. renderToStringWithData fails to reference the right store.

Bug: Fixed issue with context in SSR #218

Bug: Fixed lifecycle events for componentWillMount() on the server #205

Bug: Created better reference to updateQuery when bound early. It will also throw if called before it should be.

Bug: Fixed issue with updateQuery not being present during componentWillMount #203

Feature: Allow optional variables by passing null value on behalf of the variable #200

Feature: Added link to recompose to use the compose function. This makes it easy to combine multiple queries on a single component. #194

// old
renderToStringWithData(component).then(markup); // markup had a script tag

// new

renderToStringWithData(component).then({ markup, initialState }); // markup has not tag, and state is passed

Feature: Removed client as a prop and fixed warnings when not using ApolloProvider #189

Feature: Added updateQuery to data props

Bug: Fixed renderToStringWithData causing react warning #169

Bug: Fixed ssr fragment issue #178

Bug: Fixed loading state for skipped queries #190

Bug: Fixed loading state on remounted component with different variables

Bug: Fixed SSR issue with context #165

Bug: Fixed issue when context changes in parent container not going through to child; #162

Bug: Fixed loading state on remount of forceFetch operations; #161

Bug: Fixed issue with variable merging after fetchMore #150

Feature: Allow options value to be an object instead of a method. #144

Bug: Fixed issue with missing methods on initial props #142

Bug: Fixed oddity with multi nested enhancers on SSR #141

Bug: Fixed issue with variable merging #139

Feature: Support a different store in the tree that is immutable (support immutable redux) #137

Bug: Fixed refetch methods when no result is returned

BREAKING Feature: Brand new API! See the docs for more information;

Bug: Fixed loading state on refetch more when data doesn't change

Feature: added fetchMore #123

Bug: Retain compatibility with version 0.3.0 of Apollo Client via a backcompat shim. #109

Feature: Support 0.4.0 of Apollo Client, and pass through new mutation options #105 #106

Bug: Fixed but where SSR wouldn't get calculated props from redux actions #103

Feature: integrated SSR #83

Feature: added ability to hoist statics on components #99

Bug: Don't strip data away from the component when the query errors #98

Bug: Fixed issue where react native would error on aggressive cloneing of client

Feature: pass through all methods on apollo client

Bug: fixed issue causing errors to be passed to apollo-client #89

Bug: fixed overrendering of components on redux state changes

Bug: fixed bug where SSR would fail due to later updates. This should also prevent unmounted components from throwing errors.

Feature: provide add watchQuery to components via connect

Bug: Don't use old props on store change change

Bug: Reset loading state when a refetched query has returned

Bug: Loading state is no longer true on uncalled mutations.

Return promise from the refetch method

Bug: Fix bug where state / props weren't accurate when executing mutations.

• Improvement: Increase performance by limiting re-renders and re-execution of queries. Chore: Split tests to make them easier to maintain.

Feature: add startPolling and stopPolling to the prop object for queries

Bug: Fix bug where full options were not being passed to watchQuery

Feature: Support 0.3.0 of apollo-client

Feature: Change Provider export to be ApolloProvider and use Provider from react-redux

Feature: Support 0.1.0 and 0.2.0 of apollo-client

Breaking change:

Feature: Remove result key in favor of dynamic key matching root fields of the query or mutation. (https://github.com/apollostack/react-apollo/pull/31)

{
  loading: false,
  result: {
    posts: []
  }
}

becomes

{
  loading: false,
  posts: []
}

Bug: Get state directly from redux store internally

Bug: Fix bug with willReceiveProps

Bug: - Adjust loading lifecycle marker to better match the behavior of apollo-client #11

Feature: - Update to support new observable API from apollo-client #9

Initial release. Brings in support for binding GraphQL data to components easily as well as perform mutations.

We didn't track changes before this version.

Improved TS types (even more) in both Query component and graphql HoC. #1617

Improved TypeScript types of Query Component #1581

Improvement: Allow for better typescript usage with improved types #862

Improvement: Reduce re-renders by using forceUpdate instead of setState({ }) PR #775

Improvement: Refactor dataForChild to use bound function to reduce rerenders PR #772

Improvement: don't set the loading state to false if forceFetch is true

Fix errorPolicy when 'all' not passing data and errors

Fix bundles and run test suite on all shippable code

Fix React Component detection bug in getDataFromTree #1604

fix skip on component update #1330

fix skip on component update.

Fix: ensure client option can be used with mutation query #1145

fix shallowEqual bug.

Fix: handle calling refetch in child componentDidMount

Fix: ensure options gets up to date props #1025

Fix: ensure queryRecycler exists before using it

Fix: Scope query recyclers by client #876

Fix: fix issue with bad deploy

Fix: fix UMD bundle pointing to apolloClient for some reason

Fix: fix matching types with exports for flow and ts

Fix: Ensure typescript and flow type definitions match in name

Fix: Fix issue where withRef-option of graphql did not work when the query was skipped #865

Fix: export all types from main type file

Fix: Fix issue around hoisting non react statics for RN #859

Fix: Fix issue where options was called even though skip was present #859

Fix: Fix issue when using flow definitions PR# 787

Fix: Add in missing types for MutationOpts PR #770

Fix: Fix component reference and variable statement for flow types

Fix: Fix compilation of test-utils from move to ES bundles

Fix: Fix bug with sync re-renders and recyled queries PR #740

Fix: Render full markup on the server when using the cache-and-network fetchPolicy PR #688

Fix: Use standby fetchPolicy for recycled queries PR #671

Fix: Re-export all Apollo Client exports from react-apollo PR #650

Fix: move prop-types from devDependencies to dependencies PR #656

Fix version lock down for peer dependency version of React. PR #626

Fix: convert deprecated React.PropTypes to PropTypes provided by the prop-types package. PR #628

Fix: Make sure recycled queries are in cache only mode so they do not trigger network requests. PR #531

Fix bug where options was mutated causing variables to not update appropriately. PR #537

Fix updateQueries not running for queries attached to unmounted components. PR #462

Fix wrong invariant sanity checks for GraphQL document PR #457