cdk-nextjs 0.7.5 → 0.7.7

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

@@ -38,21 +38,43 @@ function createDefaultUseCacheHandler(options = {}) {
     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");
+    // Expired entries, which `get` drops anyway, don't count as held for a
+    // refresh to wait for, nor hold `completeSince`'s pruning back past the
+    // next scan.
+    tags.judgeEntriesOf((scan) => scan ? memory.oldestTimestamp((0, use_cache_common_1.now)()) : memory.oldestBound((0, use_cache_common_1.now)()), () => memory.holdsLive((0, use_cache_common_1.now)()));
+    /**
+     * Read the markers of whichever of `tagList` are untracked: first, when the
+     * answer depends on them, or else in the background. Read either way, so
+     * the tags join the rolling re-read, which catches a revalidation whose log
+     * row failed to write.
+     */
+    const ensureTags = (needed, tagList) => (0, use_cache_common_1.awaitIf)(needed, tags.ensure(tagList), "Error reading cache tags:");
     return {
-        async get(cacheKey) {
+        async get(cacheKey, softTags = []) {
             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) {
+            if ((0, use_cache_common_1.isPastRevalidate)(stored, (0, use_cache_common_1.now)())) {
                 debug(`EXPIRED ${cacheKey}`);
                 memory.delete(cacheKey);
                 return undefined;
             }
-            await tags.ensure(stored.tags);
-            const state = tags.state(stored.tags, stored.timestamp);
+            // Only an entry older than what the manifest fully knows needs its tags'
+            // markers read first: see `completeSince`. Every entry stored since the
+            // instance started is newer, so its first read waits on nothing - nor
+            // does a new path's, whose implicit tags it has never read.
+            await ensureTags(stored.timestamp < tags.completeSince, [
+                ...stored.tags,
+                ...softTags,
+            ]);
+            // Implicit tags count once expired, not stale, as Next.js compares
+            // `getExpiration`'s answer.
+            const state = tags.expiration(softTags) >= stored.timestamp
+                ? "expired"
+                : tags.state(stored.tags, stored.timestamp);
             if (state === "expired") {
                 debug(`EXPIRED BY TAG ${cacheKey}`);
                 memory.delete(cacheKey);
@@ -72,7 +94,11 @@ function createDefaultUseCacheHandler(options = {}) {
                     return;
                 }
                 memory.set(cacheKey, stored);
-                tags.track(stored.tags);
+                // In the background, now rather than at the first `get`: a
+                // revalidation from before the log's first lookback with an `expire`
+                // still to come expires this entry when it comes, and only the marker
+                // says so. See `completeSince`.
+                void ensureTags(false, stored.tags);
                 debug(`SET ${cacheKey}`);
             }
             catch (error) {
@@ -84,7 +110,11 @@ function createDefaultUseCacheHandler(options = {}) {
             }
         },
         ...(0, use_cache_common_1.tagMethods)(tags),
+        // `Infinity` has Next.js pass the implicit tags to `get` instead, so they
+        // are judged against the entry read: whether answering needs a marker
+        // read depends on that entry's `timestamp`, which this does not know.
+        getExpiration: async () => Infinity,
     };
 }
 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"]}
+//# 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  awaitIf,\n  cacheEntryOf,\n  DEFAULT_MEMORY_BYTES,\n  EntryLru,\n  isDynamicEntry,\n  isPastRevalidate,\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  // Expired entries, which `get` drops anyway, don't count as held for a\n  // refresh to wait for, nor hold `completeSince`'s pruning back past the\n  // next scan.\n  tags.judgeEntriesOf(\n    (scan) =>\n      scan ? memory.oldestTimestamp(now()) : memory.oldestBound(now()),\n    () => memory.holdsLive(now()),\n  );\n\n  /**\n   * Read the markers of whichever of `tagList` are untracked: first, when the\n   * answer depends on them, or else in the background. Read either way, so\n   * the tags join the rolling re-read, which catches a revalidation whose log\n   * row failed to write.\n   */\n  const ensureTags = (needed: boolean, tagList: readonly string[]) =>\n    awaitIf(needed, tags.ensure(tagList), \"Error reading cache tags:\");\n\n  return {\n    async get(\n      cacheKey: string,\n      softTags: string[] = [],\n    ): 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 (isPastRevalidate(stored, now())) {\n        debug(`EXPIRED ${cacheKey}`);\n        memory.delete(cacheKey);\n        return undefined;\n      }\n      // Only an entry older than what the manifest fully knows needs its tags'\n      // markers read first: see `completeSince`. Every entry stored since the\n      // instance started is newer, so its first read waits on nothing - nor\n      // does a new path's, whose implicit tags it has never read.\n      await ensureTags(stored.timestamp < tags.completeSince, [\n        ...stored.tags,\n        ...softTags,\n      ]);\n      // Implicit tags count once expired, not stale, as Next.js compares\n      // `getExpiration`'s answer.\n      const state =\n        tags.expiration(softTags) >= stored.timestamp\n          ? \"expired\"\n          : 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        // In the background, now rather than at the first `get`: a\n        // revalidation from before the log's first lookback with an `expire`\n        // still to come expires this entry when it comes, and only the marker\n        // says so. See `completeSince`.\n        void ensureTags(false, 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    // `Infinity` has Next.js pass the implicit tags to `get` instead, so they\n    // are judged against the entry read: whether answering needs a marker\n    // read depends on that entry's `timestamp`, which this does not know.\n    getExpiration: async () => Infinity,\n  };\n}\n\nexport default lazyHandler(() => createDefaultUseCacheHandler());\n"]}