cdk-nextjs 0.6.2 → 0.7.1

package/lib/runtime/public-files.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publicDirKey = publicDirKey;
+exports.readPublicFiles = readPublicFiles;
+exports.resolvePublicFiles = resolvePublicFiles;
+/**
+ * `public/`, as the runtime finds it on disk.
+ *
+ * Listed at cold start, the way `next start` lists it
+ * (`next/dist/server/lib/router-utils/filesystem.js`, `recursiveReadDir` of
+ * `public/`), rather than at build time in the manifest. The build-time list
+ * was the wrong source of truth in two ways: `onBuildComplete` runs inside
+ * `next build`, so anything an app's `postbuild` writes into `public/` —
+ * `next-sitemap`'s `sitemap.xml` and `robots.txt`, Pagefind's `_pagefind/` — was
+ * in the image and missing from the list; and every Lambda deployment carried
+ * the whole list for files CloudFront or API Gateway always answers from S3.
+ *
+ * Only the `NextjsRegionalContainers` image copies `public/` in. The other
+ * types' deployment roots carry the list instead — {@link PUBLIC_FILES_FILE_NAME}, written at synth after the build
+ * command, so a `postbuild` file is in it — and the runtime streams a listed
+ * file from the assets bucket when a request lands on it. A file's own URL
+ * never gets that far (the edge routes it to S3); a rewrite onto one does.
+ */
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const manifest_1 = require("./manifest");
+/** Where `public/` sits in the deployment root, as a POSIX key. */
+function publicDirKey(manifest) {
+    const { relativeProjectDir } = manifest;
+    return relativeProjectDir ? `${relativeProjectDir}/public` : "public";
+}
+/**
+ * Every file under `public/`, as `/`-separated paths relative to it, unencoded:
+ * `static/hello e2e.png`, `images/logo@2x.png`.
+ *
+ * Symlinks are followed, files and directories alike, because Next.js's
+ * `recursiveReadDir` follows them and so does everything that puts `public/` in
+ * front of a user: Docker `COPY` keeps a working link in the image, and CDK's
+ * asset staging uploads the target's bytes to S3. `Dirent.isFile()` describes the
+ * link, not its target, so filtering on it silently dropped them. A directory
+ * is not entered from inside itself, so a link cycle terminates.
+ */
+function readPublicFiles(dir) {
+    const files = [];
+    /** The real paths of the directories being walked, root to current. */
+    const ancestors = new Set();
+    const walk = (absolute, relative) => {
+        let real;
+        try {
+            real = (0, node_fs_1.realpathSync)(absolute);
+        }
+        catch {
+            return;
+        }
+        if (ancestors.has(real))
+            return;
+        ancestors.add(real);
+        for (const entry of (0, node_fs_1.readdirSync)(absolute, { withFileTypes: true })) {
+            const childAbsolute = (0, node_path_1.join)(absolute, entry.name);
+            const childRelative = relative ? `${relative}/${entry.name}` : entry.name;
+            let isDirectory = entry.isDirectory();
+            let isFile = entry.isFile();
+            if (entry.isSymbolicLink()) {
+                try {
+                    const target = (0, node_fs_1.statSync)(childAbsolute);
+                    isDirectory = target.isDirectory();
+                    isFile = target.isFile();
+                }
+                catch {
+                    // A dangling link: nothing to serve.
+                    continue;
+                }
+            }
+            if (isDirectory) {
+                walk(childAbsolute, childRelative);
+            }
+            else if (isFile) {
+                files.push(childRelative);
+            }
+        }
+        ancestors.delete(real);
+    };
+    try {
+        walk(dir, "");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    return files.sort();
+}
+/**
+ * The synth-time list when the deployment root has one, which is every type but
+ * `NextjsRegionalContainers`, and `public/` off disk otherwise. The list wins
+ * even when some of `public/` is on disk: a route that reads a `public/` file
+ * through `fs` gets that file traced into a Lambda root, and the rest of
+ * `public/` is still only in S3.
+ */
+function resolvePublicFiles(deploymentRoot, manifest) {
+    let listed;
+    try {
+        listed = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(deploymentRoot, manifest_1.RUNTIME_DIR_NAME, manifest_1.PUBLIC_FILES_FILE_NAME), "utf-8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            const onDisk = (0, node_path_1.join)(deploymentRoot, publicDirKey(manifest));
+            return { files: readPublicFiles(onDisk), inS3: false };
+        }
+        throw error;
+    }
+    if (!Array.isArray(listed) ||
+        !listed.every((file) => typeof file === "string")) {
+        throw new Error(`${manifest_1.RUNTIME_DIR_NAME}/${manifest_1.PUBLIC_FILES_FILE_NAME} is not a JSON array of paths.`);
+    }
+    return { files: listed, inS3: true };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"public-files.js","sourceRoot":"","sources":["../../src/runtime/public-files.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * `public/`, as the runtime finds it on disk.\n *\n * Listed at cold start, the way `next start` lists it\n * (`next/dist/server/lib/router-utils/filesystem.js`, `recursiveReadDir` of\n * `public/`), rather than at build time in the manifest. The build-time list\n * was the wrong source of truth in two ways: `onBuildComplete` runs inside\n * `next build`, so anything an app's `postbuild` writes into `public/` —\n * `next-sitemap`'s `sitemap.xml` and `robots.txt`, Pagefind's `_pagefind/` — was\n * in the image and missing from the list; and every Lambda deployment carried\n * the whole list for files CloudFront or API Gateway always answers from S3.\n *\n * Only the `NextjsRegionalContainers` image copies `public/` in. The other\n * types' deployment roots carry the list instead — {@link PUBLIC_FILES_FILE_NAME}, written at synth after the build\n * command, so a `postbuild` file is in it — and the runtime streams a listed\n * file from the assets bucket when a request lands on it. A file's own URL\n * never gets that far (the edge routes it to S3); a rewrite onto one does.\n */\nimport { readdirSync, readFileSync, realpathSync, statSync } from \"node:fs\";\nimport { join } from \"node:path\";\nimport {\n  AdapterManifest,\n  PUBLIC_FILES_FILE_NAME,\n  RUNTIME_DIR_NAME,\n} from \"./manifest\";\n\n/** Where `public/` sits in the deployment root, as a POSIX key. */\nexport function publicDirKey(manifest: AdapterManifest): string {\n  const { relativeProjectDir } = manifest;\n  return relativeProjectDir ? `${relativeProjectDir}/public` : \"public\";\n}\n\n/**\n * Every file under `public/`, as `/`-separated paths relative to it, unencoded:\n * `static/hello e2e.png`, `images/logo@2x.png`.\n *\n * Symlinks are followed, files and directories alike, because Next.js's\n * `recursiveReadDir` follows them and so does everything that puts `public/` in\n * front of a user: Docker `COPY` keeps a working link in the image, and CDK's\n * asset staging uploads the target's bytes to S3. `Dirent.isFile()` describes the\n * link, not its target, so filtering on it silently dropped them. A directory\n * is not entered from inside itself, so a link cycle terminates.\n */\nexport function readPublicFiles(dir: string): string[] {\n  const files: string[] = [];\n  /** The real paths of the directories being walked, root to current. */\n  const ancestors = new Set<string>();\n\n  const walk = (absolute: string, relative: string) => {\n    let real: string;\n    try {\n      real = realpathSync(absolute);\n    } catch {\n      return;\n    }\n    if (ancestors.has(real)) return;\n    ancestors.add(real);\n\n    for (const entry of readdirSync(absolute, { withFileTypes: true })) {\n      const childAbsolute = join(absolute, entry.name);\n      const childRelative = relative ? `${relative}/${entry.name}` : entry.name;\n      let isDirectory = entry.isDirectory();\n      let isFile = entry.isFile();\n      if (entry.isSymbolicLink()) {\n        try {\n          const target = statSync(childAbsolute);\n          isDirectory = target.isDirectory();\n          isFile = target.isFile();\n        } catch {\n          // A dangling link: nothing to serve.\n          continue;\n        }\n      }\n      if (isDirectory) {\n        walk(childAbsolute, childRelative);\n      } else if (isFile) {\n        files.push(childRelative);\n      }\n    }\n    ancestors.delete(real);\n  };\n\n  try {\n    walk(dir, \"\");\n  } catch (error) {\n    if ((error as { code?: string }).code !== \"ENOENT\") throw error;\n  }\n  return files.sort();\n}\n\n/** `public/` as the runtime serves it, and where its bytes are. */\nexport interface PublicFiles {\n  readonly files: readonly string[];\n  /**\n   * `true` when `files` came from {@link PUBLIC_FILES_FILE_NAME}: every type\n   * but `NextjsRegionalContainers`. Their bytes are in S3.\n   */\n  readonly inS3: boolean;\n}\n\n/**\n * The synth-time list when the deployment root has one, which is every type but\n * `NextjsRegionalContainers`, and `public/` off disk otherwise. The list wins\n * even when some of `public/` is on disk: a route that reads a `public/` file\n * through `fs` gets that file traced into a Lambda root, and the rest of\n * `public/` is still only in S3.\n */\nexport function resolvePublicFiles(\n  deploymentRoot: string,\n  manifest: AdapterManifest,\n): PublicFiles {\n  let listed: unknown;\n  try {\n    listed = JSON.parse(\n      readFileSync(\n        join(deploymentRoot, RUNTIME_DIR_NAME, PUBLIC_FILES_FILE_NAME),\n        \"utf-8\",\n      ),\n    );\n  } catch (error) {\n    if ((error as { code?: string }).code === \"ENOENT\") {\n      const onDisk = join(deploymentRoot, publicDirKey(manifest));\n      return { files: readPublicFiles(onDisk), inS3: false };\n    }\n    throw error;\n  }\n  if (\n    !Array.isArray(listed) ||\n    !listed.every((file) => typeof file === \"string\")\n  ) {\n    throw new Error(\n      `${RUNTIME_DIR_NAME}/${PUBLIC_FILES_FILE_NAME} is not a JSON array of paths.`,\n    );\n  }\n  return { files: listed as string[], inS3: true };\n}\n"]}

package/lib/runtime/public-files.test.d.ts

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

package/lib/runtime/public-files.test.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const manifest_1 = require("./manifest");
+const public_files_1 = require("./public-files");
+function tempDir() {
+    return (0, node_fs_1.realpathSync)((0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "cdk-nextjs-public-")));
+}
+describe("readPublicFiles", () => {
+    it("lists every file, nested, unencoded and sorted", () => {
+        const dir = tempDir();
+        (0, node_fs_1.mkdirSync)((0, node_path_1.join)(dir, "images"));
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(dir, "robots.txt"), "");
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(dir, "images", "logo@2x.png"), "");
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(dir, "hello e2e.png"), "");
+        expect((0, public_files_1.readPublicFiles)(dir)).toEqual([
+            "hello e2e.png",
+            "images/logo@2x.png",
+            "robots.txt",
+        ]);
+    });
+    it("follows symlinks to files and directories, as Next.js does", () => {
+        // `Dirent.isFile()` describes the link, so filtering on it dropped
+        // `public/latest.pdf -> v2/report.pdf` while Docker and S3 both carry it.
+        const dir = tempDir();
+        (0, node_fs_1.mkdirSync)((0, node_path_1.join)(dir, "v2"));
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(dir, "v2", "report.pdf"), "");
+        (0, node_fs_1.symlinkSync)((0, node_path_1.join)(dir, "v2", "report.pdf"), (0, node_path_1.join)(dir, "latest.pdf"));
+        (0, node_fs_1.symlinkSync)((0, node_path_1.join)(dir, "v2"), (0, node_path_1.join)(dir, "current"));
+        expect((0, public_files_1.readPublicFiles)(dir)).toEqual([
+            "current/report.pdf",
+            "latest.pdf",
+            "v2/report.pdf",
+        ]);
+    });
+    it("stops at a link cycle and skips a dangling link", () => {
+        const dir = tempDir();
+        (0, node_fs_1.mkdirSync)((0, node_path_1.join)(dir, "a"));
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(dir, "a", "file.txt"), "");
+        (0, node_fs_1.symlinkSync)((0, node_path_1.join)(dir, "a"), (0, node_path_1.join)(dir, "a", "loop"));
+        (0, node_fs_1.symlinkSync)((0, node_path_1.join)(dir, "missing"), (0, node_path_1.join)(dir, "dangling"));
+        expect((0, public_files_1.readPublicFiles)(dir)).toEqual(["a/file.txt"]);
+    });
+    it("is empty when there is no public/, as on the Lambda types", () => {
+        expect((0, public_files_1.readPublicFiles)((0, node_path_1.join)(tempDir(), "public"))).toEqual([]);
+    });
+});
+describe("resolvePublicFiles", () => {
+    const manifest = { relativeProjectDir: "apps/web" };
+    function writeList(root, contents) {
+        (0, node_fs_1.mkdirSync)((0, node_path_1.join)(root, manifest_1.RUNTIME_DIR_NAME), { recursive: true });
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(root, manifest_1.RUNTIME_DIR_NAME, manifest_1.PUBLIC_FILES_FILE_NAME), contents);
+    }
+    it("lists public/ off disk when there is no list, on RegionalContainers", () => {
+        const root = tempDir();
+        (0, node_fs_1.mkdirSync)((0, node_path_1.join)(root, "apps/web/public"), { recursive: true });
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(root, "apps/web/public/robots.txt"), "");
+        expect((0, public_files_1.resolvePublicFiles)(root, manifest)).toEqual({
+            files: ["robots.txt"],
+            inS3: false,
+        });
+    });
+    it("reads the synth-time list when public/ is not staged, on the Lambda types", () => {
+        const root = tempDir();
+        writeList(root, JSON.stringify(["feed.xml", "sitemap.xml"]));
+        expect((0, public_files_1.resolvePublicFiles)(root, manifest)).toEqual({
+            files: ["feed.xml", "sitemap.xml"],
+            inS3: true,
+        });
+    });
+    it("prefers the list over a public/ file the trace staged", () => {
+        // An OG-image route reading `public/fonts/Inter.ttf` through `fs` gets it
+        // traced into a Lambda root; the rest of `public/` is still only in S3.
+        const root = tempDir();
+        (0, node_fs_1.mkdirSync)((0, node_path_1.join)(root, "apps/web/public/fonts"), { recursive: true });
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(root, "apps/web/public/fonts/Inter.ttf"), "");
+        writeList(root, JSON.stringify(["fonts/Inter.ttf", "logo.png"]));
+        expect((0, public_files_1.resolvePublicFiles)(root, manifest)).toEqual({
+            files: ["fonts/Inter.ttf", "logo.png"],
+            inS3: true,
+        });
+    });
+    it("is empty for an app with neither", () => {
+        expect((0, public_files_1.resolvePublicFiles)(tempDir(), manifest)).toEqual({
+            files: [],
+            inS3: false,
+        });
+    });
+    it("rejects a list that is not an array of paths", () => {
+        const root = tempDir();
+        writeList(root, JSON.stringify({ files: [] }));
+        expect(() => (0, public_files_1.resolvePublicFiles)(root, manifest)).toThrow(/is not a JSON array of paths/);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"public-files.test.js","sourceRoot":"","sources":["../../src/runtime/public-files.test.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  mkdirSync,\n  mkdtempSync,\n  realpathSync,\n  symlinkSync,\n  writeFileSync,\n} from \"node:fs\";\nimport { tmpdir } from \"node:os\";\nimport { join } from \"node:path\";\nimport {\n  AdapterManifest,\n  PUBLIC_FILES_FILE_NAME,\n  RUNTIME_DIR_NAME,\n} from \"./manifest\";\nimport { readPublicFiles, resolvePublicFiles } from \"./public-files\";\n\nfunction tempDir(): string {\n  return realpathSync(mkdtempSync(join(tmpdir(), \"cdk-nextjs-public-\")));\n}\n\ndescribe(\"readPublicFiles\", () => {\n  it(\"lists every file, nested, unencoded and sorted\", () => {\n    const dir = tempDir();\n    mkdirSync(join(dir, \"images\"));\n    writeFileSync(join(dir, \"robots.txt\"), \"\");\n    writeFileSync(join(dir, \"images\", \"logo@2x.png\"), \"\");\n    writeFileSync(join(dir, \"hello e2e.png\"), \"\");\n    expect(readPublicFiles(dir)).toEqual([\n      \"hello e2e.png\",\n      \"images/logo@2x.png\",\n      \"robots.txt\",\n    ]);\n  });\n\n  it(\"follows symlinks to files and directories, as Next.js does\", () => {\n    // `Dirent.isFile()` describes the link, so filtering on it dropped\n    // `public/latest.pdf -> v2/report.pdf` while Docker and S3 both carry it.\n    const dir = tempDir();\n    mkdirSync(join(dir, \"v2\"));\n    writeFileSync(join(dir, \"v2\", \"report.pdf\"), \"\");\n    symlinkSync(join(dir, \"v2\", \"report.pdf\"), join(dir, \"latest.pdf\"));\n    symlinkSync(join(dir, \"v2\"), join(dir, \"current\"));\n    expect(readPublicFiles(dir)).toEqual([\n      \"current/report.pdf\",\n      \"latest.pdf\",\n      \"v2/report.pdf\",\n    ]);\n  });\n\n  it(\"stops at a link cycle and skips a dangling link\", () => {\n    const dir = tempDir();\n    mkdirSync(join(dir, \"a\"));\n    writeFileSync(join(dir, \"a\", \"file.txt\"), \"\");\n    symlinkSync(join(dir, \"a\"), join(dir, \"a\", \"loop\"));\n    symlinkSync(join(dir, \"missing\"), join(dir, \"dangling\"));\n    expect(readPublicFiles(dir)).toEqual([\"a/file.txt\"]);\n  });\n\n  it(\"is empty when there is no public/, as on the Lambda types\", () => {\n    expect(readPublicFiles(join(tempDir(), \"public\"))).toEqual([]);\n  });\n});\n\ndescribe(\"resolvePublicFiles\", () => {\n  const manifest = { relativeProjectDir: \"apps/web\" } as AdapterManifest;\n\n  function writeList(root: string, contents: string): void {\n    mkdirSync(join(root, RUNTIME_DIR_NAME), { recursive: true });\n    writeFileSync(\n      join(root, RUNTIME_DIR_NAME, PUBLIC_FILES_FILE_NAME),\n      contents,\n    );\n  }\n\n  it(\"lists public/ off disk when there is no list, on RegionalContainers\", () => {\n    const root = tempDir();\n    mkdirSync(join(root, \"apps/web/public\"), { recursive: true });\n    writeFileSync(join(root, \"apps/web/public/robots.txt\"), \"\");\n    expect(resolvePublicFiles(root, manifest)).toEqual({\n      files: [\"robots.txt\"],\n      inS3: false,\n    });\n  });\n\n  it(\"reads the synth-time list when public/ is not staged, on the Lambda types\", () => {\n    const root = tempDir();\n    writeList(root, JSON.stringify([\"feed.xml\", \"sitemap.xml\"]));\n    expect(resolvePublicFiles(root, manifest)).toEqual({\n      files: [\"feed.xml\", \"sitemap.xml\"],\n      inS3: true,\n    });\n  });\n\n  it(\"prefers the list over a public/ file the trace staged\", () => {\n    // An OG-image route reading `public/fonts/Inter.ttf` through `fs` gets it\n    // traced into a Lambda root; the rest of `public/` is still only in S3.\n    const root = tempDir();\n    mkdirSync(join(root, \"apps/web/public/fonts\"), { recursive: true });\n    writeFileSync(join(root, \"apps/web/public/fonts/Inter.ttf\"), \"\");\n    writeList(root, JSON.stringify([\"fonts/Inter.ttf\", \"logo.png\"]));\n    expect(resolvePublicFiles(root, manifest)).toEqual({\n      files: [\"fonts/Inter.ttf\", \"logo.png\"],\n      inS3: true,\n    });\n  });\n\n  it(\"is empty for an app with neither\", () => {\n    expect(resolvePublicFiles(tempDir(), manifest)).toEqual({\n      files: [],\n      inS3: false,\n    });\n  });\n\n  it(\"rejects a list that is not an array of paths\", () => {\n    const root = tempDir();\n    writeList(root, JSON.stringify({ files: [] }));\n    expect(() => resolvePublicFiles(root, manifest)).toThrow(\n      /is not a JSON array of paths/,\n    );\n  });\n});\n"]}