A modern programming language that makes developers happier.

kotlinlang

I'm missing the cache with queries where arguments are provided in nested fields, not in the top level query. :thread:

`Object 'UserCardsPayload:{field=CreatedAt, order=Desc}' not found`

```type Query {
    user: User
}

type User {
    cards(afterId: UUID, language: String, limit: Int, search: String, sortBy: CardSortingInput): UserCardsPayload!
    decks(afterId: UUID, limit: Int, sortBy: DeckSortingInput, tags: [String!], title: String): UserDecksPayload!
}

type UserCardsPayload {
    cards: [Card!]
    errors: [AccessError!]!
    hasNext: Boolean!
}

type UserDecksPayload {
    decks: [Deck!]
    errors: [AccessError!]!
    hasNext: Boolean!
}```
```query Collection {
    user {
        decks {
            decks {
                ...DeckItem
            }
            hasNext
        }
        cards(sortBy: {field: CreatedAt, order: Desc}) {
            cards {
                ...CardItem
            }
            hasNext
        }
    }
}```
```extend type User @fieldPolicy(forField: "decks", keyArgs: "afterId sortBy tags title")
extend type User @fieldPolicy(forField: "cards", keyArgs: "afterId sortBy search language")

extend type Deck @typePolicy(keyFields: "id")
extend type Card @typePolicy(keyFields: "id")
extend type User @typePolicy(keyFields: "id")```

so, `user.decks`  works and would get retrieved from the cache but `user.cards(sortBy: {...})`  cannot be found with the log on top

image.png

I'm also a bit confused by `Object 'UserCardsPayload:{field=CreatedAt, order=Desc}' not found`  since it's supposed to be a fieldPolicy to `user.cards` , is it trying to find the payload class as if there was a typePolicy set or is this just what the logs look like?

You need a typePolicy on `UserCardsPayload` that matches the fieldPolicy for user.cards (of type `UserCardsPayload`) - otherwise the generated cache ids will be different when writing to vs when reading from the cache, which results in the cache miss.
But in your case, you can't really do that, since the arguments have no equivalents in the return's type fields.

You should probably remove these fieldPolicies and the default cache id (uses the path) will be used.

yeah that's what mainly confused me. Omitting the policies seems to indeed work, thanks

btw what's the use behind `paginationArgs`  for fieldPolicies? it says they're omitted for computing the cache key?

yes exactly - This is an experimental feature. The implementation used to live on the main repo but now its development happens on the <https://github.com/apollographql/apollo-kotlin-normalized-cache-incubating|incubating cache> repo. More info <https://apollographql.github.io/apollo-kotlin-normalized-cache-incubating/pagination.html|here> - if you want to experiment with it, feedback is welcome!

Looks great! And seems to also work in my case with
```extend type User @fieldPolicy(forField: "cards", paginationArgs: "afterId")```


Cool :slightly_smiling_face:  Warning though, if you only do this, each new page will override the previous one in the cache, which is not really what you want. You'll probably need to implement the whole thing (either manually with `ApolloStore` or with the incubating lib)

yes yes, I just wanted to test if I can even add a fieldpolicy due to the above issue

however, is it supposed to just always do a network call when including paging arguments and cache first without? currently it seems to always retrieve from cache, no matter the afterId arg

yeah that's expected, afterId is ignored, so the list is found in the cache

so I'm supposed to set a NetworkFirst fetch policy for paging queries?

If you want the app to refresh the list, yes you can do that