cdk-nextjs 0.6.2 → 0.7.0

package/lib/adapter/aws-cache-store.test.d.ts

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

package/lib/adapter/aws-cache-store.test.js

@@ -0,0 +1,361 @@
+"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");
+/** 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];
+};
+describe("resolveAwsCacheConfig", () => {
+    const env = process.env;
+    beforeEach(() => {
+        process.env = { ...env };
+    });
+    afterAll(() => {
+        process.env = env;
+    });
+    it("reads the environment the constructs set", () => {
+        process.env.CDK_NEXTJS_CACHE_BUCKET_NAME = "bucket";
+        process.env.CDK_NEXTJS_REVALIDATION_TABLE_NAME = "table";
+        process.env.CDK_NEXTJS_BUILD_ID = "build";
+        process.env.AWS_REGION = "eu-west-1";
+        expect((0, aws_cache_store_1.resolveAwsCacheConfig)()).toEqual({
+            bucketName: "bucket",
+            tableName: "table",
+            buildId: "build",
+            region: "eu-west-1",
+        });
+    });
+    it("reports what is unset as empty", () => {
+        delete process.env.CDK_NEXTJS_CACHE_BUCKET_NAME;
+        delete process.env.CDK_NEXTJS_REVALIDATION_TABLE_NAME;
+        delete process.env.CDK_NEXTJS_BUILD_ID;
+        delete process.env.AWS_REGION;
+        expect((0, aws_cache_store_1.resolveAwsCacheConfig)()).toEqual({
+            bucketName: "",
+            tableName: "",
+            buildId: "",
+            region: "us-east-1",
+        });
+    });
+});
+describe("S3 keys", () => {
+    it("keeps the incremental cache's {buildId}/{key}.json convention", () => {
+        expect((0, aws_cache_store_1.buildS3Key)("b", "/")).toBe("b/index.json");
+        expect((0, aws_cache_store_1.buildS3Key)("b", "")).toBe("b/index.json");
+        expect((0, aws_cache_store_1.buildS3Key)("b", "/blog/post")).toBe("b/blog/post.json");
+        expect((0, aws_cache_store_1.buildS3Key)("b", "abc123")).toBe("b/abc123.json");
+    });
+    it("puts 'use cache' entries where no incremental key can land", () => {
+        const key = (0, aws_cache_store_1.useCacheS3Key)("b", "f".repeat(64));
+        expect(key).toBe(`b/_use-cache/${"f".repeat(64)}.entry`);
+        // Even a route spelled like the use-cache key gets `.json` appended.
+        expect((0, aws_cache_store_1.buildS3Key)("b", `/_use-cache/${"f".repeat(64)}.entry`)).not.toBe(key);
+        expect(key.endsWith(".json")).toBe(false);
+    });
+});
+describe("tag markers", () => {
+    it("writes what markerFor applies locally", () => {
+        for (const durations of [undefined, {}, { expire: 60 }]) {
+            const update = (0, aws_cache_store_1.markerUpdate)(1000, durations);
+            const local = (0, aws_cache_store_1.markerFor)(1000, durations);
+            const written = {};
+            for (const [name, value] of Object.entries(update.ExpressionAttributeValues)) {
+                written[name.slice(1)] = Number(value.N);
+            }
+            expect(written).toEqual(local);
+        }
+        expect((0, aws_cache_store_1.markerFor)(1000, { expire: 60 })).toEqual({
+            staleAt: 1000,
+            expiredAt: 61000,
+        });
+    });
+    it("keeps an earlier expiredAt a profile with no expire leaves", () => {
+        // The row keeps it (`SET staleAt` only), so an instance learning of the
+        // second revalidation from the log has to keep it too.
+        const first = (0, aws_cache_store_1.markerFor)(1000, { expire: 60 });
+        const second = (0, aws_cache_store_1.markerFor)(2000, {});
+        expect((0, aws_cache_store_1.mergeMarkers)(first, second)).toEqual({
+            staleAt: 2000,
+            expiredAt: 61000,
+        });
+        expect((0, aws_cache_store_1.mergeMarkers)(second, first)).toEqual({
+            staleAt: 2000,
+            expiredAt: 61000,
+        });
+        // A newer `expire` still replaces it.
+        expect((0, aws_cache_store_1.mergeMarkers)(first, (0, aws_cache_store_1.markerFor)(2000, { expire: 1 }))).toEqual({
+            staleAt: 2000,
+            expiredAt: 3000,
+        });
+    });
+    it("judges an entry the way the incremental cache always has", () => {
+        // Expired outright after creation.
+        expect((0, aws_cache_store_1.markerState)({ revalidatedAt: 20 }, 10, 30)).toBe("expired");
+        // Revalidated before the entry was created: no effect.
+        expect((0, aws_cache_store_1.markerState)({ revalidatedAt: 5 }, 10, 30)).toBe("fresh");
+        // A profile: stale now, expired once `expiredAt` passes.
+        expect((0, aws_cache_store_1.markerState)({ staleAt: 20, expiredAt: 50 }, 10, 30)).toBe("stale");
+        expect((0, aws_cache_store_1.markerState)({ staleAt: 20, expiredAt: 50 }, 10, 60)).toBe("expired");
+        // `expire: 0`: stale and expired at once.
+        expect((0, aws_cache_store_1.markerState)({ staleAt: 20, expiredAt: 20 }, 10, 30)).toBe("expired");
+        expect((0, aws_cache_store_1.markerState)({}, 10, 30)).toBe("fresh");
+    });
+});
+describe("TagMarkerTable", () => {
+    const send = jest.fn();
+    let table;
+    beforeEach(() => {
+        send.mockReset();
+        client_dynamodb_1.DynamoDBClient.mockImplementation(() => ({ send }));
+        table = new aws_cache_store_1.TagMarkerTable(new client_dynamodb_1.DynamoDBClient({}), "tbl", "build");
+    });
+    it("writes the marker row under the build", async () => {
+        send.mockResolvedValue({});
+        await table.write("posts", 1000, { expire: 1 });
+        const input = commandInput(send.mock.calls[0][0], client_dynamodb_1.UpdateItemCommand);
+        expect(input).toEqual({
+            TableName: "tbl",
+            Key: { pk: { S: "build" }, sk: { S: "posts" } },
+            UpdateExpression: "SET staleAt = :staleAt, expiredAt = :expiredAt",
+            ExpressionAttributeValues: {
+                ":staleAt": { N: "1000" },
+                ":expiredAt": { N: "2000" },
+            },
+            ReturnValues: "ALL_NEW",
+        });
+    });
+    it("reads markers in batches of 100 and parses them", async () => {
+        send.mockImplementation((command) => {
+            const { RequestItems } = commandInput(command, client_dynamodb_1.BatchGetItemCommand);
+            const keys = RequestItems.tbl.Keys;
+            return Promise.resolve({
+                Responses: {
+                    tbl: keys
+                        .filter(({ sk }) => sk.S.endsWith("0"))
+                        .map(({ sk }) => ({ sk, revalidatedAt: { N: "7" } })),
+                },
+            });
+        });
+        const tags = Array.from({ length: 150 }, (_, i) => `t${i}`);
+        const markers = await table.read([...tags, "t0"]);
+        expect(send).toHaveBeenCalledTimes(2);
+        expect(markers.size).toBe(15);
+        expect(markers.get("t10")).toEqual({
+            revalidatedAt: 7,
+            staleAt: undefined,
+            expiredAt: undefined,
+        });
+    });
+    // A read-back after the write is eventually consistent, so it can return
+    // the marker from before it: the writer tracks what the write returned.
+    it("returns the row as the write left it", async () => {
+        send.mockResolvedValueOnce({
+            Attributes: {
+                sk: { S: "posts" },
+                revalidatedAt: { N: "5000" },
+                staleAt: { N: "10" },
+            },
+        });
+        expect(await table.write("posts", 5000, undefined)).toEqual({
+            revalidatedAt: 5000,
+            staleAt: 10,
+            expiredAt: undefined,
+        });
+        send.mockResolvedValueOnce({});
+        expect(await table.write("posts", 6000, undefined)).toBeUndefined();
+    });
+    it("asks again for unprocessed keys, and gives up after three tries", async () => {
+        const unprocessed = {
+            UnprocessedKeys: {
+                tbl: { Keys: [{ pk: { S: "build" }, sk: { S: "a" } }] },
+            },
+        };
+        send.mockResolvedValueOnce(unprocessed).mockResolvedValueOnce({
+            Responses: { tbl: [{ sk: { S: "a" }, staleAt: { N: "3" } }] },
+        });
+        expect((await table.read(["a"])).get("a")?.staleAt).toBe(3);
+        send.mockResolvedValue(unprocessed);
+        await expect(table.read(["a"])).rejects.toThrow(/unread after retrying/);
+    });
+});
+describe("RevalidationLog", () => {
+    const send = jest.fn();
+    let log;
+    beforeEach(() => {
+        send.mockReset();
+        client_dynamodb_1.DynamoDBClient.mockImplementation(() => ({ send }));
+        log = new aws_cache_store_1.RevalidationLog(new client_dynamodb_1.DynamoDBClient({}), "tbl", "build");
+    });
+    it("puts one row per revalidation under the build's log, with a TTL", async () => {
+        send.mockResolvedValue({});
+        const at = 1_727_000_000_123;
+        await log.put("user#42", at, { staleAt: 5, expiredAt: 6 });
+        expect(commandInput(send.mock.calls[0][0], client_dynamodb_1.PutItemCommand)).toEqual({
+            TableName: "tbl",
+            Item: {
+                pk: { S: "build#log" },
+                sk: { S: "001727000000123#user#42" },
+                ttl: { N: String(Math.ceil((at + aws_cache_store_1.REVALIDATION_LOG_TTL_MS) / 1000)) },
+                staleAt: { N: "5" },
+                expiredAt: { N: "6" },
+            },
+            ConditionExpression: "attribute_not_exists(sk)",
+        });
+    });
+    it("moves a row to the next millisecond rather than overwrite another revalidation", async () => {
+        // `updateTag('x')` and `revalidateTag('x', 'max')` in one millisecond.
+        const taken = Object.assign(new Error("taken"), {
+            name: "ConditionalCheckFailedException",
+        });
+        send.mockRejectedValueOnce(taken).mockResolvedValueOnce({});
+        await log.put("x", 1000.5, { revalidatedAt: 5 });
+        expect(send.mock.calls.map(([command]) => commandInput(command, client_dynamodb_1.PutItemCommand).Item.sk.S)).toEqual(["000000000001000#x", "000000000001001#x"]);
+    });
+    it("gives up after a bounded number of collisions, and on other errors at once", async () => {
+        const taken = Object.assign(new Error("taken"), {
+            name: "ConditionalCheckFailedException",
+        });
+        send.mockRejectedValue(taken);
+        await expect(log.put("x", 1000, {})).rejects.toBe(taken);
+        expect(send).toHaveBeenCalledTimes(5);
+        send.mockReset();
+        const throttled = new Error("throttled");
+        send.mockRejectedValue(throttled);
+        await expect(log.put("x", 1000, {})).rejects.toBe(throttled);
+        expect(send).toHaveBeenCalledTimes(1);
+    });
+    it("queries from a zero-padded cursor and parses the tag after it", async () => {
+        send
+            .mockResolvedValueOnce({
+            Items: [
+                { sk: { S: "000000000001000#a" }, revalidatedAt: { N: "7" } },
+                { sk: { S: "not a log row" } },
+            ],
+            LastEvaluatedKey: { pk: { S: "build#log" }, sk: { S: "x" } },
+        })
+            .mockResolvedValueOnce({
+            Items: [{ sk: { S: "000000000002000#user#42" }, staleAt: { N: "8" } }],
+        });
+        const { rows, truncated } = await log.query(999.5);
+        const first = commandInput(send.mock.calls[0][0], client_dynamodb_1.QueryCommand);
+        expect(first).toMatchObject({
+            TableName: "tbl",
+            KeyConditionExpression: "pk = :pk AND sk >= :since",
+            ExpressionAttributeValues: {
+                ":pk": { S: "build#log" },
+                ":since": { S: "000000000000999" },
+            },
+        });
+        expect(commandInput(send.mock.calls[1][0], client_dynamodb_1.QueryCommand).ExclusiveStartKey).toEqual({ pk: { S: "build#log" }, sk: { S: "x" } });
+        expect(truncated).toBe(false);
+        expect(rows).toEqual([
+            {
+                sk: "000000000001000#a",
+                at: 1000,
+                tag: "a",
+                marker: { revalidatedAt: 7, staleAt: undefined, expiredAt: undefined },
+            },
+            {
+                sk: "000000000002000#user#42",
+                at: 2000,
+                tag: "user#42",
+                marker: { revalidatedAt: undefined, staleAt: 8, expiredAt: undefined },
+            },
+        ]);
+    });
+    it("stops after its page bound and says so", async () => {
+        send.mockResolvedValue({
+            Items: [],
+            LastEvaluatedKey: { pk: { S: "build#log" }, sk: { S: "x" } },
+        });
+        expect((await log.query(0)).truncated).toBe(true);
+        expect(send).toHaveBeenCalledTimes(aws_cache_store_1.REVALIDATION_LOG_MAX_PAGES);
+    });
+});
+describe("CacheBucket", () => {
+    const send = jest.fn();
+    let bucket;
+    beforeEach(() => {
+        send.mockReset();
+        client_s3_1.S3Client.mockImplementation(() => ({ send }));
+        bucket = new aws_cache_store_1.CacheBucket(new client_s3_1.S3Client({}), "bkt");
+    });
+    it("reads an object as text", async () => {
+        send.mockResolvedValue({
+            Body: { transformToString: jest.fn().mockResolvedValue("{}") },
+            ContentType: "application/json",
+        });
+        expect(await bucket.get("k")).toBe("{}");
+        expect(commandInput(send.mock.calls[0][0], client_s3_1.GetObjectCommand)).toEqual({
+            Bucket: "bkt",
+            Key: "k",
+        });
+    });
+    it("answers a missing object or body with undefined, and throws the rest", async () => {
+        send.mockRejectedValueOnce(new client_s3_1.NoSuchKey({ message: "missing", $metadata: {} }));
+        expect(await bucket.get("k")).toBeUndefined();
+        send.mockResolvedValueOnce({ Body: null });
+        expect(await bucket.get("k")).toBeUndefined();
+        send.mockRejectedValueOnce(new Error("AccessDenied"));
+        await expect(bucket.get("k")).rejects.toThrow("AccessDenied");
+    });
+    it("writes JSON", async () => {
+        send.mockResolvedValue({});
+        await bucket.putJson("k", "{}");
+        expect(commandInput(send.mock.calls[0][0], client_s3_1.PutObjectCommand)).toEqual({
+            Bucket: "bkt",
+            Key: "k",
+            Body: "{}",
+            ContentType: "application/json; charset=utf-8",
+        });
+    });
+});
+describe("TrackedTagMarkers", () => {
+    it("does not skip a row for an untracked tag that its first read missed", async () => {
+        // The writer puts the log row and the marker at the same time, and the
+        // marker read is eventually consistent: `refresh` can see the row, then
+        // `ensure` read the marker from before it. Marked applied while the tag
+        // was untracked, the row was skipped by every query the lookback returned
+        // it to, and the instance served the stale entry until the rolling re-read.
+        let clock = 1_000_000;
+        const revalidatedAt = 999_000;
+        const row = {
+            sk: `${String(clock).padStart(15, "0")}#posts`,
+            at: clock,
+            tag: "posts",
+            marker: { revalidatedAt },
+        };
+        const query = jest.fn(async (since) => ({
+            rows: [row].filter((r) => r.at >= since),
+            truncated: false,
+        }));
+        // A replica that has not seen the write yet.
+        const read = jest.fn(async () => new Map());
+        const markers = new aws_cache_store_1.TrackedTagMarkers({
+            markers: { read },
+            log: { query },
+            refreshIntervalMs: 1000,
+            clock: () => clock,
+            random: () => 0,
+        });
+        // Something tracked, so the refresh queries the log.
+        await markers.ensure(["other"]);
+        clock += 1000;
+        await markers.refresh();
+        await markers.ensure(["posts"]);
+        expect(markers.get("posts")).toEqual({});
+        clock += 1000;
+        await markers.refresh();
+        expect(query).toHaveBeenCalledTimes(2);
+        expect(markers.get("posts")).toEqual({ revalidatedAt });
+        // Only the one read each tag's first use costs.
+        expect(read).toHaveBeenCalledTimes(2);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws-cache-store.test.js","sourceRoot":"","sources":["../../src/adapter/aws-cache-store.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  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 {\n  buildS3Key,\n  CacheBucket,\n  markerFor,\n  markerState,\n  markerUpdate,\n  mergeMarkers,\n  resolveAwsCacheConfig,\n  REVALIDATION_LOG_MAX_PAGES,\n  REVALIDATION_LOG_TTL_MS,\n  RevalidationLog,\n  RevalidationLogRow,\n  TagMarker,\n  TagMarkerTable,\n  TrackedTagMarkers,\n  useCacheS3Key,\n} from \"./aws-cache-store\";\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\ndescribe(\"resolveAwsCacheConfig\", () => {\n  const env = process.env;\n  beforeEach(() => {\n    process.env = { ...env };\n  });\n  afterAll(() => {\n    process.env = env;\n  });\n\n  it(\"reads the environment the constructs set\", () => {\n    process.env.CDK_NEXTJS_CACHE_BUCKET_NAME = \"bucket\";\n    process.env.CDK_NEXTJS_REVALIDATION_TABLE_NAME = \"table\";\n    process.env.CDK_NEXTJS_BUILD_ID = \"build\";\n    process.env.AWS_REGION = \"eu-west-1\";\n    expect(resolveAwsCacheConfig()).toEqual({\n      bucketName: \"bucket\",\n      tableName: \"table\",\n      buildId: \"build\",\n      region: \"eu-west-1\",\n    });\n  });\n\n  it(\"reports what is unset as empty\", () => {\n    delete process.env.CDK_NEXTJS_CACHE_BUCKET_NAME;\n    delete process.env.CDK_NEXTJS_REVALIDATION_TABLE_NAME;\n    delete process.env.CDK_NEXTJS_BUILD_ID;\n    delete process.env.AWS_REGION;\n    expect(resolveAwsCacheConfig()).toEqual({\n      bucketName: \"\",\n      tableName: \"\",\n      buildId: \"\",\n      region: \"us-east-1\",\n    });\n  });\n});\n\ndescribe(\"S3 keys\", () => {\n  it(\"keeps the incremental cache's {buildId}/{key}.json convention\", () => {\n    expect(buildS3Key(\"b\", \"/\")).toBe(\"b/index.json\");\n    expect(buildS3Key(\"b\", \"\")).toBe(\"b/index.json\");\n    expect(buildS3Key(\"b\", \"/blog/post\")).toBe(\"b/blog/post.json\");\n    expect(buildS3Key(\"b\", \"abc123\")).toBe(\"b/abc123.json\");\n  });\n\n  it(\"puts 'use cache' entries where no incremental key can land\", () => {\n    const key = useCacheS3Key(\"b\", \"f\".repeat(64));\n    expect(key).toBe(`b/_use-cache/${\"f\".repeat(64)}.entry`);\n    // Even a route spelled like the use-cache key gets `.json` appended.\n    expect(buildS3Key(\"b\", `/_use-cache/${\"f\".repeat(64)}.entry`)).not.toBe(\n      key,\n    );\n    expect(key.endsWith(\".json\")).toBe(false);\n  });\n});\n\ndescribe(\"tag markers\", () => {\n  it(\"writes what markerFor applies locally\", () => {\n    for (const durations of [undefined, {}, { expire: 60 }]) {\n      const update = markerUpdate(1000, durations);\n      const local = markerFor(1000, durations);\n      const written: Record<string, number> = {};\n      for (const [name, value] of Object.entries(\n        update.ExpressionAttributeValues!,\n      )) {\n        written[name.slice(1)] = Number(value.N);\n      }\n      expect(written).toEqual(local);\n    }\n    expect(markerFor(1000, { expire: 60 })).toEqual({\n      staleAt: 1000,\n      expiredAt: 61000,\n    });\n  });\n\n  it(\"keeps an earlier expiredAt a profile with no expire leaves\", () => {\n    // The row keeps it (`SET staleAt` only), so an instance learning of the\n    // second revalidation from the log has to keep it too.\n    const first = markerFor(1000, { expire: 60 });\n    const second = markerFor(2000, {});\n    expect(mergeMarkers(first, second)).toEqual({\n      staleAt: 2000,\n      expiredAt: 61000,\n    });\n    expect(mergeMarkers(second, first)).toEqual({\n      staleAt: 2000,\n      expiredAt: 61000,\n    });\n    // A newer `expire` still replaces it.\n    expect(mergeMarkers(first, markerFor(2000, { expire: 1 }))).toEqual({\n      staleAt: 2000,\n      expiredAt: 3000,\n    });\n  });\n\n  it(\"judges an entry the way the incremental cache always has\", () => {\n    // Expired outright after creation.\n    expect(markerState({ revalidatedAt: 20 }, 10, 30)).toBe(\"expired\");\n    // Revalidated before the entry was created: no effect.\n    expect(markerState({ revalidatedAt: 5 }, 10, 30)).toBe(\"fresh\");\n    // A profile: stale now, expired once `expiredAt` passes.\n    expect(markerState({ staleAt: 20, expiredAt: 50 }, 10, 30)).toBe(\"stale\");\n    expect(markerState({ staleAt: 20, expiredAt: 50 }, 10, 60)).toBe(\"expired\");\n    // `expire: 0`: stale and expired at once.\n    expect(markerState({ staleAt: 20, expiredAt: 20 }, 10, 30)).toBe(\"expired\");\n    expect(markerState({}, 10, 30)).toBe(\"fresh\");\n  });\n});\n\ndescribe(\"TagMarkerTable\", () => {\n  const send = jest.fn();\n  let table: TagMarkerTable;\n\n  beforeEach(() => {\n    send.mockReset();\n    (DynamoDBClient as jest.Mock).mockImplementation(() => ({ send }));\n    table = new TagMarkerTable(new DynamoDBClient({}), \"tbl\", \"build\");\n  });\n\n  it(\"writes the marker row under the build\", async () => {\n    send.mockResolvedValue({});\n    await table.write(\"posts\", 1000, { expire: 1 });\n    const input = commandInput(send.mock.calls[0][0], UpdateItemCommand);\n    expect(input).toEqual({\n      TableName: \"tbl\",\n      Key: { pk: { S: \"build\" }, sk: { S: \"posts\" } },\n      UpdateExpression: \"SET staleAt = :staleAt, expiredAt = :expiredAt\",\n      ExpressionAttributeValues: {\n        \":staleAt\": { N: \"1000\" },\n        \":expiredAt\": { N: \"2000\" },\n      },\n      ReturnValues: \"ALL_NEW\",\n    });\n  });\n\n  it(\"reads markers in batches of 100 and parses them\", async () => {\n    send.mockImplementation((command: unknown) => {\n      const { RequestItems } = commandInput(command, BatchGetItemCommand);\n      const keys = RequestItems.tbl.Keys as { sk: { S: string } }[];\n      return Promise.resolve({\n        Responses: {\n          tbl: keys\n            .filter(({ sk }) => sk.S.endsWith(\"0\"))\n            .map(({ sk }) => ({ sk, revalidatedAt: { N: \"7\" } })),\n        },\n      });\n    });\n    const tags = Array.from({ length: 150 }, (_, i) => `t${i}`);\n    const markers = await table.read([...tags, \"t0\"]);\n    expect(send).toHaveBeenCalledTimes(2);\n    expect(markers.size).toBe(15);\n    expect(markers.get(\"t10\")).toEqual({\n      revalidatedAt: 7,\n      staleAt: undefined,\n      expiredAt: undefined,\n    });\n  });\n\n  // A read-back after the write is eventually consistent, so it can return\n  // the marker from before it: the writer tracks what the write returned.\n  it(\"returns the row as the write left it\", async () => {\n    send.mockResolvedValueOnce({\n      Attributes: {\n        sk: { S: \"posts\" },\n        revalidatedAt: { N: \"5000\" },\n        staleAt: { N: \"10\" },\n      },\n    });\n    expect(await table.write(\"posts\", 5000, undefined)).toEqual({\n      revalidatedAt: 5000,\n      staleAt: 10,\n      expiredAt: undefined,\n    });\n    send.mockResolvedValueOnce({});\n    expect(await table.write(\"posts\", 6000, undefined)).toBeUndefined();\n  });\n\n  it(\"asks again for unprocessed keys, and gives up after three tries\", async () => {\n    const unprocessed = {\n      UnprocessedKeys: {\n        tbl: { Keys: [{ pk: { S: \"build\" }, sk: { S: \"a\" } }] },\n      },\n    };\n    send.mockResolvedValueOnce(unprocessed).mockResolvedValueOnce({\n      Responses: { tbl: [{ sk: { S: \"a\" }, staleAt: { N: \"3\" } }] },\n    });\n    expect((await table.read([\"a\"])).get(\"a\")?.staleAt).toBe(3);\n\n    send.mockResolvedValue(unprocessed);\n    await expect(table.read([\"a\"])).rejects.toThrow(/unread after retrying/);\n  });\n});\n\ndescribe(\"RevalidationLog\", () => {\n  const send = jest.fn();\n  let log: RevalidationLog;\n\n  beforeEach(() => {\n    send.mockReset();\n    (DynamoDBClient as jest.Mock).mockImplementation(() => ({ send }));\n    log = new RevalidationLog(new DynamoDBClient({}), \"tbl\", \"build\");\n  });\n\n  it(\"puts one row per revalidation under the build's log, with a TTL\", async () => {\n    send.mockResolvedValue({});\n    const at = 1_727_000_000_123;\n    await log.put(\"user#42\", at, { staleAt: 5, expiredAt: 6 });\n    expect(commandInput(send.mock.calls[0][0], PutItemCommand)).toEqual({\n      TableName: \"tbl\",\n      Item: {\n        pk: { S: \"build#log\" },\n        sk: { S: \"001727000000123#user#42\" },\n        ttl: { N: String(Math.ceil((at + REVALIDATION_LOG_TTL_MS) / 1000)) },\n        staleAt: { N: \"5\" },\n        expiredAt: { N: \"6\" },\n      },\n      ConditionExpression: \"attribute_not_exists(sk)\",\n    });\n  });\n\n  it(\"moves a row to the next millisecond rather than overwrite another revalidation\", async () => {\n    // `updateTag('x')` and `revalidateTag('x', 'max')` in one millisecond.\n    const taken = Object.assign(new Error(\"taken\"), {\n      name: \"ConditionalCheckFailedException\",\n    });\n    send.mockRejectedValueOnce(taken).mockResolvedValueOnce({});\n    await log.put(\"x\", 1000.5, { revalidatedAt: 5 });\n    expect(\n      send.mock.calls.map(\n        ([command]) => commandInput(command, PutItemCommand).Item.sk.S,\n      ),\n    ).toEqual([\"000000000001000#x\", \"000000000001001#x\"]);\n  });\n\n  it(\"gives up after a bounded number of collisions, and on other errors at once\", async () => {\n    const taken = Object.assign(new Error(\"taken\"), {\n      name: \"ConditionalCheckFailedException\",\n    });\n    send.mockRejectedValue(taken);\n    await expect(log.put(\"x\", 1000, {})).rejects.toBe(taken);\n    expect(send).toHaveBeenCalledTimes(5);\n\n    send.mockReset();\n    const throttled = new Error(\"throttled\");\n    send.mockRejectedValue(throttled);\n    await expect(log.put(\"x\", 1000, {})).rejects.toBe(throttled);\n    expect(send).toHaveBeenCalledTimes(1);\n  });\n\n  it(\"queries from a zero-padded cursor and parses the tag after it\", async () => {\n    send\n      .mockResolvedValueOnce({\n        Items: [\n          { sk: { S: \"000000000001000#a\" }, revalidatedAt: { N: \"7\" } },\n          { sk: { S: \"not a log row\" } },\n        ],\n        LastEvaluatedKey: { pk: { S: \"build#log\" }, sk: { S: \"x\" } },\n      })\n      .mockResolvedValueOnce({\n        Items: [{ sk: { S: \"000000000002000#user#42\" }, staleAt: { N: \"8\" } }],\n      });\n    const { rows, truncated } = await log.query(999.5);\n\n    const first = commandInput(send.mock.calls[0][0], QueryCommand);\n    expect(first).toMatchObject({\n      TableName: \"tbl\",\n      KeyConditionExpression: \"pk = :pk AND sk >= :since\",\n      ExpressionAttributeValues: {\n        \":pk\": { S: \"build#log\" },\n        \":since\": { S: \"000000000000999\" },\n      },\n    });\n    expect(\n      commandInput(send.mock.calls[1][0], QueryCommand).ExclusiveStartKey,\n    ).toEqual({ pk: { S: \"build#log\" }, sk: { S: \"x\" } });\n    expect(truncated).toBe(false);\n    expect(rows).toEqual([\n      {\n        sk: \"000000000001000#a\",\n        at: 1000,\n        tag: \"a\",\n        marker: { revalidatedAt: 7, staleAt: undefined, expiredAt: undefined },\n      },\n      {\n        sk: \"000000000002000#user#42\",\n        at: 2000,\n        tag: \"user#42\",\n        marker: { revalidatedAt: undefined, staleAt: 8, expiredAt: undefined },\n      },\n    ]);\n  });\n\n  it(\"stops after its page bound and says so\", async () => {\n    send.mockResolvedValue({\n      Items: [],\n      LastEvaluatedKey: { pk: { S: \"build#log\" }, sk: { S: \"x\" } },\n    });\n    expect((await log.query(0)).truncated).toBe(true);\n    expect(send).toHaveBeenCalledTimes(REVALIDATION_LOG_MAX_PAGES);\n  });\n});\n\ndescribe(\"CacheBucket\", () => {\n  const send = jest.fn();\n  let bucket: CacheBucket;\n\n  beforeEach(() => {\n    send.mockReset();\n    (S3Client as jest.Mock).mockImplementation(() => ({ send }));\n    bucket = new CacheBucket(new S3Client({}), \"bkt\");\n  });\n\n  it(\"reads an object as text\", async () => {\n    send.mockResolvedValue({\n      Body: { transformToString: jest.fn().mockResolvedValue(\"{}\") },\n      ContentType: \"application/json\",\n    });\n    expect(await bucket.get(\"k\")).toBe(\"{}\");\n    expect(commandInput(send.mock.calls[0][0], GetObjectCommand)).toEqual({\n      Bucket: \"bkt\",\n      Key: \"k\",\n    });\n  });\n\n  it(\"answers a missing object or body with undefined, and throws the rest\", async () => {\n    send.mockRejectedValueOnce(\n      new NoSuchKey({ message: \"missing\", $metadata: {} }),\n    );\n    expect(await bucket.get(\"k\")).toBeUndefined();\n    send.mockResolvedValueOnce({ Body: null });\n    expect(await bucket.get(\"k\")).toBeUndefined();\n    send.mockRejectedValueOnce(new Error(\"AccessDenied\"));\n    await expect(bucket.get(\"k\")).rejects.toThrow(\"AccessDenied\");\n  });\n\n  it(\"writes JSON\", async () => {\n    send.mockResolvedValue({});\n    await bucket.putJson(\"k\", \"{}\");\n    expect(commandInput(send.mock.calls[0][0], PutObjectCommand)).toEqual({\n      Bucket: \"bkt\",\n      Key: \"k\",\n      Body: \"{}\",\n      ContentType: \"application/json; charset=utf-8\",\n    });\n  });\n});\n\ndescribe(\"TrackedTagMarkers\", () => {\n  it(\"does not skip a row for an untracked tag that its first read missed\", async () => {\n    // The writer puts the log row and the marker at the same time, and the\n    // marker read is eventually consistent: `refresh` can see the row, then\n    // `ensure` read the marker from before it. Marked applied while the tag\n    // was untracked, the row was skipped by every query the lookback returned\n    // it to, and the instance served the stale entry until the rolling re-read.\n    let clock = 1_000_000;\n    const revalidatedAt = 999_000;\n    const row: RevalidationLogRow = {\n      sk: `${String(clock).padStart(15, \"0\")}#posts`,\n      at: clock,\n      tag: \"posts\",\n      marker: { revalidatedAt },\n    };\n    const query = jest.fn(async (since: number) => ({\n      rows: [row].filter((r) => r.at >= since),\n      truncated: false,\n    }));\n    // A replica that has not seen the write yet.\n    const read = jest.fn(async () => new Map<string, TagMarker>());\n    const markers = new TrackedTagMarkers({\n      markers: { read } as unknown as TagMarkerTable,\n      log: { query } as unknown as RevalidationLog,\n      refreshIntervalMs: 1000,\n      clock: () => clock,\n      random: () => 0,\n    });\n    // Something tracked, so the refresh queries the log.\n    await markers.ensure([\"other\"]);\n\n    clock += 1000;\n    await markers.refresh();\n    await markers.ensure([\"posts\"]);\n    expect(markers.get(\"posts\")).toEqual({});\n\n    clock += 1000;\n    await markers.refresh();\n    expect(query).toHaveBeenCalledTimes(2);\n    expect(markers.get(\"posts\")).toEqual({ revalidatedAt });\n    // Only the one read each tag's first use costs.\n    expect(read).toHaveBeenCalledTimes(2);\n  });\n});\n"]}

package/lib/adapter/build-outputs.d.ts

@@ -0,0 +1,80 @@
+import { NextAdapter } from "next";
+import { FunctionGroupSpec } from "./function-groups";
+import { AdapterManifest } from "../runtime/manifest";
+/**
+ * The `onBuildComplete` argument. Derived from the `next` typings rather than
+ * restated so a `next` bump surfaces as a compile error here.
+ */
+export type BuildCompleteContext = Parameters<NonNullable<NextAdapter["onBuildComplete"]>>[0];
+/**
+ * Staging key (repo-root-relative POSIX) → absolute source path on the build
+ * machine. The deduped union that replaces the standalone tree.
+ */
+export type StagingPlan = ReadonlyMap<string, string>;
+export interface BuildOutputsOptions {
+    /**
+     * The directory `next build` was invoked from. Defaults to `process.cwd()`,
+     * which is the real answer inside `onBuildComplete`; a parameter only so the
+     * unit tests can drive the fixtures' synthetic project dirs.
+     */
+    readonly buildCwd?: string;
+    /**
+     * Resolved `functionGroups`. Defaults to {@link FUNCTION_GROUPS_ENV_VAR},
+     * which is how the constructs get them here: `onBuildComplete` runs inside
+     * `next build` and cannot read CDK props.
+     *
+     * `undefined` means one deployment root holding every route, which is the
+     * default and the only thing the Containers types ever do.
+     */
+    readonly functionGroups?: FunctionGroupSpec[];
+}
+/** One deployment root: the staging plan for it, and where it goes. */
+export interface StagedGroup {
+    /**
+     * Group name, `default` for the implicit group. Always present — a build with
+     * no `functionGroups` produces exactly one {@link StagedGroup} named `default`,
+     * so callers never branch on "is this split".
+     */
+    readonly name: string;
+    /**
+     * Directory inside `cdk-nextjs-adapter`, POSIX: `app` when not splitting,
+     * `groups/<name>` when splitting.
+     */
+    readonly dirName: string;
+    readonly staging: StagingPlan;
+}
+export interface BuildAdapterManifestResult {
+    readonly manifest: AdapterManifest;
+    /** One entry per deployment root to stage. Length 1 unless splitting. */
+    readonly groups: StagedGroup[];
+}
+/** A staged deployment root on disk. */
+export interface StagedGroupResult {
+    readonly name: string;
+    /** Absolute path to the deployment root. */
+    readonly path: string;
+    readonly fileCount: number;
+}
+export interface WriteBuildOutputsResult extends BuildAdapterManifestResult {
+    /** Absolute path to `<distDir>/cdk-nextjs-adapter`. */
+    readonly adapterDir: string;
+    /** Absolute path to the written manifest. */
+    readonly manifestPath: string;
+    /** One per deployment root, in the order they were staged. */
+    readonly stagedGroups: StagedGroupResult[];
+}
+/**
+ * Build the manifest and staging plan, stage the files, and write the manifest.
+ * Called from `onBuildComplete`, which is the only place that holds the build
+ * outputs.
+ */
+export declare function writeBuildOutputs(ctx: BuildCompleteContext, options?: BuildOutputsOptions): Promise<WriteBuildOutputsResult>;
+/**
+ * The pure half of {@link writeBuildOutputs}: everything derived from the build
+ * outputs, with no writes. Split out so it can be unit tested against committed
+ * `onBuildComplete` fixtures.
+ *
+ * Throws on any non-Node output and on any staging key two outputs map to
+ * different content.
+ */
+export declare function buildAdapterManifest(ctx: BuildCompleteContext, options?: BuildOutputsOptions): BuildAdapterManifestResult;