Issue: require all exposed fields to be annotated with `@loadable`

[rbalicki2]

If you choose to take this task on, we should hop on a call to hammer out all the details. It seems like a lot of work, but in practice it's not — as long as you know where to make the changes. (Hence the need for a call.)

The impact of this is high, it merges an unnecessary building block (refetch/exposed mutation fields) into another abstraction: @loadable fields (which is the one we want to go with in the long term)

This is a relatively thin outline:

Background

loadable fields

• If a client field selects selects a client field (e.g. UserDetail selects full_name), the initial parameter to UserDetail will include the result of calling full_name (or a renderable react component, if it was an @component client field.)
• You can add @loadable to any client field. (Ideally, we would allow that on any field eventually!)
• If you selected full_name @loadable, you would instead receive something that contains a function that, when called, will make a network request for the data needed by full_name. This returns a fragment reference, which you can pass to useResult to get the value back (or suspend, if the query is in flight.)

__refetch and re-exposed fields

• Re-exposed fields (see schema-extension.graphql) and __refetch fields are similar, in that they're almost like fields that are always selected loadably. But, that function that makes the network request returns void instead of a FragmentReference.
• Specifically, their type is (/* refetch has no param, the other one does */) => [string, () => void], whereas a LoadableField is (argsOrVoid) => [string, () => FragmentReference<ReadOutType>]

Steps

There are (at least!) four main tasks here, all of which should happen in separate PRs. 1-3 will land as a single commit, 4 can land separately:

Step 1: Enforce @loadable

The compiler should emit an error if we don't select the __refetch and exposed mutation fields loadably.

This is a pure Rust change.

Step 2: modify the generated types

• Adding @loadable to __refetch in PetUpdated results in __refetch: LoadableField<void, Pet____refetch__output_type>, in isograph/demos/pet-demo/src/components/__isograph/Pet/PetUpdater/param_type.ts. This behavior is correct!
• However, we need to change export type Pet____refetch__output_type = () => [string, () => void]; to be export type Pet____refetch__output_type = void in isograph/demos/pet-demo/src/components/isograph/Pet/refetch/output_type.ts.
• This should be relatively easy, the hard part is finding out where to change the file.

Step 3: Implementation of the refetch field

Right now, the __refetch field's inner function returns void. It should return a FragmentReference<void>.

Refetch fields and exposed mutation fields (at least for now) have nothing that you actually want to read as a result of calling them. But, you might want to suspend if the network request is in flight, get a loading indicator, etc. and the mechanism for that is to return a FragmentReference

Step 4: Unify some APIs

useImperativeExposedMutationField is now useless, and it can be replaced with useImperativeLoadableField! Woohoo!

The user can also call useClientSideDefer with refetch fields (maybe we should lint against that, that's likely to be a mistake?) and with mutations (which does make sense!)

[byhlel]

/assign :)

[rbalicki2]

... comment moved to description ...

[byhlel]

Okay I'm down to try, would I encounter difficulties or be unavailable to continue working on the issue I'll make sure to keep you updated! Looking forward to contributing though!