relay-runtime 20.1.1 → 21.0.1

package/llm-docs/api-reference/relay-runtime/commit-mutation.mdx

@@ -0,0 +1,65 @@
+---
+id: commit-mutation
+title: commitMutation
+slug: /api-reference/commit-mutation/
+description: API reference for commitMutation, which imperatively executes a mutation
+keywords:
+  - mutation
+---
+
+import DocsRating from '@site/src/core/DocsRating';
+import {OssOnly, FbInternalOnly} from 'docusaurus-plugin-internaldocs-fb/internal';
+import MutationConfig from '../types/MutationConfig.mdx';
+import Disposable from '../types/Disposable.mdx';
+
+## `commitMutation`
+
+Imperatively execute a mutation.
+
+See also the [`useMutation`](../use-mutation/) API and [Guide to Updating Data](../../guided-tour/updating-data/introduction.mdx).
+
+```js
+import type {FeedbackLikeMutation} from 'FeedbackLikeMutation.graphql';
+const React = require('React');
+
+const {graphql, commitMutation} = require('react-relay');
+
+function likeFeedback(environment: IEnvironment): Disposable {
+  return commitMutation<FeedbackLikeMutation>(environment, {
+    mutation: graphql`
+      mutation FeedbackLikeMutation($input: FeedbackLikeData!) {
+        feedback_like(data: $input) {
+          feedback {
+            id
+            viewer_does_like
+            like_count
+          }
+        }
+      }
+    `,
+    variables: {
+      input: {
+        id: '123',
+      },
+    },
+  });
+}
+```
+
+### Arguments
+
+* `environment`: `IEnvironment`. A Relay environment.
+* `config`: [`MutationConfig<TMutation>`](#type-mutationconfigtmutationconfig-mutationparameters).
+
+<MutationConfig />
+
+
+### Return Value
+
+* A [`Disposable`](#interface-disposable) which:
+  * If called before the request completes, will cancel and revert any optimistic updates and prevent the `onComplete` and `onError` callbacks from being executed. It will not necessarily cancel any network request. Will cause the `onUnsubscribe` callback to be called.
+  * If called after the initial request completes, will do nothing.
+
+<Disposable />
+
+<DocsRating />

package/llm-docs/api-reference/relay-runtime/fetch-query.mdx

@@ -0,0 +1,118 @@
+---
+id: fetch-query
+title: fetchQuery
+slug: /api-reference/fetch-query/
+description: API reference for fetchQuery, which imperatively fetches data for a query and returns an observable
+keywords:
+  - observable
+  - query
+  - fetch
+---
+
+import DocsRating from '@site/src/core/DocsRating';
+import {OssOnly, FbInternalOnly} from 'docusaurus-plugin-internaldocs-fb/internal';
+
+## `fetchQuery`
+
+If you want to fetch a query outside of React, you can use the `fetchQuery` function from `react-relay`:
+
+```js
+// You should prefer passing an environment that was returned from useRelayEnvironment()
+const MyEnvironment = require('MyEnvironment');
+const {fetchQuery} = require('react-relay');
+
+fetchQuery(
+  environment,
+  graphql`
+    query AppQuery($id: ID!) {
+      user(id: $id) {
+        name
+      }
+    }
+  `,
+  {id: 4},
+)
+.subscribe({
+  start: () => {...},
+  complete: () => {...},
+  error: (error) => {...},
+  next: (data) => {...}
+});
+```
+
+### Arguments
+
+* `environment`: A Relay Environment instance to execute the request on. If you're starting this request somewhere within a React component, you probably want to use the environment you obtain from using [`useRelayEnvironment`](../use-relay-environment/).
+* `query`: GraphQL query to fetch, specified using a `graphql` template literal.
+* `variables`: Object containing the variable values to fetch the query. These variables need to match GraphQL variables declared inside the query.
+* `options`: *_[Optional]_* options object
+    * `networkCacheConfig`: *_[Optional]_ *Object containing cache config options
+        * `force`: Boolean value. If true, will bypass the network response cache. Defaults to true.
+    * `fetchPolicy`: *_[Optional]_* Determines whether `fetchQuery` should reuse data that is already available in the local Relay store. Must be one of the following values:
+        * `"network-only"`: *(default)* Always issue a network request, regardless of what is in the store.
+        * `"store-or-network"`: Reuse data from the store if the full query is available locally; otherwise, issue a network request.
+
+        The `"store-and-network"` and `"store-only"` fetch policies are **not supported** by `fetchQuery`, because it is designed around issuing a single network request and returning the response.
+
+### Flow Type Parameters
+
+* `TQuery`: Type parameter that should correspond to the Flow type for the specified query. This type is available to import from the the auto-generated file: `<query_name>.graphql.js`. It will ensure that the type of the data provided by the observable matches the shape of the query, and enforces that the `variables` passed as input to `fetchQuery` match the type of the variables expected by the query.
+
+### Return Value
+
+* `observable`: Returns an observable instance. To start the request, `subscribe` or `toPromise` must be called on the observable. Exposes the following methods:
+    * `subscribe`: Function that can be called to subscribe to the observable for the network request. Keep in mind that this subscribes you only to the fetching of the query, not to any subsequent changes to the data within the Relay Store.
+        * Arguments:
+            * `observer`: Object that specifies observer functions for different events occurring on the network request observable. May specify the following event handlers as keys in the observer object:
+                * `start`: Function that will be called when the network requests starts. It will receive a single `subscription` argument, which represents the subscription on the network observable.
+                * `complete`: Function that will be called if and when the network request completes successfully.
+                * `next`: Function that will be called every time a payload is received from the network. It will receive a single `data` argument, which represents a snapshot of the query data read from the Relay store at the moment a payload was received from the server.
+                * `error`:  Function that will be called if an error occurs during the network request. It will receive a single `error` argument, containing the error that occurred.
+                * `unsubscribe`: Function that will be called whenever the subscription is unsubscribed. It will receive a single `subscription` argument, which represents the subscription on the network observable.
+        * Return Value:
+            * `subscription`: Object representing a subscription to the observable. Calling `subscription.unsubscribe()` will cancel the network request.
+    * `toPromise`:
+        * Return Value:
+            * `promise`: Returns a promise that will resolve when the first network response is received from the server. If the request fails, the promise will reject. Cannot be cancelled.
+
+<FbInternalOnly>
+
+:::info
+The `next` function may be called multiple times when using Relay's [Incremental Data Delivery](../../guides/incremental-data-delivery/) capabilities to receive multiple payloads from the server.
+:::
+
+</FbInternalOnly>
+
+### Behavior
+
+* `fetchQuery` will automatically save the fetched data to the in-memory Relay store, and notify any components subscribed to the relevant data.
+* `fetchQuery` will **NOT** retain the data for the query, meaning that it is not guaranteed that the data will remain saved in the Relay store at any point after the request completes. If you wish to make sure that the data is retained outside of the scope of the request, you need to call `environment.retain()` directly on the query to ensure it doesn't get deleted. See our section on [Controlling Relay's GC Policy](../../guided-tour/reusing-cached-data/presence-of-data) for more details.
+* `fetchQuery` will automatically de-dupe identical network requests (same query and variables) that are in flight at the same time, and that were initiated with `fetchQuery`.
+
+
+### Behavior with `.toPromise()`
+
+If desired, you can convert the request into a Promise using `**.toPromise()**`. Note that toPromise will start the query and return a Promise that will resolve when the *first* piece of data returns from the server and *cancel further processing*. That means any deferred or 3D data in the query may not be processed. **We generally recommend against using toPromise() for this reason.**
+
+```js
+const {fetchQuery} = require('react-relay');
+
+fetchQuery(
+  environment,
+  graphql`
+    query AppQuery($id: ID!) {
+      user(id: $id) {
+        name
+      }
+    }
+  `,
+  {id: 4},
+)
+.toPromise() // NOTE: don't use, this can cause data to be missing!
+.then(data => {...})
+.catch(error => {...};
+```
+
+* `toPromise` Returns a promise that will resolve when the first network response is received from the server. If the request fails, the promise will reject. Cannot be cancelled.
+
+<DocsRating />

package/llm-docs/api-reference/relay-runtime/field-logger.mdx

@@ -0,0 +1,170 @@
+---
+id: field-logger
+title: relayFieldLogger
+slug: /api-reference/field-logger/
+description: API reference for the `relayFieldLogger` Environment config option
+keywords:
+  - environment
+  - logging
+  - error
+---
+
+Relay includes a number of features that allow for granular handling of field errors:
+
+- [`@required`](../../guides/required-directive.mdx) provides declarative handling of field nullability
+- [`@catch`](../../guides/catch-directive.mdx) allows you to explicitly handle field errors
+- [`@throwOnFieldError`](../../guides/throw-on-field-error-directive.mdx) lets you treat field errors as exceptions
+- [Relay Resolvers](../../guides/relay-resolvers/introduction.mdx) coerce thrown exceptions to null, matching the GraphQL spec
+
+In each of these cases, field errors are handled by Relay. However, it can still be important to track that these errors are occurring in your app, and monitor or resolve them. To enable this, the Relay Environment can be configured with a `relayFieldLogger`. This logger is a function which is called with events each time Relay handles a field-level error.
+
+Providing a field logger looks something like this:
+```ts
+import {Environment} from "relay-runtime";
+
+const environment = new Environment({
+    relayFieldLogger: (event) => {
+        switch(event.kind) {
+            case "missing_expected_data.log":
+                // ...
+                break;
+            // ... handle other events
+        }
+    },
+    network: // ...
+    store: // ...
+});
+```
+
+## Event Types
+
+The Field Logger currently can receive the following events:
+
+## Missing Expected Data Log
+
+Data which Relay expected to be in the store (because it was requested by the parent query/mutation/subscription) was missing. This can happen due to graph relationship changes observed by other queries/mutations, or imperative updates that don't provide all needed data.
+
+See [Graph Relationship Changes](../../debugging/why-null/#graph-relationship-change).
+
+In this case Relay will render with the referenced field as `undefined`.
+
+:::note
+This may break with the type contract of Relay's generated types.
+:::
+
+To turn this into a hard error for a given fragment/query, you can use [`@throwOnFieldError`](../../guides/throw-on-field-error-directive/)
+
+```ts
+export type MissingExpectedDataLogEvent = {
+  +kind: 'missing_expected_data.log',
+  +owner: string,
+  +fieldPath: string,
+};
+```
+
+## Missing Expected Data Throw
+
+Data which Relay expected to be in the store (because it was requested by the parent query/mutation/subscription) was missing. This can happen due to graph relationship changes observed by other queries/mutations, or imperative updates that don't provide all needed data.
+
+See [Graph Relationship Changes](../../debugging/why-null/#graph-relationship-change).
+
+
+This event is called `.throw` because the missing data was encountered in a
+ query/fragment/mutation with [`@throwOnFieldError`](../../guides/throw-on-field-error-directive/)
+
+Relay will throw immediately after logging this event. If you wish to
+customize the error being thrown, you may throw your own error.
+
+:::note
+Only throw on this event if `handled` is false. Errors that have been handled by a `@catch` directive or by making a resolver null will have `handled: true` and should not trigger a throw.
+:::
+
+```ts
+export type MissingExpectedDataThrowEvent = {
+  +kind: 'missing_expected_data.throw',
+  +owner: string,
+  +fieldPath: string,
+  +handled: boolean,
+};
+```
+
+The `fieldPath` property is a `.` separated string containing the path from the query/mutation/fragment root to the field which was missing. Note that there are some cases where we are missing data that is not strictly a field. In those cases the path will end with one of these segments:
+
+1. `path.to.<record>` An edge points to an ID that is not present in the Relay store
+2. `path.to.<abstract-type-hint>` A virtual field inserted by the Relay compiler to detect if a type condition holds is missing from the Relay store
+
+## Missing Required Field Log
+
+A field was marked as [@required(action: LOG)](../../guides/required-directive.mdx#action) but was null or missing in the store.
+
+```ts
+export type MissingRequiredFieldLogEvent = {
+  +kind: 'missing_required_field.log',
+  +owner: string,
+  +fieldPath: string,
+};
+```
+
+## Missing Required Field Throw
+
+A field was marked as [@required(action: THROW)](../../guides/required-directive.mdx#action) but was null or missing in the store.
+
+Relay will throw immediately after logging this event. If you wish to customize the error being thrown, you may throw your own error.
+
+:::note
+Only throw on this event if `handled` is false. Errors that have been
+handled by a `@catch` directive or by making a resolver null will have
+`handled: true` and should not trigger a throw.
+:::
+
+```ts
+export type MissingRequiredFieldThrowEvent = {
+  +kind: 'missing_required_field.throw',
+  +owner: string,
+  +fieldPath: string,
+  +handled: boolean,
+};
+```
+
+## Relay Resolver Error
+
+
+A [Relay Resolver](../../guides/relay-resolvers/introduction.mdx) that is currently being read threw a JavaScript error when it was last evaluated. By default, the value has been coerced to null and passed to the product code.
+
+If [`@throwOnFieldError`](../../guides/throw-on-field-error-directive.mdx) was used on the parent query/fragment/mutation, you will also receive a runtime exception when the field is read.
+
+:::note
+Only throw on this event if `handled` is false. Errors that have been handled by a `@catch` directive or by making a resolver null will have `handled: true` and should not trigger a throw.
+
+```ts
+export type RelayResolverErrorEvent = {
+  +kind: 'relay_resolver.error',
+  +owner: string,
+  +fieldPath: string,
+  +error: Error,
+  +shouldThrow: boolean,
+  +handled: boolean,
+};
+```
+
+## GraphQL Payload Field Error
+
+
+A field being read by Relay was marked as being in an error state by the [GraphQL response](https://spec.graphql.org/October2021/#sec-Errors.Field-errors)
+
+If the field's parent query/fragment/mutation was annotated with [`@throwOnFieldError`](../../guides/throw-on-field-error-directive.mdx) and no [`@catch`](../../guides/catch-directive.mdx) directive was used to catch the error, Relay will throw an error immediately after logging this event.
+
+:::note
+Only throw on this event if `handled` is false. Errors that have been handled by a `@catch` directive or by making a resolver null will have `handled: true` and should not trigger a throw.
+:::
+
+```ts
+export type RelayFieldPayloadErrorEvent = {
+  +kind: 'relay_field_payload.error',
+  +owner: string,
+  +fieldPath: string,
+  +error: TRelayFieldError,
+  +shouldThrow: boolean,
+  +handled: boolean,
+};
+```

package/llm-docs/api-reference/relay-runtime/observe-fragment.mdx

@@ -0,0 +1,92 @@
+---
+id: observe-fragment
+title: observeFragment
+slug: api-reference/observe-fragment
+description: Read the value of a fragment and observe its state and value over time
+keywords:
+  - observable
+  - fragment
+---
+
+import DocsRating from '@site/src/core/DocsRating';
+
+:::warning
+`observeFragment` is still an experimental API. It currently has some limitations and may evolve slightly during this phase.
+:::
+
+## `observeFragment`
+
+In some cases it can be useful to define data that you wish to read using a GraphQL fragment, but then consume it outside of React render function. `observeFragment` allows you to consume the state and value of a fragment as it changes over time. This includes loading and error states as well as changes to the data as it gets updated by local updates, mutations or updates to Relay's normalized store from other queries.
+
+To read a fragment's data just once, see [`waitForFragmentData`](./wait-for-fragment-data.mdx).
+
+:::caution
+When using `observeFragment` with a plural fragment, the current implementation notifies the subscription multiple times if a store update impacting multiple list items gets published. Since the notifications happen synchronously, it is advised to debounce for a tick and only use the last payload for batching.
+:::
+
+### Example
+
+```ts
+import {observeFragment} from "relay-runtime/experimental";
+import { useEffect } from "react";
+import { useFragment } from "react-relay";
+import { graphql } from "relay-runtime";
+
+function MyComponent({ key }) {
+  const user = useFragment(
+    graphql`
+      fragment UserFragment on User {
+        ...TitleFragment
+      }
+    `,
+    key,
+  );
+
+  // Update the title as the user's name changes without triggering rerenders.
+  useEffect(() => {
+    const subscription = observeFragment(
+      graphql`
+        fragment TitleFragment on User {
+          name
+        }
+      `,
+      user,
+    ).subscribe({
+      next: (result) => {
+        switch(result.kind) {
+          case "loading":
+            window.title = "...loading";
+            break;
+          case "error":
+            window.title = "Oops, we hit an error";
+            break;
+          case "ok":
+            window.title = `Welcome ${result.value.name}`;
+            break;
+        }
+      }
+    });
+    return () => {
+      subscription.unsubscribe();
+    };
+  }, [user]);
+
+  return <div>Check out the document title!</div>;
+}
+```
+
+### Arguments
+
+* `environment`: `IEnvironment`. A Relay environment.
+* `fragment`: GraphQL fragment specified using a `graphql` template literal.
+* `fragmentReference`: The *fragment reference* is an opaque Relay object that Relay uses to read the data for the fragment from the store; more specifically, it contains information about which particular object instance the data should be read from.
+    * The type of the fragment reference can be imported from the generated Flow types, from the file `<fragment_name>.graphql.js`, and can be used to declare the type of your `Props`. The name of the fragment reference type will be: `<fragment_name>$key`. We use our [lint rule](https://github.com/relayjs/eslint-plugin-relay) to enforce that the type of the fragment reference prop is correctly declared.
+
+### Return Value
+
+* An [`Observable`](../../glossary/glossary.mdx#observable) which returns a discriminated union modeling the three possible states in which a fragment's data might be:
+  * `{state: 'ok', value: T}` - When data is available the state is `'ok'`. `T` is the data defined in the fragment.
+  * `{state: 'error': error: Error}` - When the fragment is in an error state either due to network level errors, [`@throwOnFieldError`](../../guides/throw-on-field-error-directive.mdx) or [`@required(action: THROW)`](../../guides/required-directive.mdx) field errors.
+  * `{state: 'loading'}` - When the parent request, or current `@defer` payload is still in flight, or a [`@live` Relay Resolver](../../guides/relay-resolvers/live-fields.mdx) being read is in a suspended state.
+
+<DocsRating />

package/llm-docs/api-reference/relay-runtime/relay-environment.mdx

@@ -0,0 +1,53 @@
+---
+id: relay-environment
+title: Relay Environment
+slug: /api-reference/relay-runtime/relay-environment
+description: Setting up a Relay Environment
+---
+
+The core of Relay's runtime is the `Environment`. The environment knows how to make requests to your GraphQL server and contains the `Store`, Relay's normalized data cache. Generally your application will construct a single environment which is configured to fetch data from your server, and then expose that environment to all of your components via `RelayEnvironmentProvider`.
+
+## Creating an Environment
+
+To create your environment you must provide two key pieces, a [`Network`](../../guides/network-layer.mdx) and a [`Store`](store.mdx).
+
+The `Network` is responsible for making requests to your GraphQL server. The `Store` holds the normalized data cache.
+
+A minimal implementation of an environment might look like this:
+
+```ts title="RelayEnvironment.js"
+import { Environment, Store, RecordSource, Network, FetchFunction } from "relay-runtime";
+
+const HTTP_ENDPOINT = "https://graphql.org/graphql/";
+
+const fetchGraphQL: FetchFunction = async (request, variables) => {
+  const resp = await fetch(HTTP_ENDPOINT, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ query: request.text, variables }),
+  });
+  if (!resp.ok) {
+    throw new Error("Response failed.");
+  }
+  return await resp.json();
+};
+
+export const environment = new Environment({
+  store: new Store(new RecordSource({})),
+  network: Network.create(fetchGraphQL),
+});
+```
+
+## Advanced Configuration
+
+The Relay environment accepts a number of additional configuration options when it is created. These options are all optional, but can be used to customize the behavior of the environment.
+
+Notable options include:
+
+* `log` - A function that will be called with telemetry events. See the types for [`LogEvent`](https://github.com/facebook/relay/blob/0414c9ad0744483e349e07defcb6d70a52cf8b3c/packages/relay-runtime/store/RelayStoreTypes.js#L799) for a full list of events and their fields.
+* [`missingFieldHandlers`](../../guided-tour/reusing-cached-data/filling-in-missing-data.mdx) - A list of handlers that will be called when a field is missing from the store. This can be used to enable fulfilling queries to fields like `Query.node` from cache.
+* `getDataID` - A function that will be called to generate a unique ID for a given object. This can be used to customize the way that Relay generates IDs for objects if your server does not implement the [Global Object Identification spec](https://graphql.org/learn/global-object-identification/).
+* [`relayFieldLogger`](./field-logger.mdx) - A function that will be called when Relay encounters a field-level error.
+* `deferDeduplicatedFields` - When set to `true`, this option prevents Relay from throwing an error when missing fields are received in a deferred response. This is required for the [latest](https://github.com/graphql/defer-stream-wg/discussions/69) `@defer` spec proposal, which does not send duplicate fields in deferred responses. While Relay does not yet attempt to support the latest spec proposal, this option allows users to transform responses into a format that Relay can accept.
+
+For a full list of options, inspect the [provided TypeScript types](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/relay-runtime/lib/store/RelayModernEnvironment.d.ts#L26-L43).

package/llm-docs/api-reference/relay-runtime/request-subscription.mdx

@@ -0,0 +1,54 @@
+---
+id: request-subscription
+title: requestSubscription
+slug: /api-reference/request-subscription/
+description: API reference for requestSubscription, which imperatively establishes a GraphQL subscription
+keywords:
+  - subscription
+---
+
+import DocsRating from '@site/src/core/DocsRating';
+import {OssOnly, FbInternalOnly} from 'docusaurus-plugin-internaldocs-fb/internal';
+import GraphQLSubscriptionConfig from '../types/GraphQLSubscriptionConfig.mdx';
+import Disposable from '../types/Disposable.mdx';
+
+## `requestSubscription`
+
+Imperative API for establishing a GraphQL Subscription.
+See also the [`useSubscription`](../use-subscription/) API and the [Guide to Updating Data](../../guided-tour/updating-data/introduction.mdx).
+```js
+import {graphql, requestSubscription} from 'react-relay';
+
+const subscription = graphql`
+  subscription UserDataSubscription($input: InputData!) {
+    # ...
+  }
+`;
+
+function createSubscription(environment: IEnvironment): Disposable {
+  return requestSubscription(environment, {
+    subscription,
+    variables: {input: {userId: '4'}},
+  });
+}
+```
+
+### Arguments
+
+* `environment`: A Relay Environment
+* `config`: `GraphQLSubscriptionConfig`
+
+<GraphQLSubscriptionConfig />
+
+### Return Type
+
+* A [`Disposable`](#interface-disposable) that clears the subscription.
+
+<Disposable />
+
+### Behavior
+
+* Imperatively establish a subscription.
+* See the [GraphQL Subscriptions Guide](../../guided-tour/updating-data/graphql-subscriptions/) for a more detailed explanation of how to work with subscriptions.
+
+<DocsRating />

package/llm-docs/api-reference/relay-runtime/runtime-configuration.mdx

@@ -0,0 +1,52 @@
+---
+id: runtime-config
+title: Runtime Configuration
+slug: /api-reference/runtime-config/
+description: Configuring the Relay Runtime
+keywords:
+  - feature flags
+  - configuration
+---
+
+## ConnectionInterface
+
+If your server's implementation of the Connection Spec differs from the default interface you will need to configure the Relay Runtime to expect the connection type and field names used in your schema. This is done by updating the global ConnectionInterface instance exported by Relay:
+
+:::note
+You will also need to update your [Relay Compiler Config](../../getting-started/compiler-config/#ConnectionInterface) with these same values at the path `schemaConfig.connectionInterface`.
+:::
+
+```ts title="/src/ConfigureRelay.ts"
+import { ConnectionInterface } from 'relay-runtime';
+
+// Note: This must match the values configured in the Relay compiler config.
+ConnectionInterface.inject({
+  END_CURSOR: 'end_cursor',
+  HAS_NEXT_PAGE: 'has_next_page',
+  HAS_PREV_PAGE: 'has_previous_page',
+  START_CURSOR: 'start_cursor',
+  PAGE_INFO: 'page_info',
+  NODE: 'node',
+  CURSOR: 'cursor',
+  EDGES: 'edges',
+  PAGE_INFO_TYPE: 'PageInfo',
+});
+```
+
+## Feature Flags
+
+:::warning
+Feature Flags are used for enabling and configuring unstable Relay features, **regular use of Relay should not need to modify runtime feature flags**. They are documented here for purely informational purposes
+:::
+
+Relay has a number of runtime options called "Feature Flags". In general, these are used for enabling experimental features which are not yet stable and thus not yet enabled by default.
+
+Feature flags in the Relay Runtime are implemented as a global mutable object. To set/configure a feature flag, import that object and mutate it. If you do this in the module scope, the updates will apply before Relay looks at them.
+
+```ts title="/src/ConfigureRelay.ts"
+import { RelayFeatureFlags } from 'relay-runtime';
+
+RelayFeatureFlags.ENABLE_SOME_EXPERIMENT = true;
+```
+
+You can find the full list of feature flags [here](https://github.com/facebook/relay/blob/203d8b10e9144a37466b8a72edbe6add48f64e7d/packages/relay-runtime/util/RelayFeatureFlags.js#L4), but keep in mind that **feature flags may change arbitrarily between versions of Relay**.