`@urql/exchange-suspense` -> `@urql/exchange-graphcache`

This should never happen but I figured given the
changes in write we should at least have a case
for this.

* Add failing test for writing nested root fields

There are several fields in mutations that may not
have keys. Since the root type (Mutation / Subscription)
won't have keys, when the next entity down doesn't
have a key either, they're dangling and are ignored.

* Write nested keyless entities in write

* (docs) - add links and explanations to README

* (docs) - add explanations for keys, resolvers and updates

* (docs) - add optimistic and correct some wording in resolvers and updates

* (fix) - default options and pass keys

* (fix) - bump urql peer dependency to 1.3.0 since we need the formatDocument export

* (fix) - change exchangeOptions to an optional argument

* Add configs for custom key generation

* Add short API note to README

* Add simple exchange tests

* Fix mock implementation for reexecuteOperation

* Add simple heuristic fragment matching

* Move fragment matching into separate function

* Readd getOperationName helper

* Add helpers in exchange to detect mutations

* Implement writeOptimistic in write operation

Left lottttts of TODOs

* Add internal store state

* Integrate global state into query and write

* Run optimistic updates in exchange

* Add processDependencies to optimisticUpdate

* Remove setting data to null for empty query results

This shouldn't be necessary.
The exchange should always decide whether to use
a result or not based on the completeness

* (fix) - write with addTodo as a rootField

* (tests) - add optimisticWrite and dep tests

* (refactor) - clean up fix

* (chore) - add explanatory comment

* (tests) - allow for dependency testing

* (refactor) - use the right fix

* (tests) - test store.clearOptimistic

* Allow resolver to return Links or Data

* Copy over extra fields from resolver result

* Fix input type for resolveResolverResult

* Remove Entity type and refactor

* Remove GC implementation

* Delete Store.serialize method and adjust tests

* Replace record/link stores with pessimism Map

* (feat) - implement basic resolve function

* (feat) - allow passing of key to resolve

* (chore) - add test and make size optimisation

* (chore) - remove initial from the exchangeOptions for now. We won't  serialize our new HAMT structure for the MVP

* (docs) - getting started

* (docs) - write about architecture

* (tests) - add a way to test the updateQuery method on our store

* (feat) - allow for mutationUpdates on the store and introduce the updateQuery method

* (feat) - add mutationUpdates to store

* (tests) - make test for when store has mutationUpdates

* (feat) - make our write operation aware of possible mutationUpdates

* (fix) - prettier formatted and ts-ignore dissapeared

* (types) - make data any for now

* (refactor) - apply comments received from kitten

* (tests) - test for store.writeFragment

* (feat) - implement a basic POC for writeFragment

* (chore) - remove the return, this was meant to stop the linter from nagging

* (chore) - correct types

* (chore) - add some basic error handling

* (refactor) - handle pr feedback | switch out loop for just taking the first element and error merge

* (fix) - switch arguments for writeSelection

* (refactor) - abstract out shared field data derivation

* (refactor) - improve readability by streamlining arguments order

* (undo) - abstraction of getting field data

* (docs) - add meaningfull comments to query

* (chore) - correct failing test

* (chore) - add replacePlugin -60B

* (chore) - avoid implicit return and needless var creation -10B

* Replace null fields for links with undefined

On entities we previously treated null fieldValues
as both a possible scalar or a hint that links should
be checked.

Instead we can use the undefined field and rely
on the presence of a selectionSet to see whether
a link should be read.

The field still needs to be set to undefined
however, so that the GC operation can walk
all entities.

We also have a special case for "invalid"
entities, which is a special case just in case
something goes very wrong.

* Update resolveProperty to use undefined hint

* (types) - add resolver info type

* (feat) - allow addition of resolvers to store and exchange

* (tests) - add initial test for queryResolvers

* (feat) - implement queryResolvers in the query functions

* (types) - initial typing of our info param

* (tests) - add test for the Store.resolveX methods

* (types) - adjust the Resolve types since we are not using a dedicated cache but the instance of our store

* (feat) - make a POC implementation for the resolve methods

* (feat) - make cacheResolvers affect our entity resolving

* (tests) - add test for nested and normal entity level query resolvers

* (feat) - enable nested entity level access with queryResolvers

* (feat) - resolving links

* (tests) - add correct assertion

* (chore) - move to an explicit if else since prettier messes up the @ts-ignore

* (chore) - add todo and update types

* Add selection and scalar support to field resolver

* Handle Store.resolveProperty edge cases

* Simplify GraphQLResolveInfo

* Rename GraphQLResolveInfo to ResolveInfo

* (types) - remove null from ResolverResult since this is inherited from Scalar.Primitive

* (chore) - remove processSchema file

* Refactor types

* Clean up ast helpers

* Remove getOperationType

* (refactor) - start types refactor inside /operations

* Move forEachFieldNode to ast helpers

* Refactor operations types

* Fix Store types

* Fix OperationRequest type to match urql's type

* (refactor) - implement types in our operations

* (tests) - update tests

* (chore) - update types on exchange and write

* (fix) - fix types in the exchange

* (chore) - transfor Array[] to Set {} in snapshots

* (chore) - add Set test assertion

* (chore) - dedup arguments that were double to not-using a Set

* (fix) - assert correct types and fix __typename not passed in tests

* Prevent prototype pollution on ast/variables helpers

* Remove unused types
Co-authored-by: Jovi De Croock <decroockjovi@gmail.com>