react-relay 0.0.0-main-510cf1ea → 0.0.0-main-b3837342

package/ReactRelayContext.js

@@ -1,5 +1,5 @@
 /**
- * Relay v0.0.0-main-510cf1ea
+ * Relay v0.0.0-main-b3837342
  *
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *

package/hooks.js

@@ -1,5 +1,5 @@
 /**
- * Relay v0.0.0-main-510cf1ea
+ * Relay v0.0.0-main-b3837342
  *
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *

package/index.js

@@ -1,5 +1,5 @@
 /**
- * Relay v0.0.0-main-510cf1ea
+ * Relay v0.0.0-main-b3837342
  *
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *

package/legacy.js

@@ -1,5 +1,5 @@
 /**
- * Relay v0.0.0-main-510cf1ea
+ * Relay v0.0.0-main-b3837342
  *
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *

package/lib/relay-hooks/rsc/serverPreloadQuery.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var invariant = require('invariant');
+var _require = require('relay-runtime'),
+  createOperationDescriptor = _require.createOperationDescriptor,
+  getRequest = _require.getRequest;
+function serverPreloadQuery(environment, query, variables) {
+  var _ref, _request$params$id;
+  var request = getRequest(query);
+  var operationDescriptor = createOperationDescriptor(request, variables);
+  var observable = environment.execute({
+    operation: operationDescriptor
+  });
+  var queryId = (_ref = (_request$params$id = request.params.id) !== null && _request$params$id !== void 0 ? _request$params$id : request.params.cacheID) !== null && _ref !== void 0 ? _ref : request.params.name;
+  var response = observable.toPromise().then(function (rawResponse) {
+    !(rawResponse != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'Unexpected null response from execute') : invariant(false) : void 0;
+    !!Array.isArray(rawResponse) ? process.env.NODE_ENV !== "production" ? invariant(false, '@defer is not yet supported in serverPreloadQuery') : invariant(false) : void 0;
+    return {
+      data: rawResponse.data,
+      errors: rawResponse.errors
+    };
+  });
+  return {
+    kind: 'PreloadedQueryRef',
+    queryId: queryId,
+    variables: variables,
+    _response: response,
+    fetchedAt: Date.now()
+  };
+}
+module.exports = serverPreloadQuery;

package/lib/relay-hooks/rsc/useQueryFromServer.js

@@ -0,0 +1,62 @@
+'use client';
+'use strict';
+
+var usePreloadedQuery = require('../usePreloadedQuery');
+var useRelayEnvironment = require('../useRelayEnvironment');
+var _require = require('react'),
+  use = _require.use,
+  useMemo = _require.useMemo;
+var _require2 = require('relay-runtime'),
+  __internal = _require2.__internal,
+  ROOT_TYPE = _require2.ROOT_TYPE,
+  createOperationDescriptor = _require2.createOperationDescriptor,
+  getRequest = _require2.getRequest;
+var defaultGetDataID = __internal.defaultGetDataID,
+  normalizeResponse = __internal.normalizeResponse;
+var committedRefs = new WeakSet();
+var DEFAULT_STALE_MS = 30_000;
+function useQueryFromServer(query, queryRef, options) {
+  var _options$staleThresho, _environment$_getData;
+  var environment = useRelayEnvironment();
+  var request = getRequest(query);
+  var threshold = (_options$staleThresho = options === null || options === void 0 ? void 0 : options.staleThresholdMs) !== null && _options$staleThresho !== void 0 ? _options$staleThresho : DEFAULT_STALE_MS;
+  var getDataID = (_environment$_getData = environment._getDataID) !== null && _environment$_getData !== void 0 ? _environment$_getData : defaultGetDataID;
+  var response = use(queryRef._response);
+  var isFresh = response.data != null && Date.now() - queryRef.fetchedAt <= threshold;
+  var shouldCommit = isFresh && !committedRefs.has(queryRef);
+  if (shouldCommit) {
+    var _environment$__log;
+    committedRefs.add(queryRef);
+    var operation = createOperationDescriptor(request, queryRef.variables);
+    var responsePayload = {
+      data: response.data,
+      errors: response.errors
+    };
+    var relayPayload = normalizeResponse(responsePayload, operation.root, ROOT_TYPE, {
+      getDataID: getDataID,
+      treatMissingFieldsAsNull: false,
+      deferDeduplicatedFields: false,
+      log: (_environment$__log = environment.__log) !== null && _environment$__log !== void 0 ? _environment$__log : null,
+      path: [],
+      shouldProcessClientComponents: false
+    }, false);
+    environment.getStore().publish(relayPayload.source);
+  }
+  var preloadedQuery = useMemo(function () {
+    var _request$params$id;
+    var isFreshAtMemo = response.data != null && Date.now() - queryRef.fetchedAt <= threshold;
+    var useStore = isFreshAtMemo || committedRefs.has(queryRef);
+    return {
+      kind: 'PreloadedQuery_DEPRECATED',
+      environment: environment,
+      fetchKey: queryRef.fetchedAt,
+      fetchPolicy: useStore ? 'store-or-network' : 'network-only',
+      id: (_request$params$id = request.params.id) !== null && _request$params$id !== void 0 ? _request$params$id : request.params.name,
+      name: request.params.name,
+      source: null,
+      variables: queryRef.variables
+    };
+  }, [environment, queryRef.fetchedAt, response.data, queryRef.variables, request.params.id, request.params.name, threshold]);
+  return usePreloadedQuery(query, preloadedQuery);
+}
+module.exports = useQueryFromServer;

package/lib/rsc-client_EXPERIMENTAL.js

@@ -0,0 +1,7 @@
+'use client';
+'use strict';
+
+var useQueryFromServer = require('./relay-hooks/rsc/useQueryFromServer');
+module.exports = {
+  useQueryFromServer: useQueryFromServer
+};

package/lib/rsc_EXPERIMENTAL.js

@@ -2,6 +2,7 @@
 
 var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator").default;
 var serverFetchQueryImpl = require('./relay-hooks/rsc/serverFetchQuery');
+var serverPreloadQueryImpl = require('./relay-hooks/rsc/serverPreloadQuery');
 var serverReadFragmentImpl = require('./relay-hooks/rsc/serverReadFragment');
 var invariant = require('invariant');
 var React = require('react');
@@ -18,6 +19,9 @@ function createServerEnvironment(create) {
     });
     return _serverFetchQuery.apply(this, arguments);
   }
+  function serverPreloadQuery(query, variables) {
+    return serverPreloadQueryImpl(getEnvironment(), query, variables);
+  }
   function serverReadFragment(_x3, _x4) {
     return _serverReadFragment.apply(this, arguments);
   }
@@ -30,6 +34,7 @@ function createServerEnvironment(create) {
   return {
     getEnvironment: getEnvironment,
     serverFetchQuery: serverFetchQuery,
+    serverPreloadQuery: serverPreloadQuery,
     serverReadFragment: serverReadFragment
   };
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "react-relay",
   "description": "A framework for building GraphQL-driven React applications.",
-  "version": "0.0.0-main-510cf1ea",
+  "version": "0.0.0-main-b3837342",
   "keywords": [
     "graphql",
     "relay",
@@ -20,7 +20,7 @@
     "fbjs": "^3.0.2",
     "invariant": "^2.2.4",
     "nullthrows": "^1.1.1",
-    "relay-runtime": "0.0.0-main-510cf1ea"
+    "relay-runtime": "0.0.0-main-b3837342"
   },
   "peerDependencies": {
     "react": "^16.9.0 || ^17 || ^18 || ^19"

package/relay-hooks/rsc/serverPreloadQuery.js.flow

@@ -0,0 +1,69 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall relay
+ */
+
+'use strict';
+
+import type {IEnvironment, PayloadError, Query, Variables} from 'relay-runtime';
+
+const invariant = require('invariant');
+const {createOperationDescriptor, getRequest} = require('relay-runtime');
+
+export type PreloadedQueryResponse<TData> = {
+  +data: TData,
+  +errors?: ReadonlyArray<PayloadError>,
+};
+
+export type PreloadedQueryRef<TVariables, TData> = {
+  +kind: 'PreloadedQueryRef',
+  +queryId: string,
+  +variables: TVariables,
+  +_response: Promise<PreloadedQueryResponse<TData>>,
+  +fetchedAt: number,
+};
+
+function serverPreloadQuery<TVariables extends Variables, TData>(
+  environment: IEnvironment,
+  query: Query<TVariables, TData>,
+  variables: TVariables,
+): PreloadedQueryRef<TVariables, TData> {
+  const request = getRequest(query);
+  const operationDescriptor = createOperationDescriptor(request, variables);
+
+  const observable = environment.execute({operation: operationDescriptor});
+
+  const queryId =
+    request.params.id ?? request.params.cacheID ?? request.params.name;
+
+  const response: Promise<PreloadedQueryResponse<TData>> =
+    // $FlowFixMe[incompatible-type] PayloadData -> TData; shape validated by the Relay compiler
+    observable.toPromise().then(rawResponse => {
+      invariant(rawResponse != null, 'Unexpected null response from execute');
+      // TODO: @defer returns batched responses; this only handles the first payload
+      invariant(
+        !Array.isArray(rawResponse),
+        '@defer is not yet supported in serverPreloadQuery',
+      );
+      return {
+        data: rawResponse.data,
+        errors: rawResponse.errors,
+      };
+    });
+
+  return {
+    kind: 'PreloadedQueryRef',
+    queryId,
+    variables,
+    _response: response,
+    fetchedAt: Date.now(),
+  };
+}
+
+module.exports = serverPreloadQuery;

package/relay-hooks/rsc/useQueryFromServer.js.flow

@@ -0,0 +1,135 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall relay
+ */
+
+'use client';
+'use strict';
+
+import type {
+  PreloadedQueryRef,
+  PreloadedQueryResponse,
+} from './serverPreloadQuery';
+import type {Query, Variables} from 'relay-runtime';
+
+const usePreloadedQuery = require('../usePreloadedQuery');
+const useRelayEnvironment = require('../useRelayEnvironment');
+// $FlowFixMe[missing-export] React.use is available in React 19+
+const {use, useMemo} = require('react');
+const {
+  __internal,
+  ROOT_TYPE,
+  createOperationDescriptor,
+  getRequest,
+} = require('relay-runtime');
+
+const {defaultGetDataID, normalizeResponse} = __internal;
+
+// $FlowFixMe[unclear-type] WeakSet used for identity-based dedup only
+const committedRefs: WeakSet<any> = new WeakSet();
+
+const DEFAULT_STALE_MS = 30_000;
+
+function useQueryFromServer<TVariables extends Variables, TData>(
+  query: Query<TVariables, TData>,
+  queryRef: PreloadedQueryRef<TVariables, TData>,
+  options?: {staleThresholdMs?: number},
+): TData {
+  const environment = useRelayEnvironment();
+  const request = getRequest(query);
+  const threshold = options?.staleThresholdMs ?? DEFAULT_STALE_MS;
+  // TODO: Add a method to IEnvironment for server-side publish so custom
+  // IEnvironment implementations don't need to access _getDataID.
+  // $FlowFixMe[prop-missing] _getDataID is not on IEnvironment
+  // $FlowFixMe[unclear-type]
+  const getDataID: any = environment._getDataID ?? defaultGetDataID;
+
+  const response: PreloadedQueryResponse<TData> = use(queryRef._response);
+
+  const isFresh =
+    response.data != null && Date.now() - queryRef.fetchedAt <= threshold;
+
+  const shouldCommit = isFresh && !committedRefs.has(queryRef);
+
+  // Publish server data to the Relay store without notifying subscribers.
+  // This avoids the React "Cannot update a component while rendering a
+  // different component" error that occurs when store.notify() triggers
+  // setState in other mounted components that subscribe to overlapping records.
+  if (shouldCommit) {
+    committedRefs.add(queryRef);
+
+    const operation = createOperationDescriptor(request, queryRef.variables);
+
+    // $FlowFixMe[unclear-type]
+    const responsePayload: any = {
+      data: response.data,
+      errors: response.errors,
+    };
+    const relayPayload = normalizeResponse(
+      responsePayload,
+      operation.root,
+      ROOT_TYPE,
+      {
+        getDataID,
+        treatMissingFieldsAsNull: false,
+        deferDeduplicatedFields: false,
+        // $FlowFixMe[prop-missing]
+        log: environment.__log ?? null,
+        path: [],
+        shouldProcessClientComponents: false,
+      },
+      false,
+    );
+
+    environment.getStore().publish(relayPayload.source);
+  }
+
+  // Build a PreloadedQuery shim. Fresh data was committed to the store
+  // above, so source is null and fetchPolicy is "store-or-network".
+  // Stale path uses "network-only" to trigger a client-side refetch.
+  const preloadedQuery = useMemo(() => {
+    const isFreshAtMemo =
+      response.data != null && Date.now() - queryRef.fetchedAt <= threshold;
+
+    // If this queryRef was already committed to the store by a previous
+    // component instance, read from the store even if the server timestamp
+    // is past the staleness threshold. This prevents a network refetch
+    // from overwriting store mutations made after the initial commit.
+    const useStore = isFreshAtMemo || committedRefs.has(queryRef);
+
+    return {
+      kind: 'PreloadedQuery_DEPRECATED',
+      environment,
+      fetchKey: queryRef.fetchedAt,
+      fetchPolicy: useStore ? 'store-or-network' : 'network-only',
+      id: request.params.id ?? request.params.name,
+      name: request.params.name,
+      source: null,
+      variables: queryRef.variables,
+    };
+  }, [
+    environment,
+    queryRef.fetchedAt,
+    response.data,
+    queryRef.variables,
+    request.params.id,
+    request.params.name,
+    threshold,
+  ]);
+
+  // usePreloadedQuery expects an opaque PreloadedQuery that can only be
+  // created via loadQuery/useQueryLoader. There's no public API to create
+  // one from server-fetched data, so we construct a plain object with the
+  // fields usePreloadedQuery reads internally.
+  // $FlowFixMe[incompatible-call]
+  // $FlowFixMe[incompatible-type]
+  return usePreloadedQuery(query, preloadedQuery);
+}
+
+module.exports = useQueryFromServer;

package/rsc-client_EXPERIMENTAL.js

@@ -0,0 +1,10 @@
+/**
+ * Relay v0.0.0-main-b3837342
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+module.exports = require('./lib/rsc-client_EXPERIMENTAL.js');

package/rsc-client_EXPERIMENTAL.js.flow

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall relay
+ */
+
+'use client';
+'use strict';
+
+import type {PreloadedQueryRef} from './relay-hooks/rsc/serverPreloadQuery';
+
+const useQueryFromServer = require('./relay-hooks/rsc/useQueryFromServer');
+
+export type {PreloadedQueryRef};
+
+module.exports = {
+  useQueryFromServer,
+};

package/rsc_EXPERIMENTAL.js

@@ -1,5 +1,5 @@
 /**
- * Relay v0.0.0-main-510cf1ea
+ * Relay v0.0.0-main-b3837342
  *
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *

package/rsc_EXPERIMENTAL.js.flow

@@ -11,6 +11,7 @@
 
 'use strict';
 
+import type {PreloadedQueryRef} from './relay-hooks/rsc/serverPreloadQuery';
 import type {
   Fragment,
   FragmentType,
@@ -20,10 +21,13 @@ import type {
 } from 'relay-runtime';
 
 const serverFetchQueryImpl = require('./relay-hooks/rsc/serverFetchQuery');
+const serverPreloadQueryImpl = require('./relay-hooks/rsc/serverPreloadQuery');
 const serverReadFragmentImpl = require('./relay-hooks/rsc/serverReadFragment');
 const invariant = require('invariant');
 const React = require('react');
 
+export type {PreloadedQueryRef};
+
 type HasSpread<TFragmentType> = {+$fragmentSpreads: TFragmentType, ...};
 
 export type ServerEnvironment = {
@@ -32,6 +36,10 @@ export type ServerEnvironment = {
     query: Query<TVariables, TData>,
     variables: TVariables,
   ) => Promise<TData>,
+  +serverPreloadQuery: <TVariables extends Variables, TData>(
+    query: Query<TVariables, TData>,
+    variables: TVariables,
+  ) => PreloadedQueryRef<TVariables, TData>,
   +serverReadFragment: <TFragmentType extends FragmentType, TData>(
     fragment: Fragment<TFragmentType, TData>,
     fragmentRef:
@@ -55,6 +63,13 @@ function createServerEnvironment(
     return serverFetchQueryImpl(getEnvironment(), query, variables);
   }
 
+  function serverPreloadQuery<TVariables extends Variables, TData>(
+    query: Query<TVariables, TData>,
+    variables: TVariables,
+  ): PreloadedQueryRef<TVariables, TData> {
+    return serverPreloadQueryImpl(getEnvironment(), query, variables);
+  }
+
   async function serverReadFragment<TFragmentType extends FragmentType, TData>(
     fragment: Fragment<TFragmentType, TData>,
     fragmentRef:
@@ -67,6 +82,7 @@ function createServerEnvironment(
   return {
     getEnvironment,
     serverFetchQuery,
+    serverPreloadQuery,
     serverReadFragment,
   };
 }