cdk-nextjs 0.6.2 → 0.7.1

package/lib/adapter/use-cache-remote-handler.js

@@ -0,0 +1,186 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRemoteUseCacheHandler = createRemoteUseCacheHandler;
+/*
+  The `cacheHandlers.remote` handler, for `'use cache: remote'`.
+  See: https://nextjs.org/docs/app/api-reference/config/next-config-js/cacheHandlers
+
+  Entries are stored in the cache bucket, so every instance reads what any
+  instance wrote, with a bounded in-memory tier in front. Tags go through the
+  revalidation table's marker rows, shared with plain `'use cache'` and with the
+  incremental cache. Without this, Next.js maps `remote` to its in-memory
+  default handler, and `'use cache: remote'` is no more shared than
+  `'use cache'`.
+*/
+/* eslint-disable import/no-extraneous-dependencies */
+const node_crypto_1 = require("node:crypto");
+const client_s3_1 = require("@aws-sdk/client-s3");
+const debug_1 = __importDefault(require("debug"));
+const aws_cache_store_1 = require("./aws-cache-store");
+const cache_utils_1 = require("./cache-utils");
+const use_cache_common_1 = require("./use-cache-common");
+function bucketFromEnv() {
+    if ((0, use_cache_common_1.isBuildPhase)()) {
+        // No credentials, and nothing a build-time entry could be read back by:
+        // prerenders keep what they need in their own resume data cache.
+        return null;
+    }
+    const { bucketName, region } = (0, aws_cache_store_1.resolveAwsCacheConfig)();
+    if (!bucketName) {
+        console.warn("CDK_NEXTJS_CACHE_BUCKET_NAME environment variable not set, 'use cache: remote' entries are local to each instance");
+        return null;
+    }
+    return new aws_cache_store_1.CacheBucket(new client_s3_1.S3Client({ region }), bucketName);
+}
+/** Whether `stored` is past `revalidate`, so a fresher copy may exist. */
+function isPastRevalidate(stored, at) {
+    return at > stored.timestamp + stored.revalidate * 1000;
+}
+/** Whether `stored` is past `expire`, and may no longer be served at all. */
+function isPastExpire(stored, at) {
+    return at > stored.timestamp + stored.expire * 1000;
+}
+/**
+ * A `'use cache: remote'` handler: S3 for storage, memory in front, and the
+ * revalidation table for tags.
+ *
+ * Unlike the default handler an entry is served until `expire`, not dropped at
+ * `revalidate`: a remote read is worth serving stale while Next.js's wrapper
+ * regenerates it in the background, which is what `revalidate` is for. A memory
+ * copy past `revalidate` is checked against S3 first, since another instance may
+ * already have written the regenerated entry.
+ */
+function createRemoteUseCacheHandler(options = {}) {
+    const bucket = options.bucket === undefined ? bucketFromEnv() : options.bucket;
+    const buildId = options.buildId ?? (0, aws_cache_store_1.resolveAwsCacheConfig)().buildId;
+    const tags = options.tags ?? (0, use_cache_common_1.sharedTagManifest)();
+    const memory = new use_cache_common_1.EntryLru((0, use_cache_common_1.numberFromEnv)("CDK_NEXTJS_USE_CACHE_MEMORY_BYTES", use_cache_common_1.DEFAULT_MEMORY_BYTES));
+    const pending = new use_cache_common_1.PendingSets();
+    const debug = (0, debug_1.default)("cdk-nextjs:cache-handler:use-cache:remote");
+    const s3Key = (cacheKey) => (0, aws_cache_store_1.useCacheS3Key)(buildId, (0, node_crypto_1.createHash)("sha256").update(cacheKey).digest("hex"));
+    async function readFromS3(cacheKey) {
+        if (!bucket) {
+            return undefined;
+        }
+        const key = s3Key(cacheKey);
+        try {
+            const object = await bucket.get(key);
+            if (!object) {
+                debug(`S3 MISS ${cacheKey}`);
+                return undefined;
+            }
+            const parsed = (0, cache_utils_1.parseCacheValue)(object);
+            if (parsed.key !== cacheKey) {
+                // A hash collision, or an object that is not ours: never serve it.
+                console.warn(`'use cache: remote' entry ${key} is for another key`);
+                return undefined;
+            }
+            return {
+                tags: parsed.tags,
+                stale: parsed.stale,
+                timestamp: parsed.timestamp,
+                expire: parsed.expire,
+                revalidate: parsed.revalidate,
+                value: new Uint8Array(parsed.value),
+            };
+        }
+        catch (error) {
+            console.error(`Error reading 'use cache: remote' entry ${key} from S3:`, error);
+            return undefined;
+        }
+    }
+    async function writeToS3(cacheKey, stored) {
+        if (!bucket) {
+            return;
+        }
+        const key = s3Key(cacheKey);
+        const serialized = {
+            ...stored,
+            key: cacheKey,
+            value: Buffer.from(stored.value),
+        };
+        try {
+            await bucket.putJson(key, (0, cache_utils_1.serializeCacheValue)(serialized));
+            debug(`S3 SET ${cacheKey} (${key})`);
+        }
+        catch (error) {
+            // The entry is still in memory here; other instances just miss.
+            console.error(`Error writing 'use cache: remote' entry ${key} to S3:`, error);
+        }
+    }
+    return {
+        async get(cacheKey) {
+            await pending.wait(cacheKey);
+            const at = (0, use_cache_common_1.now)();
+            let stored = memory.get(cacheKey);
+            if (stored) {
+                await tags.ensure(stored.tags);
+            }
+            // Past `revalidate`, or stale or expired by tag: another instance may
+            // already have written the regenerated entry, and serving that beats
+            // regenerating it here too. An expired entry S3 has nothing newer for is
+            // dropped below.
+            if (!stored ||
+                isPastRevalidate(stored, at) ||
+                tags.state(stored.tags, stored.timestamp) !== "fresh") {
+                const fromS3 = await readFromS3(cacheKey);
+                if (fromS3 && (!stored || fromS3.timestamp > stored.timestamp)) {
+                    stored = fromS3;
+                    // An entry written by another instance: its tags may have been
+                    // revalidated at any time since, so they are read before judging it.
+                    await tags.ensure(stored.tags);
+                    memory.set(cacheKey, stored);
+                }
+            }
+            if (!stored) {
+                debug(`MISS ${cacheKey}`);
+                return undefined;
+            }
+            if (isPastExpire(stored, at)) {
+                debug(`EXPIRED ${cacheKey}`);
+                memory.delete(cacheKey);
+                return undefined;
+            }
+            const state = tags.state(stored.tags, stored.timestamp);
+            if (state === "expired") {
+                debug(`EXPIRED BY TAG ${cacheKey}`);
+                memory.delete(cacheKey);
+                return undefined;
+            }
+            debug(`HIT ${cacheKey}${state === "stale" ? " (stale tag)" : ""}`);
+            // `revalidate: -1` makes the wrapper serve the entry and regenerate it in
+            // the background, the built-in handler's answer to a stale tag.
+            return (0, use_cache_common_1.cacheEntryOf)(stored, state === "stale" ? -1 : stored.revalidate);
+        },
+        async set(cacheKey, pendingEntry) {
+            const done = pending.begin(cacheKey);
+            let stored;
+            try {
+                stored = await (0, use_cache_common_1.storedEntryOf)(pendingEntry);
+            }
+            catch (error) {
+                // The stream errored: store nothing rather than a partial entry.
+                debug(`SET FAILED ${cacheKey}`, error);
+                done();
+                return;
+            }
+            if ((0, use_cache_common_1.isDynamicEntry)(stored)) {
+                debug(`SKIP dynamic entry ${cacheKey}`);
+                done();
+                return;
+            }
+            memory.set(cacheKey, stored);
+            tags.track(stored.tags);
+            // A `get` waiting on this `set` can be answered from memory now; only
+            // other instances need the S3 copy.
+            done();
+            await writeToS3(cacheKey, stored);
+        },
+        ...(0, use_cache_common_1.tagMethods)(tags),
+    };
+}
+exports.default = (0, use_cache_common_1.lazyHandler)(() => createRemoteUseCacheHandler());
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"use-cache-remote-handler.js","sourceRoot":"","sources":["../../src/adapter/use-cache-remote-handler.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n  The `cacheHandlers.remote` handler, for `'use cache: remote'`.\n  See: https://nextjs.org/docs/app/api-reference/config/next-config-js/cacheHandlers\n\n  Entries are stored in the cache bucket, so every instance reads what any\n  instance wrote, with a bounded in-memory tier in front. Tags go through the\n  revalidation table's marker rows, shared with plain `'use cache'` and with the\n  incremental cache. Without this, Next.js maps `remote` to its in-memory\n  default handler, and `'use cache: remote'` is no more shared than\n  `'use cache'`.\n*/\n/* eslint-disable import/no-extraneous-dependencies */\nimport { createHash } from \"node:crypto\";\nimport { S3Client } from \"@aws-sdk/client-s3\";\nimport getDebug from \"debug\";\nimport type {\n  CacheEntry,\n  CacheHandler,\n} from \"next/dist/server/lib/cache-handlers/types\";\nimport {\n  CacheBucket,\n  resolveAwsCacheConfig,\n  TrackedTagMarkers,\n  useCacheS3Key,\n} from \"./aws-cache-store\";\nimport { parseCacheValue, serializeCacheValue } from \"./cache-utils\";\nimport {\n  cacheEntryOf,\n  DEFAULT_MEMORY_BYTES,\n  EntryLru,\n  isBuildPhase,\n  isDynamicEntry,\n  lazyHandler,\n  now,\n  numberFromEnv,\n  PendingSets,\n  sharedTagManifest,\n  StoredEntry,\n  storedEntryOf,\n  tagMethods,\n} from \"./use-cache-common\";\n\nexport interface RemoteUseCacheHandlerOptions {\n  /**\n   * The bucket entries are stored in, or `null` for memory only. From\n   * `CDK_NEXTJS_CACHE_BUCKET_NAME` by default, and never at build time.\n   */\n  bucket?: CacheBucket | null;\n  /** Prefixes every S3 key; `CDK_NEXTJS_BUILD_ID` by default. */\n  buildId?: string;\n  /** Tag state; the process-wide one from the environment by default. */\n  tags?: TrackedTagMarkers;\n}\n\n/** What is written to S3 for one entry. */\ninterface SerializedEntry extends Omit<StoredEntry, \"value\"> {\n  /** The full cache key, checked on read; the object key is only its hash. */\n  key: string;\n  value: Buffer;\n}\n\nfunction bucketFromEnv(): CacheBucket | null {\n  if (isBuildPhase()) {\n    // No credentials, and nothing a build-time entry could be read back by:\n    // prerenders keep what they need in their own resume data cache.\n    return null;\n  }\n  const { bucketName, region } = resolveAwsCacheConfig();\n  if (!bucketName) {\n    console.warn(\n      \"CDK_NEXTJS_CACHE_BUCKET_NAME environment variable not set, 'use cache: remote' entries are local to each instance\",\n    );\n    return null;\n  }\n  return new CacheBucket(new S3Client({ region }), bucketName);\n}\n\n/** Whether `stored` is past `revalidate`, so a fresher copy may exist. */\nfunction isPastRevalidate(stored: StoredEntry, at: number): boolean {\n  return at > stored.timestamp + stored.revalidate * 1000;\n}\n\n/** Whether `stored` is past `expire`, and may no longer be served at all. */\nfunction isPastExpire(stored: StoredEntry, at: number): boolean {\n  return at > stored.timestamp + stored.expire * 1000;\n}\n\n/**\n * A `'use cache: remote'` handler: S3 for storage, memory in front, and the\n * revalidation table for tags.\n *\n * Unlike the default handler an entry is served until `expire`, not dropped at\n * `revalidate`: a remote read is worth serving stale while Next.js's wrapper\n * regenerates it in the background, which is what `revalidate` is for. A memory\n * copy past `revalidate` is checked against S3 first, since another instance may\n * already have written the regenerated entry.\n */\nexport function createRemoteUseCacheHandler(\n  options: RemoteUseCacheHandlerOptions = {},\n): CacheHandler {\n  const bucket =\n    options.bucket === undefined ? bucketFromEnv() : options.bucket;\n  const buildId = options.buildId ?? resolveAwsCacheConfig().buildId;\n  const tags = options.tags ?? sharedTagManifest();\n  const memory = new EntryLru(\n    numberFromEnv(\"CDK_NEXTJS_USE_CACHE_MEMORY_BYTES\", DEFAULT_MEMORY_BYTES),\n  );\n  const pending = new PendingSets();\n  const debug = getDebug(\"cdk-nextjs:cache-handler:use-cache:remote\");\n\n  const s3Key = (cacheKey: string) =>\n    useCacheS3Key(buildId, createHash(\"sha256\").update(cacheKey).digest(\"hex\"));\n\n  async function readFromS3(\n    cacheKey: string,\n  ): Promise<StoredEntry | undefined> {\n    if (!bucket) {\n      return undefined;\n    }\n    const key = s3Key(cacheKey);\n    try {\n      const object = await bucket.get(key);\n      if (!object) {\n        debug(`S3 MISS ${cacheKey}`);\n        return undefined;\n      }\n      const parsed = parseCacheValue(object) as SerializedEntry;\n      if (parsed.key !== cacheKey) {\n        // A hash collision, or an object that is not ours: never serve it.\n        console.warn(`'use cache: remote' entry ${key} is for another key`);\n        return undefined;\n      }\n      return {\n        tags: parsed.tags,\n        stale: parsed.stale,\n        timestamp: parsed.timestamp,\n        expire: parsed.expire,\n        revalidate: parsed.revalidate,\n        value: new Uint8Array(parsed.value),\n      };\n    } catch (error) {\n      console.error(\n        `Error reading 'use cache: remote' entry ${key} from S3:`,\n        error,\n      );\n      return undefined;\n    }\n  }\n\n  async function writeToS3(cacheKey: string, stored: StoredEntry) {\n    if (!bucket) {\n      return;\n    }\n    const key = s3Key(cacheKey);\n    const serialized: SerializedEntry = {\n      ...stored,\n      key: cacheKey,\n      value: Buffer.from(stored.value),\n    };\n    try {\n      await bucket.putJson(key, serializeCacheValue(serialized));\n      debug(`S3 SET ${cacheKey} (${key})`);\n    } catch (error) {\n      // The entry is still in memory here; other instances just miss.\n      console.error(\n        `Error writing 'use cache: remote' entry ${key} to S3:`,\n        error,\n      );\n    }\n  }\n\n  return {\n    async get(cacheKey: string): Promise<CacheEntry | undefined> {\n      await pending.wait(cacheKey);\n      const at = now();\n\n      let stored = memory.get(cacheKey);\n      if (stored) {\n        await tags.ensure(stored.tags);\n      }\n\n      // Past `revalidate`, or stale or expired by tag: another instance may\n      // already have written the regenerated entry, and serving that beats\n      // regenerating it here too. An expired entry S3 has nothing newer for is\n      // dropped below.\n      if (\n        !stored ||\n        isPastRevalidate(stored, at) ||\n        tags.state(stored.tags, stored.timestamp) !== \"fresh\"\n      ) {\n        const fromS3 = await readFromS3(cacheKey);\n        if (fromS3 && (!stored || fromS3.timestamp > stored.timestamp)) {\n          stored = fromS3;\n          // An entry written by another instance: its tags may have been\n          // revalidated at any time since, so they are read before judging it.\n          await tags.ensure(stored.tags);\n          memory.set(cacheKey, stored);\n        }\n      }\n\n      if (!stored) {\n        debug(`MISS ${cacheKey}`);\n        return undefined;\n      }\n      if (isPastExpire(stored, at)) {\n        debug(`EXPIRED ${cacheKey}`);\n        memory.delete(cacheKey);\n        return undefined;\n      }\n      const state = tags.state(stored.tags, stored.timestamp);\n      if (state === \"expired\") {\n        debug(`EXPIRED BY TAG ${cacheKey}`);\n        memory.delete(cacheKey);\n        return undefined;\n      }\n      debug(`HIT ${cacheKey}${state === \"stale\" ? \" (stale tag)\" : \"\"}`);\n      // `revalidate: -1` makes the wrapper serve the entry and regenerate it in\n      // the background, the built-in handler's answer to a stale tag.\n      return cacheEntryOf(stored, state === \"stale\" ? -1 : stored.revalidate);\n    },\n\n    async set(\n      cacheKey: string,\n      pendingEntry: Promise<CacheEntry>,\n    ): Promise<void> {\n      const done = pending.begin(cacheKey);\n      let stored: StoredEntry;\n      try {\n        stored = await storedEntryOf(pendingEntry);\n      } catch (error) {\n        // The stream errored: store nothing rather than a partial entry.\n        debug(`SET FAILED ${cacheKey}`, error);\n        done();\n        return;\n      }\n      if (isDynamicEntry(stored)) {\n        debug(`SKIP dynamic entry ${cacheKey}`);\n        done();\n        return;\n      }\n      memory.set(cacheKey, stored);\n      tags.track(stored.tags);\n      // A `get` waiting on this `set` can be answered from memory now; only\n      // other instances need the S3 copy.\n      done();\n      await writeToS3(cacheKey, stored);\n    },\n\n    ...tagMethods(tags),\n  };\n}\n\nexport default lazyHandler(() => createRemoteUseCacheHandler());\n"]}