next
Version:
The React Framework
211 lines (210 loc) • 10.3 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "default", {
enumerable: true,
get: function() {
return ResponseCache;
}
});
0 && __export(require("./types"));
const _batcher = require("../../lib/batcher");
const _scheduler = require("../../lib/scheduler");
const _utils = require("./utils");
_export_star(require("./types"), exports);
function _export_star(from, to) {
Object.keys(from).forEach(function(k) {
if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
Object.defineProperty(to, k, {
enumerable: true,
get: function() {
return from[k];
}
});
}
});
return from;
}
class ResponseCache {
constructor(minimal_mode){
this.getBatcher = _batcher.Batcher.create({
// Ensure on-demand revalidate doesn't block normal requests, it should be
// safe to run an on-demand revalidate for the same key as a normal request.
cacheKeyFn: ({ key, isOnDemandRevalidate })=>`${key}-${isOnDemandRevalidate ? '1' : '0'}`,
// We wait to do any async work until after we've added our promise to
// `pendingResponses` to ensure that any any other calls will reuse the
// same promise until we've fully finished our work.
schedulerFn: _scheduler.scheduleOnNextTick
});
this.revalidateBatcher = _batcher.Batcher.create({
// We wait to do any async work until after we've added our promise to
// `pendingResponses` to ensure that any any other calls will reuse the
// same promise until we've fully finished our work.
schedulerFn: _scheduler.scheduleOnNextTick
});
this.minimal_mode = minimal_mode;
}
/**
* Gets the response cache entry for the given key.
*
* @param key - The key to get the response cache entry for.
* @param responseGenerator - The response generator to use to generate the response cache entry.
* @param context - The context for the get request.
* @returns The response cache entry.
*/ async get(key, responseGenerator, context) {
var _this_previousCacheItem;
// If there is no key for the cache, we can't possibly look this up in the
// cache so just return the result of the response generator.
if (!key) {
return responseGenerator({
hasResolved: false,
previousCacheEntry: null
});
}
// Check minimal mode cache before doing any other work
if (this.minimal_mode && ((_this_previousCacheItem = this.previousCacheItem) == null ? void 0 : _this_previousCacheItem.key) === key && this.previousCacheItem.expiresAt > Date.now()) {
return (0, _utils.toResponseCacheEntry)(this.previousCacheItem.entry);
}
const { incrementalCache, isOnDemandRevalidate = false, isFallback = false, isRoutePPREnabled = false, isPrefetch = false, waitUntil, routeKind } = context;
const response = await this.getBatcher.batch({
key,
isOnDemandRevalidate
}, ({ resolve })=>{
const promise = this.handleGet(key, responseGenerator, {
incrementalCache,
isOnDemandRevalidate,
isFallback,
isRoutePPREnabled,
isPrefetch,
routeKind
}, resolve);
// We need to ensure background revalidates are passed to waitUntil.
if (waitUntil) waitUntil(promise);
return promise;
});
return (0, _utils.toResponseCacheEntry)(response);
}
/**
* Handles the get request for the response cache.
*
* @param key - The key to get the response cache entry for.
* @param responseGenerator - The response generator to use to generate the response cache entry.
* @param context - The context for the get request.
* @param resolve - The resolve function to use to resolve the response cache entry.
* @returns The response cache entry.
*/ async handleGet(key, responseGenerator, context, resolve) {
let previousIncrementalCacheEntry = null;
let resolved = false;
try {
// Get the previous cache entry if not in minimal mode
previousIncrementalCacheEntry = !this.minimal_mode ? await context.incrementalCache.get(key, {
kind: (0, _utils.routeKindToIncrementalCacheKind)(context.routeKind),
isRoutePPREnabled: context.isRoutePPREnabled,
isFallback: context.isFallback
}) : null;
if (previousIncrementalCacheEntry && !context.isOnDemandRevalidate) {
resolve(previousIncrementalCacheEntry);
resolved = true;
if (!previousIncrementalCacheEntry.isStale || context.isPrefetch) {
// The cached value is still valid, so we don't need to update it yet.
return previousIncrementalCacheEntry;
}
}
// Revalidate the cache entry
const incrementalResponseCacheEntry = await this.revalidate(key, context.incrementalCache, context.isRoutePPREnabled, context.isFallback, responseGenerator, previousIncrementalCacheEntry, previousIncrementalCacheEntry !== null && !context.isOnDemandRevalidate);
// Handle null response
if (!incrementalResponseCacheEntry) {
// Unset the previous cache item if it was set so we don't use it again.
if (this.minimal_mode) this.previousCacheItem = undefined;
return null;
}
// Resolve for on-demand revalidation or if not already resolved
if (context.isOnDemandRevalidate && !resolved) {
return incrementalResponseCacheEntry;
}
return incrementalResponseCacheEntry;
} catch (err) {
// If we've already resolved the cache entry, we can't reject as we
// already resolved the cache entry so log the error here.
if (resolved) {
console.error(err);
return null;
}
throw err;
}
}
/**
* Revalidates the cache entry for the given key.
*
* @param key - The key to revalidate the cache entry for.
* @param incrementalCache - The incremental cache to use to revalidate the cache entry.
* @param isRoutePPREnabled - Whether the route is PPR enabled.
* @param isFallback - Whether the route is a fallback.
* @param responseGenerator - The response generator to use to generate the response cache entry.
* @param previousIncrementalCacheEntry - The previous cache entry to use to revalidate the cache entry.
* @param hasResolved - Whether the response has been resolved.
* @returns The revalidated cache entry.
*/ async revalidate(key, incrementalCache, isRoutePPREnabled, isFallback, responseGenerator, previousIncrementalCacheEntry, hasResolved, waitUntil) {
return this.revalidateBatcher.batch(key, ()=>{
const promise = this.handleRevalidate(key, incrementalCache, isRoutePPREnabled, isFallback, responseGenerator, previousIncrementalCacheEntry, hasResolved);
// We need to ensure background revalidates are passed to waitUntil.
if (waitUntil) waitUntil(promise);
return promise;
});
}
async handleRevalidate(key, incrementalCache, isRoutePPREnabled, isFallback, responseGenerator, previousIncrementalCacheEntry, hasResolved) {
try {
// Generate the response cache entry using the response generator.
const responseCacheEntry = await responseGenerator({
hasResolved,
previousCacheEntry: previousIncrementalCacheEntry,
isRevalidating: true
});
if (!responseCacheEntry) {
return null;
}
// Convert the response cache entry to an incremental response cache entry.
const incrementalResponseCacheEntry = await (0, _utils.fromResponseCacheEntry)({
...responseCacheEntry,
isMiss: !previousIncrementalCacheEntry
});
// We want to persist the result only if it has a cache control value
// defined.
if (incrementalResponseCacheEntry.cacheControl) {
if (this.minimal_mode) {
this.previousCacheItem = {
key,
entry: incrementalResponseCacheEntry,
expiresAt: Date.now() + 1000
};
} else {
await incrementalCache.set(key, incrementalResponseCacheEntry.value, {
cacheControl: incrementalResponseCacheEntry.cacheControl,
isRoutePPREnabled,
isFallback
});
}
}
return incrementalResponseCacheEntry;
} catch (err) {
// When a path is erroring we automatically re-set the existing cache
// with new revalidate and expire times to prevent non-stop retrying.
if (previousIncrementalCacheEntry == null ? void 0 : previousIncrementalCacheEntry.cacheControl) {
const revalidate = Math.min(Math.max(previousIncrementalCacheEntry.cacheControl.revalidate || 3, 3), 30);
const expire = previousIncrementalCacheEntry.cacheControl.expire === undefined ? undefined : Math.max(revalidate + 3, previousIncrementalCacheEntry.cacheControl.expire);
await incrementalCache.set(key, previousIncrementalCacheEntry.value, {
cacheControl: {
revalidate: revalidate,
expire: expire
},
isRoutePPREnabled,
isFallback
});
}
// We haven't resolved yet, so let's throw to indicate an error.
throw err;
}
}
}
//# sourceMappingURL=index.js.map