You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
131 lines
5.5 KiB
131 lines
5.5 KiB
4 months ago
|
import { __assign, __spreadArray } from "tslib";
|
||
|
import * as React from "rehackt";
|
||
|
import { invariant } from "../../utilities/globals/index.js";
|
||
|
import { ApolloError, NetworkStatus } from "../../core/index.js";
|
||
|
import { isNonEmptyArray } from "../../utilities/index.js";
|
||
|
import { useApolloClient } from "./useApolloClient.js";
|
||
|
import { DocumentType, verifyDocumentType } from "../parser/index.js";
|
||
|
import { __use, useDeepMemo } from "./internal/index.js";
|
||
|
import { getSuspenseCache } from "../internal/index.js";
|
||
|
import { canonicalStringify } from "../../cache/index.js";
|
||
|
import { skipToken } from "./constants.js";
|
||
|
export function useSuspenseQuery(query, options) {
|
||
|
if (options === void 0) { options = Object.create(null); }
|
||
|
var client = useApolloClient(options.client);
|
||
|
var suspenseCache = getSuspenseCache(client);
|
||
|
var watchQueryOptions = useWatchQueryOptions({
|
||
|
client: client,
|
||
|
query: query,
|
||
|
options: options,
|
||
|
});
|
||
|
var fetchPolicy = watchQueryOptions.fetchPolicy, variables = watchQueryOptions.variables;
|
||
|
var _a = options.queryKey, queryKey = _a === void 0 ? [] : _a;
|
||
|
var cacheKey = __spreadArray([
|
||
|
query,
|
||
|
canonicalStringify(variables)
|
||
|
], [].concat(queryKey), true);
|
||
|
var queryRef = suspenseCache.getQueryRef(cacheKey, function () {
|
||
|
return client.watchQuery(watchQueryOptions);
|
||
|
});
|
||
|
var _b = React.useState([queryRef.key, queryRef.promise]), current = _b[0], setPromise = _b[1];
|
||
|
// This saves us a re-execution of the render function when a variable changed.
|
||
|
if (current[0] !== queryRef.key) {
|
||
|
current[0] = queryRef.key;
|
||
|
current[1] = queryRef.promise;
|
||
|
}
|
||
|
var promise = current[1];
|
||
|
if (queryRef.didChangeOptions(watchQueryOptions)) {
|
||
|
current[1] = promise = queryRef.applyOptions(watchQueryOptions);
|
||
|
}
|
||
|
React.useEffect(function () {
|
||
|
var dispose = queryRef.retain();
|
||
|
var removeListener = queryRef.listen(function (promise) {
|
||
|
setPromise([queryRef.key, promise]);
|
||
|
});
|
||
|
return function () {
|
||
|
removeListener();
|
||
|
dispose();
|
||
|
};
|
||
|
}, [queryRef]);
|
||
|
var skipResult = React.useMemo(function () {
|
||
|
var error = toApolloError(queryRef.result);
|
||
|
return {
|
||
|
loading: false,
|
||
|
data: queryRef.result.data,
|
||
|
networkStatus: error ? NetworkStatus.error : NetworkStatus.ready,
|
||
|
error: error,
|
||
|
};
|
||
|
}, [queryRef.result]);
|
||
|
var result = fetchPolicy === "standby" ? skipResult : __use(promise);
|
||
|
var fetchMore = React.useCallback((function (options) {
|
||
|
var promise = queryRef.fetchMore(options);
|
||
|
setPromise([queryRef.key, queryRef.promise]);
|
||
|
return promise;
|
||
|
}), [queryRef]);
|
||
|
var refetch = React.useCallback(function (variables) {
|
||
|
var promise = queryRef.refetch(variables);
|
||
|
setPromise([queryRef.key, queryRef.promise]);
|
||
|
return promise;
|
||
|
}, [queryRef]);
|
||
|
var subscribeToMore = React.useCallback(function (options) { return queryRef.observable.subscribeToMore(options); }, [queryRef]);
|
||
|
return React.useMemo(function () {
|
||
|
return {
|
||
|
client: client,
|
||
|
data: result.data,
|
||
|
error: toApolloError(result),
|
||
|
networkStatus: result.networkStatus,
|
||
|
fetchMore: fetchMore,
|
||
|
refetch: refetch,
|
||
|
subscribeToMore: subscribeToMore,
|
||
|
};
|
||
|
}, [client, fetchMore, refetch, result, subscribeToMore]);
|
||
|
}
|
||
|
function validateOptions(options) {
|
||
|
var query = options.query, fetchPolicy = options.fetchPolicy, returnPartialData = options.returnPartialData;
|
||
|
verifyDocumentType(query, DocumentType.Query);
|
||
|
validateFetchPolicy(fetchPolicy);
|
||
|
validatePartialDataReturn(fetchPolicy, returnPartialData);
|
||
|
}
|
||
|
function validateFetchPolicy(fetchPolicy) {
|
||
|
if (fetchPolicy === void 0) { fetchPolicy = "cache-first"; }
|
||
|
var supportedFetchPolicies = [
|
||
|
"cache-first",
|
||
|
"network-only",
|
||
|
"no-cache",
|
||
|
"cache-and-network",
|
||
|
];
|
||
|
invariant(supportedFetchPolicies.includes(fetchPolicy), 56, fetchPolicy);
|
||
|
}
|
||
|
function validatePartialDataReturn(fetchPolicy, returnPartialData) {
|
||
|
if (fetchPolicy === "no-cache" && returnPartialData) {
|
||
|
globalThis.__DEV__ !== false && invariant.warn(57);
|
||
|
}
|
||
|
}
|
||
|
export function toApolloError(result) {
|
||
|
return isNonEmptyArray(result.errors) ?
|
||
|
new ApolloError({ graphQLErrors: result.errors })
|
||
|
: result.error;
|
||
|
}
|
||
|
export function useWatchQueryOptions(_a) {
|
||
|
var client = _a.client, query = _a.query, options = _a.options;
|
||
|
return useDeepMemo(function () {
|
||
|
var _a;
|
||
|
if (options === skipToken) {
|
||
|
return { query: query, fetchPolicy: "standby" };
|
||
|
}
|
||
|
var fetchPolicy = options.fetchPolicy ||
|
||
|
((_a = client.defaultOptions.watchQuery) === null || _a === void 0 ? void 0 : _a.fetchPolicy) ||
|
||
|
"cache-first";
|
||
|
var watchQueryOptions = __assign(__assign({}, options), { fetchPolicy: fetchPolicy, query: query, notifyOnNetworkStatusChange: false, nextFetchPolicy: void 0 });
|
||
|
if (globalThis.__DEV__ !== false) {
|
||
|
validateOptions(watchQueryOptions);
|
||
|
}
|
||
|
// Assign the updated fetch policy after our validation since `standby` is
|
||
|
// not a supported fetch policy on its own without the use of `skip`.
|
||
|
if (options.skip) {
|
||
|
watchQueryOptions.fetchPolicy = "standby";
|
||
|
}
|
||
|
return watchQueryOptions;
|
||
|
}, [client, options, query]);
|
||
|
}
|
||
|
//# sourceMappingURL=useSuspenseQuery.js.map
|