Apollo duplicates first result to every node in array of edges

Put this in your App.js

cache: new InMemoryCache({
    dataIdFromObject: o => o.id ? `${o.__typename}-${o.id}` : `${o.__typename}-${o.cursor}`,
  })

I believe the approach in other two answers should be avoided in favor of following approach:

Actually it is quite simple. To understand how it works simply log obj as follows:

dataIdFromObject: (obj) => {
   let id = defaultDataIdFromObject(obj);
   console.log('defaultDataIdFromObject OBJ ID', obj, id);
}

You will see that id will be null in your logs if you have this problem.

Pay attention to logged 'obj'. It will be printed for every object returned.

These objects are the ones from which Apollo tries to get unique id ( you have to tell to Apollo which field in your object is unique for each object in your array of 'items' returned from GraphQL - the same way you pass unique value for 'key' in React when you use 'map' or other iterations when rendering DOM elements).

From Apollo dox:

By default, InMemoryCache will attempt to use the commonly found primary keys of id and _id for the unique identifier if they exist along with __typename on an object.

So look at logged 'obj' used by 'defaultDataIdFromObject ' - if you don't see 'id' or '_id' then you should provide the field in your object that is unique for each object.

I changed example from Apollo dox to cover three cases when you may have provided incorrect identifiers - it is for cases when you have more than one GraphQL types:

dataIdFromObject: (obj) => {
   let id = defaultDataIdFromObject(obj);
   console.log('defaultDataIdFromObject OBJ ID', obj, id);

   if (!id) {
     const { __typename: typename } = obj;
     switch (typename) {
       case 'Blog': {
      // if you are using other than 'id' and '_id' - 'blogId' in this case
         const undef = `${typename}:${obj.id}`;
         const defined = `${typename}:${obj.blogId}`;
         console.log('in Blogs -', undef, defined);
         return `${typename}:${obj.blogId}`; // return 'blogId' as it is a unique
     //identifier. Using any other identifier will lead to above defined problem.
       }
       case 'Post': {
       // if you are using hash key and sort key then hash key is not unique.
       // If you do query in DB it will always be the same.
       // If you do scan in DB quite often it will be the same value. 
       // So use both hash key and sort key instead to avoid the problem.
       // Using both ensures ID used by Apollo is always unique.
       // If for post you are using hashKey of blogID and sortKey of postId
          const notUniq = `${typename}:${obj.blogId}`;
          const notUniq2 = `${typename}:${obj.postId}`;
          const uniq = `${typename}:${obj.blogId}${obj.postId}`;
          console.log('in Post -',  notUniq, notUniq2, uniq);
          return `${typename}:${obj.blogId}${obj.postId}`;
       }
       case 'Comment': {
         // lets assume 'comment's identifier is 'id'
         // but you dont use it in your app and do not fetch from GraphQl, that is
         // you omitted 'id' in your GraphQL query definition.
         const undefnd = `${typename}:${obj.id}`;
         console.log('in Comment -', undefnd);  
         // log result - null
         // to fix it simply add 'id' in your GraphQL definition.
         return `${typename}:${obj.id}`;
       }
       default: {
         console.log('one falling to default-not good-define this in separate Case', ${typename});
         return id;
       }

I hope now you see that the approach in other two answers are risky.

YOU ALWAYS HAVE UNIQUE IDENTIFIER. SIMPLY HELP APOLLO BY LETTING KNOW WHICH FIELD IN OBJECT IT IS. If it is not fetched by adding in query definition add it.

The reason this happens is because the items in your array get "normalized" to the same values in the Apollo cache. AKA, they look the same to Apollo. This usually happens because they share the same Symbol(id).

If you print out your Apollo response object, you'll notice that each of the objects have Symbol(id) which is used by Apollo cache. Your array items probably have the same Symbol(id) which causes them to repeat. Why does this happen?

By default, Apollo cache runs this function for normalization.

export function defaultDataIdFromObject(result: any): string | null {
  if (result.__typename) {
    if (result.id !== undefined) {
      return `${result.__typename}:${result.id}`;
    }
    if (result._id !== undefined) {
      return `${result.__typename}:${result._id}`;
    }
  }
  return null;
}

Your array item properties cause multiple items to return the same data id. In my case, multiple items had _id = null which caused all of these items to be repeated. When this function returns null the docs say

InMemoryCache will fall back to the path to the object in the query, such as ROOT_QUERY.allPeople.0 for the first record returned on the allPeople root query.

This is the behavior we actually want when our array items don't work well with defaultDataIdFromObject.

Therefore the solution is to manually configure these unique identifiers with the dataIdFromObject option passed to the InMemoryCache constructor within your ApolloClient. The following worked for me as all my objects use _id and had __typename.

const client = new ApolloClient({
  link: authLink.concat(httpLink),
  cache: new InMemoryCache({
    dataIdFromObject: o => (o._id ? `${o.__typename}:${o._id}`: null),
  })
});