[Modern] Client schema docs and examples

[ivosabev]

Any idea when docs and examples would be available?

Client Schema Extensions
The Relay Modern Core adds support for client schema extensions. These allow Relay to conveniently store some extra information with data fetched from the server and be rendered like any other field fetched from the server. This should be able to replace some use cases that previously required a Flux/Redux store on the side.

https://facebook.github.io/relay/docs/new-in-relay-modern.html#client-schema-extensions

[leethree]

👍 I was trying to find any reference to how to do "client schema extensions" but failed.

[mjmahone]

My suspicion is it'll happen in an example in RelayExamples before hitting official documentation here. I don't have a timeline, but that's your best bet for taking advantage of this feature. It already works (at least, it works on my machine :)), and you can find references to it via things like the RelayFilterDirectivesTransform, but getting this to work outside the FB environment hasn't yet happened.

[abhishiv]

I would like to know more about this to as well.

This is what I figured out till now

1. extendSchema function to extend schema. Also it's interesting to note that transformers are using this function.

2. From the tests it looks like lookup, and commitPayload can be used to read and save data.

Am I missing anything else?

[josephsavona]

I tried documenting this the other day and realized that there is an issue with the OSS compiler that prevents schema extensions from being defined. Once this is fixed we can document this feature.

Cc @kassens

[josephsavona]

@unirey The idea is that you can do something like this:

// client-schema.graphql
extend type SomeType {
  client: String
}

// compile script:
relay-compiler --schema schema.graphql --client-schema client-schema.graphql ...

// container fragment
graphql`
  fragment on SomeType {
    client
  }
`

// mutation updater
function updater(store) {
  const someValue = store.get(idOfValueOfSomeType);
  someValue.setValue("Foo", "client");  // value, field name
}

The missing part is that the oss compiler binary doesn't expose a way to tell the compiler about the client schema - all the primitives exist in the compiler to support client fields, and the runtime supports them as regular fields.

The client schema can also define new types: you can do

extend type Foo { field: NewType} 
type NewType { ... }

[fsenart]

Hi there
Please, do you have any news and/or roadmap about this compiler feature?

[chadfurman]

FYI anyone new to react / relay looking for a temporary workaround, a "dirty" solution as suggested in #1787 is to use context at the application root

[chadfurman]

@josephsavona In terms of changes, we're looking at :

https://github.com/facebook/relay/blob/master/packages/relay-compiler/generic/core/RelayCompiler.js#L52

class RelayCompiler {
  _context: RelayCompilerContext;
  _schema: GraphQLSchema;
  _transformedQueryContext: ?RelayCompilerContext;
  _transforms: CompilerTransforms;

  // The context passed in must already have any Relay-specific schema extensions
  constructor(
    schema: GraphQLSchema,
    context: RelayCompilerContext,
    transforms: CompilerTransforms,
  ) {
    this._context = context;
    // some transforms depend on this being the original schema,
    // not the transformed schema/context's schema
    this._schema = schema;
    this._transforms = transforms;
  }

We currently only have schema and context so we'll have to add in clientSchema and clientContext yes? Then manage these separately? Or do we have to have to merge the two schemas?

[josephsavona]

@chadfurman The compiler is configured to treat this._schema as the canonical server schema, while this._context has its own copy of the schema that may include client extensions. So I think what we probably want is to add an optional clientSchema: string constructor argument. Each time the context is rebuilt, do a final pass to parse the client schema and extend the this._context's schema. Something like these lines to parse the client schema text into definitions and add them to context. Maybe do this here (or similar), ie constructing a fresh context just before actually running it through all the transforms.

[adjourn]

@josephsavona Im trying to follow the discussion. Are the steps you mentioned only ones left?

The missing part is that the oss compiler binary doesn't expose a way to tell the compiler about the client schema [...]

This is still missing? I don't even know what oss compiler binary exactly stands for or where to look.

[chadfurman]

@adjourn I'd guess this is the OSS compiler: https://github.com/facebook/relay/tree/master/packages/relay-compiler

[austinamorusotraceme]

This would be a super helpful feature.