How to use the optimism.wrap function in optimism
To help you get started, we’ve selected a few optimism examples, based on popular ways it is used in public projects.
Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
apollographql / apollo-client / packages / apollo-cache-inmemory / src / readFromStore.ts View on Github 
// The result of executeStoreQuery can be safely cached only if the
// underlying store is capable of tracking dependencies and invalidating
// the cache when relevant data have changed.
if (contextValue.store instanceof DepTrackingCache) {
return cacheKeyRoot.lookup(
contextValue.store,
query,
fragmentMatcher,
JSON.stringify(variableValues),
rootValue.id,
);
}
}
});
this.executeSelectionSet = wrap((options: ExecSelectionSetOptions) => {
return executeSelectionSet.call(this, options);
}, {
makeCacheKey({
selectionSet,
rootValue,
execContext,
}: ExecSelectionSetOptions) {
if (execContext.contextValue.store instanceof DepTrackingCache) {
return cacheKeyRoot.lookup(
execContext.contextValue.store,
selectionSet,
execContext.fragmentMatcher,
JSON.stringify(execContext.variableValues),
rootValue.id,
);
}constructor({
cacheKeyRoot = new KeyTrie(canUseWeakMap),
freezeResults = false,
}: StoreReaderConfig = {}) {
const {
executeStoreQuery,
executeSelectionSet,
executeSubSelectedArray,
} = this;
this.freezeResults = freezeResults;
this.executeStoreQuery = wrap((options: ExecStoreQueryOptions) => {
return executeStoreQuery.call(this, options);
}, {
makeCacheKey({
query,
rootValue,
contextValue,
variableValues,
fragmentMatcher,
}: ExecStoreQueryOptions) {
// The result of executeStoreQuery can be safely cached only if the
// underlying store is capable of tracking dependencies and invalidating
// the cache when relevant data have changed.
if (contextValue.store instanceof DepTrackingCache) {
return cacheKeyRoot.lookup(
contextValue.store,
query,// When no optimistic writes are currently active, cache.optimisticData ===
// cache.data, so there are no additional layers on top of the actual data.
// When an optimistic update happens, this.optimisticData will become a
// linked list of OptimisticCacheLayer objects that terminates with the
// original this.data cache object.
this.optimisticData = this.data;
this.storeWriter = new StoreWriter();
this.storeReader = new StoreReader({
cacheKeyRoot: this.cacheKeyRoot,
freezeResults: config.freezeResults,
});
const cache = this;
const { maybeBroadcastWatch } = cache;
this.maybeBroadcastWatch = wrap((c: Cache.WatchOptions) => {
return maybeBroadcastWatch.call(this, c);
}, {
makeCacheKey(c: Cache.WatchOptions) {
if (c.optimistic) {
// If we're reading optimistic data, it doesn't matter if this.data
// is a DepTrackingCache, since it will be ignored.
return;
}
if (c.previousResult) {
// If a previousResult was provided, assume the caller would prefer
// to compare the previous data to the new data to determine whether
// to broadcast, so we should disable caching by returning here, to
// give maybeBroadcastWatch a chance to do that comparison.
return;
}rootValue,
execContext,
}: ExecSelectionSetOptions) {
if (execContext.contextValue.store instanceof DepTrackingCache) {
return cacheKeyRoot.lookup(
execContext.contextValue.store,
selectionSet,
execContext.fragmentMatcher,
JSON.stringify(execContext.variableValues),
rootValue.id,
);
}
}
});
this.executeSubSelectedArray = wrap((options: ExecSubSelectedArrayOptions) => {
return executeSubSelectedArray.call(this, options);
}, {
makeCacheKey({ field, array, execContext }) {
if (execContext.contextValue.store instanceof DepTrackingCache) {
return cacheKeyRoot.lookup(
execContext.contextValue.store,
field,
array,
JSON.stringify(execContext.variableValues),
);
}
}
});
}const cacheKeyRoot =
config && config.cacheKeyRoot || new KeyTrie(canUseWeakMap);
this.config = {
addTypename: true,
cacheKeyRoot,
...config,
};
const {
executeStoreQuery,
executeSelectionSet,
executeSubSelectedArray,
} = this;
this.executeStoreQuery = wrap((options: ExecStoreQueryOptions) => {
return executeStoreQuery.call(this, options);
}, {
makeCacheKey({
query,
objectOrReference,
contextValue,
variableValues,
}: ExecStoreQueryOptions) {
if (supportsResultCaching(contextValue.store)) {
return cacheKeyRoot.lookup(
contextValue.store,
query,
JSON.stringify(variableValues),
isReference(objectOrReference) ? objectOrReference.__ref : objectOrReference,
);
}constructor(private data: NormalizedCacheObject = Object.create(null)) {
this.depend = wrap((dataId: string) => this.data[dataId], {
disposable: true,
makeCacheKey(dataId: string) {
return dataId;
},
});
}objectOrReference,
contextValue,
variableValues,
}: ExecStoreQueryOptions) {
if (supportsResultCaching(contextValue.store)) {
return cacheKeyRoot.lookup(
contextValue.store,
query,
JSON.stringify(variableValues),
isReference(objectOrReference) ? objectOrReference.__ref : objectOrReference,
);
}
}
});
this.executeSelectionSet = wrap((options: ExecSelectionSetOptions) => {
return executeSelectionSet.call(this, options);
}, {
makeCacheKey({
selectionSet,
objectOrReference,
execContext,
}: ExecSelectionSetOptions) {
if (supportsResultCaching(execContext.contextValue.store)) {
return cacheKeyRoot.lookup(
execContext.contextValue.store,
selectionSet,
JSON.stringify(execContext.variableValues),
isReference(objectOrReference) ? objectOrReference.__ref : objectOrReference,
);
}
}selectionSet,
objectOrReference,
execContext,
}: ExecSelectionSetOptions) {
if (supportsResultCaching(execContext.contextValue.store)) {
return cacheKeyRoot.lookup(
execContext.contextValue.store,
selectionSet,
JSON.stringify(execContext.variableValues),
isReference(objectOrReference) ? objectOrReference.__ref : objectOrReference,
);
}
}
});
this.executeSubSelectedArray = wrap((options: ExecSubSelectedArrayOptions) => {
return executeSubSelectedArray.call(this, options);
}, {
makeCacheKey({ field, array, execContext }) {
if (supportsResultCaching(execContext.contextValue.store)) {
return cacheKeyRoot.lookup(
execContext.contextValue.store,
field,
array,
JSON.stringify(execContext.variableValues),
);
}
}
});
}optimism
Composable reactive caching with efficient invalidation.
