react-relay 20.1.1 → 21.0.0

package/lib/legacy.js

@@ -7,21 +7,34 @@ var ReactRelayPaginationContainer = require('./ReactRelayPaginationContainer');
 var ReactRelayQueryRenderer = require('./ReactRelayQueryRenderer');
 var ReactRelayRefetchContainer = require('./ReactRelayRefetchContainer');
 var RelayRuntime = require('relay-runtime');
+var ConnectionHandler = RelayRuntime.ConnectionHandler,
+  MutationTypes = RelayRuntime.MutationTypes,
+  RangeOperations = RelayRuntime.RangeOperations,
+  applyOptimisticMutation = RelayRuntime.applyOptimisticMutation,
+  commitLocalUpdate = RelayRuntime.commitLocalUpdate,
+  commitMutation = RelayRuntime.commitMutation,
+  fetchQuery_DEPRECATED = RelayRuntime.fetchQuery_DEPRECATED,
+  graphql = RelayRuntime.graphql,
+  readInlineData = RelayRuntime.readInlineData,
+  requestSubscription = RelayRuntime.requestSubscription;
+var createFragmentContainer = ReactRelayFragmentContainer.createContainer;
+var createPaginationContainer = ReactRelayPaginationContainer.createContainer;
+var createRefetchContainer = ReactRelayRefetchContainer.createContainer;
 module.exports = {
-  ConnectionHandler: RelayRuntime.ConnectionHandler,
+  ConnectionHandler: ConnectionHandler,
   QueryRenderer: ReactRelayQueryRenderer,
   LocalQueryRenderer: ReactRelayLocalQueryRenderer,
-  MutationTypes: RelayRuntime.MutationTypes,
-  RangeOperations: RelayRuntime.RangeOperations,
+  MutationTypes: MutationTypes,
+  RangeOperations: RangeOperations,
   ReactRelayContext: ReactRelayContext,
-  applyOptimisticMutation: RelayRuntime.applyOptimisticMutation,
-  commitLocalUpdate: RelayRuntime.commitLocalUpdate,
-  commitMutation: RelayRuntime.commitMutation,
-  createFragmentContainer: ReactRelayFragmentContainer.createContainer,
-  createPaginationContainer: ReactRelayPaginationContainer.createContainer,
-  createRefetchContainer: ReactRelayRefetchContainer.createContainer,
-  fetchQuery_DEPRECATED: RelayRuntime.fetchQuery_DEPRECATED,
-  graphql: RelayRuntime.graphql,
-  readInlineData: RelayRuntime.readInlineData,
-  requestSubscription: RelayRuntime.requestSubscription
+  applyOptimisticMutation: applyOptimisticMutation,
+  commitLocalUpdate: commitLocalUpdate,
+  commitMutation: commitMutation,
+  createFragmentContainer: createFragmentContainer,
+  createPaginationContainer: createPaginationContainer,
+  createRefetchContainer: createRefetchContainer,
+  fetchQuery_DEPRECATED: fetchQuery_DEPRECATED,
+  graphql: graphql,
+  readInlineData: readInlineData,
+  requestSubscription: requestSubscription
 };

package/lib/relay-hooks/legacy/useBlockingPaginationFragment.js

@@ -75,10 +75,10 @@ function useBlockingPaginationFragment(fragmentInput, parentFragmentRef) {
   }, [disposeFetchNext, disposeFetchPrevious, refetch]);
   return {
     data: fragmentData,
-    loadNext: loadNext,
-    loadPrevious: loadPrevious,
     hasNext: hasNext,
     hasPrevious: hasPrevious,
+    loadNext: loadNext,
+    loadPrevious: loadPrevious,
     refetch: refetchPagination
   };
 }
@@ -102,6 +102,8 @@ function useLoadMore(args) {
   };
   var observer = {
     complete: promiseResolve,
+    error: promiseResolve,
+    next: promiseResolve,
     start: function start() {
       disableStoreUpdates();
       var promise = new Promise(function (resolve) {
@@ -112,9 +114,7 @@ function useLoadMore(args) {
       });
       requestPromiseRef.current = promise;
       setRequestPromise(promise);
-    },
-    next: promiseResolve,
-    error: promiseResolve
+    }
   };
   var _useLoadMoreFunction = useLoadMoreFunction((0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, loadMoreArgs), {}, {
       observer: observer,

package/lib/relay-hooks/legacy/useRefetchableFragmentNode.js

@@ -94,9 +94,9 @@ function useRefetchableFragmentNode(fragmentNode, parentFragmentRef, componentDi
     identifierInfo = _getRefetchMetadata2.identifierInfo;
   if (shouldReset) {
     dispatch({
-      type: 'reset',
       environment: environment,
-      fragmentIdentifier: fragmentIdentifier
+      fragmentIdentifier: fragmentIdentifier,
+      type: 'reset'
     });
     disposeQuery();
   } else if (refetchQuery != null && queryRef != null) {
@@ -110,13 +110,13 @@ function useRefetchableFragmentNode(fragmentNode, parentFragmentRef, componentDi
     var fetchObservable = queryRef.source != null ? queryRef.source : fetchQuery(environment, refetchQuery);
     var queryResult = profilerContext.wrapPrepareQueryResource(function () {
       return QueryResource.prepare(refetchQuery, fetchObservable, fetchPolicy, renderPolicy, {
-        error: handleQueryCompleted,
         complete: function complete() {
           if (process.env.NODE_ENV !== "production") {
             debugFunctions.checkSameTypeAfterRefetch(debugPreviousIDAndTypename, environment, fragmentNode, componentDisplayName);
           }
           handleQueryCompleted();
-        }
+        },
+        error: handleQueryCompleted
       }, queryRef.fetchKey, profilerContext);
     });
     var queryData = FragmentResource.read(queryResult.fragmentNode, queryResult.fragmentRef, componentDisplayName).data;
@@ -133,11 +133,11 @@ function useRefetchableFragmentNode(fragmentNode, parentFragmentRef, componentDi
     enableStoreUpdates = _useFragmentNode.enableStoreUpdates;
   var refetch = useRefetchFunction(componentDisplayName, dispatch, disposeQuery, fragmentData, fragmentIdentifier, fragmentNode, fragmentRefPathInResponse, identifierInfo, loadQuery, parentFragmentRef, refetchableRequest);
   return {
+    disableStoreUpdates: disableStoreUpdates,
+    enableStoreUpdates: enableStoreUpdates,
     fragmentData: fragmentData,
     fragmentRef: fragmentRef,
-    refetch: refetch,
-    disableStoreUpdates: disableStoreUpdates,
-    enableStoreUpdates: enableStoreUpdates
+    refetch: refetch
   };
 }
 function useRefetchFunction(componentDisplayName, dispatch, disposeQuery, fragmentData, fragmentIdentifier, fragmentNode, fragmentRefPathInResponse, identifierInfo, loadQuery, parentFragmentRef, refetchableRequest) {
@@ -182,17 +182,17 @@ function useRefetchFunction(componentDisplayName, dispatch, disposeQuery, fragme
       force: true
     });
     loadQuery(refetchQuery.request.variables, {
-      fetchPolicy: fetchPolicy,
       __environment: refetchEnvironment,
-      __nameForWarning: 'refetch'
+      __nameForWarning: 'refetch',
+      fetchPolicy: fetchPolicy
     });
     dispatch({
-      type: 'refetch',
       fetchPolicy: fetchPolicy,
       onComplete: onComplete,
       refetchEnvironment: refetchEnvironment,
       refetchQuery: refetchQuery,
-      renderPolicy: renderPolicy
+      renderPolicy: renderPolicy,
+      type: 'refetch'
     });
     return {
       dispose: disposeQuery
@@ -202,23 +202,16 @@ function useRefetchFunction(componentDisplayName, dispatch, disposeQuery, fragme
 var debugFunctions;
 if (process.env.NODE_ENV !== "production") {
   debugFunctions = {
-    getInitialIDAndType: function getInitialIDAndType(memoRefetchVariables, fragmentRefPathInResponse, identifierQueryVariableName, environment) {
-      var _require5 = require('relay-runtime'),
-        Record = _require5.Record;
-      var id = memoRefetchVariables === null || memoRefetchVariables === void 0 ? void 0 : memoRefetchVariables[identifierQueryVariableName !== null && identifierQueryVariableName !== void 0 ? identifierQueryVariableName : 'id'];
-      if (fragmentRefPathInResponse.length !== 1 || fragmentRefPathInResponse[0] !== 'node' || id == null) {
-        return null;
+    checkSameIDAfterRefetch: function checkSameIDAfterRefetch(previousIDAndTypename, refetchedFragmentRef, fragmentNode, componentDisplayName) {
+      if (previousIDAndTypename == null || refetchedFragmentRef == null) {
+        return;
       }
-      var recordSource = environment.getStore().getSource();
-      var record = recordSource.get(id);
-      var typename = record == null ? null : Record.getType(record);
-      if (typename == null) {
-        return null;
+      var _require5 = require('relay-runtime'),
+        ID_KEY = _require5.ID_KEY;
+      var resultID = refetchedFragmentRef[ID_KEY];
+      if (resultID != null && resultID !== previousIDAndTypename.id) {
+        process.env.NODE_ENV !== "production" ? warning(false, 'Relay: Call to `refetch` returned a different id, expected ' + '`%s`, got `%s`, on `%s` in `%s`. ' + 'Please make sure the server correctly implements ' + 'unique id requirement.', resultID, previousIDAndTypename.id, fragmentNode.name, componentDisplayName) : void 0;
       }
-      return {
-        id: id,
-        typename: typename
-      };
     },
     checkSameTypeAfterRefetch: function checkSameTypeAfterRefetch(previousIDAndType, environment, fragmentNode, componentDisplayName) {
       var _require6 = require('relay-runtime'),
@@ -233,16 +226,23 @@ if (process.env.NODE_ENV !== "production") {
         process.env.NODE_ENV !== "production" ? warning(false, 'Relay: Call to `refetch` returned data with a different ' + '__typename: was `%s`, now `%s`, on `%s` in `%s`. ' + 'Please make sure the server correctly implements' + 'unique id requirement.', previousIDAndType.typename, typename, fragmentNode.name, componentDisplayName) : void 0;
       }
     },
-    checkSameIDAfterRefetch: function checkSameIDAfterRefetch(previousIDAndTypename, refetchedFragmentRef, fragmentNode, componentDisplayName) {
-      if (previousIDAndTypename == null || refetchedFragmentRef == null) {
-        return;
-      }
+    getInitialIDAndType: function getInitialIDAndType(memoRefetchVariables, fragmentRefPathInResponse, identifierQueryVariableName, environment) {
       var _require7 = require('relay-runtime'),
-        ID_KEY = _require7.ID_KEY;
-      var resultID = refetchedFragmentRef[ID_KEY];
-      if (resultID != null && resultID !== previousIDAndTypename.id) {
-        process.env.NODE_ENV !== "production" ? warning(false, 'Relay: Call to `refetch` returned a different id, expected ' + '`%s`, got `%s`, on `%s` in `%s`. ' + 'Please make sure the server correctly implements ' + 'unique id requirement.', resultID, previousIDAndTypename.id, fragmentNode.name, componentDisplayName) : void 0;
+        Record = _require7.Record;
+      var id = memoRefetchVariables === null || memoRefetchVariables === void 0 ? void 0 : memoRefetchVariables[identifierQueryVariableName !== null && identifierQueryVariableName !== void 0 ? identifierQueryVariableName : 'id'];
+      if (fragmentRefPathInResponse.length !== 1 || fragmentRefPathInResponse[0] !== 'node' || id == null) {
+        return null;
       }
+      var recordSource = environment.getStore().getSource();
+      var record = recordSource.get(id);
+      var typename = record == null ? null : Record.getType(record);
+      if (typename == null) {
+        return null;
+      }
+      return {
+        id: id,
+        typename: typename
+      };
     }
   };
 }

package/lib/relay-hooks/loadEntryPoint.js

@@ -29,9 +29,9 @@ function loadEntryPoint(environmentProvider, entryPoint, entryPointParams) {
       }
       var environment = environmentProvider.getEnvironment(environmentProviderOptions);
       preloadedQueries[queryPropName] = loadQuery(environment, parameters, variables, {
+        __nameForWarning: 'loadEntryPoint',
         fetchPolicy: options === null || options === void 0 ? void 0 : options.fetchPolicy,
-        networkCacheConfig: options === null || options === void 0 ? void 0 : options.networkCacheConfig,
-        __nameForWarning: 'loadEntryPoint'
+        networkCacheConfig: options === null || options === void 0 ? void 0 : options.networkCacheConfig
       }, environmentProviderOptions);
     });
   }

package/lib/relay-hooks/loadQuery.js

@@ -44,15 +44,15 @@ function loadQuery(environment, preloadableRequest, variables, options, environm
       return network.execute(params, variables, networkCacheConfig, undefined, undefined, undefined, undefined, checkOperation);
     });
     var _observable$subscribe = observable.subscribe({
+        complete: function complete() {
+          subject.complete();
+        },
         error: function error(err) {
           networkError = err;
           subject.error(err);
         },
         next: function next(data) {
           subject.next(data);
-        },
-        complete: function complete() {
-          subject.complete();
         }
       }),
       unsubscribe = _observable$subscribe.unsubscribe;
@@ -69,14 +69,14 @@ function loadQuery(environment, preloadableRequest, variables, options, environm
   var executeDeduped = function executeDeduped(operation, fetchFn) {
     didMakeNetworkRequest = true;
     var _fetchQueryDeduped$su = fetchQueryDeduped(environment, operation.request.identifier, fetchFn).subscribe({
+      complete: function complete() {
+        executionSubject.complete();
+      },
       error: function error(err) {
         executionSubject.error(err);
       },
       next: function next(data) {
         executionSubject.next(data);
-      },
-      complete: function complete() {
-        executionSubject.complete();
       }
     });
     unsubscribeFromExecution = _fetchQueryDeduped$su.unsubscribe;
@@ -154,9 +154,7 @@ function loadQuery(environment, preloadableRequest, variables, options, environm
     isNetworkRequestCancelled = true;
   };
   return {
-    kind: 'PreloadedQuery',
-    environment: environment,
-    environmentProviderOptions: environmentProviderOptions,
+    cancelNetworkRequest: cancelNetworkRequest,
     dispose: function dispose() {
       if (isDisposed) {
         return;
@@ -165,19 +163,21 @@ function loadQuery(environment, preloadableRequest, variables, options, environm
       cancelNetworkRequest();
       isDisposed = true;
     },
-    releaseQuery: releaseQuery,
-    cancelNetworkRequest: cancelNetworkRequest,
+    environment: environment,
+    environmentProviderOptions: environmentProviderOptions,
     fetchKey: fetchKey,
+    fetchPolicy: fetchPolicy,
     id: queryId,
     get isDisposed() {
       return isDisposed || isReleased;
     },
+    kind: 'PreloadedQuery',
+    name: params.name,
+    networkCacheConfig: networkCacheConfig,
     get networkError() {
       return networkError;
     },
-    name: params.name,
-    networkCacheConfig: networkCacheConfig,
-    fetchPolicy: fetchPolicy,
+    releaseQuery: releaseQuery,
     source: didMakeNetworkRequest ? returnedObservable : undefined,
     variables: variables
   };

package/lib/relay-hooks/preloadQuery_DEPRECATED.js

@@ -45,17 +45,17 @@ function preloadQuery(environment, preloadableRequest, variables, options, envir
     };
   }) : null;
   return {
-    kind: 'PreloadedQuery_DEPRECATED',
     environment: environment,
     environmentProviderOptions: environmentProviderOptions,
     fetchKey: queryEntry.fetchKey,
     fetchPolicy: queryEntry.fetchPolicy,
-    networkCacheConfig: options === null || options === void 0 ? void 0 : options.networkCacheConfig,
     id: queryEntry.id,
+    kind: 'PreloadedQuery_DEPRECATED',
     name: queryEntry.name,
+    networkCacheConfig: options === null || options === void 0 ? void 0 : options.networkCacheConfig,
     source: source,
-    variables: variables,
-    status: queryEntry.status
+    status: queryEntry.status,
+    variables: variables
   };
 }
 function preloadQueryDeduped(environment, pendingQueries, preloadableRequest, variables, options) {
@@ -93,13 +93,13 @@ function preloadQueryDeduped(environment, pendingQueries, preloadableRequest, va
       cacheKey: cacheKey,
       fetchKey: fetchKey,
       fetchPolicy: fetchPolicy,
-      kind: 'cache',
       id: params.id,
+      kind: 'cache',
       name: params.name,
       status: {
         cacheConfig: networkCacheConfig,
-        source: 'cache',
-        fetchTime: (_availability$fetchTi = availability === null || availability === void 0 ? void 0 : availability.fetchTime) !== null && _availability$fetchTi !== void 0 ? _availability$fetchTi : null
+        fetchTime: (_availability$fetchTi = availability === null || availability === void 0 ? void 0 : availability.fetchTime) !== null && _availability$fetchTi !== void 0 ? _availability$fetchTi : null,
+        source: 'cache'
       }
     };
     if (!environment.isServer() && prevQueryEntry == null) {
@@ -116,13 +116,13 @@ function preloadQueryDeduped(environment, pendingQueries, preloadableRequest, va
       cacheKey: cacheKey,
       fetchKey: fetchKey,
       fetchPolicy: fetchPolicy,
-      kind: 'network',
       id: params.id,
+      kind: 'network',
       name: params.name,
       status: {
         cacheConfig: networkCacheConfig,
-        source: 'network',
-        fetchTime: null
+        fetchTime: null,
+        source: 'network'
       },
       subject: subject,
       subscription: source["finally"](function () {

package/lib/relay-hooks/readFragmentInternal.js

@@ -103,18 +103,18 @@ function getFragmentState(environment, fragmentSelector) {
       };
     } else {
       return {
+        epoch: environment.getStore().getEpoch(),
         kind: 'plural',
         snapshots: fragmentSelector.selectors.map(function (s) {
           return environment.lookup(s);
-        }),
-        epoch: environment.getStore().getEpoch()
+        })
       };
     }
   } else {
     return {
+      epoch: environment.getStore().getEpoch(),
       kind: 'singular',
-      snapshot: environment.lookup(fragmentSelector),
-      epoch: environment.getStore().getEpoch()
+      snapshot: environment.lookup(fragmentSelector)
     };
   }
 }
@@ -175,8 +175,8 @@ function readFragmentInternal(environment, fragmentNode, fragmentRef, hookDispla
     }
   }
   return {
-    data: data,
-    clientEdgeQueries: clientEdgeQueries
+    clientEdgeQueries: clientEdgeQueries,
+    data: data
   };
 }
 module.exports = readFragmentInternal;

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

@@ -0,0 +1,20 @@
+'use strict';
+
+var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator").default;
+var _require = require('relay-runtime'),
+  fetchQuery = _require.fetchQuery;
+function serverFetchQuery(_x, _x2, _x3) {
+  return _serverFetchQuery.apply(this, arguments);
+}
+function _serverFetchQuery() {
+  _serverFetchQuery = _asyncToGenerator(function* (environment, query, variables) {
+    var observable = fetchQuery(environment, query, variables);
+    var result = yield observable.toPromise();
+    if (result == null) {
+      throw new Error('Unexpected null response from fetchQuery');
+    }
+    return result;
+  });
+  return _serverFetchQuery.apply(this, arguments);
+}
+module.exports = serverFetchQuery;

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/serverReadFragment.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator").default;
+var _require = require('relay-runtime/experimental'),
+  waitForFragmentData = _require.waitForFragmentData;
+function serverReadFragment(_x, _x2, _x3) {
+  return _serverReadFragment.apply(this, arguments);
+}
+function _serverReadFragment() {
+  _serverReadFragment = _asyncToGenerator(function* (environment, fragment, fragmentRef) {
+    return waitForFragmentData(environment, fragment, fragmentRef);
+  });
+  return _serverReadFragment.apply(this, arguments);
+}
+module.exports = serverReadFragment;

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;