File: D:/HostingSpaces/SBogers10/shop.komma.nl/node_modules/apollo-client/core/LocalState.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var tslib_1 = require("tslib");
var visitor_1 = require("graphql/language/visitor");
var apollo_utilities_1 = require("apollo-utilities");
var ts_invariant_1 = require("ts-invariant");
var capitalizeFirstLetter_1 = require("../util/capitalizeFirstLetter");
var LocalState = (function () {
function LocalState(_a) {
var cache = _a.cache, client = _a.client, resolvers = _a.resolvers, fragmentMatcher = _a.fragmentMatcher;
this.cache = cache;
if (client) {
this.client = client;
}
if (resolvers) {
this.addResolvers(resolvers);
}
if (fragmentMatcher) {
this.setFragmentMatcher(fragmentMatcher);
}
}
LocalState.prototype.addResolvers = function (resolvers) {
var _this = this;
this.resolvers = this.resolvers || {};
if (Array.isArray(resolvers)) {
resolvers.forEach(function (resolverGroup) {
_this.resolvers = apollo_utilities_1.mergeDeep(_this.resolvers, resolverGroup);
});
}
else {
this.resolvers = apollo_utilities_1.mergeDeep(this.resolvers, resolvers);
}
};
LocalState.prototype.setResolvers = function (resolvers) {
this.resolvers = {};
this.addResolvers(resolvers);
};
LocalState.prototype.getResolvers = function () {
return this.resolvers || {};
};
LocalState.prototype.runResolvers = function (_a) {
var document = _a.document, remoteResult = _a.remoteResult, context = _a.context, variables = _a.variables, _b = _a.onlyRunForcedResolvers, onlyRunForcedResolvers = _b === void 0 ? false : _b;
return tslib_1.__awaiter(this, void 0, void 0, function () {
return tslib_1.__generator(this, function (_c) {
if (document) {
return [2, this.resolveDocument(document, remoteResult.data, context, variables, this.fragmentMatcher, onlyRunForcedResolvers).then(function (localResult) { return (tslib_1.__assign(tslib_1.__assign({}, remoteResult), { data: localResult.result })); })];
}
return [2, remoteResult];
});
});
};
LocalState.prototype.setFragmentMatcher = function (fragmentMatcher) {
this.fragmentMatcher = fragmentMatcher;
};
LocalState.prototype.getFragmentMatcher = function () {
return this.fragmentMatcher;
};
LocalState.prototype.clientQuery = function (document) {
if (apollo_utilities_1.hasDirectives(['client'], document)) {
if (this.resolvers) {
return document;
}
ts_invariant_1.invariant.warn('Found @client directives in a query but no ApolloClient resolvers ' +
'were specified. This means ApolloClient local resolver handling ' +
'has been disabled, and @client directives will be passed through ' +
'to your link chain.');
}
return null;
};
LocalState.prototype.serverQuery = function (document) {
return this.resolvers ? apollo_utilities_1.removeClientSetsFromDocument(document) : document;
};
LocalState.prototype.prepareContext = function (context) {
if (context === void 0) { context = {}; }
var cache = this.cache;
var newContext = tslib_1.__assign(tslib_1.__assign({}, context), { cache: cache, getCacheKey: function (obj) {
if (cache.config) {
return cache.config.dataIdFromObject(obj);
}
else {
ts_invariant_1.invariant(false, 'To use context.getCacheKey, you need to use a cache that has ' +
'a configurable dataIdFromObject, like apollo-cache-inmemory.');
}
} });
return newContext;
};
LocalState.prototype.addExportedVariables = function (document, variables, context) {
if (variables === void 0) { variables = {}; }
if (context === void 0) { context = {}; }
return tslib_1.__awaiter(this, void 0, void 0, function () {
return tslib_1.__generator(this, function (_a) {
if (document) {
return [2, this.resolveDocument(document, this.buildRootValueFromCache(document, variables) || {}, this.prepareContext(context), variables).then(function (data) { return (tslib_1.__assign(tslib_1.__assign({}, variables), data.exportedVariables)); })];
}
return [2, tslib_1.__assign({}, variables)];
});
});
};
LocalState.prototype.shouldForceResolvers = function (document) {
var forceResolvers = false;
visitor_1.visit(document, {
Directive: {
enter: function (node) {
if (node.name.value === 'client' && node.arguments) {
forceResolvers = node.arguments.some(function (arg) {
return arg.name.value === 'always' &&
arg.value.kind === 'BooleanValue' &&
arg.value.value === true;
});
if (forceResolvers) {
return visitor_1.BREAK;
}
}
},
},
});
return forceResolvers;
};
LocalState.prototype.buildRootValueFromCache = function (document, variables) {
return this.cache.diff({
query: apollo_utilities_1.buildQueryFromSelectionSet(document),
variables: variables,
returnPartialData: true,
optimistic: false,
}).result;
};
LocalState.prototype.resolveDocument = function (document, rootValue, context, variables, fragmentMatcher, onlyRunForcedResolvers) {
if (context === void 0) { context = {}; }
if (variables === void 0) { variables = {}; }
if (fragmentMatcher === void 0) { fragmentMatcher = function () { return true; }; }
if (onlyRunForcedResolvers === void 0) { onlyRunForcedResolvers = false; }
return tslib_1.__awaiter(this, void 0, void 0, function () {
var mainDefinition, fragments, fragmentMap, definitionOperation, defaultOperationType, _a, cache, client, execContext;
return tslib_1.__generator(this, function (_b) {
mainDefinition = apollo_utilities_1.getMainDefinition(document);
fragments = apollo_utilities_1.getFragmentDefinitions(document);
fragmentMap = apollo_utilities_1.createFragmentMap(fragments);
definitionOperation = mainDefinition
.operation;
defaultOperationType = definitionOperation
? capitalizeFirstLetter_1.capitalizeFirstLetter(definitionOperation)
: 'Query';
_a = this, cache = _a.cache, client = _a.client;
execContext = {
fragmentMap: fragmentMap,
context: tslib_1.__assign(tslib_1.__assign({}, context), { cache: cache,
client: client }),
variables: variables,
fragmentMatcher: fragmentMatcher,
defaultOperationType: defaultOperationType,
exportedVariables: {},
onlyRunForcedResolvers: onlyRunForcedResolvers,
};
return [2, this.resolveSelectionSet(mainDefinition.selectionSet, rootValue, execContext).then(function (result) { return ({
result: result,
exportedVariables: execContext.exportedVariables,
}); })];
});
});
};
LocalState.prototype.resolveSelectionSet = function (selectionSet, rootValue, execContext) {
return tslib_1.__awaiter(this, void 0, void 0, function () {
var fragmentMap, context, variables, resultsToMerge, execute;
var _this = this;
return tslib_1.__generator(this, function (_a) {
fragmentMap = execContext.fragmentMap, context = execContext.context, variables = execContext.variables;
resultsToMerge = [rootValue];
execute = function (selection) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
var fragment, typeCondition;
return tslib_1.__generator(this, function (_a) {
if (!apollo_utilities_1.shouldInclude(selection, variables)) {
return [2];
}
if (apollo_utilities_1.isField(selection)) {
return [2, this.resolveField(selection, rootValue, execContext).then(function (fieldResult) {
var _a;
if (typeof fieldResult !== 'undefined') {
resultsToMerge.push((_a = {},
_a[apollo_utilities_1.resultKeyNameFromField(selection)] = fieldResult,
_a));
}
})];
}
if (apollo_utilities_1.isInlineFragment(selection)) {
fragment = selection;
}
else {
fragment = fragmentMap[selection.name.value];
ts_invariant_1.invariant(fragment, "No fragment named " + selection.name.value);
}
if (fragment && fragment.typeCondition) {
typeCondition = fragment.typeCondition.name.value;
if (execContext.fragmentMatcher(rootValue, typeCondition, context)) {
return [2, this.resolveSelectionSet(fragment.selectionSet, rootValue, execContext).then(function (fragmentResult) {
resultsToMerge.push(fragmentResult);
})];
}
}
return [2];
});
}); };
return [2, Promise.all(selectionSet.selections.map(execute)).then(function () {
return apollo_utilities_1.mergeDeepArray(resultsToMerge);
})];
});
});
};
LocalState.prototype.resolveField = function (field, rootValue, execContext) {
return tslib_1.__awaiter(this, void 0, void 0, function () {
var variables, fieldName, aliasedFieldName, aliasUsed, defaultResult, resultPromise, resolverType, resolverMap, resolve;
var _this = this;
return tslib_1.__generator(this, function (_a) {
variables = execContext.variables;
fieldName = field.name.value;
aliasedFieldName = apollo_utilities_1.resultKeyNameFromField(field);
aliasUsed = fieldName !== aliasedFieldName;
defaultResult = rootValue[aliasedFieldName] || rootValue[fieldName];
resultPromise = Promise.resolve(defaultResult);
if (!execContext.onlyRunForcedResolvers ||
this.shouldForceResolvers(field)) {
resolverType = rootValue.__typename || execContext.defaultOperationType;
resolverMap = this.resolvers && this.resolvers[resolverType];
if (resolverMap) {
resolve = resolverMap[aliasUsed ? fieldName : aliasedFieldName];
if (resolve) {
resultPromise = Promise.resolve(resolve(rootValue, apollo_utilities_1.argumentsObjectFromField(field, variables), execContext.context, { field: field, fragmentMap: execContext.fragmentMap }));
}
}
}
return [2, resultPromise.then(function (result) {
if (result === void 0) { result = defaultResult; }
if (field.directives) {
field.directives.forEach(function (directive) {
if (directive.name.value === 'export' && directive.arguments) {
directive.arguments.forEach(function (arg) {
if (arg.name.value === 'as' && arg.value.kind === 'StringValue') {
execContext.exportedVariables[arg.value.value] = result;
}
});
}
});
}
if (!field.selectionSet) {
return result;
}
if (result == null) {
return result;
}
if (Array.isArray(result)) {
return _this.resolveSubSelectedArray(field, result, execContext);
}
if (field.selectionSet) {
return _this.resolveSelectionSet(field.selectionSet, result, execContext);
}
})];
});
});
};
LocalState.prototype.resolveSubSelectedArray = function (field, result, execContext) {
var _this = this;
return Promise.all(result.map(function (item) {
if (item === null) {
return null;
}
if (Array.isArray(item)) {
return _this.resolveSubSelectedArray(field, item, execContext);
}
if (field.selectionSet) {
return _this.resolveSelectionSet(field.selectionSet, item, execContext);
}
}));
};
return LocalState;
}());
exports.LocalState = LocalState;
//# sourceMappingURL=LocalState.js.map