apollo-cache-inmemory
Version:
Core abstract of Caching layer for Apollo Client
239 lines • 9.92 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var tslib_1 = require("tslib");
require("./fixPolyfills");
var apollo_cache_1 = require("apollo-cache");
var apollo_utilities_1 = require("apollo-utilities");
var optimism_1 = require("optimism");
var ts_invariant_1 = require("ts-invariant");
var fragmentMatcher_1 = require("./fragmentMatcher");
var readFromStore_1 = require("./readFromStore");
var writeToStore_1 = require("./writeToStore");
var depTrackingCache_1 = require("./depTrackingCache");
var optimism_2 = require("optimism");
var objectCache_1 = require("./objectCache");
var defaultConfig = {
fragmentMatcher: new fragmentMatcher_1.HeuristicFragmentMatcher(),
dataIdFromObject: defaultDataIdFromObject,
addTypename: true,
resultCaching: true,
freezeResults: false,
};
function defaultDataIdFromObject(result) {
if (result.__typename) {
if (result.id !== undefined) {
return result.__typename + ":" + result.id;
}
if (result._id !== undefined) {
return result.__typename + ":" + result._id;
}
}
return null;
}
exports.defaultDataIdFromObject = defaultDataIdFromObject;
var hasOwn = Object.prototype.hasOwnProperty;
var OptimisticCacheLayer = (function (_super) {
tslib_1.__extends(OptimisticCacheLayer, _super);
function OptimisticCacheLayer(optimisticId, parent, transaction) {
var _this = _super.call(this, Object.create(null)) || this;
_this.optimisticId = optimisticId;
_this.parent = parent;
_this.transaction = transaction;
return _this;
}
OptimisticCacheLayer.prototype.toObject = function () {
return tslib_1.__assign(tslib_1.__assign({}, this.parent.toObject()), this.data);
};
OptimisticCacheLayer.prototype.get = function (dataId) {
return hasOwn.call(this.data, dataId)
? this.data[dataId]
: this.parent.get(dataId);
};
return OptimisticCacheLayer;
}(objectCache_1.ObjectCache));
exports.OptimisticCacheLayer = OptimisticCacheLayer;
var InMemoryCache = (function (_super) {
tslib_1.__extends(InMemoryCache, _super);
function InMemoryCache(config) {
if (config === void 0) { config = {}; }
var _this = _super.call(this) || this;
_this.watches = new Set();
_this.typenameDocumentCache = new Map();
_this.cacheKeyRoot = new optimism_2.KeyTrie(apollo_utilities_1.canUseWeakMap);
_this.silenceBroadcast = false;
_this.config = tslib_1.__assign(tslib_1.__assign({}, defaultConfig), config);
if (_this.config.customResolvers) {
ts_invariant_1.invariant.warn('customResolvers have been renamed to cacheRedirects. Please update your config as we will be deprecating customResolvers in the next major version.');
_this.config.cacheRedirects = _this.config.customResolvers;
}
if (_this.config.cacheResolvers) {
ts_invariant_1.invariant.warn('cacheResolvers have been renamed to cacheRedirects. Please update your config as we will be deprecating cacheResolvers in the next major version.');
_this.config.cacheRedirects = _this.config.cacheResolvers;
}
_this.addTypename = !!_this.config.addTypename;
_this.data = _this.config.resultCaching
? new depTrackingCache_1.DepTrackingCache()
: new objectCache_1.ObjectCache();
_this.optimisticData = _this.data;
_this.storeWriter = new writeToStore_1.StoreWriter();
_this.storeReader = new readFromStore_1.StoreReader({
cacheKeyRoot: _this.cacheKeyRoot,
freezeResults: config.freezeResults,
});
var cache = _this;
var maybeBroadcastWatch = cache.maybeBroadcastWatch;
_this.maybeBroadcastWatch = optimism_1.wrap(function (c) {
return maybeBroadcastWatch.call(_this, c);
}, {
makeCacheKey: function (c) {
if (c.optimistic) {
return;
}
if (c.previousResult) {
return;
}
if (cache.data instanceof depTrackingCache_1.DepTrackingCache) {
return cache.cacheKeyRoot.lookup(c.query, JSON.stringify(c.variables));
}
}
});
return _this;
}
InMemoryCache.prototype.restore = function (data) {
if (data)
this.data.replace(data);
return this;
};
InMemoryCache.prototype.extract = function (optimistic) {
if (optimistic === void 0) { optimistic = false; }
return (optimistic ? this.optimisticData : this.data).toObject();
};
InMemoryCache.prototype.read = function (options) {
if (typeof options.rootId === 'string' &&
typeof this.data.get(options.rootId) === 'undefined') {
return null;
}
var fragmentMatcher = this.config.fragmentMatcher;
var fragmentMatcherFunction = fragmentMatcher && fragmentMatcher.match;
return this.storeReader.readQueryFromStore({
store: options.optimistic ? this.optimisticData : this.data,
query: this.transformDocument(options.query),
variables: options.variables,
rootId: options.rootId,
fragmentMatcherFunction: fragmentMatcherFunction,
previousResult: options.previousResult,
config: this.config,
}) || null;
};
InMemoryCache.prototype.write = function (write) {
var fragmentMatcher = this.config.fragmentMatcher;
var fragmentMatcherFunction = fragmentMatcher && fragmentMatcher.match;
this.storeWriter.writeResultToStore({
dataId: write.dataId,
result: write.result,
variables: write.variables,
document: this.transformDocument(write.query),
store: this.data,
dataIdFromObject: this.config.dataIdFromObject,
fragmentMatcherFunction: fragmentMatcherFunction,
});
this.broadcastWatches();
};
InMemoryCache.prototype.diff = function (query) {
var fragmentMatcher = this.config.fragmentMatcher;
var fragmentMatcherFunction = fragmentMatcher && fragmentMatcher.match;
return this.storeReader.diffQueryAgainstStore({
store: query.optimistic ? this.optimisticData : this.data,
query: this.transformDocument(query.query),
variables: query.variables,
returnPartialData: query.returnPartialData,
previousResult: query.previousResult,
fragmentMatcherFunction: fragmentMatcherFunction,
config: this.config,
});
};
InMemoryCache.prototype.watch = function (watch) {
var _this = this;
this.watches.add(watch);
return function () {
_this.watches.delete(watch);
};
};
InMemoryCache.prototype.evict = function (query) {
throw new ts_invariant_1.InvariantError("eviction is not implemented on InMemory Cache");
};
InMemoryCache.prototype.reset = function () {
this.data.clear();
this.broadcastWatches();
return Promise.resolve();
};
InMemoryCache.prototype.removeOptimistic = function (idToRemove) {
var toReapply = [];
var removedCount = 0;
var layer = this.optimisticData;
while (layer instanceof OptimisticCacheLayer) {
if (layer.optimisticId === idToRemove) {
++removedCount;
}
else {
toReapply.push(layer);
}
layer = layer.parent;
}
if (removedCount > 0) {
this.optimisticData = layer;
while (toReapply.length > 0) {
var layer_1 = toReapply.pop();
this.performTransaction(layer_1.transaction, layer_1.optimisticId);
}
this.broadcastWatches();
}
};
InMemoryCache.prototype.performTransaction = function (transaction, optimisticId) {
var _a = this, data = _a.data, silenceBroadcast = _a.silenceBroadcast;
this.silenceBroadcast = true;
if (typeof optimisticId === 'string') {
this.data = this.optimisticData = new OptimisticCacheLayer(optimisticId, this.optimisticData, transaction);
}
try {
transaction(this);
}
finally {
this.silenceBroadcast = silenceBroadcast;
this.data = data;
}
this.broadcastWatches();
};
InMemoryCache.prototype.recordOptimisticTransaction = function (transaction, id) {
return this.performTransaction(transaction, id);
};
InMemoryCache.prototype.transformDocument = function (document) {
if (this.addTypename) {
var result = this.typenameDocumentCache.get(document);
if (!result) {
result = apollo_utilities_1.addTypenameToDocument(document);
this.typenameDocumentCache.set(document, result);
this.typenameDocumentCache.set(result, result);
}
return result;
}
return document;
};
InMemoryCache.prototype.broadcastWatches = function () {
var _this = this;
if (!this.silenceBroadcast) {
this.watches.forEach(function (c) { return _this.maybeBroadcastWatch(c); });
}
};
InMemoryCache.prototype.maybeBroadcastWatch = function (c) {
c.callback(this.diff({
query: c.query,
variables: c.variables,
previousResult: c.previousResult && c.previousResult(),
optimistic: c.optimistic,
}));
};
return InMemoryCache;
}(apollo_cache_1.ApolloCache));
exports.InMemoryCache = InMemoryCache;
//# sourceMappingURL=inMemoryCache.js.map