mirror of
https://github.com/CamHenlin/MessagesForMacintosh.git
synced 2024-11-29 23:49:20 +00:00
239 lines
9.7 KiB
JavaScript
239 lines
9.7 KiB
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
|