File: D:/HostingSpaces/SBogers10/shop.komma.nl/node_modules/apollo-client/core/QueryManager.js
"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