From a2df575505e28b8c288b241c0b94f520f3a7cbd9 Mon Sep 17 00:00:00 2001
From: Gregory Collett <gregcollett@mixcloud.com>
Date: Tue, 28 Jul 2026 11:28:53 +0100
Subject: [PATCH] Export PreloadableConcreteRequest from relay-runtime's Flow
 types

relay-runtime's TypeScript declarations already define
`PreloadableConcreteRequest` in `util/RelayConcreteNode.d.ts` and
re-export it from `index.d.ts`, but the Flow types did not expose it:
the Flow definition only lived in react-relay
(`EntryPointTypes.flow.js`). As a result a Flow consumer could not
`import type {PreloadableConcreteRequest} from 'relay-runtime'`, even
though the equivalent TypeScript import works.

Move the canonical Flow definition down into
`relay-runtime/util/RelayConcreteNode.js` (mirroring the `.d.ts`
layout) and export it from `relay-runtime`'s `index.js`. react-relay's
`EntryPointTypes.flow.js` now imports and re-exports it from
relay-runtime instead of defining its own identical copy, so the type
has a single source of truth. Types-only; no runtime change.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../relay-hooks/EntryPointTypes.flow.js       | 14 +++--------
 packages/relay-runtime/index.js               |  1 +
 .../relay-runtime/util/RelayConcreteNode.js   | 24 +++++++++++++++++++
 3 files changed, 28 insertions(+), 11 deletions(-)

diff --git a/packages/react-relay/relay-hooks/EntryPointTypes.flow.js b/packages/react-relay/relay-hooks/EntryPointTypes.flow.js
index 5df282d16aec7..8f0f1c92657c6 100644
--- a/packages/react-relay/relay-hooks/EntryPointTypes.flow.js
+++ b/packages/react-relay/relay-hooks/EntryPointTypes.flow.js
@@ -22,10 +22,13 @@ import type {
   IEnvironment,
   Observable,
   OperationType,
+  PreloadableConcreteRequest,
   RequestParameters,
   VariablesOf as _VariablesOf,
 } from 'relay-runtime';
 
+export type {PreloadableConcreteRequest};
+
 export type VariablesOf<T> = _VariablesOf<T>;
 
 export type PreloadFetchPolicy =
@@ -46,17 +49,6 @@ export type LoadQueryOptions = {
   readonly __nameForWarning?: ?string,
 };
 
-export type PreloadableConcreteRequest<out TQuery extends OperationType> = {
-  kind: 'PreloadableConcreteRequest',
-  params: RequestParameters,
-  // Note: the phantom type parameter here helps ensures that the
-  // $Parameters.js value matches the type param provided to preloadQuery.
-  // We also need to add usage of this generic here,
-  // becuase not using the generic in the definition makes it
-  // unconstrained in the call to a function that accepts PreloadableConcreteRequest<T>
-  readonly __phantom__?: ?TQuery,
-};
-
 export type EnvironmentProviderOptions = {readonly [string]: unknown, ...};
 
 export type PreloadedQuery<
diff --git a/packages/relay-runtime/index.js b/packages/relay-runtime/index.js
index 196eb3c4b144e..a485e966eff76 100644
--- a/packages/relay-runtime/index.js
+++ b/packages/relay-runtime/index.js
@@ -223,6 +223,7 @@ export type {
   ClientRequest,
   ConcreteUpdatableQuery,
   GeneratedNode,
+  PreloadableConcreteRequest,
   RequestParameters,
 } from './util/RelayConcreteNode';
 export type {
diff --git a/packages/relay-runtime/util/RelayConcreteNode.js b/packages/relay-runtime/util/RelayConcreteNode.js
index 6790a951eb5e8..542479de7184e 100644
--- a/packages/relay-runtime/util/RelayConcreteNode.js
+++ b/packages/relay-runtime/util/RelayConcreteNode.js
@@ -16,6 +16,7 @@ import type {
   NormalizationSplitOperation,
 } from './NormalizationNode';
 import type {ReaderFragment, ReaderInlineDataFragment} from './ReaderNode';
+import type {OperationType} from './RelayRuntimeTypes';
 
 /**
  * Represents a common GraphQL request that can be executed, an `operation`
@@ -35,6 +36,29 @@ export type ConcreteUpdatableQuery = {
   readonly fragment: ReaderFragment,
 };
 
+/**
+ * A lightweight stand-in for a `ConcreteRequest` emitted by the compiler for
+ * `@preloadable` queries: a `$Parameters.js` artifact containing only the
+ * `RequestParameters` (e.g. the persisted query `id`), so that the full
+ * normalization/reader AST can be code-split away from eager query loaders.
+ *
+ * This mirrors the type already published in the TypeScript declarations
+ * (`RelayConcreteNode.d.ts`) and re-exported from `relay-runtime`'s
+ * `index.d.ts`; the Flow definition previously only lived in `react-relay`
+ * (`EntryPointTypes.flow.js`), so Flow consumers could not import it from
+ * `relay-runtime` the way TypeScript consumers can.
+ */
+export type PreloadableConcreteRequest<out TQuery extends OperationType> = {
+  kind: 'PreloadableConcreteRequest',
+  params: RequestParameters,
+  // Note: the phantom type parameter here helps ensures that the
+  // $Parameters.js value matches the type param provided to preloadQuery.
+  // We also need to add usage of this generic here,
+  // becuase not using the generic in the definition makes it
+  // unconstrained in the call to a function that accepts PreloadableConcreteRequest<T>
+  readonly __phantom__?: ?TQuery,
+};
+
 export type NormalizationRootNode =
   ConcreteRequest | NormalizationSplitOperation;