sgauthier
6e64e138e2
All checks were successful
Publish To Prod / deploy_and_publish (push) Successful in 35s
867 lines
44 KiB
JavaScript
867 lines
44 KiB
JavaScript
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var tslib_1 = require("tslib");
|
|
var apollo_link_1 = require("apollo-link");
|
|
var apollo_utilities_1 = require("apollo-utilities");
|
|
var ts_invariant_1 = require("ts-invariant");
|
|
var ApolloError_1 = require("../errors/ApolloError");
|
|
var Observable_1 = require("../util/Observable");
|
|
var mutations_1 = require("../data/mutations");
|
|
var queries_1 = require("../data/queries");
|
|
var ObservableQuery_1 = require("./ObservableQuery");
|
|
var networkStatus_1 = require("./networkStatus");
|
|
var types_1 = require("./types");
|
|
var LocalState_1 = require("./LocalState");
|
|
var observables_1 = require("../util/observables");
|
|
var arrays_1 = require("../util/arrays");
|
|
var hasOwnProperty = Object.prototype.hasOwnProperty;
|
|
var QueryManager = (function () {
|
|
function QueryManager(_a) {
|
|
var link = _a.link, _b = _a.queryDeduplication, queryDeduplication = _b === void 0 ? false : _b, store = _a.store, _c = _a.onBroadcast, onBroadcast = _c === void 0 ? function () { return undefined; } : _c, _d = _a.ssrMode, ssrMode = _d === void 0 ? false : _d, _e = _a.clientAwareness, clientAwareness = _e === void 0 ? {} : _e, localState = _a.localState, assumeImmutableResults = _a.assumeImmutableResults;
|
|
this.mutationStore = new mutations_1.MutationStore();
|
|
this.queryStore = new queries_1.QueryStore();
|
|
this.clientAwareness = {};
|
|
this.idCounter = 1;
|
|
this.queries = new Map();
|
|
this.fetchQueryRejectFns = new Map();
|
|
this.transformCache = new (apollo_utilities_1.canUseWeakMap ? WeakMap : Map)();
|
|
this.inFlightLinkObservables = new Map();
|
|
this.pollingInfoByQueryId = new Map();
|
|
this.link = link;
|
|
this.queryDeduplication = queryDeduplication;
|
|
this.dataStore = store;
|
|
this.onBroadcast = onBroadcast;
|
|
this.clientAwareness = clientAwareness;
|
|
this.localState = localState || new LocalState_1.LocalState({ cache: store.getCache() });
|
|
this.ssrMode = ssrMode;
|
|
this.assumeImmutableResults = !!assumeImmutableResults;
|
|
}
|
|
QueryManager.prototype.stop = function () {
|
|
var _this = this;
|
|
this.queries.forEach(function (_info, queryId) {
|
|
_this.stopQueryNoBroadcast(queryId);
|
|
});
|
|
this.fetchQueryRejectFns.forEach(function (reject) {
|
|
reject(new ts_invariant_1.InvariantError('QueryManager stopped while query was in flight'));
|
|
});
|
|
};
|
|
QueryManager.prototype.mutate = function (_a) {
|
|
var mutation = _a.mutation, variables = _a.variables, optimisticResponse = _a.optimisticResponse, updateQueriesByName = _a.updateQueries, _b = _a.refetchQueries, refetchQueries = _b === void 0 ? [] : _b, _c = _a.awaitRefetchQueries, awaitRefetchQueries = _c === void 0 ? false : _c, updateWithProxyFn = _a.update, _d = _a.errorPolicy, errorPolicy = _d === void 0 ? 'none' : _d, fetchPolicy = _a.fetchPolicy, _e = _a.context, context = _e === void 0 ? {} : _e;
|
|
return tslib_1.__awaiter(this, void 0, void 0, function () {
|
|
var mutationId, generateUpdateQueriesInfo, self;
|
|
var _this = this;
|
|
return tslib_1.__generator(this, function (_f) {
|
|
switch (_f.label) {
|
|
case 0:
|
|
ts_invariant_1.invariant(mutation, 'mutation option is required. You must specify your GraphQL document in the mutation option.');
|
|
ts_invariant_1.invariant(!fetchPolicy || fetchPolicy === 'no-cache', "Mutations only support a 'no-cache' fetchPolicy. If you don't want to disable the cache, remove your fetchPolicy setting to proceed with the default mutation behavior.");
|
|
mutationId = this.generateQueryId();
|
|
mutation = this.transform(mutation).document;
|
|
this.setQuery(mutationId, function () { return ({ document: mutation }); });
|
|
variables = this.getVariables(mutation, variables);
|
|
if (!this.transform(mutation).hasClientExports) return [3, 2];
|
|
return [4, this.localState.addExportedVariables(mutation, variables, context)];
|
|
case 1:
|
|
variables = _f.sent();
|
|
_f.label = 2;
|
|
case 2:
|
|
generateUpdateQueriesInfo = function () {
|
|
var ret = {};
|
|
if (updateQueriesByName) {
|
|
_this.queries.forEach(function (_a, queryId) {
|
|
var observableQuery = _a.observableQuery;
|
|
if (observableQuery) {
|
|
var queryName = observableQuery.queryName;
|
|
if (queryName &&
|
|
hasOwnProperty.call(updateQueriesByName, queryName)) {
|
|
ret[queryId] = {
|
|
updater: updateQueriesByName[queryName],
|
|
query: _this.queryStore.get(queryId),
|
|
};
|
|
}
|
|
}
|
|
});
|
|
}
|
|
return ret;
|
|
};
|
|
this.mutationStore.initMutation(mutationId, mutation, variables);
|
|
this.dataStore.markMutationInit({
|
|
mutationId: mutationId,
|
|
document: mutation,
|
|
variables: variables,
|
|
updateQueries: generateUpdateQueriesInfo(),
|
|
update: updateWithProxyFn,
|
|
optimisticResponse: optimisticResponse,
|
|
});
|
|
this.broadcastQueries();
|
|
self = this;
|
|
return [2, new Promise(function (resolve, reject) {
|
|
var storeResult;
|
|
var error;
|
|
self.getObservableFromLink(mutation, tslib_1.__assign(tslib_1.__assign({}, context), { optimisticResponse: optimisticResponse }), variables, false).subscribe({
|
|
next: function (result) {
|
|
if (apollo_utilities_1.graphQLResultHasError(result) && errorPolicy === 'none') {
|
|
error = new ApolloError_1.ApolloError({
|
|
graphQLErrors: result.errors,
|
|
});
|
|
return;
|
|
}
|
|
self.mutationStore.markMutationResult(mutationId);
|
|
if (fetchPolicy !== 'no-cache') {
|
|
self.dataStore.markMutationResult({
|
|
mutationId: mutationId,
|
|
result: result,
|
|
document: mutation,
|
|
variables: variables,
|
|
updateQueries: generateUpdateQueriesInfo(),
|
|
update: updateWithProxyFn,
|
|
});
|
|
}
|
|
storeResult = result;
|
|
},
|
|
error: function (err) {
|
|
self.mutationStore.markMutationError(mutationId, err);
|
|
self.dataStore.markMutationComplete({
|
|
mutationId: mutationId,
|
|
optimisticResponse: optimisticResponse,
|
|
});
|
|
self.broadcastQueries();
|
|
self.setQuery(mutationId, function () { return ({ document: null }); });
|
|
reject(new ApolloError_1.ApolloError({
|
|
networkError: err,
|
|
}));
|
|
},
|
|
complete: function () {
|
|
if (error) {
|
|
self.mutationStore.markMutationError(mutationId, error);
|
|
}
|
|
self.dataStore.markMutationComplete({
|
|
mutationId: mutationId,
|
|
optimisticResponse: optimisticResponse,
|
|
});
|
|
self.broadcastQueries();
|
|
if (error) {
|
|
reject(error);
|
|
return;
|
|
}
|
|
if (typeof refetchQueries === 'function') {
|
|
refetchQueries = refetchQueries(storeResult);
|
|
}
|
|
var refetchQueryPromises = [];
|
|
if (arrays_1.isNonEmptyArray(refetchQueries)) {
|
|
refetchQueries.forEach(function (refetchQuery) {
|
|
if (typeof refetchQuery === 'string') {
|
|
self.queries.forEach(function (_a) {
|
|
var observableQuery = _a.observableQuery;
|
|
if (observableQuery &&
|
|
observableQuery.queryName === refetchQuery) {
|
|
refetchQueryPromises.push(observableQuery.refetch());
|
|
}
|
|
});
|
|
}
|
|
else {
|
|
var queryOptions = {
|
|
query: refetchQuery.query,
|
|
variables: refetchQuery.variables,
|
|
fetchPolicy: 'network-only',
|
|
};
|
|
if (refetchQuery.context) {
|
|
queryOptions.context = refetchQuery.context;
|
|
}
|
|
refetchQueryPromises.push(self.query(queryOptions));
|
|
}
|
|
});
|
|
}
|
|
Promise.all(awaitRefetchQueries ? refetchQueryPromises : []).then(function () {
|
|
self.setQuery(mutationId, function () { return ({ document: null }); });
|
|
if (errorPolicy === 'ignore' &&
|
|
storeResult &&
|
|
apollo_utilities_1.graphQLResultHasError(storeResult)) {
|
|
delete storeResult.errors;
|
|
}
|
|
resolve(storeResult);
|
|
});
|
|
},
|
|
});
|
|
})];
|
|
}
|
|
});
|
|
});
|
|
};
|
|
QueryManager.prototype.fetchQuery = function (queryId, options, fetchType, fetchMoreForQueryId) {
|
|
return tslib_1.__awaiter(this, void 0, void 0, function () {
|
|
var _a, metadata, _b, fetchPolicy, _c, context, query, variables, storeResult, isNetworkOnly, needToFetch, _d, complete, result, shouldFetch, requestId, cancel, networkResult;
|
|
var _this = this;
|
|
return tslib_1.__generator(this, function (_e) {
|
|
switch (_e.label) {
|
|
case 0:
|
|
_a = options.metadata, metadata = _a === void 0 ? null : _a, _b = options.fetchPolicy, fetchPolicy = _b === void 0 ? 'cache-first' : _b, _c = options.context, context = _c === void 0 ? {} : _c;
|
|
query = this.transform(options.query).document;
|
|
variables = this.getVariables(query, options.variables);
|
|
if (!this.transform(query).hasClientExports) return [3, 2];
|
|
return [4, this.localState.addExportedVariables(query, variables, context)];
|
|
case 1:
|
|
variables = _e.sent();
|
|
_e.label = 2;
|
|
case 2:
|
|
options = tslib_1.__assign(tslib_1.__assign({}, options), { variables: variables });
|
|
isNetworkOnly = fetchPolicy === 'network-only' || fetchPolicy === 'no-cache';
|
|
needToFetch = isNetworkOnly;
|
|
if (!isNetworkOnly) {
|
|
_d = this.dataStore.getCache().diff({
|
|
query: query,
|
|
variables: variables,
|
|
returnPartialData: true,
|
|
optimistic: false,
|
|
}), complete = _d.complete, result = _d.result;
|
|
needToFetch = !complete || fetchPolicy === 'cache-and-network';
|
|
storeResult = result;
|
|
}
|
|
shouldFetch = needToFetch && fetchPolicy !== 'cache-only' && fetchPolicy !== 'standby';
|
|
if (apollo_utilities_1.hasDirectives(['live'], query))
|
|
shouldFetch = true;
|
|
requestId = this.idCounter++;
|
|
cancel = fetchPolicy !== 'no-cache'
|
|
? this.updateQueryWatch(queryId, query, options)
|
|
: undefined;
|
|
this.setQuery(queryId, function () { return ({
|
|
document: query,
|
|
lastRequestId: requestId,
|
|
invalidated: true,
|
|
cancel: cancel,
|
|
}); });
|
|
this.invalidate(fetchMoreForQueryId);
|
|
this.queryStore.initQuery({
|
|
queryId: queryId,
|
|
document: query,
|
|
storePreviousVariables: shouldFetch,
|
|
variables: variables,
|
|
isPoll: fetchType === types_1.FetchType.poll,
|
|
isRefetch: fetchType === types_1.FetchType.refetch,
|
|
metadata: metadata,
|
|
fetchMoreForQueryId: fetchMoreForQueryId,
|
|
});
|
|
this.broadcastQueries();
|
|
if (shouldFetch) {
|
|
networkResult = this.fetchRequest({
|
|
requestId: requestId,
|
|
queryId: queryId,
|
|
document: query,
|
|
options: options,
|
|
fetchMoreForQueryId: fetchMoreForQueryId,
|
|
}).catch(function (error) {
|
|
if (ApolloError_1.isApolloError(error)) {
|
|
throw error;
|
|
}
|
|
else {
|
|
if (requestId >= _this.getQuery(queryId).lastRequestId) {
|
|
_this.queryStore.markQueryError(queryId, error, fetchMoreForQueryId);
|
|
_this.invalidate(queryId);
|
|
_this.invalidate(fetchMoreForQueryId);
|
|
_this.broadcastQueries();
|
|
}
|
|
throw new ApolloError_1.ApolloError({ networkError: error });
|
|
}
|
|
});
|
|
if (fetchPolicy !== 'cache-and-network') {
|
|
return [2, networkResult];
|
|
}
|
|
networkResult.catch(function () { });
|
|
}
|
|
this.queryStore.markQueryResultClient(queryId, !shouldFetch);
|
|
this.invalidate(queryId);
|
|
this.invalidate(fetchMoreForQueryId);
|
|
if (this.transform(query).hasForcedResolvers) {
|
|
return [2, this.localState.runResolvers({
|
|
document: query,
|
|
remoteResult: { data: storeResult },
|
|
context: context,
|
|
variables: variables,
|
|
onlyRunForcedResolvers: true,
|
|
}).then(function (result) {
|
|
_this.markQueryResult(queryId, result, options, fetchMoreForQueryId);
|
|
_this.broadcastQueries();
|
|
return result;
|
|
})];
|
|
}
|
|
this.broadcastQueries();
|
|
return [2, { data: storeResult }];
|
|
}
|
|
});
|
|
});
|
|
};
|
|
QueryManager.prototype.markQueryResult = function (queryId, result, _a, fetchMoreForQueryId) {
|
|
var fetchPolicy = _a.fetchPolicy, variables = _a.variables, errorPolicy = _a.errorPolicy;
|
|
if (fetchPolicy === 'no-cache') {
|
|
this.setQuery(queryId, function () { return ({
|
|
newData: { result: result.data, complete: true },
|
|
}); });
|
|
}
|
|
else {
|
|
this.dataStore.markQueryResult(result, this.getQuery(queryId).document, variables, fetchMoreForQueryId, errorPolicy === 'ignore' || errorPolicy === 'all');
|
|
}
|
|
};
|
|
QueryManager.prototype.queryListenerForObserver = function (queryId, options, observer) {
|
|
var _this = this;
|
|
function invoke(method, argument) {
|
|
if (observer[method]) {
|
|
try {
|
|
observer[method](argument);
|
|
}
|
|
catch (e) {
|
|
ts_invariant_1.invariant.error(e);
|
|
}
|
|
}
|
|
else if (method === 'error') {
|
|
ts_invariant_1.invariant.error(argument);
|
|
}
|
|
}
|
|
return function (queryStoreValue, newData) {
|
|
_this.invalidate(queryId, false);
|
|
if (!queryStoreValue)
|
|
return;
|
|
var _a = _this.getQuery(queryId), observableQuery = _a.observableQuery, document = _a.document;
|
|
var fetchPolicy = observableQuery
|
|
? observableQuery.options.fetchPolicy
|
|
: options.fetchPolicy;
|
|
if (fetchPolicy === 'standby')
|
|
return;
|
|
var loading = networkStatus_1.isNetworkRequestInFlight(queryStoreValue.networkStatus);
|
|
var lastResult = observableQuery && observableQuery.getLastResult();
|
|
var networkStatusChanged = !!(lastResult &&
|
|
lastResult.networkStatus !== queryStoreValue.networkStatus);
|
|
var shouldNotifyIfLoading = options.returnPartialData ||
|
|
(!newData && queryStoreValue.previousVariables) ||
|
|
(networkStatusChanged && options.notifyOnNetworkStatusChange) ||
|
|
fetchPolicy === 'cache-only' ||
|
|
fetchPolicy === 'cache-and-network';
|
|
if (loading && !shouldNotifyIfLoading) {
|
|
return;
|
|
}
|
|
var hasGraphQLErrors = arrays_1.isNonEmptyArray(queryStoreValue.graphQLErrors);
|
|
var errorPolicy = observableQuery
|
|
&& observableQuery.options.errorPolicy
|
|
|| options.errorPolicy
|
|
|| 'none';
|
|
if (errorPolicy === 'none' && hasGraphQLErrors || queryStoreValue.networkError) {
|
|
return invoke('error', new ApolloError_1.ApolloError({
|
|
graphQLErrors: queryStoreValue.graphQLErrors,
|
|
networkError: queryStoreValue.networkError,
|
|
}));
|
|
}
|
|
try {
|
|
var data = void 0;
|
|
var isMissing = void 0;
|
|
if (newData) {
|
|
if (fetchPolicy !== 'no-cache' && fetchPolicy !== 'network-only') {
|
|
_this.setQuery(queryId, function () { return ({ newData: null }); });
|
|
}
|
|
data = newData.result;
|
|
isMissing = !newData.complete;
|
|
}
|
|
else {
|
|
var lastError = observableQuery && observableQuery.getLastError();
|
|
var errorStatusChanged = errorPolicy !== 'none' &&
|
|
(lastError && lastError.graphQLErrors) !==
|
|
queryStoreValue.graphQLErrors;
|
|
if (lastResult && lastResult.data && !errorStatusChanged) {
|
|
data = lastResult.data;
|
|
isMissing = false;
|
|
}
|
|
else {
|
|
var diffResult = _this.dataStore.getCache().diff({
|
|
query: document,
|
|
variables: queryStoreValue.previousVariables ||
|
|
queryStoreValue.variables,
|
|
returnPartialData: true,
|
|
optimistic: true,
|
|
});
|
|
data = diffResult.result;
|
|
isMissing = !diffResult.complete;
|
|
}
|
|
}
|
|
var stale = isMissing && !(options.returnPartialData ||
|
|
fetchPolicy === 'cache-only');
|
|
var resultFromStore = {
|
|
data: stale ? lastResult && lastResult.data : data,
|
|
loading: loading,
|
|
networkStatus: queryStoreValue.networkStatus,
|
|
stale: stale,
|
|
};
|
|
if (errorPolicy === 'all' && hasGraphQLErrors) {
|
|
resultFromStore.errors = queryStoreValue.graphQLErrors;
|
|
}
|
|
invoke('next', resultFromStore);
|
|
}
|
|
catch (networkError) {
|
|
invoke('error', new ApolloError_1.ApolloError({ networkError: networkError }));
|
|
}
|
|
};
|
|
};
|
|
QueryManager.prototype.transform = function (document) {
|
|
var transformCache = this.transformCache;
|
|
if (!transformCache.has(document)) {
|
|
var cache = this.dataStore.getCache();
|
|
var transformed = cache.transformDocument(document);
|
|
var forLink = apollo_utilities_1.removeConnectionDirectiveFromDocument(cache.transformForLink(transformed));
|
|
var clientQuery = this.localState.clientQuery(transformed);
|
|
var serverQuery = this.localState.serverQuery(forLink);
|
|
var cacheEntry_1 = {
|
|
document: transformed,
|
|
hasClientExports: apollo_utilities_1.hasClientExports(transformed),
|
|
hasForcedResolvers: this.localState.shouldForceResolvers(transformed),
|
|
clientQuery: clientQuery,
|
|
serverQuery: serverQuery,
|
|
defaultVars: apollo_utilities_1.getDefaultValues(apollo_utilities_1.getOperationDefinition(transformed)),
|
|
};
|
|
var add = function (doc) {
|
|
if (doc && !transformCache.has(doc)) {
|
|
transformCache.set(doc, cacheEntry_1);
|
|
}
|
|
};
|
|
add(document);
|
|
add(transformed);
|
|
add(clientQuery);
|
|
add(serverQuery);
|
|
}
|
|
return transformCache.get(document);
|
|
};
|
|
QueryManager.prototype.getVariables = function (document, variables) {
|
|
return tslib_1.__assign(tslib_1.__assign({}, this.transform(document).defaultVars), variables);
|
|
};
|
|
QueryManager.prototype.watchQuery = function (options, shouldSubscribe) {
|
|
if (shouldSubscribe === void 0) { shouldSubscribe = true; }
|
|
ts_invariant_1.invariant(options.fetchPolicy !== 'standby', 'client.watchQuery cannot be called with fetchPolicy set to "standby"');
|
|
options.variables = this.getVariables(options.query, options.variables);
|
|
if (typeof options.notifyOnNetworkStatusChange === 'undefined') {
|
|
options.notifyOnNetworkStatusChange = false;
|
|
}
|
|
var transformedOptions = tslib_1.__assign({}, options);
|
|
return new ObservableQuery_1.ObservableQuery({
|
|
queryManager: this,
|
|
options: transformedOptions,
|
|
shouldSubscribe: shouldSubscribe,
|
|
});
|
|
};
|
|
QueryManager.prototype.query = function (options) {
|
|
var _this = this;
|
|
ts_invariant_1.invariant(options.query, 'query option is required. You must specify your GraphQL document ' +
|
|
'in the query option.');
|
|
ts_invariant_1.invariant(options.query.kind === 'Document', 'You must wrap the query string in a "gql" tag.');
|
|
ts_invariant_1.invariant(!options.returnPartialData, 'returnPartialData option only supported on watchQuery.');
|
|
ts_invariant_1.invariant(!options.pollInterval, 'pollInterval option only supported on watchQuery.');
|
|
return new Promise(function (resolve, reject) {
|
|
var watchedQuery = _this.watchQuery(options, false);
|
|
_this.fetchQueryRejectFns.set("query:" + watchedQuery.queryId, reject);
|
|
watchedQuery
|
|
.result()
|
|
.then(resolve, reject)
|
|
.then(function () {
|
|
return _this.fetchQueryRejectFns.delete("query:" + watchedQuery.queryId);
|
|
});
|
|
});
|
|
};
|
|
QueryManager.prototype.generateQueryId = function () {
|
|
return String(this.idCounter++);
|
|
};
|
|
QueryManager.prototype.stopQueryInStore = function (queryId) {
|
|
this.stopQueryInStoreNoBroadcast(queryId);
|
|
this.broadcastQueries();
|
|
};
|
|
QueryManager.prototype.stopQueryInStoreNoBroadcast = function (queryId) {
|
|
this.stopPollingQuery(queryId);
|
|
this.queryStore.stopQuery(queryId);
|
|
this.invalidate(queryId);
|
|
};
|
|
QueryManager.prototype.addQueryListener = function (queryId, listener) {
|
|
this.setQuery(queryId, function (_a) {
|
|
var listeners = _a.listeners;
|
|
listeners.add(listener);
|
|
return { invalidated: false };
|
|
});
|
|
};
|
|
QueryManager.prototype.updateQueryWatch = function (queryId, document, options) {
|
|
var _this = this;
|
|
var cancel = this.getQuery(queryId).cancel;
|
|
if (cancel)
|
|
cancel();
|
|
var previousResult = function () {
|
|
var previousResult = null;
|
|
var observableQuery = _this.getQuery(queryId).observableQuery;
|
|
if (observableQuery) {
|
|
var lastResult = observableQuery.getLastResult();
|
|
if (lastResult) {
|
|
previousResult = lastResult.data;
|
|
}
|
|
}
|
|
return previousResult;
|
|
};
|
|
return this.dataStore.getCache().watch({
|
|
query: document,
|
|
variables: options.variables,
|
|
optimistic: true,
|
|
previousResult: previousResult,
|
|
callback: function (newData) {
|
|
_this.setQuery(queryId, function () { return ({ invalidated: true, newData: newData }); });
|
|
},
|
|
});
|
|
};
|
|
QueryManager.prototype.addObservableQuery = function (queryId, observableQuery) {
|
|
this.setQuery(queryId, function () { return ({ observableQuery: observableQuery }); });
|
|
};
|
|
QueryManager.prototype.removeObservableQuery = function (queryId) {
|
|
var cancel = this.getQuery(queryId).cancel;
|
|
this.setQuery(queryId, function () { return ({ observableQuery: null }); });
|
|
if (cancel)
|
|
cancel();
|
|
};
|
|
QueryManager.prototype.clearStore = function () {
|
|
this.fetchQueryRejectFns.forEach(function (reject) {
|
|
reject(new ts_invariant_1.InvariantError('Store reset while query was in flight (not completed in link chain)'));
|
|
});
|
|
var resetIds = [];
|
|
this.queries.forEach(function (_a, queryId) {
|
|
var observableQuery = _a.observableQuery;
|
|
if (observableQuery)
|
|
resetIds.push(queryId);
|
|
});
|
|
this.queryStore.reset(resetIds);
|
|
this.mutationStore.reset();
|
|
return this.dataStore.reset();
|
|
};
|
|
QueryManager.prototype.resetStore = function () {
|
|
var _this = this;
|
|
return this.clearStore().then(function () {
|
|
return _this.reFetchObservableQueries();
|
|
});
|
|
};
|
|
QueryManager.prototype.reFetchObservableQueries = function (includeStandby) {
|
|
var _this = this;
|
|
if (includeStandby === void 0) { includeStandby = false; }
|
|
var observableQueryPromises = [];
|
|
this.queries.forEach(function (_a, queryId) {
|
|
var observableQuery = _a.observableQuery;
|
|
if (observableQuery) {
|
|
var fetchPolicy = observableQuery.options.fetchPolicy;
|
|
observableQuery.resetLastResults();
|
|
if (fetchPolicy !== 'cache-only' &&
|
|
(includeStandby || fetchPolicy !== 'standby')) {
|
|
observableQueryPromises.push(observableQuery.refetch());
|
|
}
|
|
_this.setQuery(queryId, function () { return ({ newData: null }); });
|
|
_this.invalidate(queryId);
|
|
}
|
|
});
|
|
this.broadcastQueries();
|
|
return Promise.all(observableQueryPromises);
|
|
};
|
|
QueryManager.prototype.observeQuery = function (queryId, options, observer) {
|
|
this.addQueryListener(queryId, this.queryListenerForObserver(queryId, options, observer));
|
|
return this.fetchQuery(queryId, options);
|
|
};
|
|
QueryManager.prototype.startQuery = function (queryId, options, listener) {
|
|
ts_invariant_1.invariant.warn("The QueryManager.startQuery method has been deprecated");
|
|
this.addQueryListener(queryId, listener);
|
|
this.fetchQuery(queryId, options)
|
|
.catch(function () { return undefined; });
|
|
return queryId;
|
|
};
|
|
QueryManager.prototype.startGraphQLSubscription = function (_a) {
|
|
var _this = this;
|
|
var query = _a.query, fetchPolicy = _a.fetchPolicy, variables = _a.variables;
|
|
query = this.transform(query).document;
|
|
variables = this.getVariables(query, variables);
|
|
var makeObservable = function (variables) {
|
|
return _this.getObservableFromLink(query, {}, variables, false).map(function (result) {
|
|
if (!fetchPolicy || fetchPolicy !== 'no-cache') {
|
|
_this.dataStore.markSubscriptionResult(result, query, variables);
|
|
_this.broadcastQueries();
|
|
}
|
|
if (apollo_utilities_1.graphQLResultHasError(result)) {
|
|
throw new ApolloError_1.ApolloError({
|
|
graphQLErrors: result.errors,
|
|
});
|
|
}
|
|
return result;
|
|
});
|
|
};
|
|
if (this.transform(query).hasClientExports) {
|
|
var observablePromise_1 = this.localState.addExportedVariables(query, variables).then(makeObservable);
|
|
return new Observable_1.Observable(function (observer) {
|
|
var sub = null;
|
|
observablePromise_1.then(function (observable) { return sub = observable.subscribe(observer); }, observer.error);
|
|
return function () { return sub && sub.unsubscribe(); };
|
|
});
|
|
}
|
|
return makeObservable(variables);
|
|
};
|
|
QueryManager.prototype.stopQuery = function (queryId) {
|
|
this.stopQueryNoBroadcast(queryId);
|
|
this.broadcastQueries();
|
|
};
|
|
QueryManager.prototype.stopQueryNoBroadcast = function (queryId) {
|
|
this.stopQueryInStoreNoBroadcast(queryId);
|
|
this.removeQuery(queryId);
|
|
};
|
|
QueryManager.prototype.removeQuery = function (queryId) {
|
|
this.fetchQueryRejectFns.delete("query:" + queryId);
|
|
this.fetchQueryRejectFns.delete("fetchRequest:" + queryId);
|
|
this.getQuery(queryId).subscriptions.forEach(function (x) { return x.unsubscribe(); });
|
|
this.queries.delete(queryId);
|
|
};
|
|
QueryManager.prototype.getCurrentQueryResult = function (observableQuery, optimistic) {
|
|
if (optimistic === void 0) { optimistic = true; }
|
|
var _a = observableQuery.options, variables = _a.variables, query = _a.query, fetchPolicy = _a.fetchPolicy, returnPartialData = _a.returnPartialData;
|
|
var lastResult = observableQuery.getLastResult();
|
|
var newData = this.getQuery(observableQuery.queryId).newData;
|
|
if (newData && newData.complete) {
|
|
return { data: newData.result, partial: false };
|
|
}
|
|
if (fetchPolicy === 'no-cache' || fetchPolicy === 'network-only') {
|
|
return { data: undefined, partial: false };
|
|
}
|
|
var _b = this.dataStore.getCache().diff({
|
|
query: query,
|
|
variables: variables,
|
|
previousResult: lastResult ? lastResult.data : undefined,
|
|
returnPartialData: true,
|
|
optimistic: optimistic,
|
|
}), result = _b.result, complete = _b.complete;
|
|
return {
|
|
data: (complete || returnPartialData) ? result : void 0,
|
|
partial: !complete,
|
|
};
|
|
};
|
|
QueryManager.prototype.getQueryWithPreviousResult = function (queryIdOrObservable) {
|
|
var observableQuery;
|
|
if (typeof queryIdOrObservable === 'string') {
|
|
var foundObserveableQuery = this.getQuery(queryIdOrObservable).observableQuery;
|
|
ts_invariant_1.invariant(foundObserveableQuery, "ObservableQuery with this id doesn't exist: " + queryIdOrObservable);
|
|
observableQuery = foundObserveableQuery;
|
|
}
|
|
else {
|
|
observableQuery = queryIdOrObservable;
|
|
}
|
|
var _a = observableQuery.options, variables = _a.variables, query = _a.query;
|
|
return {
|
|
previousResult: this.getCurrentQueryResult(observableQuery, false).data,
|
|
variables: variables,
|
|
document: query,
|
|
};
|
|
};
|
|
QueryManager.prototype.broadcastQueries = function () {
|
|
var _this = this;
|
|
this.onBroadcast();
|
|
this.queries.forEach(function (info, id) {
|
|
if (info.invalidated) {
|
|
info.listeners.forEach(function (listener) {
|
|
if (listener) {
|
|
listener(_this.queryStore.get(id), info.newData);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
};
|
|
QueryManager.prototype.getLocalState = function () {
|
|
return this.localState;
|
|
};
|
|
QueryManager.prototype.getObservableFromLink = function (query, context, variables, deduplication) {
|
|
var _this = this;
|
|
if (deduplication === void 0) { deduplication = this.queryDeduplication; }
|
|
var observable;
|
|
var serverQuery = this.transform(query).serverQuery;
|
|
if (serverQuery) {
|
|
var _a = this, inFlightLinkObservables_1 = _a.inFlightLinkObservables, link = _a.link;
|
|
var operation = {
|
|
query: serverQuery,
|
|
variables: variables,
|
|
operationName: apollo_utilities_1.getOperationName(serverQuery) || void 0,
|
|
context: this.prepareContext(tslib_1.__assign(tslib_1.__assign({}, context), { forceFetch: !deduplication })),
|
|
};
|
|
context = operation.context;
|
|
if (deduplication) {
|
|
var byVariables_1 = inFlightLinkObservables_1.get(serverQuery) || new Map();
|
|
inFlightLinkObservables_1.set(serverQuery, byVariables_1);
|
|
var varJson_1 = JSON.stringify(variables);
|
|
observable = byVariables_1.get(varJson_1);
|
|
if (!observable) {
|
|
byVariables_1.set(varJson_1, observable = observables_1.multiplex(apollo_link_1.execute(link, operation)));
|
|
var cleanup = function () {
|
|
byVariables_1.delete(varJson_1);
|
|
if (!byVariables_1.size)
|
|
inFlightLinkObservables_1.delete(serverQuery);
|
|
cleanupSub_1.unsubscribe();
|
|
};
|
|
var cleanupSub_1 = observable.subscribe({
|
|
next: cleanup,
|
|
error: cleanup,
|
|
complete: cleanup,
|
|
});
|
|
}
|
|
}
|
|
else {
|
|
observable = observables_1.multiplex(apollo_link_1.execute(link, operation));
|
|
}
|
|
}
|
|
else {
|
|
observable = Observable_1.Observable.of({ data: {} });
|
|
context = this.prepareContext(context);
|
|
}
|
|
var clientQuery = this.transform(query).clientQuery;
|
|
if (clientQuery) {
|
|
observable = observables_1.asyncMap(observable, function (result) {
|
|
return _this.localState.runResolvers({
|
|
document: clientQuery,
|
|
remoteResult: result,
|
|
context: context,
|
|
variables: variables,
|
|
});
|
|
});
|
|
}
|
|
return observable;
|
|
};
|
|
QueryManager.prototype.fetchRequest = function (_a) {
|
|
var _this = this;
|
|
var requestId = _a.requestId, queryId = _a.queryId, document = _a.document, options = _a.options, fetchMoreForQueryId = _a.fetchMoreForQueryId;
|
|
var variables = options.variables, _b = options.errorPolicy, errorPolicy = _b === void 0 ? 'none' : _b, fetchPolicy = options.fetchPolicy;
|
|
var resultFromStore;
|
|
var errorsFromStore;
|
|
return new Promise(function (resolve, reject) {
|
|
var observable = _this.getObservableFromLink(document, options.context, variables);
|
|
var fqrfId = "fetchRequest:" + queryId;
|
|
_this.fetchQueryRejectFns.set(fqrfId, reject);
|
|
var cleanup = function () {
|
|
_this.fetchQueryRejectFns.delete(fqrfId);
|
|
_this.setQuery(queryId, function (_a) {
|
|
var subscriptions = _a.subscriptions;
|
|
subscriptions.delete(subscription);
|
|
});
|
|
};
|
|
var subscription = observable.map(function (result) {
|
|
if (requestId >= _this.getQuery(queryId).lastRequestId) {
|
|
_this.markQueryResult(queryId, result, options, fetchMoreForQueryId);
|
|
_this.queryStore.markQueryResult(queryId, result, fetchMoreForQueryId);
|
|
_this.invalidate(queryId);
|
|
_this.invalidate(fetchMoreForQueryId);
|
|
_this.broadcastQueries();
|
|
}
|
|
if (errorPolicy === 'none' && arrays_1.isNonEmptyArray(result.errors)) {
|
|
return reject(new ApolloError_1.ApolloError({
|
|
graphQLErrors: result.errors,
|
|
}));
|
|
}
|
|
if (errorPolicy === 'all') {
|
|
errorsFromStore = result.errors;
|
|
}
|
|
if (fetchMoreForQueryId || fetchPolicy === 'no-cache') {
|
|
resultFromStore = result.data;
|
|
}
|
|
else {
|
|
var _a = _this.dataStore.getCache().diff({
|
|
variables: variables,
|
|
query: document,
|
|
optimistic: false,
|
|
returnPartialData: true,
|
|
}), result_1 = _a.result, complete = _a.complete;
|
|
if (complete || options.returnPartialData) {
|
|
resultFromStore = result_1;
|
|
}
|
|
}
|
|
}).subscribe({
|
|
error: function (error) {
|
|
cleanup();
|
|
reject(error);
|
|
},
|
|
complete: function () {
|
|
cleanup();
|
|
resolve({
|
|
data: resultFromStore,
|
|
errors: errorsFromStore,
|
|
loading: false,
|
|
networkStatus: networkStatus_1.NetworkStatus.ready,
|
|
stale: false,
|
|
});
|
|
},
|
|
});
|
|
_this.setQuery(queryId, function (_a) {
|
|
var subscriptions = _a.subscriptions;
|
|
subscriptions.add(subscription);
|
|
});
|
|
});
|
|
};
|
|
QueryManager.prototype.getQuery = function (queryId) {
|
|
return (this.queries.get(queryId) || {
|
|
listeners: new Set(),
|
|
invalidated: false,
|
|
document: null,
|
|
newData: null,
|
|
lastRequestId: 1,
|
|
observableQuery: null,
|
|
subscriptions: new Set(),
|
|
});
|
|
};
|
|
QueryManager.prototype.setQuery = function (queryId, updater) {
|
|
var prev = this.getQuery(queryId);
|
|
var newInfo = tslib_1.__assign(tslib_1.__assign({}, prev), updater(prev));
|
|
this.queries.set(queryId, newInfo);
|
|
};
|
|
QueryManager.prototype.invalidate = function (queryId, invalidated) {
|
|
if (invalidated === void 0) { invalidated = true; }
|
|
if (queryId) {
|
|
this.setQuery(queryId, function () { return ({ invalidated: invalidated }); });
|
|
}
|
|
};
|
|
QueryManager.prototype.prepareContext = function (context) {
|
|
if (context === void 0) { context = {}; }
|
|
var newContext = this.localState.prepareContext(context);
|
|
return tslib_1.__assign(tslib_1.__assign({}, newContext), { clientAwareness: this.clientAwareness });
|
|
};
|
|
QueryManager.prototype.checkInFlight = function (queryId) {
|
|
var query = this.queryStore.get(queryId);
|
|
return (query &&
|
|
query.networkStatus !== networkStatus_1.NetworkStatus.ready &&
|
|
query.networkStatus !== networkStatus_1.NetworkStatus.error);
|
|
};
|
|
QueryManager.prototype.startPollingQuery = function (options, queryId, listener) {
|
|
var _this = this;
|
|
var pollInterval = options.pollInterval;
|
|
ts_invariant_1.invariant(pollInterval, 'Attempted to start a polling query without a polling interval.');
|
|
if (!this.ssrMode) {
|
|
var info = this.pollingInfoByQueryId.get(queryId);
|
|
if (!info) {
|
|
this.pollingInfoByQueryId.set(queryId, (info = {}));
|
|
}
|
|
info.interval = pollInterval;
|
|
info.options = tslib_1.__assign(tslib_1.__assign({}, options), { fetchPolicy: 'network-only' });
|
|
var maybeFetch_1 = function () {
|
|
var info = _this.pollingInfoByQueryId.get(queryId);
|
|
if (info) {
|
|
if (_this.checkInFlight(queryId)) {
|
|
poll_1();
|
|
}
|
|
else {
|
|
_this.fetchQuery(queryId, info.options, types_1.FetchType.poll).then(poll_1, poll_1);
|
|
}
|
|
}
|
|
};
|
|
var poll_1 = function () {
|
|
var info = _this.pollingInfoByQueryId.get(queryId);
|
|
if (info) {
|
|
clearTimeout(info.timeout);
|
|
info.timeout = setTimeout(maybeFetch_1, info.interval);
|
|
}
|
|
};
|
|
if (listener) {
|
|
this.addQueryListener(queryId, listener);
|
|
}
|
|
poll_1();
|
|
}
|
|
return queryId;
|
|
};
|
|
QueryManager.prototype.stopPollingQuery = function (queryId) {
|
|
this.pollingInfoByQueryId.delete(queryId);
|
|
};
|
|
return QueryManager;
|
|
}());
|
|
exports.QueryManager = QueryManager;
|
|
//# sourceMappingURL=QueryManager.js.map
|