cdk-nextjs 0.6.2 → 0.7.1

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

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

package/lib/adapter/use-cache-handlers.test.js

@@ -0,0 +1,349 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable import/no-extraneous-dependencies */
+jest.mock("@aws-sdk/client-s3");
+jest.mock("@aws-sdk/client-dynamodb");
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const client_s3_1 = require("@aws-sdk/client-s3");
+const aws_cache_store_1 = require("./aws-cache-store");
+const use_cache_common_1 = require("./use-cache-common");
+const use_cache_default_handler_1 = require("./use-cache-default-handler");
+const use_cache_remote_handler_1 = require("./use-cache-remote-handler");
+/** The input an automocked SDK command was constructed with. */
+const commandInput = (command, type) => {
+    const mock = type;
+    return mock.mock.calls[mock.mock.instances.indexOf(command)][0];
+};
+/**
+ * S3 as a map. Every "instance" in these tests is a separate handler over the
+ * same map, which is what the cache bucket is to separate Lambda instances.
+ */
+const objects = new Map();
+const s3Send = jest.fn(async (command) => {
+    if (command instanceof client_s3_1.PutObjectCommand) {
+        const { Key, Body } = commandInput(command, client_s3_1.PutObjectCommand);
+        objects.set(Key, Body);
+        return {};
+    }
+    if (command instanceof client_s3_1.GetObjectCommand) {
+        const { Key } = commandInput(command, client_s3_1.GetObjectCommand);
+        const body = objects.get(Key);
+        if (body === undefined) {
+            throw new client_s3_1.NoSuchKey({ message: "NoSuchKey", $metadata: {} });
+        }
+        return {
+            Body: { transformToString: async () => body },
+            ContentType: "application/json; charset=utf-8",
+        };
+    }
+    throw new Error("unexpected S3 command");
+});
+/** The revalidation table's marker rows, as a map. */
+const rows = new Map();
+/** Its revalidation log rows, by sort key. */
+const logRows = new Map();
+const dynamoSend = jest.fn(async (command) => {
+    if (command instanceof client_dynamodb_1.UpdateItemCommand) {
+        const { Key, ExpressionAttributeValues } = commandInput(command, client_dynamodb_1.UpdateItemCommand);
+        const row = rows.get(Key.sk.S) ?? {
+            sk: Key.sk,
+        };
+        for (const [name, value] of Object.entries(ExpressionAttributeValues)) {
+            row[name.slice(1)] = value;
+        }
+        rows.set(Key.sk.S, row);
+        return {};
+    }
+    if (command instanceof client_dynamodb_1.BatchGetItemCommand) {
+        const { RequestItems } = commandInput(command, client_dynamodb_1.BatchGetItemCommand);
+        const [[table, { Keys }]] = Object.entries(RequestItems);
+        return {
+            Responses: {
+                [table]: Keys.map(({ sk }) => rows.get(sk.S)).filter(Boolean),
+            },
+        };
+    }
+    if (command instanceof client_dynamodb_1.PutItemCommand) {
+        const { Item } = commandInput(command, client_dynamodb_1.PutItemCommand);
+        logRows.set(Item.sk.S, Item);
+        return {};
+    }
+    if (command instanceof client_dynamodb_1.QueryCommand) {
+        const { ExpressionAttributeValues } = commandInput(command, client_dynamodb_1.QueryCommand);
+        const since = ExpressionAttributeValues[":since"].S;
+        return {
+            Items: Array.from(logRows.keys())
+                .filter((sk) => sk >= since)
+                .sort()
+                .map((sk) => logRows.get(sk)),
+        };
+    }
+    throw new Error("unexpected DynamoDB command");
+});
+client_s3_1.S3Client.mockImplementation(() => ({ send: s3Send }));
+client_dynamodb_1.DynamoDBClient.mockImplementation(() => ({ send: dynamoSend }));
+const s3Calls = (type) => s3Send.mock.calls.filter(([command]) => command instanceof type)
+    .length;
+const dynamoCalls = (type) => dynamoSend.mock.calls.filter(([command]) => command instanceof type).length;
+/** One compute instance's view of the shared table. */
+function tagManifest(refreshIntervalMs = 0) {
+    return new aws_cache_store_1.TrackedTagMarkers({
+        markers: new aws_cache_store_1.TagMarkerTable(new client_dynamodb_1.DynamoDBClient({}), "table", "build"),
+        log: new aws_cache_store_1.RevalidationLog(new client_dynamodb_1.DynamoDBClient({}), "table", "build"),
+        refreshIntervalMs,
+    });
+}
+function bucket() {
+    return new aws_cache_store_1.CacheBucket(new client_s3_1.S3Client({}), "bucket");
+}
+function remoteInstance(tags = tagManifest()) {
+    return (0, use_cache_remote_handler_1.createRemoteUseCacheHandler)({
+        bucket: bucket(),
+        buildId: "build",
+        tags,
+    });
+}
+function defaultInstance(tags = tagManifest()) {
+    return (0, use_cache_default_handler_1.createDefaultUseCacheHandler)({ tags });
+}
+function streamOf(text) {
+    return new ReadableStream({
+        start(controller) {
+            controller.enqueue(new TextEncoder().encode(text));
+            controller.close();
+        },
+    });
+}
+function entry(text, extra = {}) {
+    return {
+        value: streamOf(text),
+        tags: ["posts"],
+        stale: 300,
+        timestamp: performance.timeOrigin + performance.now(),
+        expire: 3600,
+        revalidate: 900,
+        ...extra,
+    };
+}
+async function textOf(result) {
+    return result
+        ? new TextDecoder().decode(await (0, use_cache_common_1.readStream)(result.value))
+        : undefined;
+}
+/** A request's worth of what Next.js does before reading an entry. */
+async function read(handler, key) {
+    await handler.refreshTags();
+    return textOf(await handler.get(key, []));
+}
+beforeEach(() => {
+    objects.clear();
+    rows.clear();
+    logRows.clear();
+});
+describe("cacheHandlers.remote", () => {
+    it("answers every instance from the entry any one of them stored", async () => {
+        const a = remoteInstance();
+        const b = remoteInstance();
+        await a.set("k", Promise.resolve(entry("from-a")));
+        expect(await read(b, "k")).toBe("from-a");
+        expect(Array.from(objects.keys())).toEqual([
+            expect.stringMatching(/^build\/_use-cache\/[0-9a-f]{64}\.entry$/),
+        ]);
+    });
+    it("serves a repeat read from memory", async () => {
+        const b = remoteInstance();
+        await remoteInstance().set("k", Promise.resolve(entry("v")));
+        await read(b, "k");
+        s3Send.mockClear();
+        expect(await read(b, "k")).toBe("v");
+        expect(s3Calls(client_s3_1.GetObjectCommand)).toBe(0);
+    });
+    it("expires the entry on every instance when a tag is revalidated", async () => {
+        const a = remoteInstance();
+        const b = remoteInstance();
+        await a.set("k", Promise.resolve(entry("old", { timestamp: Date.now() - 1000 })));
+        expect(await read(a, "k")).toBe("old");
+        expect(await read(b, "k")).toBe("old");
+        await a.updateTags(["posts"]);
+        expect(await read(a, "k")).toBeUndefined();
+        expect(await read(b, "k")).toBeUndefined();
+        // A fresh instance reading the stale object from S3 misses too.
+        expect(await read(remoteInstance(), "k")).toBeUndefined();
+    });
+    it("serves a profile-revalidated entry stale, for Next.js to regenerate", async () => {
+        const a = remoteInstance();
+        await a.set("k", Promise.resolve(entry("old", { timestamp: Date.now() - 1000 })));
+        await a.updateTags(["posts"], { expire: 3600 });
+        const b = remoteInstance();
+        await b.refreshTags();
+        const result = await b.get("k", []);
+        expect(result?.revalidate).toBe(-1);
+        expect(await textOf(result)).toBe("old");
+    });
+    it("picks up another instance's regenerated entry once its own is stale", async () => {
+        const a = remoteInstance();
+        const b = remoteInstance();
+        const past = performance.timeOrigin + performance.now() - 10_000;
+        await a.set("k", Promise.resolve(entry("v1", { timestamp: past, revalidate: 1 })));
+        expect(await read(b, "k")).toBe("v1");
+        await a.set("k", Promise.resolve(entry("v2")));
+        // `b`'s memory copy is past `revalidate`, so S3 is asked for a newer one.
+        expect(await read(b, "k")).toBe("v2");
+    });
+    it("does not serve an entry past its expire", async () => {
+        const past = performance.timeOrigin + performance.now() - 10_000;
+        await remoteInstance().set("k", Promise.resolve(entry("v", { timestamp: past, revalidate: 1, expire: 2 })));
+        expect(await read(remoteInstance(), "k")).toBeUndefined();
+    });
+    it("makes a get wait for a pending set of the same key", async () => {
+        const a = remoteInstance();
+        let resolve = () => { };
+        const set = a.set("k", new Promise((r) => (resolve = r)));
+        const get = a.get("k", []);
+        resolve(entry("v"));
+        expect(await textOf(await get)).toBe("v");
+        await set;
+    });
+    it("stores nothing from a stream that errors", async () => {
+        const a = remoteInstance();
+        const failing = new ReadableStream({
+            start(controller) {
+                controller.enqueue(new Uint8Array([1]));
+                controller.error(new Error("render failed"));
+            },
+        });
+        await a.set("k", Promise.resolve({ ...entry(""), value: failing }));
+        expect(objects.size).toBe(0);
+        expect(await read(a, "k")).toBeUndefined();
+    });
+    it("does not store an entry Next.js regenerates on every read", async () => {
+        const a = remoteInstance();
+        await a.set("k", Promise.resolve(entry("v", { expire: 0 })));
+        expect(objects.size).toBe(0);
+        expect(await read(a, "k")).toBeUndefined();
+    });
+    it("never serves an object stored for another key", async () => {
+        const a = remoteInstance();
+        await a.set("k", Promise.resolve(entry("v")));
+        const [key] = Array.from(objects.keys());
+        objects.set(key, objects.get(key).replace('"key":"k"', '"key":"other"'));
+        const warn = jest.spyOn(console, "warn").mockImplementation(() => { });
+        expect(await read(remoteInstance(), "k")).toBeUndefined();
+        warn.mockRestore();
+    });
+    it("keeps working from memory when S3 fails", async () => {
+        const error = jest.spyOn(console, "error").mockImplementation(() => { });
+        s3Send.mockRejectedValueOnce(new Error("SlowDown"));
+        const a = remoteInstance();
+        await a.set("k", Promise.resolve(entry("v")));
+        expect(await read(a, "k")).toBe("v");
+        s3Send.mockRejectedValueOnce(new Error("SlowDown"));
+        expect(await read(remoteInstance(), "k")).toBeUndefined();
+        error.mockRestore();
+    });
+    it("is memory-only without a bucket", async () => {
+        const a = (0, use_cache_remote_handler_1.createRemoteUseCacheHandler)({
+            bucket: null,
+            buildId: "build",
+            tags: tagManifest(),
+        });
+        await a.set("k", Promise.resolve(entry("v")));
+        expect(await read(a, "k")).toBe("v");
+        expect(s3Send).not.toHaveBeenCalled();
+    });
+    it("reads an S3 entry's tags before trusting it, once per instance", async () => {
+        await remoteInstance().set("k", Promise.resolve(entry("v")));
+        const b = remoteInstance(tagManifest(60_000));
+        dynamoSend.mockClear();
+        await read(b, "k");
+        await read(b, "k");
+        expect(dynamoCalls(client_dynamodb_1.BatchGetItemCommand)).toBe(1);
+    });
+});
+describe("cacheHandlers.remote, across a revalidation before an instance started", () => {
+    afterEach(() => jest.restoreAllMocks());
+    // A stores K1; C revalidates its tag; B starts after C's log row is behind
+    // its cursor, stores K2 with the same tag, then reads K1 from S3.
+    it("does not serve an older S3 entry as fresh after storing a newer one with its tag", async () => {
+        const a = remoteInstance();
+        await a.set("k1", Promise.resolve(entry("before", { timestamp: Date.now() - 1000 })));
+        await remoteInstance().updateTags(["posts"], { expire: 0 });
+        const later = Date.now() + 10_000;
+        jest.spyOn(Date, "now").mockReturnValue(later);
+        const b = remoteInstance();
+        await b.set("k2", Promise.resolve(entry("after", { timestamp: later })));
+        expect(await read(b, "k1")).toBeUndefined();
+        expect(await read(b, "k2")).toBe("after");
+    });
+});
+describe("cacheHandlers.default", () => {
+    it("keeps entries in each instance's memory", async () => {
+        const a = defaultInstance();
+        const b = defaultInstance();
+        await a.set("k", Promise.resolve(entry("v")));
+        expect(await read(a, "k")).toBe("v");
+        expect(await read(b, "k")).toBeUndefined();
+        expect(s3Send).not.toHaveBeenCalled();
+    });
+    it("expires an entry on an instance that did not run revalidateTag", async () => {
+        const a = defaultInstance();
+        const b = defaultInstance();
+        const created = { timestamp: Date.now() - 1000 };
+        await a.set("k", Promise.resolve(entry("a", created)));
+        await b.set("k", Promise.resolve(entry("b", created)));
+        // Its first read of its own entry reads the tag's marker, once.
+        expect(await read(b, "k")).toBe("b");
+        // What Next.js does for `revalidateTag`: `updateTags` on every handler of
+        // the instance that ran it - here, `a`.
+        await a.updateTags(["posts"], { expire: 0 });
+        dynamoSend.mockClear();
+        expect(await read(a, "k")).toBeUndefined();
+        expect(await read(b, "k")).toBeUndefined();
+        // `b` learned of it from the log, not by re-reading its tags' markers.
+        expect(dynamoCalls(client_dynamodb_1.QueryCommand)).toBeGreaterThan(0);
+        expect(dynamoCalls(client_dynamodb_1.BatchGetItemCommand)).toBe(0);
+    });
+    it("waits for the refresh interval before re-reading tags", async () => {
+        const b = defaultInstance(tagManifest(60_000));
+        await b.set("k", Promise.resolve(entry("b", { timestamp: Date.now() - 1000 })));
+        await read(b, "k");
+        await defaultInstance().updateTags(["posts"]);
+        dynamoSend.mockClear();
+        // Inside the window: still served, and no read spent on it.
+        expect(await read(b, "k")).toBe("b");
+        expect(dynamoCalls(client_dynamodb_1.BatchGetItemCommand)).toBe(0);
+        expect(dynamoCalls(client_dynamodb_1.QueryCommand)).toBe(0);
+    });
+    it("drops an entry past revalidate, as Next.js's in-memory handler does", async () => {
+        const a = defaultInstance();
+        const past = performance.timeOrigin + performance.now() - 10_000;
+        await a.set("k", Promise.resolve(entry("v", { timestamp: past, revalidate: 1 })));
+        expect(await read(a, "k")).toBeUndefined();
+    });
+    it("reports stale tags as revalidate -1", async () => {
+        const a = defaultInstance();
+        await a.set("k", Promise.resolve(entry("v", { timestamp: Date.now() - 1000 })));
+        await a.updateTags(["posts"], { expire: 3600 });
+        const result = await a.get("k", []);
+        expect(result?.revalidate).toBe(-1);
+    });
+    it("answers getExpiration from another instance's revalidatePath", async () => {
+        const a = defaultInstance();
+        const b = defaultInstance();
+        await a.updateTags(["_N_T_/blog/layout"]);
+        const expiration = await b.getExpiration(["_N_T_/", "_N_T_/blog/layout"]);
+        expect(expiration).toBeGreaterThan(0);
+        expect(await b.getExpiration(["_N_T_/other"])).toBe(0);
+    });
+    it("stores nothing from a stream that errors, and releases the pending get", async () => {
+        const a = defaultInstance();
+        const failing = new ReadableStream({
+            start(controller) {
+                controller.error(new Error("render failed"));
+            },
+        });
+        await a.set("k", Promise.resolve({ ...entry(""), value: failing }));
+        expect(await read(a, "k")).toBeUndefined();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"use-cache-handlers.test.js","sourceRoot":"","sources":["../../src/adapter/use-cache-handlers.test.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\njest.mock(\"@aws-sdk/client-s3\");\njest.mock(\"@aws-sdk/client-dynamodb\");\n\nimport {\n  AttributeValue,\n  BatchGetItemCommand,\n  DynamoDBClient,\n  PutItemCommand,\n  QueryCommand,\n  UpdateItemCommand,\n} from \"@aws-sdk/client-dynamodb\";\nimport {\n  GetObjectCommand,\n  NoSuchKey,\n  PutObjectCommand,\n  S3Client,\n} from \"@aws-sdk/client-s3\";\nimport type {\n  CacheEntry,\n  CacheHandler,\n} from \"next/dist/server/lib/cache-handlers/types\";\nimport {\n  CacheBucket,\n  RevalidationLog,\n  TagMarkerTable,\n  TrackedTagMarkers,\n} from \"./aws-cache-store\";\nimport { readStream } from \"./use-cache-common\";\nimport { createDefaultUseCacheHandler } from \"./use-cache-default-handler\";\nimport { createRemoteUseCacheHandler } from \"./use-cache-remote-handler\";\n\n/** The input an automocked SDK command was constructed with. */\nconst commandInput = (command: unknown, type: unknown) => {\n  const mock = type as jest.Mock;\n  return mock.mock.calls[mock.mock.instances.indexOf(command)][0];\n};\n\n/**\n * S3 as a map. Every \"instance\" in these tests is a separate handler over the\n * same map, which is what the cache bucket is to separate Lambda instances.\n */\nconst objects = new Map<string, string>();\nconst s3Send = jest.fn(async (command: unknown) => {\n  if (command instanceof PutObjectCommand) {\n    const { Key, Body } = commandInput(command, PutObjectCommand);\n    objects.set(Key, Body);\n    return {};\n  }\n  if (command instanceof GetObjectCommand) {\n    const { Key } = commandInput(command, GetObjectCommand);\n    const body = objects.get(Key);\n    if (body === undefined) {\n      throw new NoSuchKey({ message: \"NoSuchKey\", $metadata: {} });\n    }\n    return {\n      Body: { transformToString: async () => body },\n      ContentType: \"application/json; charset=utf-8\",\n    };\n  }\n  throw new Error(\"unexpected S3 command\");\n});\n\n/** The revalidation table's marker rows, as a map. */\nconst rows = new Map<string, Record<string, AttributeValue>>();\n/** Its revalidation log rows, by sort key. */\nconst logRows = new Map<string, Record<string, AttributeValue>>();\nconst dynamoSend = jest.fn(async (command: unknown) => {\n  if (command instanceof UpdateItemCommand) {\n    const { Key, ExpressionAttributeValues } = commandInput(\n      command,\n      UpdateItemCommand,\n    );\n    const row: Record<string, AttributeValue> = rows.get(Key.sk.S) ?? {\n      sk: Key.sk,\n    };\n    for (const [name, value] of Object.entries(ExpressionAttributeValues)) {\n      row[name.slice(1)] = value as AttributeValue;\n    }\n    rows.set(Key.sk.S, row);\n    return {};\n  }\n  if (command instanceof BatchGetItemCommand) {\n    const { RequestItems } = commandInput(command, BatchGetItemCommand);\n    const [[table, { Keys }]] = Object.entries(RequestItems) as [\n      string,\n      { Keys: { sk: { S: string } }[] },\n    ][];\n    return {\n      Responses: {\n        [table]: Keys.map(({ sk }) => rows.get(sk.S)).filter(Boolean),\n      },\n    };\n  }\n  if (command instanceof PutItemCommand) {\n    const { Item } = commandInput(command, PutItemCommand);\n    logRows.set(Item.sk.S, Item);\n    return {};\n  }\n  if (command instanceof QueryCommand) {\n    const { ExpressionAttributeValues } = commandInput(command, QueryCommand);\n    const since = ExpressionAttributeValues[\":since\"].S as string;\n    return {\n      Items: Array.from(logRows.keys())\n        .filter((sk) => sk >= since)\n        .sort()\n        .map((sk) => logRows.get(sk)),\n    };\n  }\n  throw new Error(\"unexpected DynamoDB command\");\n});\n\n(S3Client as jest.Mock).mockImplementation(() => ({ send: s3Send }));\n(DynamoDBClient as jest.Mock).mockImplementation(() => ({ send: dynamoSend }));\n\nconst s3Calls = (type: unknown) =>\n  s3Send.mock.calls.filter(([command]) => command instanceof (type as never))\n    .length;\nconst dynamoCalls = (type: unknown) =>\n  dynamoSend.mock.calls.filter(\n    ([command]) => command instanceof (type as never),\n  ).length;\n\n/** One compute instance's view of the shared table. */\nfunction tagManifest(refreshIntervalMs = 0) {\n  return new TrackedTagMarkers({\n    markers: new TagMarkerTable(new DynamoDBClient({}), \"table\", \"build\"),\n    log: new RevalidationLog(new DynamoDBClient({}), \"table\", \"build\"),\n    refreshIntervalMs,\n  });\n}\n\nfunction bucket() {\n  return new CacheBucket(new S3Client({}), \"bucket\");\n}\n\nfunction remoteInstance(tags = tagManifest()) {\n  return createRemoteUseCacheHandler({\n    bucket: bucket(),\n    buildId: \"build\",\n    tags,\n  });\n}\n\nfunction defaultInstance(tags = tagManifest()) {\n  return createDefaultUseCacheHandler({ tags });\n}\n\nfunction streamOf(text: string): ReadableStream<Uint8Array> {\n  return new ReadableStream({\n    start(controller) {\n      controller.enqueue(new TextEncoder().encode(text));\n      controller.close();\n    },\n  });\n}\n\nfunction entry(text: string, extra: Partial<CacheEntry> = {}): CacheEntry {\n  return {\n    value: streamOf(text),\n    tags: [\"posts\"],\n    stale: 300,\n    timestamp: performance.timeOrigin + performance.now(),\n    expire: 3600,\n    revalidate: 900,\n    ...extra,\n  };\n}\n\nasync function textOf(result: CacheEntry | undefined) {\n  return result\n    ? new TextDecoder().decode(await readStream(result.value))\n    : undefined;\n}\n\n/** A request's worth of what Next.js does before reading an entry. */\nasync function read(handler: CacheHandler, key: string) {\n  await handler.refreshTags();\n  return textOf(await handler.get(key, []));\n}\n\nbeforeEach(() => {\n  objects.clear();\n  rows.clear();\n  logRows.clear();\n});\n\ndescribe(\"cacheHandlers.remote\", () => {\n  it(\"answers every instance from the entry any one of them stored\", async () => {\n    const a = remoteInstance();\n    const b = remoteInstance();\n\n    await a.set(\"k\", Promise.resolve(entry(\"from-a\")));\n\n    expect(await read(b, \"k\")).toBe(\"from-a\");\n    expect(Array.from(objects.keys())).toEqual([\n      expect.stringMatching(/^build\\/_use-cache\\/[0-9a-f]{64}\\.entry$/),\n    ]);\n  });\n\n  it(\"serves a repeat read from memory\", async () => {\n    const b = remoteInstance();\n    await remoteInstance().set(\"k\", Promise.resolve(entry(\"v\")));\n    await read(b, \"k\");\n    s3Send.mockClear();\n    expect(await read(b, \"k\")).toBe(\"v\");\n    expect(s3Calls(GetObjectCommand)).toBe(0);\n  });\n\n  it(\"expires the entry on every instance when a tag is revalidated\", async () => {\n    const a = remoteInstance();\n    const b = remoteInstance();\n    await a.set(\n      \"k\",\n      Promise.resolve(entry(\"old\", { timestamp: Date.now() - 1000 })),\n    );\n    expect(await read(a, \"k\")).toBe(\"old\");\n    expect(await read(b, \"k\")).toBe(\"old\");\n\n    await a.updateTags([\"posts\"]);\n\n    expect(await read(a, \"k\")).toBeUndefined();\n    expect(await read(b, \"k\")).toBeUndefined();\n    // A fresh instance reading the stale object from S3 misses too.\n    expect(await read(remoteInstance(), \"k\")).toBeUndefined();\n  });\n\n  it(\"serves a profile-revalidated entry stale, for Next.js to regenerate\", async () => {\n    const a = remoteInstance();\n    await a.set(\n      \"k\",\n      Promise.resolve(entry(\"old\", { timestamp: Date.now() - 1000 })),\n    );\n    await a.updateTags([\"posts\"], { expire: 3600 });\n\n    const b = remoteInstance();\n    await b.refreshTags();\n    const result = await b.get(\"k\", []);\n    expect(result?.revalidate).toBe(-1);\n    expect(await textOf(result)).toBe(\"old\");\n  });\n\n  it(\"picks up another instance's regenerated entry once its own is stale\", async () => {\n    const a = remoteInstance();\n    const b = remoteInstance();\n    const past = performance.timeOrigin + performance.now() - 10_000;\n    await a.set(\n      \"k\",\n      Promise.resolve(entry(\"v1\", { timestamp: past, revalidate: 1 })),\n    );\n    expect(await read(b, \"k\")).toBe(\"v1\");\n\n    await a.set(\"k\", Promise.resolve(entry(\"v2\")));\n    // `b`'s memory copy is past `revalidate`, so S3 is asked for a newer one.\n    expect(await read(b, \"k\")).toBe(\"v2\");\n  });\n\n  it(\"does not serve an entry past its expire\", async () => {\n    const past = performance.timeOrigin + performance.now() - 10_000;\n    await remoteInstance().set(\n      \"k\",\n      Promise.resolve(\n        entry(\"v\", { timestamp: past, revalidate: 1, expire: 2 }),\n      ),\n    );\n    expect(await read(remoteInstance(), \"k\")).toBeUndefined();\n  });\n\n  it(\"makes a get wait for a pending set of the same key\", async () => {\n    const a = remoteInstance();\n    let resolve: (value: CacheEntry) => void = () => {};\n    const set = a.set(\"k\", new Promise((r) => (resolve = r)));\n    const get = a.get(\"k\", []);\n    resolve(entry(\"v\"));\n    expect(await textOf(await get)).toBe(\"v\");\n    await set;\n  });\n\n  it(\"stores nothing from a stream that errors\", async () => {\n    const a = remoteInstance();\n    const failing = new ReadableStream<Uint8Array>({\n      start(controller) {\n        controller.enqueue(new Uint8Array([1]));\n        controller.error(new Error(\"render failed\"));\n      },\n    });\n    await a.set(\"k\", Promise.resolve({ ...entry(\"\"), value: failing }));\n    expect(objects.size).toBe(0);\n    expect(await read(a, \"k\")).toBeUndefined();\n  });\n\n  it(\"does not store an entry Next.js regenerates on every read\", async () => {\n    const a = remoteInstance();\n    await a.set(\"k\", Promise.resolve(entry(\"v\", { expire: 0 })));\n    expect(objects.size).toBe(0);\n    expect(await read(a, \"k\")).toBeUndefined();\n  });\n\n  it(\"never serves an object stored for another key\", async () => {\n    const a = remoteInstance();\n    await a.set(\"k\", Promise.resolve(entry(\"v\")));\n    const [key] = Array.from(objects.keys());\n    objects.set(key, objects.get(key)!.replace('\"key\":\"k\"', '\"key\":\"other\"'));\n    const warn = jest.spyOn(console, \"warn\").mockImplementation(() => {});\n    expect(await read(remoteInstance(), \"k\")).toBeUndefined();\n    warn.mockRestore();\n  });\n\n  it(\"keeps working from memory when S3 fails\", async () => {\n    const error = jest.spyOn(console, \"error\").mockImplementation(() => {});\n    s3Send.mockRejectedValueOnce(new Error(\"SlowDown\"));\n    const a = remoteInstance();\n    await a.set(\"k\", Promise.resolve(entry(\"v\")));\n    expect(await read(a, \"k\")).toBe(\"v\");\n    s3Send.mockRejectedValueOnce(new Error(\"SlowDown\"));\n    expect(await read(remoteInstance(), \"k\")).toBeUndefined();\n    error.mockRestore();\n  });\n\n  it(\"is memory-only without a bucket\", async () => {\n    const a = createRemoteUseCacheHandler({\n      bucket: null,\n      buildId: \"build\",\n      tags: tagManifest(),\n    });\n    await a.set(\"k\", Promise.resolve(entry(\"v\")));\n    expect(await read(a, \"k\")).toBe(\"v\");\n    expect(s3Send).not.toHaveBeenCalled();\n  });\n\n  it(\"reads an S3 entry's tags before trusting it, once per instance\", async () => {\n    await remoteInstance().set(\"k\", Promise.resolve(entry(\"v\")));\n    const b = remoteInstance(tagManifest(60_000));\n    dynamoSend.mockClear();\n    await read(b, \"k\");\n    await read(b, \"k\");\n    expect(dynamoCalls(BatchGetItemCommand)).toBe(1);\n  });\n});\n\ndescribe(\"cacheHandlers.remote, across a revalidation before an instance started\", () => {\n  afterEach(() => jest.restoreAllMocks());\n\n  // A stores K1; C revalidates its tag; B starts after C's log row is behind\n  // its cursor, stores K2 with the same tag, then reads K1 from S3.\n  it(\"does not serve an older S3 entry as fresh after storing a newer one with its tag\", async () => {\n    const a = remoteInstance();\n    await a.set(\n      \"k1\",\n      Promise.resolve(entry(\"before\", { timestamp: Date.now() - 1000 })),\n    );\n    await remoteInstance().updateTags([\"posts\"], { expire: 0 });\n\n    const later = Date.now() + 10_000;\n    jest.spyOn(Date, \"now\").mockReturnValue(later);\n    const b = remoteInstance();\n    await b.set(\"k2\", Promise.resolve(entry(\"after\", { timestamp: later })));\n\n    expect(await read(b, \"k1\")).toBeUndefined();\n    expect(await read(b, \"k2\")).toBe(\"after\");\n  });\n});\n\ndescribe(\"cacheHandlers.default\", () => {\n  it(\"keeps entries in each instance's memory\", async () => {\n    const a = defaultInstance();\n    const b = defaultInstance();\n    await a.set(\"k\", Promise.resolve(entry(\"v\")));\n    expect(await read(a, \"k\")).toBe(\"v\");\n    expect(await read(b, \"k\")).toBeUndefined();\n    expect(s3Send).not.toHaveBeenCalled();\n  });\n\n  it(\"expires an entry on an instance that did not run revalidateTag\", async () => {\n    const a = defaultInstance();\n    const b = defaultInstance();\n    const created = { timestamp: Date.now() - 1000 };\n    await a.set(\"k\", Promise.resolve(entry(\"a\", created)));\n    await b.set(\"k\", Promise.resolve(entry(\"b\", created)));\n    // Its first read of its own entry reads the tag's marker, once.\n    expect(await read(b, \"k\")).toBe(\"b\");\n\n    // What Next.js does for `revalidateTag`: `updateTags` on every handler of\n    // the instance that ran it - here, `a`.\n    await a.updateTags([\"posts\"], { expire: 0 });\n    dynamoSend.mockClear();\n\n    expect(await read(a, \"k\")).toBeUndefined();\n    expect(await read(b, \"k\")).toBeUndefined();\n    // `b` learned of it from the log, not by re-reading its tags' markers.\n    expect(dynamoCalls(QueryCommand)).toBeGreaterThan(0);\n    expect(dynamoCalls(BatchGetItemCommand)).toBe(0);\n  });\n\n  it(\"waits for the refresh interval before re-reading tags\", async () => {\n    const b = defaultInstance(tagManifest(60_000));\n    await b.set(\n      \"k\",\n      Promise.resolve(entry(\"b\", { timestamp: Date.now() - 1000 })),\n    );\n    await read(b, \"k\");\n    await defaultInstance().updateTags([\"posts\"]);\n    dynamoSend.mockClear();\n\n    // Inside the window: still served, and no read spent on it.\n    expect(await read(b, \"k\")).toBe(\"b\");\n    expect(dynamoCalls(BatchGetItemCommand)).toBe(0);\n    expect(dynamoCalls(QueryCommand)).toBe(0);\n  });\n\n  it(\"drops an entry past revalidate, as Next.js's in-memory handler does\", async () => {\n    const a = defaultInstance();\n    const past = performance.timeOrigin + performance.now() - 10_000;\n    await a.set(\n      \"k\",\n      Promise.resolve(entry(\"v\", { timestamp: past, revalidate: 1 })),\n    );\n    expect(await read(a, \"k\")).toBeUndefined();\n  });\n\n  it(\"reports stale tags as revalidate -1\", async () => {\n    const a = defaultInstance();\n    await a.set(\n      \"k\",\n      Promise.resolve(entry(\"v\", { timestamp: Date.now() - 1000 })),\n    );\n    await a.updateTags([\"posts\"], { expire: 3600 });\n    const result = await a.get(\"k\", []);\n    expect(result?.revalidate).toBe(-1);\n  });\n\n  it(\"answers getExpiration from another instance's revalidatePath\", async () => {\n    const a = defaultInstance();\n    const b = defaultInstance();\n    await a.updateTags([\"_N_T_/blog/layout\"]);\n    const expiration = await b.getExpiration([\"_N_T_/\", \"_N_T_/blog/layout\"]);\n    expect(expiration).toBeGreaterThan(0);\n    expect(await b.getExpiration([\"_N_T_/other\"])).toBe(0);\n  });\n\n  it(\"stores nothing from a stream that errors, and releases the pending get\", async () => {\n    const a = defaultInstance();\n    const failing = new ReadableStream<Uint8Array>({\n      start(controller) {\n        controller.error(new Error(\"render failed\"));\n      },\n    });\n    await a.set(\"k\", Promise.resolve({ ...entry(\"\"), value: failing }));\n    expect(await read(a, \"k\")).toBeUndefined();\n  });\n});\n"]}

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

@@ -0,0 +1,26 @@
+import type { CacheHandler } from "next/dist/server/lib/cache-handlers/types";
+import { CacheBucket, TrackedTagMarkers } from "./aws-cache-store";
+export interface RemoteUseCacheHandlerOptions {
+    /**
+     * The bucket entries are stored in, or `null` for memory only. From
+     * `CDK_NEXTJS_CACHE_BUCKET_NAME` by default, and never at build time.
+     */
+    bucket?: CacheBucket | null;
+    /** Prefixes every S3 key; `CDK_NEXTJS_BUILD_ID` by default. */
+    buildId?: string;
+    /** Tag state; the process-wide one from the environment by default. */
+    tags?: TrackedTagMarkers;
+}
+/**
+ * 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.
+ */
+export declare function createRemoteUseCacheHandler(options?: RemoteUseCacheHandlerOptions): CacheHandler;
+declare const _default: CacheHandler;
+export default _default;