cdk-nextjs 0.6.1 → 0.7.0

package/lib/adapter/use-cache-default-handler.d.ts

@@ -0,0 +1,24 @@
+import type { CacheHandler } from "next/dist/server/lib/cache-handlers/types";
+import { TrackedTagMarkers } from "./aws-cache-store";
+export interface DefaultUseCacheHandlerOptions {
+    /** Tag state; the process-wide one from the environment by default. */
+    tags?: TrackedTagMarkers;
+}
+/**
+ * A `'use cache'` handler with the semantics of Next.js's built-in one
+ * (`next/dist/server/lib/cache-handlers/default.js`) and tags shared across
+ * instances.
+ *
+ * An equivalent rather than a wrapper: the built-in handler judges tags against
+ * the module-level `tagsManifest` of whichever copy of `next` it was required
+ * from, and this bundle cannot be sure of reaching the copy the server loaded
+ * (the same reason `S3CacheHandler` reads that manifest from the module cache
+ * instead of requiring it). Keeping the tag state here removes the question.
+ *
+ * As in the built-in handler, an entry is dropped once it is past `revalidate`
+ * rather than served stale: an in-memory entry is likely evicted before a
+ * background refresh would pay off.
+ */
+export declare function createDefaultUseCacheHandler(options?: DefaultUseCacheHandlerOptions): CacheHandler;
+declare const _default: CacheHandler;
+export default _default;

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

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefaultUseCacheHandler = createDefaultUseCacheHandler;
+/*
+  The `cacheHandlers.default` handler, for plain `'use cache'`.
+  See: https://nextjs.org/docs/app/api-reference/config/next-config-js/cacheHandlers
+
+  Storage stays in memory, per instance, as Next.js intends for `'use cache'`
+  (`'use cache: remote'` is the shared one). What this changes is tags: Next.js's
+  built-in handler keeps them in a process-local map, so a `revalidateTag` on
+  one instance left every other instance serving the revalidated entry. Here
+  they go through the revalidation table's marker rows. See
+  `TrackedTagMarkers`.
+*/
+/* eslint-disable import/no-extraneous-dependencies */
+const debug_1 = __importDefault(require("debug"));
+const use_cache_common_1 = require("./use-cache-common");
+/**
+ * A `'use cache'` handler with the semantics of Next.js's built-in one
+ * (`next/dist/server/lib/cache-handlers/default.js`) and tags shared across
+ * instances.
+ *
+ * An equivalent rather than a wrapper: the built-in handler judges tags against
+ * the module-level `tagsManifest` of whichever copy of `next` it was required
+ * from, and this bundle cannot be sure of reaching the copy the server loaded
+ * (the same reason `S3CacheHandler` reads that manifest from the module cache
+ * instead of requiring it). Keeping the tag state here removes the question.
+ *
+ * As in the built-in handler, an entry is dropped once it is past `revalidate`
+ * rather than served stale: an in-memory entry is likely evicted before a
+ * background refresh would pay off.
+ */
+function createDefaultUseCacheHandler(options = {}) {
+    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:default");
+    return {
+        async get(cacheKey) {
+            await pending.wait(cacheKey);
+            const stored = memory.get(cacheKey);
+            if (!stored) {
+                debug(`MISS ${cacheKey}`);
+                return undefined;
+            }
+            if ((0, use_cache_common_1.now)() > stored.timestamp + stored.revalidate * 1000) {
+                debug(`EXPIRED ${cacheKey}`);
+                memory.delete(cacheKey);
+                return undefined;
+            }
+            await tags.ensure(stored.tags);
+            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` is how the built-in handler reports a stale tag: the
+            // wrapper serves the entry and regenerates it in the background.
+            return (0, use_cache_common_1.cacheEntryOf)(stored, state === "stale" ? -1 : stored.revalidate);
+        },
+        async set(cacheKey, pendingEntry) {
+            const done = pending.begin(cacheKey);
+            try {
+                const stored = await (0, use_cache_common_1.storedEntryOf)(pendingEntry);
+                if ((0, use_cache_common_1.isDynamicEntry)(stored)) {
+                    debug(`SKIP dynamic entry ${cacheKey}`);
+                    return;
+                }
+                memory.set(cacheKey, stored);
+                tags.track(stored.tags);
+                debug(`SET ${cacheKey}`);
+            }
+            catch (error) {
+                // The stream errored: store nothing rather than a partial entry.
+                debug(`SET FAILED ${cacheKey}`, error);
+            }
+            finally {
+                done();
+            }
+        },
+        ...(0, use_cache_common_1.tagMethods)(tags),
+    };
+}
+exports.default = (0, use_cache_common_1.lazyHandler)(() => createDefaultUseCacheHandler());
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"use-cache-default-handler.js","sourceRoot":"","sources":["../../src/adapter/use-cache-default-handler.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n  The `cacheHandlers.default` handler, for plain `'use cache'`.\n  See: https://nextjs.org/docs/app/api-reference/config/next-config-js/cacheHandlers\n\n  Storage stays in memory, per instance, as Next.js intends for `'use cache'`\n  (`'use cache: remote'` is the shared one). What this changes is tags: Next.js's\n  built-in handler keeps them in a process-local map, so a `revalidateTag` on\n  one instance left every other instance serving the revalidated entry. Here\n  they go through the revalidation table's marker rows. See\n  `TrackedTagMarkers`.\n*/\n/* eslint-disable import/no-extraneous-dependencies */\nimport getDebug from \"debug\";\nimport type {\n  CacheEntry,\n  CacheHandler,\n} from \"next/dist/server/lib/cache-handlers/types\";\nimport { TrackedTagMarkers } from \"./aws-cache-store\";\nimport {\n  cacheEntryOf,\n  DEFAULT_MEMORY_BYTES,\n  EntryLru,\n  isDynamicEntry,\n  lazyHandler,\n  now,\n  numberFromEnv,\n  PendingSets,\n  sharedTagManifest,\n  storedEntryOf,\n  tagMethods,\n} from \"./use-cache-common\";\n\nexport interface DefaultUseCacheHandlerOptions {\n  /** Tag state; the process-wide one from the environment by default. */\n  tags?: TrackedTagMarkers;\n}\n\n/**\n * A `'use cache'` handler with the semantics of Next.js's built-in one\n * (`next/dist/server/lib/cache-handlers/default.js`) and tags shared across\n * instances.\n *\n * An equivalent rather than a wrapper: the built-in handler judges tags against\n * the module-level `tagsManifest` of whichever copy of `next` it was required\n * from, and this bundle cannot be sure of reaching the copy the server loaded\n * (the same reason `S3CacheHandler` reads that manifest from the module cache\n * instead of requiring it). Keeping the tag state here removes the question.\n *\n * As in the built-in handler, an entry is dropped once it is past `revalidate`\n * rather than served stale: an in-memory entry is likely evicted before a\n * background refresh would pay off.\n */\nexport function createDefaultUseCacheHandler(\n  options: DefaultUseCacheHandlerOptions = {},\n): CacheHandler {\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:default\");\n\n  return {\n    async get(cacheKey: string): Promise<CacheEntry | undefined> {\n      await pending.wait(cacheKey);\n      const stored = memory.get(cacheKey);\n      if (!stored) {\n        debug(`MISS ${cacheKey}`);\n        return undefined;\n      }\n      if (now() > stored.timestamp + stored.revalidate * 1000) {\n        debug(`EXPIRED ${cacheKey}`);\n        memory.delete(cacheKey);\n        return undefined;\n      }\n      await tags.ensure(stored.tags);\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` is how the built-in handler reports a stale tag: the\n      // wrapper serves the entry and regenerates it in the background.\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      try {\n        const stored = await storedEntryOf(pendingEntry);\n        if (isDynamicEntry(stored)) {\n          debug(`SKIP dynamic entry ${cacheKey}`);\n          return;\n        }\n        memory.set(cacheKey, stored);\n        tags.track(stored.tags);\n        debug(`SET ${cacheKey}`);\n      } catch (error) {\n        // The stream errored: store nothing rather than a partial entry.\n        debug(`SET FAILED ${cacheKey}`, error);\n      } finally {\n        done();\n      }\n    },\n\n    ...tagMethods(tags),\n  };\n}\n\nexport default lazyHandler(() => createDefaultUseCacheHandler());\n"]}