cdk-nextjs 0.7.6 → 0.7.8

package/lib/adapter/use-cache-common.d.ts

@@ -57,23 +57,88 @@ export declare class EntryLru {
     private readonly maxBytes;
     private readonly entries;
     private bytes;
+    /**
+     * No later than the oldest entry's `timestamp`: the last scan's answer, less
+     * whatever was set since. Entries dropped since only make it early. See
+     * {@link oldestBound}.
+     */
+    private lowest;
     constructor(maxBytes: number);
     get(key: string): StoredEntry | undefined;
     set(key: string, entry: StoredEntry): void;
     delete(key: string): void;
+    /**
+     * The `timestamp` of the oldest entry held, `Infinity` with none, dropping
+     * on the way the entries past `revalidate` at `at` (`now()`): a handler
+     * that drops them when next read would otherwise hold them until then, and
+     * they would count here meanwhile. A scan, so asked once in a while: in
+     * between, {@link oldestBound} answers.
+     */
+    oldestTimestamp(at?: number): number;
+    /**
+     * No later than {@link oldestTimestamp}, without its scan: as of the last
+     * one, less the entries set since. `Infinity` with none held. Drops the
+     * entries past `revalidate` at `at` from the least recently used end, up to
+     * the first that isn't, so {@link holdsLive} doesn't walk past them on every
+     * request until the next scan.
+     */
+    oldestBound(at?: number): number;
+    /**
+     * Whether an entry not past `revalidate` at `at` is held. Usually the first
+     * entry answers; the expired ones it passes are dropped by the scan
+     * {@link oldestTimestamp} makes, not here, so asking changes nothing.
+     */
+    holdsLive(at: number): boolean;
     get size(): number;
 }
+/** Whether `stored` is past `revalidate` at `at` (`now()`). */
+export declare function isPastRevalidate(stored: StoredEntry, at: number): boolean;
 /** Default size of each handler's memory store: Next.js's default, 50 MB. */
 export declare const DEFAULT_MEMORY_BYTES: number;
+/**
+ * How long one revalidation table request may take, per attempt. The SDK sets
+ * no limit, and a refresh left in flight across a Lambda freeze can sit on a
+ * connection that died meanwhile without a reset: every request that waits
+ * for the refresh (an instance `behind`, ISR) would wait with it. The SDK
+ * retries a timed-out attempt, so a dead connection costs up to its attempts
+ * times this.
+ */
+export declare const TAG_TABLE_REQUEST_TIMEOUT_MS = 3000;
+/**
+ * Wait for `work` if `wait`, or else let it run on: either way a rejection is
+ * logged with `failure` rather than thrown.
+ */
+export declare function awaitIf(wait: boolean, work: Promise<void>, failure: string): Promise<void>;
+export interface TagMethodsOptions {
+    /**
+     * Whether `refreshTags` always waits for the revalidation log query, rather
+     * than only when the instance is `behind`.
+     * @default false
+     */
+    readonly blocking?: boolean;
+}
 /**
  * The `cacheHandlers` methods that only go through `tags`, the same for the
  * `default` and `remote` handlers.
  */
-export declare function tagMethods(tags: TrackedTagMarkers): Pick<CacheHandler, "refreshTags" | "getExpiration" | "updateTags">;
+export declare function tagMethods(tags: TrackedTagMarkers, options?: TagMethodsOptions): Pick<CacheHandler, "refreshTags" | "updateTags">;
+/**
+ * Run a cache handler method's work outside the request that called it
+ * ({@link TrackedTagMarkers.outsideRender}). Next.js awaits these methods
+ * inside a staged render, and 16.4 ends the render's static stage on any
+ * `Date.now()`, `new Date()`, `Math.random()` or `crypto` random call made in
+ * the request's context during it: ours, the AWS SDK's (request signing,
+ * invocation ids) and `debug`'s alike. A draft mode page, rendered whole at
+ * request time, lost its static stage that way to `refreshTags`, so the client
+ * cached nothing from its HTML. Creating the manifest is in here too: the
+ * first handler call of a process does it, inside a render.
+ */
+export declare function outsideRender<T>(fn: () => T): T;
 /**
  * A handler built by `create` on first use rather than on import, so loading
  * the module - which jest, and Next.js's config validation, do without using
  * it - neither constructs AWS clients nor warns about missing configuration.
+ * Every method runs {@link outsideRender}.
  */
 export declare function lazyHandler(create: () => CacheHandler): CacheHandler;
 /**

package/lib/adapter/use-cache-common.js

@@ -3,14 +3,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_MEMORY_BYTES = exports.EntryLru = exports.PendingSets = exports.now = void 0;
+exports.TAG_TABLE_REQUEST_TIMEOUT_MS = exports.DEFAULT_MEMORY_BYTES = exports.EntryLru = exports.PendingSets = exports.now = void 0;
 exports.isBuildPhase = isBuildPhase;
 exports.numberFromEnv = numberFromEnv;
 exports.readStream = readStream;
 exports.storedEntryOf = storedEntryOf;
 exports.cacheEntryOf = cacheEntryOf;
 exports.isDynamicEntry = isDynamicEntry;
+exports.isPastRevalidate = isPastRevalidate;
+exports.awaitIf = awaitIf;
 exports.tagMethods = tagMethods;
+exports.outsideRender = outsideRender;
 exports.lazyHandler = lazyHandler;
 exports.sharedTagManifest = sharedTagManifest;
 /*
@@ -24,6 +27,7 @@ exports.sharedTagManifest = sharedTagManifest;
 const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
 const debug_1 = __importDefault(require("debug"));
 const aws_cache_store_1 = require("./aws-cache-store");
+const tag_manifest_1 = require("../runtime/tag-manifest");
 var aws_cache_store_2 = require("./aws-cache-store");
 Object.defineProperty(exports, "now", { enumerable: true, get: function () { return aws_cache_store_2.markerClock; } });
 /** Whether this process is `next build` rather than a deployed server. */
@@ -133,6 +137,12 @@ class EntryLru {
     maxBytes;
     entries = new Map();
     bytes = 0;
+    /**
+     * No later than the oldest entry's `timestamp`: the last scan's answer, less
+     * whatever was set since. Entries dropped since only make it early. See
+     * {@link oldestBound}.
+     */
+    lowest = Infinity;
     constructor(maxBytes) {
         this.maxBytes = maxBytes;
     }
@@ -153,6 +163,7 @@ class EntryLru {
         }
         this.entries.set(key, entry);
         this.bytes += size;
+        this.lowest = Math.min(this.lowest, entry.timestamp);
         for (const [oldestKey, oldest] of this.entries) {
             if (this.bytes <= this.maxBytes) {
                 break;
@@ -166,7 +177,59 @@ class EntryLru {
         if (existing) {
             this.entries.delete(key);
             this.bytes -= sizeOf(key, existing);
+            if (this.entries.size === 0) {
+                this.lowest = Infinity;
+            }
+        }
+    }
+    /**
+     * The `timestamp` of the oldest entry held, `Infinity` with none, dropping
+     * on the way the entries past `revalidate` at `at` (`now()`): a handler
+     * that drops them when next read would otherwise hold them until then, and
+     * they would count here meanwhile. A scan, so asked once in a while: in
+     * between, {@link oldestBound} answers.
+     */
+    oldestTimestamp(at = -Infinity) {
+        let oldest = Infinity;
+        for (const [key, entry] of this.entries) {
+            if (isPastRevalidate(entry, at)) {
+                this.delete(key);
+            }
+            else {
+                oldest = Math.min(oldest, entry.timestamp);
+            }
+        }
+        this.lowest = oldest;
+        return oldest;
+    }
+    /**
+     * No later than {@link oldestTimestamp}, without its scan: as of the last
+     * one, less the entries set since. `Infinity` with none held. Drops the
+     * entries past `revalidate` at `at` from the least recently used end, up to
+     * the first that isn't, so {@link holdsLive} doesn't walk past them on every
+     * request until the next scan.
+     */
+    oldestBound(at = -Infinity) {
+        for (const [key, entry] of this.entries) {
+            if (!isPastRevalidate(entry, at)) {
+                break;
+            }
+            this.delete(key);
+        }
+        return this.entries.size === 0 ? Infinity : this.lowest;
+    }
+    /**
+     * Whether an entry not past `revalidate` at `at` is held. Usually the first
+     * entry answers; the expired ones it passes are dropped by the scan
+     * {@link oldestTimestamp} makes, not here, so asking changes nothing.
+     */
+    holdsLive(at) {
+        for (const entry of this.entries.values()) {
+            if (!isPastRevalidate(entry, at)) {
+                return true;
+            }
         }
+        return false;
     }
     get size() {
         return this.entries.size;
@@ -176,41 +239,89 @@ exports.EntryLru = EntryLru;
 function sizeOf(key, entry) {
     return entry.value.byteLength + key.length;
 }
+/** Whether `stored` is past `revalidate` at `at` (`now()`). */
+function isPastRevalidate(stored, at) {
+    return at > stored.timestamp + stored.revalidate * 1000;
+}
 /** Default size of each handler's memory store: Next.js's default, 50 MB. */
 exports.DEFAULT_MEMORY_BYTES = 50 * 1024 * 1024;
+/**
+ * How long one revalidation table request may take, per attempt. The SDK sets
+ * no limit, and a refresh left in flight across a Lambda freeze can sit on a
+ * connection that died meanwhile without a reset: every request that waits
+ * for the refresh (an instance `behind`, ISR) would wait with it. The SDK
+ * retries a timed-out attempt, so a dead connection costs up to its attempts
+ * times this.
+ */
+exports.TAG_TABLE_REQUEST_TIMEOUT_MS = 3000;
+/**
+ * Wait for `work` if `wait`, or else let it run on: either way a rejection is
+ * logged with `failure` rather than thrown.
+ */
+async function awaitIf(wait, work, failure) {
+    const logged = work.catch((error) => {
+        console.error(failure, error);
+    });
+    if (wait) {
+        await logged;
+    }
+}
 /**
  * The `cacheHandlers` methods that only go through `tags`, the same for the
  * `default` and `remote` handlers.
  */
-function tagMethods(tags) {
+function tagMethods(tags, options = {}) {
     return {
-        refreshTags: () => tags.refresh(),
-        async getExpiration(implicitTags) {
-            await tags.ensure(implicitTags);
-            return tags.expiration(implicitTags);
-        },
+        // Started, not awaited, while the instance keeps up, unless `blocking`.
+        // Next.js awaits `refreshTags` inside the first `'use cache'` lookup of a
+        // request (`use-cache-wrapper`), and a staged render ends its static stage
+        // on a timer: a log `Query` there pushed the entry out of the static
+        // stage, so a cached navigation stored the page segment without it. What
+        // the query finds applies from the next request. Awaited once the instance
+        // is `behind`, which the runtime settles before a page render starts
+        // (`catchUp`): the first request after an idle or frozen spell would
+        // otherwise serve whatever was revalidated elsewhere meanwhile. A page's
+        // render just after `catchUp` gets a grace more (`behindInRender`), so a
+        // request that came in just short of the line doesn't cross it inside
+        // the render. Not even then while the instance holds no entry the query
+        // could expire (`holdsEntries`), with a `refreshIntervalMs` of `0` too.
+        refreshTags: () => awaitIf(options.blocking === true || (tags.behindInRender && tags.holdsEntries), tags.refresh(), "Error refreshing cache tags:"),
         async updateTags(revalidatedTags, durations) {
             await tags.update(revalidatedTags, durations);
         },
     };
 }
+/**
+ * Run a cache handler method's work outside the request that called it
+ * ({@link TrackedTagMarkers.outsideRender}). Next.js awaits these methods
+ * inside a staged render, and 16.4 ends the render's static stage on any
+ * `Date.now()`, `new Date()`, `Math.random()` or `crypto` random call made in
+ * the request's context during it: ours, the AWS SDK's (request signing,
+ * invocation ids) and `debug`'s alike. A draft mode page, rendered whole at
+ * request time, lost its static stage that way to `refreshTags`, so the client
+ * cached nothing from its HTML. Creating the manifest is in here too: the
+ * first handler call of a process does it, inside a render.
+ */
+function outsideRender(fn) {
+    return (0, tag_manifest_1.outsideRequest)(sharedTagManifest).outsideRender(fn);
+}
 /**
  * A handler built by `create` on first use rather than on import, so loading
  * the module - which jest, and Next.js's config validation, do without using
  * it - neither constructs AWS clients nor warns about missing configuration.
+ * Every method runs {@link outsideRender}.
  */
 function lazyHandler(create) {
     let handler;
     const instance = () => (handler ??= create());
     return {
-        get: (cacheKey, softTags) => instance().get(cacheKey, softTags),
-        set: (cacheKey, pendingEntry) => instance().set(cacheKey, pendingEntry),
-        refreshTags: () => instance().refreshTags(),
-        getExpiration: (tags) => instance().getExpiration(tags),
-        updateTags: (tags, durations) => instance().updateTags(tags, durations),
+        get: (cacheKey, softTags) => outsideRender(() => instance().get(cacheKey, softTags)),
+        set: (cacheKey, pendingEntry) => outsideRender(() => instance().set(cacheKey, pendingEntry)),
+        refreshTags: () => outsideRender(() => instance().refreshTags()),
+        getExpiration: (tags) => outsideRender(() => instance().getExpiration(tags)),
+        updateTags: (tags, durations) => outsideRender(() => instance().updateTags(tags, durations)),
     };
 }
-const TAG_MANIFEST_SYMBOL = Symbol.for("cdk-nextjs.use-cache.tag-manifest");
 /**
  * The process's one {@link TrackedTagMarkers}, from the environment.
  *
@@ -224,27 +335,39 @@ const TAG_MANIFEST_SYMBOL = Symbol.for("cdk-nextjs.use-cache.tag-manifest");
  */
 function sharedTagManifest() {
     const global = globalThis;
-    if (!global[TAG_MANIFEST_SYMBOL]) {
+    if (!global[tag_manifest_1.TAG_MANIFEST_SYMBOL]) {
         const config = (0, aws_cache_store_1.resolveAwsCacheConfig)();
         const refreshIntervalMs = numberFromEnv("CDK_NEXTJS_TAG_REFRESH_MS", aws_cache_store_1.DEFAULT_TAG_REFRESH_MS);
         if (config.tableName && !isBuildPhase()) {
-            const client = new client_dynamodb_1.DynamoDBClient({ region: config.region });
-            global[TAG_MANIFEST_SYMBOL] = new aws_cache_store_1.TrackedTagMarkers({
+            const client = new client_dynamodb_1.DynamoDBClient({
+                region: config.region,
+                // Without `throwOnRequestTimeout` the timeout only logs a warning. It
+                // ends once the response headers arrive: `socketTimeout`, an
+                // inactivity timer kept until the request closes, covers the body.
+                requestHandler: {
+                    requestTimeout: exports.TAG_TABLE_REQUEST_TIMEOUT_MS,
+                    throwOnRequestTimeout: true,
+                    socketTimeout: exports.TAG_TABLE_REQUEST_TIMEOUT_MS,
+                },
+            });
+            global[tag_manifest_1.TAG_MANIFEST_SYMBOL] = new aws_cache_store_1.TrackedTagMarkers({
                 markers: new aws_cache_store_1.TagMarkerTable(client, config.tableName, config.buildId),
                 log: new aws_cache_store_1.RevalidationLog(client, config.tableName, config.buildId),
                 refreshIntervalMs,
                 debug: (0, debug_1.default)("cdk-nextjs:cache-handler:tags"),
+                // Set in every Lambda runtime; a container is never frozen.
+                canFreeze: process.env.AWS_LAMBDA_FUNCTION_NAME !== undefined,
             });
         }
         else {
             if (!isBuildPhase()) {
                 console.warn("CDK_NEXTJS_REVALIDATION_TABLE_NAME environment variable not set, cache tags are local to each instance");
             }
-            global[TAG_MANIFEST_SYMBOL] = new aws_cache_store_1.TrackedTagMarkers({
+            global[tag_manifest_1.TAG_MANIFEST_SYMBOL] = new aws_cache_store_1.TrackedTagMarkers({
                 refreshIntervalMs,
             });
         }
     }
-    return global[TAG_MANIFEST_SYMBOL];
+    return global[tag_manifest_1.TAG_MANIFEST_SYMBOL];
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"use-cache-common.js","sourceRoot":"","sources":["../../src/adapter/use-cache-common.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n  What the two `cacheHandlers` (`'use cache'` and `'use cache: remote'`) share:\n  the in-memory entry store, the pending-`set` bookkeeping Next.js requires of\n  every handler, and the process's one tag manifest (`TrackedTagMarkers`),\n  which makes `revalidateTag` reach every instance through the revalidation\n  table's marker rows.\n*/\n/* eslint-disable import/no-extraneous-dependencies */\nimport { DynamoDBClient } from \"@aws-sdk/client-dynamodb\";\nimport getDebug from \"debug\";\nimport type {\n  CacheEntry,\n  CacheHandler,\n} from \"next/dist/server/lib/cache-handlers/types\";\nimport {\n  DEFAULT_TAG_REFRESH_MS,\n  resolveAwsCacheConfig,\n  RevalidationLog,\n  TagMarkerTable,\n  TrackedTagMarkers,\n} from \"./aws-cache-store\";\n\nexport { markerClock as now } from \"./aws-cache-store\";\n\n/** Whether this process is `next build` rather than a deployed server. */\nexport function isBuildPhase(): boolean {\n  return process.env.NEXT_PHASE === \"phase-production-build\";\n}\n\n/** A positive integer environment variable, or `fallback`. */\nexport function numberFromEnv(name: string, fallback: number): number {\n  const raw = process.env[name];\n  const value = raw === undefined || raw === \"\" ? NaN : Number(raw);\n  return Number.isFinite(value) && value >= 0 ? value : fallback;\n}\n\n/**\n * A `CacheEntry` with its value read to the end: the bytes are what is kept,\n * and every `get` hands out a fresh stream over them.\n */\nexport interface StoredEntry extends Omit<CacheEntry, \"value\"> {\n  value: Uint8Array;\n}\n\n/**\n * Read `stream` to the end, or throw if it errors.\n *\n * `CacheEntry.value` \"can error and only have partial data\" (Next.js's\n * `cache-handlers/types.d.ts`). Throwing is how a partial entry is kept out:\n * both handlers store nothing when this rejects, which is what Next.js's own\n * default handler does too.\n */\nexport async function readStream(\n  stream: ReadableStream<Uint8Array>,\n): Promise<Uint8Array> {\n  const reader = stream.getReader();\n  const chunks: Uint8Array[] = [];\n  let size = 0;\n  for (;;) {\n    const { done, value } = await reader.read();\n    if (done) {\n      break;\n    }\n    chunks.push(value);\n    size += value.byteLength;\n  }\n  const bytes = new Uint8Array(size);\n  let offset = 0;\n  for (const chunk of chunks) {\n    bytes.set(chunk, offset);\n    offset += chunk.byteLength;\n  }\n  return bytes;\n}\n\n/** `pendingEntry` resolved and read to the end. See {@link readStream}. */\nexport async function storedEntryOf(\n  pendingEntry: Promise<CacheEntry>,\n): Promise<StoredEntry> {\n  const entry = await pendingEntry;\n  return { ...entry, value: await readStream(entry.value) };\n}\n\n/** `stored` as the `CacheEntry` a `get` returns, with its own stream. */\nexport function cacheEntryOf(\n  stored: StoredEntry,\n  revalidate: number = stored.revalidate,\n): CacheEntry {\n  const bytes = stored.value;\n  return {\n    ...stored,\n    revalidate,\n    value: new ReadableStream<Uint8Array>({\n      start(controller) {\n        // A copy: whoever reads the stream may transfer or mutate the chunk.\n        controller.enqueue(bytes.slice());\n        controller.close();\n      },\n    }),\n  };\n}\n\n/**\n * Whether Next.js would regenerate `entry` on every read anyway, so storing it\n * is a write nothing reads back. Next.js's default handler skips these the same\n * way, outside the dev server.\n */\nexport function isDynamicEntry(entry: Pick<CacheEntry, \"expire\">): boolean {\n  return entry.expire === 0;\n}\n\n/**\n * The in-flight `set`s, by cache key. `CacheHandler.set` receives an entry that\n * may still be streaming, and \"if a `get` for the same cache key is called\n * before the pending entry is complete, the cache handler must wait for the\n * `set` operation to finish\" (`cache-handlers/types.d.ts`).\n */\nexport class PendingSets {\n  private readonly pending = new Map<string, Promise<void>>();\n\n  /** Resolves once no `set` for `key` is in flight. */\n  async wait(key: string): Promise<void> {\n    for (let p = this.pending.get(key); p; p = this.pending.get(key)) {\n      await p;\n    }\n  }\n\n  /**\n   * Register a `set` for `key` and return the function that ends it. Safe to\n   * call more than once: only the registration it made is removed.\n   */\n  begin(key: string): () => void {\n    let resolve: () => void = () => {};\n    const promise = new Promise<void>((r) => (resolve = r));\n    this.pending.set(key, promise);\n    return () => {\n      if (this.pending.get(key) === promise) {\n        this.pending.delete(key);\n      }\n      resolve();\n    };\n  }\n}\n\n/**\n * Stored entries by cache key, least recently used evicted first once their\n * bytes pass `maxBytes`. Sized by bytes rather than entries, like Next.js's\n * default handler (`cacheMaxMemorySize`, 50 MB), since a `'use cache'` entry is\n * an RSC payload of any size.\n */\nexport class EntryLru {\n  private readonly entries = new Map<string, StoredEntry>();\n  private bytes = 0;\n\n  constructor(private readonly maxBytes: number) {}\n\n  get(key: string): StoredEntry | undefined {\n    const entry = this.entries.get(key);\n    if (entry) {\n      // Re-inserted to mark it most recently used.\n      this.entries.delete(key);\n      this.entries.set(key, entry);\n    }\n    return entry;\n  }\n\n  set(key: string, entry: StoredEntry): void {\n    this.delete(key);\n    const size = sizeOf(key, entry);\n    if (size > this.maxBytes) {\n      return;\n    }\n    this.entries.set(key, entry);\n    this.bytes += size;\n    for (const [oldestKey, oldest] of this.entries) {\n      if (this.bytes <= this.maxBytes) {\n        break;\n      }\n      this.entries.delete(oldestKey);\n      this.bytes -= sizeOf(oldestKey, oldest);\n    }\n  }\n\n  delete(key: string): void {\n    const existing = this.entries.get(key);\n    if (existing) {\n      this.entries.delete(key);\n      this.bytes -= sizeOf(key, existing);\n    }\n  }\n\n  get size(): number {\n    return this.entries.size;\n  }\n}\n\nfunction sizeOf(key: string, entry: StoredEntry): number {\n  return entry.value.byteLength + key.length;\n}\n\n/** Default size of each handler's memory store: Next.js's default, 50 MB. */\nexport const DEFAULT_MEMORY_BYTES = 50 * 1024 * 1024;\n\n/**\n * The `cacheHandlers` methods that only go through `tags`, the same for the\n * `default` and `remote` handlers.\n */\nexport function tagMethods(\n  tags: TrackedTagMarkers,\n): Pick<CacheHandler, \"refreshTags\" | \"getExpiration\" | \"updateTags\"> {\n  return {\n    refreshTags: () => tags.refresh(),\n    async getExpiration(implicitTags) {\n      await tags.ensure(implicitTags);\n      return tags.expiration(implicitTags);\n    },\n    async updateTags(revalidatedTags, durations) {\n      await tags.update(revalidatedTags, durations);\n    },\n  };\n}\n\n/**\n * A handler built by `create` on first use rather than on import, so loading\n * the module - which jest, and Next.js's config validation, do without using\n * it - neither constructs AWS clients nor warns about missing configuration.\n */\nexport function lazyHandler(create: () => CacheHandler): CacheHandler {\n  let handler: CacheHandler | undefined;\n  const instance = () => (handler ??= create());\n  return {\n    get: (cacheKey, softTags) => instance().get(cacheKey, softTags),\n    set: (cacheKey, pendingEntry) => instance().set(cacheKey, pendingEntry),\n    refreshTags: () => instance().refreshTags(),\n    getExpiration: (tags) => instance().getExpiration(tags),\n    updateTags: (tags, durations) => instance().updateTags(tags, durations),\n  };\n}\n\nconst TAG_MANIFEST_SYMBOL = Symbol.for(\"cdk-nextjs.use-cache.tag-manifest\");\n\n/**\n * The process's one {@link TrackedTagMarkers}, from the environment.\n *\n * Kept on `globalThis` because the incremental cache handler and the `default`\n * and `remote` handlers are separate bundles - separate module instances - and\n * should share one manifest: one refresh read for all of them, and one marker\n * write per `revalidateTag`.\n *\n * At build time there is no table to read (and no credentials to read it\n * with), so tags stay local to the process there.\n */\nexport function sharedTagManifest(): TrackedTagMarkers {\n  const global = globalThis as { [TAG_MANIFEST_SYMBOL]?: TrackedTagMarkers };\n  if (!global[TAG_MANIFEST_SYMBOL]) {\n    const config = resolveAwsCacheConfig();\n    const refreshIntervalMs = numberFromEnv(\n      \"CDK_NEXTJS_TAG_REFRESH_MS\",\n      DEFAULT_TAG_REFRESH_MS,\n    );\n    if (config.tableName && !isBuildPhase()) {\n      const client = new DynamoDBClient({ region: config.region });\n      global[TAG_MANIFEST_SYMBOL] = new TrackedTagMarkers({\n        markers: new TagMarkerTable(client, config.tableName, config.buildId),\n        log: new RevalidationLog(client, config.tableName, config.buildId),\n        refreshIntervalMs,\n        debug: getDebug(\"cdk-nextjs:cache-handler:tags\"),\n      });\n    } else {\n      if (!isBuildPhase()) {\n        console.warn(\n          \"CDK_NEXTJS_REVALIDATION_TABLE_NAME environment variable not set, cache tags are local to each instance\",\n        );\n      }\n      global[TAG_MANIFEST_SYMBOL] = new TrackedTagMarkers({\n        refreshIntervalMs,\n      });\n    }\n  }\n  return global[TAG_MANIFEST_SYMBOL];\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"use-cache-common.js","sourceRoot":"","sources":["../../src/adapter/use-cache-common.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n  What the two `cacheHandlers` (`'use cache'` and `'use cache: remote'`) share:\n  the in-memory entry store, the pending-`set` bookkeeping Next.js requires of\n  every handler, and the process's one tag manifest (`TrackedTagMarkers`),\n  which makes `revalidateTag` reach every instance through the revalidation\n  table's marker rows.\n*/\n/* eslint-disable import/no-extraneous-dependencies */\nimport { DynamoDBClient } from \"@aws-sdk/client-dynamodb\";\nimport getDebug from \"debug\";\nimport type {\n  CacheEntry,\n  CacheHandler,\n} from \"next/dist/server/lib/cache-handlers/types\";\nimport {\n  DEFAULT_TAG_REFRESH_MS,\n  resolveAwsCacheConfig,\n  RevalidationLog,\n  TagMarkerTable,\n  TrackedTagMarkers,\n} from \"./aws-cache-store\";\nimport { outsideRequest, TAG_MANIFEST_SYMBOL } from \"../runtime/tag-manifest\";\n\nexport { markerClock as now } from \"./aws-cache-store\";\n\n/** Whether this process is `next build` rather than a deployed server. */\nexport function isBuildPhase(): boolean {\n  return process.env.NEXT_PHASE === \"phase-production-build\";\n}\n\n/** A positive integer environment variable, or `fallback`. */\nexport function numberFromEnv(name: string, fallback: number): number {\n  const raw = process.env[name];\n  const value = raw === undefined || raw === \"\" ? NaN : Number(raw);\n  return Number.isFinite(value) && value >= 0 ? value : fallback;\n}\n\n/**\n * A `CacheEntry` with its value read to the end: the bytes are what is kept,\n * and every `get` hands out a fresh stream over them.\n */\nexport interface StoredEntry extends Omit<CacheEntry, \"value\"> {\n  value: Uint8Array;\n}\n\n/**\n * Read `stream` to the end, or throw if it errors.\n *\n * `CacheEntry.value` \"can error and only have partial data\" (Next.js's\n * `cache-handlers/types.d.ts`). Throwing is how a partial entry is kept out:\n * both handlers store nothing when this rejects, which is what Next.js's own\n * default handler does too.\n */\nexport async function readStream(\n  stream: ReadableStream<Uint8Array>,\n): Promise<Uint8Array> {\n  const reader = stream.getReader();\n  const chunks: Uint8Array[] = [];\n  let size = 0;\n  for (;;) {\n    const { done, value } = await reader.read();\n    if (done) {\n      break;\n    }\n    chunks.push(value);\n    size += value.byteLength;\n  }\n  const bytes = new Uint8Array(size);\n  let offset = 0;\n  for (const chunk of chunks) {\n    bytes.set(chunk, offset);\n    offset += chunk.byteLength;\n  }\n  return bytes;\n}\n\n/** `pendingEntry` resolved and read to the end. See {@link readStream}. */\nexport async function storedEntryOf(\n  pendingEntry: Promise<CacheEntry>,\n): Promise<StoredEntry> {\n  const entry = await pendingEntry;\n  return { ...entry, value: await readStream(entry.value) };\n}\n\n/** `stored` as the `CacheEntry` a `get` returns, with its own stream. */\nexport function cacheEntryOf(\n  stored: StoredEntry,\n  revalidate: number = stored.revalidate,\n): CacheEntry {\n  const bytes = stored.value;\n  return {\n    ...stored,\n    revalidate,\n    value: new ReadableStream<Uint8Array>({\n      start(controller) {\n        // A copy: whoever reads the stream may transfer or mutate the chunk.\n        controller.enqueue(bytes.slice());\n        controller.close();\n      },\n    }),\n  };\n}\n\n/**\n * Whether Next.js would regenerate `entry` on every read anyway, so storing it\n * is a write nothing reads back. Next.js's default handler skips these the same\n * way, outside the dev server.\n */\nexport function isDynamicEntry(entry: Pick<CacheEntry, \"expire\">): boolean {\n  return entry.expire === 0;\n}\n\n/**\n * The in-flight `set`s, by cache key. `CacheHandler.set` receives an entry that\n * may still be streaming, and \"if a `get` for the same cache key is called\n * before the pending entry is complete, the cache handler must wait for the\n * `set` operation to finish\" (`cache-handlers/types.d.ts`).\n */\nexport class PendingSets {\n  private readonly pending = new Map<string, Promise<void>>();\n\n  /** Resolves once no `set` for `key` is in flight. */\n  async wait(key: string): Promise<void> {\n    for (let p = this.pending.get(key); p; p = this.pending.get(key)) {\n      await p;\n    }\n  }\n\n  /**\n   * Register a `set` for `key` and return the function that ends it. Safe to\n   * call more than once: only the registration it made is removed.\n   */\n  begin(key: string): () => void {\n    let resolve: () => void = () => {};\n    const promise = new Promise<void>((r) => (resolve = r));\n    this.pending.set(key, promise);\n    return () => {\n      if (this.pending.get(key) === promise) {\n        this.pending.delete(key);\n      }\n      resolve();\n    };\n  }\n}\n\n/**\n * Stored entries by cache key, least recently used evicted first once their\n * bytes pass `maxBytes`. Sized by bytes rather than entries, like Next.js's\n * default handler (`cacheMaxMemorySize`, 50 MB), since a `'use cache'` entry is\n * an RSC payload of any size.\n */\nexport class EntryLru {\n  private readonly entries = new Map<string, StoredEntry>();\n  private bytes = 0;\n  /**\n   * No later than the oldest entry's `timestamp`: the last scan's answer, less\n   * whatever was set since. Entries dropped since only make it early. See\n   * {@link oldestBound}.\n   */\n  private lowest = Infinity;\n\n  constructor(private readonly maxBytes: number) {}\n\n  get(key: string): StoredEntry | undefined {\n    const entry = this.entries.get(key);\n    if (entry) {\n      // Re-inserted to mark it most recently used.\n      this.entries.delete(key);\n      this.entries.set(key, entry);\n    }\n    return entry;\n  }\n\n  set(key: string, entry: StoredEntry): void {\n    this.delete(key);\n    const size = sizeOf(key, entry);\n    if (size > this.maxBytes) {\n      return;\n    }\n    this.entries.set(key, entry);\n    this.bytes += size;\n    this.lowest = Math.min(this.lowest, entry.timestamp);\n    for (const [oldestKey, oldest] of this.entries) {\n      if (this.bytes <= this.maxBytes) {\n        break;\n      }\n      this.entries.delete(oldestKey);\n      this.bytes -= sizeOf(oldestKey, oldest);\n    }\n  }\n\n  delete(key: string): void {\n    const existing = this.entries.get(key);\n    if (existing) {\n      this.entries.delete(key);\n      this.bytes -= sizeOf(key, existing);\n      if (this.entries.size === 0) {\n        this.lowest = Infinity;\n      }\n    }\n  }\n\n  /**\n   * The `timestamp` of the oldest entry held, `Infinity` with none, dropping\n   * on the way the entries past `revalidate` at `at` (`now()`): a handler\n   * that drops them when next read would otherwise hold them until then, and\n   * they would count here meanwhile. A scan, so asked once in a while: in\n   * between, {@link oldestBound} answers.\n   */\n  oldestTimestamp(at = -Infinity): number {\n    let oldest = Infinity;\n    for (const [key, entry] of this.entries) {\n      if (isPastRevalidate(entry, at)) {\n        this.delete(key);\n      } else {\n        oldest = Math.min(oldest, entry.timestamp);\n      }\n    }\n    this.lowest = oldest;\n    return oldest;\n  }\n\n  /**\n   * No later than {@link oldestTimestamp}, without its scan: as of the last\n   * one, less the entries set since. `Infinity` with none held. Drops the\n   * entries past `revalidate` at `at` from the least recently used end, up to\n   * the first that isn't, so {@link holdsLive} doesn't walk past them on every\n   * request until the next scan.\n   */\n  oldestBound(at = -Infinity): number {\n    for (const [key, entry] of this.entries) {\n      if (!isPastRevalidate(entry, at)) {\n        break;\n      }\n      this.delete(key);\n    }\n    return this.entries.size === 0 ? Infinity : this.lowest;\n  }\n\n  /**\n   * Whether an entry not past `revalidate` at `at` is held. Usually the first\n   * entry answers; the expired ones it passes are dropped by the scan\n   * {@link oldestTimestamp} makes, not here, so asking changes nothing.\n   */\n  holdsLive(at: number): boolean {\n    for (const entry of this.entries.values()) {\n      if (!isPastRevalidate(entry, at)) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  get size(): number {\n    return this.entries.size;\n  }\n}\n\nfunction sizeOf(key: string, entry: StoredEntry): number {\n  return entry.value.byteLength + key.length;\n}\n\n/** Whether `stored` is past `revalidate` at `at` (`now()`). */\nexport function isPastRevalidate(stored: StoredEntry, at: number): boolean {\n  return at > stored.timestamp + stored.revalidate * 1000;\n}\n\n/** Default size of each handler's memory store: Next.js's default, 50 MB. */\nexport const DEFAULT_MEMORY_BYTES = 50 * 1024 * 1024;\n\n/**\n * How long one revalidation table request may take, per attempt. The SDK sets\n * no limit, and a refresh left in flight across a Lambda freeze can sit on a\n * connection that died meanwhile without a reset: every request that waits\n * for the refresh (an instance `behind`, ISR) would wait with it. The SDK\n * retries a timed-out attempt, so a dead connection costs up to its attempts\n * times this.\n */\nexport const TAG_TABLE_REQUEST_TIMEOUT_MS = 3000;\n\n/**\n * Wait for `work` if `wait`, or else let it run on: either way a rejection is\n * logged with `failure` rather than thrown.\n */\nexport async function awaitIf(\n  wait: boolean,\n  work: Promise<void>,\n  failure: string,\n): Promise<void> {\n  const logged = work.catch((error) => {\n    console.error(failure, error);\n  });\n  if (wait) {\n    await logged;\n  }\n}\n\nexport interface TagMethodsOptions {\n  /**\n   * Whether `refreshTags` always waits for the revalidation log query, rather\n   * than only when the instance is `behind`.\n   * @default false\n   */\n  readonly blocking?: boolean;\n}\n\n/**\n * The `cacheHandlers` methods that only go through `tags`, the same for the\n * `default` and `remote` handlers.\n */\nexport function tagMethods(\n  tags: TrackedTagMarkers,\n  options: TagMethodsOptions = {},\n): Pick<CacheHandler, \"refreshTags\" | \"updateTags\"> {\n  return {\n    // Started, not awaited, while the instance keeps up, unless `blocking`.\n    // Next.js awaits `refreshTags` inside the first `'use cache'` lookup of a\n    // request (`use-cache-wrapper`), and a staged render ends its static stage\n    // on a timer: a log `Query` there pushed the entry out of the static\n    // stage, so a cached navigation stored the page segment without it. What\n    // the query finds applies from the next request. Awaited once the instance\n    // is `behind`, which the runtime settles before a page render starts\n    // (`catchUp`): the first request after an idle or frozen spell would\n    // otherwise serve whatever was revalidated elsewhere meanwhile. A page's\n    // render just after `catchUp` gets a grace more (`behindInRender`), so a\n    // request that came in just short of the line doesn't cross it inside\n    // the render. Not even then while the instance holds no entry the query\n    // could expire (`holdsEntries`), with a `refreshIntervalMs` of `0` too.\n    refreshTags: () =>\n      awaitIf(\n        options.blocking === true || (tags.behindInRender && tags.holdsEntries),\n        tags.refresh(),\n        \"Error refreshing cache tags:\",\n      ),\n    async updateTags(revalidatedTags, durations) {\n      await tags.update(revalidatedTags, durations);\n    },\n  };\n}\n\n/**\n * Run a cache handler method's work outside the request that called it\n * ({@link TrackedTagMarkers.outsideRender}). Next.js awaits these methods\n * inside a staged render, and 16.4 ends the render's static stage on any\n * `Date.now()`, `new Date()`, `Math.random()` or `crypto` random call made in\n * the request's context during it: ours, the AWS SDK's (request signing,\n * invocation ids) and `debug`'s alike. A draft mode page, rendered whole at\n * request time, lost its static stage that way to `refreshTags`, so the client\n * cached nothing from its HTML. Creating the manifest is in here too: the\n * first handler call of a process does it, inside a render.\n */\nexport function outsideRender<T>(fn: () => T): T {\n  return outsideRequest(sharedTagManifest).outsideRender(fn);\n}\n\n/**\n * A handler built by `create` on first use rather than on import, so loading\n * the module - which jest, and Next.js's config validation, do without using\n * it - neither constructs AWS clients nor warns about missing configuration.\n * Every method runs {@link outsideRender}.\n */\nexport function lazyHandler(create: () => CacheHandler): CacheHandler {\n  let handler: CacheHandler | undefined;\n  const instance = () => (handler ??= create());\n  return {\n    get: (cacheKey, softTags) =>\n      outsideRender(() => instance().get(cacheKey, softTags)),\n    set: (cacheKey, pendingEntry) =>\n      outsideRender(() => instance().set(cacheKey, pendingEntry)),\n    refreshTags: () => outsideRender(() => instance().refreshTags()),\n    getExpiration: (tags) =>\n      outsideRender(() => instance().getExpiration(tags)),\n    updateTags: (tags, durations) =>\n      outsideRender(() => instance().updateTags(tags, durations)),\n  };\n}\n\n/**\n * The process's one {@link TrackedTagMarkers}, from the environment.\n *\n * Kept on `globalThis` because the incremental cache handler and the `default`\n * and `remote` handlers are separate bundles - separate module instances - and\n * should share one manifest: one refresh read for all of them, and one marker\n * write per `revalidateTag`.\n *\n * At build time there is no table to read (and no credentials to read it\n * with), so tags stay local to the process there.\n */\nexport function sharedTagManifest(): TrackedTagMarkers {\n  const global = globalThis as { [TAG_MANIFEST_SYMBOL]?: TrackedTagMarkers };\n  if (!global[TAG_MANIFEST_SYMBOL]) {\n    const config = resolveAwsCacheConfig();\n    const refreshIntervalMs = numberFromEnv(\n      \"CDK_NEXTJS_TAG_REFRESH_MS\",\n      DEFAULT_TAG_REFRESH_MS,\n    );\n    if (config.tableName && !isBuildPhase()) {\n      const client = new DynamoDBClient({\n        region: config.region,\n        // Without `throwOnRequestTimeout` the timeout only logs a warning. It\n        // ends once the response headers arrive: `socketTimeout`, an\n        // inactivity timer kept until the request closes, covers the body.\n        requestHandler: {\n          requestTimeout: TAG_TABLE_REQUEST_TIMEOUT_MS,\n          throwOnRequestTimeout: true,\n          socketTimeout: TAG_TABLE_REQUEST_TIMEOUT_MS,\n        },\n      });\n      global[TAG_MANIFEST_SYMBOL] = new TrackedTagMarkers({\n        markers: new TagMarkerTable(client, config.tableName, config.buildId),\n        log: new RevalidationLog(client, config.tableName, config.buildId),\n        refreshIntervalMs,\n        debug: getDebug(\"cdk-nextjs:cache-handler:tags\"),\n        // Set in every Lambda runtime; a container is never frozen.\n        canFreeze: process.env.AWS_LAMBDA_FUNCTION_NAME !== undefined,\n      });\n    } else {\n      if (!isBuildPhase()) {\n        console.warn(\n          \"CDK_NEXTJS_REVALIDATION_TABLE_NAME environment variable not set, cache tags are local to each instance\",\n        );\n      }\n      global[TAG_MANIFEST_SYMBOL] = new TrackedTagMarkers({\n        refreshIntervalMs,\n      });\n    }\n  }\n  return global[TAG_MANIFEST_SYMBOL];\n}\n"]}