cdk-nextjs 0.6.2 → 0.7.0

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

@@ -0,0 +1,90 @@
+import type { CacheEntry, CacheHandler } from "next/dist/server/lib/cache-handlers/types";
+import { TrackedTagMarkers } from "./aws-cache-store";
+export { markerClock as now } from "./aws-cache-store";
+/** Whether this process is `next build` rather than a deployed server. */
+export declare function isBuildPhase(): boolean;
+/** A positive integer environment variable, or `fallback`. */
+export declare function numberFromEnv(name: string, fallback: number): number;
+/**
+ * A `CacheEntry` with its value read to the end: the bytes are what is kept,
+ * and every `get` hands out a fresh stream over them.
+ */
+export interface StoredEntry extends Omit<CacheEntry, "value"> {
+    value: Uint8Array;
+}
+/**
+ * Read `stream` to the end, or throw if it errors.
+ *
+ * `CacheEntry.value` "can error and only have partial data" (Next.js's
+ * `cache-handlers/types.d.ts`). Throwing is how a partial entry is kept out:
+ * both handlers store nothing when this rejects, which is what Next.js's own
+ * default handler does too.
+ */
+export declare function readStream(stream: ReadableStream<Uint8Array>): Promise<Uint8Array>;
+/** `pendingEntry` resolved and read to the end. See {@link readStream}. */
+export declare function storedEntryOf(pendingEntry: Promise<CacheEntry>): Promise<StoredEntry>;
+/** `stored` as the `CacheEntry` a `get` returns, with its own stream. */
+export declare function cacheEntryOf(stored: StoredEntry, revalidate?: number): CacheEntry;
+/**
+ * Whether Next.js would regenerate `entry` on every read anyway, so storing it
+ * is a write nothing reads back. Next.js's default handler skips these the same
+ * way, outside the dev server.
+ */
+export declare function isDynamicEntry(entry: Pick<CacheEntry, "expire">): boolean;
+/**
+ * The in-flight `set`s, by cache key. `CacheHandler.set` receives an entry that
+ * may still be streaming, and "if a `get` for the same cache key is called
+ * before the pending entry is complete, the cache handler must wait for the
+ * `set` operation to finish" (`cache-handlers/types.d.ts`).
+ */
+export declare class PendingSets {
+    private readonly pending;
+    /** Resolves once no `set` for `key` is in flight. */
+    wait(key: string): Promise<void>;
+    /**
+     * Register a `set` for `key` and return the function that ends it. Safe to
+     * call more than once: only the registration it made is removed.
+     */
+    begin(key: string): () => void;
+}
+/**
+ * Stored entries by cache key, least recently used evicted first once their
+ * bytes pass `maxBytes`. Sized by bytes rather than entries, like Next.js's
+ * default handler (`cacheMaxMemorySize`, 50 MB), since a `'use cache'` entry is
+ * an RSC payload of any size.
+ */
+export declare class EntryLru {
+    private readonly maxBytes;
+    private readonly entries;
+    private bytes;
+    constructor(maxBytes: number);
+    get(key: string): StoredEntry | undefined;
+    set(key: string, entry: StoredEntry): void;
+    delete(key: string): void;
+    get size(): number;
+}
+/** Default size of each handler's memory store: Next.js's default, 50 MB. */
+export declare const DEFAULT_MEMORY_BYTES: number;
+/**
+ * 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">;
+/**
+ * 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.
+ */
+export declare function lazyHandler(create: () => CacheHandler): CacheHandler;
+/**
+ * The process's one {@link TrackedTagMarkers}, from the environment.
+ *
+ * Kept on `globalThis` because the incremental cache handler and the `default`
+ * and `remote` handlers are separate bundles - separate module instances - and
+ * should share one manifest: one refresh read for all of them, and one marker
+ * write per `revalidateTag`.
+ *
+ * At build time there is no table to read (and no credentials to read it
+ * with), so tags stay local to the process there.
+ */
+export declare function sharedTagManifest(): TrackedTagMarkers;

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

@@ -0,0 +1,250 @@
+"use strict";
+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.isBuildPhase = isBuildPhase;
+exports.numberFromEnv = numberFromEnv;
+exports.readStream = readStream;
+exports.storedEntryOf = storedEntryOf;
+exports.cacheEntryOf = cacheEntryOf;
+exports.isDynamicEntry = isDynamicEntry;
+exports.tagMethods = tagMethods;
+exports.lazyHandler = lazyHandler;
+exports.sharedTagManifest = sharedTagManifest;
+/*
+  What the two `cacheHandlers` (`'use cache'` and `'use cache: remote'`) share:
+  the in-memory entry store, the pending-`set` bookkeeping Next.js requires of
+  every handler, and the process's one tag manifest (`TrackedTagMarkers`),
+  which makes `revalidateTag` reach every instance through the revalidation
+  table's marker rows.
+*/
+/* eslint-disable import/no-extraneous-dependencies */
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const debug_1 = __importDefault(require("debug"));
+const aws_cache_store_1 = require("./aws-cache-store");
+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. */
+function isBuildPhase() {
+    return process.env.NEXT_PHASE === "phase-production-build";
+}
+/** A positive integer environment variable, or `fallback`. */
+function numberFromEnv(name, fallback) {
+    const raw = process.env[name];
+    const value = raw === undefined || raw === "" ? NaN : Number(raw);
+    return Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+/**
+ * Read `stream` to the end, or throw if it errors.
+ *
+ * `CacheEntry.value` "can error and only have partial data" (Next.js's
+ * `cache-handlers/types.d.ts`). Throwing is how a partial entry is kept out:
+ * both handlers store nothing when this rejects, which is what Next.js's own
+ * default handler does too.
+ */
+async function readStream(stream) {
+    const reader = stream.getReader();
+    const chunks = [];
+    let size = 0;
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done) {
+            break;
+        }
+        chunks.push(value);
+        size += value.byteLength;
+    }
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return bytes;
+}
+/** `pendingEntry` resolved and read to the end. See {@link readStream}. */
+async function storedEntryOf(pendingEntry) {
+    const entry = await pendingEntry;
+    return { ...entry, value: await readStream(entry.value) };
+}
+/** `stored` as the `CacheEntry` a `get` returns, with its own stream. */
+function cacheEntryOf(stored, revalidate = stored.revalidate) {
+    const bytes = stored.value;
+    return {
+        ...stored,
+        revalidate,
+        value: new ReadableStream({
+            start(controller) {
+                // A copy: whoever reads the stream may transfer or mutate the chunk.
+                controller.enqueue(bytes.slice());
+                controller.close();
+            },
+        }),
+    };
+}
+/**
+ * Whether Next.js would regenerate `entry` on every read anyway, so storing it
+ * is a write nothing reads back. Next.js's default handler skips these the same
+ * way, outside the dev server.
+ */
+function isDynamicEntry(entry) {
+    return entry.expire === 0;
+}
+/**
+ * The in-flight `set`s, by cache key. `CacheHandler.set` receives an entry that
+ * may still be streaming, and "if a `get` for the same cache key is called
+ * before the pending entry is complete, the cache handler must wait for the
+ * `set` operation to finish" (`cache-handlers/types.d.ts`).
+ */
+class PendingSets {
+    pending = new Map();
+    /** Resolves once no `set` for `key` is in flight. */
+    async wait(key) {
+        for (let p = this.pending.get(key); p; p = this.pending.get(key)) {
+            await p;
+        }
+    }
+    /**
+     * Register a `set` for `key` and return the function that ends it. Safe to
+     * call more than once: only the registration it made is removed.
+     */
+    begin(key) {
+        let resolve = () => { };
+        const promise = new Promise((r) => (resolve = r));
+        this.pending.set(key, promise);
+        return () => {
+            if (this.pending.get(key) === promise) {
+                this.pending.delete(key);
+            }
+            resolve();
+        };
+    }
+}
+exports.PendingSets = PendingSets;
+/**
+ * Stored entries by cache key, least recently used evicted first once their
+ * bytes pass `maxBytes`. Sized by bytes rather than entries, like Next.js's
+ * default handler (`cacheMaxMemorySize`, 50 MB), since a `'use cache'` entry is
+ * an RSC payload of any size.
+ */
+class EntryLru {
+    maxBytes;
+    entries = new Map();
+    bytes = 0;
+    constructor(maxBytes) {
+        this.maxBytes = maxBytes;
+    }
+    get(key) {
+        const entry = this.entries.get(key);
+        if (entry) {
+            // Re-inserted to mark it most recently used.
+            this.entries.delete(key);
+            this.entries.set(key, entry);
+        }
+        return entry;
+    }
+    set(key, entry) {
+        this.delete(key);
+        const size = sizeOf(key, entry);
+        if (size > this.maxBytes) {
+            return;
+        }
+        this.entries.set(key, entry);
+        this.bytes += size;
+        for (const [oldestKey, oldest] of this.entries) {
+            if (this.bytes <= this.maxBytes) {
+                break;
+            }
+            this.entries.delete(oldestKey);
+            this.bytes -= sizeOf(oldestKey, oldest);
+        }
+    }
+    delete(key) {
+        const existing = this.entries.get(key);
+        if (existing) {
+            this.entries.delete(key);
+            this.bytes -= sizeOf(key, existing);
+        }
+    }
+    get size() {
+        return this.entries.size;
+    }
+}
+exports.EntryLru = EntryLru;
+function sizeOf(key, entry) {
+    return entry.value.byteLength + key.length;
+}
+/** Default size of each handler's memory store: Next.js's default, 50 MB. */
+exports.DEFAULT_MEMORY_BYTES = 50 * 1024 * 1024;
+/**
+ * The `cacheHandlers` methods that only go through `tags`, the same for the
+ * `default` and `remote` handlers.
+ */
+function tagMethods(tags) {
+    return {
+        refreshTags: () => tags.refresh(),
+        async getExpiration(implicitTags) {
+            await tags.ensure(implicitTags);
+            return tags.expiration(implicitTags);
+        },
+        async updateTags(revalidatedTags, durations) {
+            await tags.update(revalidatedTags, durations);
+        },
+    };
+}
+/**
+ * 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.
+ */
+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),
+    };
+}
+const TAG_MANIFEST_SYMBOL = Symbol.for("cdk-nextjs.use-cache.tag-manifest");
+/**
+ * The process's one {@link TrackedTagMarkers}, from the environment.
+ *
+ * Kept on `globalThis` because the incremental cache handler and the `default`
+ * and `remote` handlers are separate bundles - separate module instances - and
+ * should share one manifest: one refresh read for all of them, and one marker
+ * write per `revalidateTag`.
+ *
+ * At build time there is no table to read (and no credentials to read it
+ * with), so tags stay local to the process there.
+ */
+function sharedTagManifest() {
+    const global = globalThis;
+    if (!global[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({
+                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"),
+            });
+        }
+        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({
+                refreshIntervalMs,
+            });
+        }
+    }
+    return global[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"]}

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

@@ -0,0 +1 @@
+export {};