cdk-nextjs 0.6.1 → 0.7.0

package/lib/runtime/static-files.d.ts

@@ -0,0 +1,50 @@
+import type { ShimIncomingMessage } from "./http/request";
+import { ShimServerResponse } from "./http/response";
+/**
+ * Returns `false` when the file is not in the deployment package, which is the
+ * caller's cue to fall through to a 404.
+ *
+ * That happens by design on every type but `NextjsRegionalContainers`, for `<distDir>/static` and
+ * `public/` alike: neither is staged, being a second copy of bytes already in
+ * S3. A `public/` file is then served by {@link serveS3PublicFile}; a
+ * `<distDir>/static` one only gets here through a rewrite onto it, and is a 404.
+ * The `NextjsRegionalContainers` image copies both in, so there they are found.
+ */
+export declare function serveStaticFile(req: ShimIncomingMessage, res: ShimServerResponse, deploymentRoot: string, filePath: string, options: {
+    readonly etag: boolean;
+}): Promise<boolean>;
+/** Where a type without `public/` on disk finds a file it does not carry. */
+export interface S3PublicFile {
+    /** `CDK_NEXTJS_STATIC_ASSETS_BUCKET_NAME`. */
+    readonly bucket: string;
+    /**
+     * `NextjsStaticAssets.keyPrefix`, without a leading slash; empty for a
+     * bucket-root deployment. `public/` is uploaded to the root of it.
+     */
+    readonly keyPrefix: string;
+    /** The file's path relative to `public/`, unencoded: its real name. */
+    readonly file: string;
+    readonly etag: boolean;
+}
+/**
+ * A `public/` file from the assets bucket, for the types whose deployment
+ * roots list `public/` without carrying it. Returns `false` when the object is not there,
+ * which is the caller's cue to fall through to a 404 as for a file missing from
+ * disk.
+ *
+ * What `send` would have answered, as far as S3 can say it: the object's
+ * `Content-Type`, `Content-Length`, `Last-Modified` and — unless
+ * `generateEtags` is off — `ETag`; a 304 for a matching `If-None-Match` or, as
+ * `fresh` has it, an `If-Modified-Since` without one; and a 206 or 416 for a
+ * `Range`. S3 evaluates all of them itself.
+ *
+ * `Cache-Control` is, in order: a `headers()` rule's, the object's own
+ * `CacheControl` metadata — what the edge serves the file's own URL with, so a
+ * rewrite onto it caches the same way — and `send`'s default,
+ * `public, max-age=0`.
+ *
+ * `If-Range` is not evaluated, because S3 has no counterpart: with one present
+ * the `Range` is dropped and the whole file sent with a 200, which RFC 9110
+ * allows (a server may ignore `Range`) and a range client accepts.
+ */
+export declare function serveS3PublicFile(req: ShimIncomingMessage, res: ShimServerResponse, file: S3PublicFile): Promise<boolean>;

package/lib/runtime/static-files.js

@@ -0,0 +1,266 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serveStaticFile = serveStaticFile;
+exports.serveS3PublicFile = serveS3PublicFile;
+/**
+ * Serving the static files that nothing in front of the compute answers.
+ *
+ * `NextjsStaticAssets` uploads `<distDir>/static` and `public` to S3, and
+ * CloudFront / API Gateway route a file's own URL there — except on
+ * `NextjsRegionalContainers`, which has nothing in front of it. What still
+ * reaches the runtime is a file some *other* URL lands on: a `rewrites` entry
+ * or a middleware rewrite onto `/maintenance.html`, `/en-US/robots.txt` in an
+ * i18n app. The `NextjsRegionalContainers` image copies `public` and
+ * `<distDir>/static` in and serves them off disk; the other types carry
+ * neither, so a `public/` file is streamed from the assets bucket instead
+ * ({@link serveS3PublicFile}).
+ * Everything else in `manifest.staticFiles` lives under `<distDir>/server` —
+ * `404.html`, `500.html`, `favicon.ico.body`, fully-static Pages Router HTML —
+ * and reaches us, exactly as it reaches `next start`.
+ *
+ * Next.js's own `serveStatic` is used rather than a `createReadStream`, because it
+ * is `send` underneath and that brings conditional requests (`If-None-Match`,
+ * `If-Modified-Since`), `Range`, `ETag`, `Last-Modified`, and content-type
+ * detection. Reimplementing those is how a "simple" file server ends up
+ * disagreeing with `next start` on a 304.
+ */
+/* eslint-disable import/no-extraneous-dependencies */
+const node_path_1 = require("node:path");
+const node_stream_1 = require("node:stream");
+const client_s3_1 = require("@aws-sdk/client-s3");
+const response_1 = require("./http/response");
+const next_modules_1 = require("./next-modules");
+const util_1 = require("./util");
+const SERVE_STATIC = "next/dist/server/serve-static.js";
+/** Resolved on the first static-file request; see {@link nextModule}. */
+let serveStaticModule;
+/**
+ * Returns `false` when the file is not in the deployment package, which is the
+ * caller's cue to fall through to a 404.
+ *
+ * That happens by design on every type but `NextjsRegionalContainers`, for `<distDir>/static` and
+ * `public/` alike: neither is staged, being a second copy of bytes already in
+ * S3. A `public/` file is then served by {@link serveS3PublicFile}; a
+ * `<distDir>/static` one only gets here through a rewrite onto it, and is a 404.
+ * The `NextjsRegionalContainers` image copies both in, so there they are found.
+ */
+async function serveStaticFile(req, res, deploymentRoot, filePath, options) {
+    serveStaticModule ??= (0, next_modules_1.nextModule)(SERVE_STATIC);
+    const { serveStatic, getContentType } = serveStaticModule;
+    setBodyFileContentType(res, filePath, getContentType);
+    try {
+        // Encoded, and relative to a `root`, which is how `next start` calls it:
+        // `send` percent-decodes whatever path it is handed, as though it were a
+        // URL. A raw filesystem path broke on any file name with a `%` in it —
+        // `100%.png` failed to decode and answered an empty 400, and `a%20b.txt`
+        // was looked up as `a b.txt`, serving a different file if there was one.
+        await serveStatic(req, (0, response_1.asServerResponse)(res), `/${filePath.split("/").map(encodeURIComponent).join("/")}`, { root: deploymentRoot, etag: options.etag });
+        return true;
+    }
+    catch (error) {
+        if (isMissingFile(error)) {
+            return false;
+        }
+        const status = httpErrorStatus(error);
+        // `send` emits its error before the first byte, so the head is still ours to
+        // set; the guard is only for a shell that already committed one.
+        if (status !== undefined && !res.headersSent) {
+            res.statusCode = status;
+            res.end();
+            return true;
+        }
+        throw error;
+    }
+}
+/**
+ * The status a `send` error carries, for the errors that are the *client's*, not
+ * ours.
+ *
+ * `serveStatic` is `send` underneath, and `send` rejects a failed precondition
+ * with a 412 and an unsatisfiable `Range` with a 416 — both attached to the error
+ * as `statusCode`. `next start` maps them back onto the response
+ * (`next/dist/server/lib/router-server.js` special-cases 400/412/416); letting
+ * them fall through to the caller's error path (`NextjsRuntime.sendError`, which
+ * answers 500 with the app's error page) instead turned `If-Match: "stale"` into
+ * a 500 and `Range: bytes=99999-` into a 500.
+ *
+ * Only 4xx is honored: a 5xx from `send` is a real failure and belongs in the
+ * error path, with the stack.
+ */
+function httpErrorStatus(error) {
+    const status = error?.statusCode;
+    if (typeof status === "number" && status >= 400 && status < 500) {
+        return status;
+    }
+    return undefined;
+}
+/**
+ * `send` types a response from the file's own extension, and a static metadata
+ * route ships as `<route>.body` — `robots.txt.body`, `manifest.webmanifest.body`,
+ * `favicon.ico.body`. `.body` is not a media type, so every one of them would go
+ * out as `application/octet-stream`.
+ *
+ * Next.js's adapter API is where the type is lost: `build-complete.ts` pushes
+ * these through `isStaticMetadataFile()` as a bare `STATIC_FILE` — `id`,
+ * `pathname`, `filePath`, and nothing else — while the headers the route handler
+ * actually set sit unreferenced in a sibling `<route>.meta`. `next start` reads
+ * that file through the response cache and answers `text/plain`.
+ *
+ * Stripping `.body` puts the route's own extension back on the end, which for
+ * this population is the same answer: the set is closed (`favicon.ico`, `icon.*`,
+ * `apple-icon.*`, `opengraph-image.*`, `twitter-image.*`, `sitemap.xml`,
+ * `robots.txt`, `manifest.{json,webmanifest}`) and every member's type is implied
+ * by its extension. `send` skips its own detection when `Content-Type` is already
+ * set (`send/index.js`, `type()`), so this wins without reaching for `opts`.
+ */
+function setBodyFileContentType(res, filePath, getContentType) {
+    if (!filePath.endsWith(".body") || res.getHeader("Content-Type")) {
+        return;
+    }
+    const ext = (0, node_path_1.extname)(filePath.slice(0, -".body".length)).slice(1);
+    if (!ext) {
+        return;
+    }
+    const contentType = getContentType(ext);
+    if (contentType) {
+        res.setHeader("Content-Type", contentType);
+    }
+}
+function isMissingFile(error) {
+    const code = error?.code;
+    // ENOENT covers a missing file and `send`'s "No directory access"; ENOTDIR is
+    // what a path segment that exists as a file produces.
+    return code === "ENOENT" || code === "ENOTDIR";
+}
+/**
+ * A `public/` file from the assets bucket, for the types whose deployment
+ * roots list `public/` without carrying it. Returns `false` when the object is not there,
+ * which is the caller's cue to fall through to a 404 as for a file missing from
+ * disk.
+ *
+ * What `send` would have answered, as far as S3 can say it: the object's
+ * `Content-Type`, `Content-Length`, `Last-Modified` and — unless
+ * `generateEtags` is off — `ETag`; a 304 for a matching `If-None-Match` or, as
+ * `fresh` has it, an `If-Modified-Since` without one; and a 206 or 416 for a
+ * `Range`. S3 evaluates all of them itself.
+ *
+ * `Cache-Control` is, in order: a `headers()` rule's, the object's own
+ * `CacheControl` metadata — what the edge serves the file's own URL with, so a
+ * rewrite onto it caches the same way — and `send`'s default,
+ * `public, max-age=0`.
+ *
+ * `If-Range` is not evaluated, because S3 has no counterpart: with one present
+ * the `Range` is dropped and the whole file sent with a 200, which RFC 9110
+ * allows (a server may ignore `Range`) and a range client accepts.
+ */
+async function serveS3PublicFile(req, res, file) {
+    const prefix = file.keyPrefix.replace(/^\/+|\/+$/g, "");
+    const key = prefix ? `${prefix}/${file.file}` : file.file;
+    const ifNoneMatch = file.etag
+        ? (0, util_1.firstValue)(req.headers["if-none-match"])
+        : undefined;
+    // `fresh` ignores it next to an `If-None-Match`, even one it cannot match
+    // because `generateEtags` is off.
+    const ifModifiedSince = req.headers["if-none-match"]
+        ? undefined
+        : httpDate((0, util_1.firstValue)(req.headers["if-modified-since"]));
+    const range = req.headers["if-range"]
+        ? undefined
+        : (0, util_1.firstValue)(req.headers.range);
+    let object;
+    try {
+        object = await (0, util_1.s3Client)().send(req.method === "HEAD"
+            ? new client_s3_1.HeadObjectCommand({
+                Bucket: file.bucket,
+                Key: key,
+                IfNoneMatch: ifNoneMatch,
+                IfModifiedSince: ifModifiedSince,
+                Range: range,
+            })
+            : new client_s3_1.GetObjectCommand({
+                Bucket: file.bucket,
+                Key: key,
+                IfNoneMatch: ifNoneMatch,
+                IfModifiedSince: ifModifiedSince,
+                Range: range,
+            }));
+    }
+    catch (error) {
+        const status = error
+            .$metadata?.httpStatusCode;
+        if (status === 304) {
+            if (!res.getHeader("Cache-Control")) {
+                res.setHeader("Cache-Control", "public, max-age=0");
+            }
+            // The object's own, not the client's `If-None-Match`, which can be a
+            // list or `*`.
+            const etag = error.$response?.headers?.etag;
+            if (etag)
+                res.setHeader("ETag", etag);
+            res.statusCode = 304;
+            res.end();
+            return true;
+        }
+        if (status === 416) {
+            // S3's `InvalidRange`. `send` adds `Content-Range: bytes */<size>`, which
+            // S3's error does not carry; the status is what a client acts on.
+            res.statusCode = 416;
+            res.setHeader("Accept-Ranges", "bytes");
+            res.end();
+            return true;
+        }
+        const name = error?.name;
+        if (status === 404 || name === "NoSuchKey" || name === "NotFound") {
+            return false;
+        }
+        throw error;
+    }
+    if (!res.getHeader("Content-Type") && object.ContentType) {
+        res.setHeader("Content-Type", object.ContentType);
+    }
+    if (!res.getHeader("Cache-Control")) {
+        res.setHeader("Cache-Control", object.CacheControl || "public, max-age=0");
+    }
+    if (object.AcceptRanges)
+        res.setHeader("Accept-Ranges", object.AcceptRanges);
+    if (object.ContentRange) {
+        res.statusCode = 206;
+        res.setHeader("Content-Range", object.ContentRange);
+    }
+    if (file.etag && object.ETag)
+        res.setHeader("ETag", object.ETag);
+    if (object.LastModified) {
+        res.setHeader("Last-Modified", object.LastModified.toUTCString());
+    }
+    if (object.ContentLength !== undefined) {
+        res.setHeader("Content-Length", String(object.ContentLength));
+    }
+    const body = object.Body;
+    if (req.method === "HEAD" || !body) {
+        res.end();
+        return true;
+    }
+    const stream = body instanceof node_stream_1.Readable
+        ? body
+        : node_stream_1.Readable.from(body);
+    try {
+        for await (const chunk of stream) {
+            if (!res.write(chunk) && !(await (0, util_1.drained)(res))) {
+                // The client went away; the rest of the object is not wanted.
+                return true;
+            }
+        }
+        res.end();
+    }
+    finally {
+        // A no-op once fully read; otherwise it releases the S3 connection.
+        stream.destroy();
+    }
+    return true;
+}
+/** An HTTP date, or `undefined` for one that does not parse, as `fresh` treats it. */
+function httpDate(value) {
+    const date = value ? new Date(value) : undefined;
+    return date && !Number.isNaN(date.getTime()) ? date : undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"static-files.js","sourceRoot":"","sources":["../../src/runtime/static-files.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Serving the static files that nothing in front of the compute answers.\n *\n * `NextjsStaticAssets` uploads `<distDir>/static` and `public` to S3, and\n * CloudFront / API Gateway route a file's own URL there — except on\n * `NextjsRegionalContainers`, which has nothing in front of it. What still\n * reaches the runtime is a file some *other* URL lands on: a `rewrites` entry\n * or a middleware rewrite onto `/maintenance.html`, `/en-US/robots.txt` in an\n * i18n app. The `NextjsRegionalContainers` image copies `public` and\n * `<distDir>/static` in and serves them off disk; the other types carry\n * neither, so a `public/` file is streamed from the assets bucket instead\n * ({@link serveS3PublicFile}).\n * Everything else in `manifest.staticFiles` lives under `<distDir>/server` —\n * `404.html`, `500.html`, `favicon.ico.body`, fully-static Pages Router HTML —\n * and reaches us, exactly as it reaches `next start`.\n *\n * Next.js's own `serveStatic` is used rather than a `createReadStream`, because it\n * is `send` underneath and that brings conditional requests (`If-None-Match`,\n * `If-Modified-Since`), `Range`, `ETag`, `Last-Modified`, and content-type\n * detection. Reimplementing those is how a \"simple\" file server ends up\n * disagreeing with `next start` on a 304.\n */\n/* eslint-disable import/no-extraneous-dependencies */\nimport { extname } from \"node:path\";\nimport { Readable } from \"node:stream\";\nimport {\n  GetObjectCommand,\n  GetObjectCommandOutput,\n  HeadObjectCommand,\n} from \"@aws-sdk/client-s3\";\nimport type { ShimIncomingMessage } from \"./http/request\";\nimport { asServerResponse, ShimServerResponse } from \"./http/response\";\nimport { nextModule } from \"./next-modules\";\nimport { drained, firstValue, s3Client } from \"./util\";\n\nconst SERVE_STATIC = \"next/dist/server/serve-static.js\";\ntype ServeStaticModule = typeof import(\"next/dist/server/serve-static.js\");\n\n/** Resolved on the first static-file request; see {@link nextModule}. */\nlet serveStaticModule: ServeStaticModule | undefined;\n\n/**\n * Returns `false` when the file is not in the deployment package, which is the\n * caller's cue to fall through to a 404.\n *\n * That happens by design on every type but `NextjsRegionalContainers`, for `<distDir>/static` and\n * `public/` alike: neither is staged, being a second copy of bytes already in\n * S3. A `public/` file is then served by {@link serveS3PublicFile}; a\n * `<distDir>/static` one only gets here through a rewrite onto it, and is a 404.\n * The `NextjsRegionalContainers` image copies both in, so there they are found.\n */\nexport async function serveStaticFile(\n  req: ShimIncomingMessage,\n  res: ShimServerResponse,\n  deploymentRoot: string,\n  filePath: string,\n  options: { readonly etag: boolean },\n): Promise<boolean> {\n  serveStaticModule ??= nextModule<ServeStaticModule>(SERVE_STATIC);\n  const { serveStatic, getContentType } = serveStaticModule;\n  setBodyFileContentType(res, filePath, getContentType);\n  try {\n    // Encoded, and relative to a `root`, which is how `next start` calls it:\n    // `send` percent-decodes whatever path it is handed, as though it were a\n    // URL. A raw filesystem path broke on any file name with a `%` in it —\n    // `100%.png` failed to decode and answered an empty 400, and `a%20b.txt`\n    // was looked up as `a b.txt`, serving a different file if there was one.\n    await serveStatic(\n      req as unknown as Parameters<typeof serveStatic>[0],\n      asServerResponse(res),\n      `/${filePath.split(\"/\").map(encodeURIComponent).join(\"/\")}`,\n      { root: deploymentRoot, etag: options.etag },\n    );\n    return true;\n  } catch (error) {\n    if (isMissingFile(error)) {\n      return false;\n    }\n    const status = httpErrorStatus(error);\n    // `send` emits its error before the first byte, so the head is still ours to\n    // set; the guard is only for a shell that already committed one.\n    if (status !== undefined && !res.headersSent) {\n      res.statusCode = status;\n      res.end();\n      return true;\n    }\n    throw error;\n  }\n}\n\n/**\n * The status a `send` error carries, for the errors that are the *client's*, not\n * ours.\n *\n * `serveStatic` is `send` underneath, and `send` rejects a failed precondition\n * with a 412 and an unsatisfiable `Range` with a 416 — both attached to the error\n * as `statusCode`. `next start` maps them back onto the response\n * (`next/dist/server/lib/router-server.js` special-cases 400/412/416); letting\n * them fall through to the caller's error path (`NextjsRuntime.sendError`, which\n * answers 500 with the app's error page) instead turned `If-Match: \"stale\"` into\n * a 500 and `Range: bytes=99999-` into a 500.\n *\n * Only 4xx is honored: a 5xx from `send` is a real failure and belongs in the\n * error path, with the stack.\n */\nfunction httpErrorStatus(error: unknown): number | undefined {\n  const status = (error as { statusCode?: unknown } | null)?.statusCode;\n  if (typeof status === \"number\" && status >= 400 && status < 500) {\n    return status;\n  }\n  return undefined;\n}\n\n/**\n * `send` types a response from the file's own extension, and a static metadata\n * route ships as `<route>.body` — `robots.txt.body`, `manifest.webmanifest.body`,\n * `favicon.ico.body`. `.body` is not a media type, so every one of them would go\n * out as `application/octet-stream`.\n *\n * Next.js's adapter API is where the type is lost: `build-complete.ts` pushes\n * these through `isStaticMetadataFile()` as a bare `STATIC_FILE` — `id`,\n * `pathname`, `filePath`, and nothing else — while the headers the route handler\n * actually set sit unreferenced in a sibling `<route>.meta`. `next start` reads\n * that file through the response cache and answers `text/plain`.\n *\n * Stripping `.body` puts the route's own extension back on the end, which for\n * this population is the same answer: the set is closed (`favicon.ico`, `icon.*`,\n * `apple-icon.*`, `opengraph-image.*`, `twitter-image.*`, `sitemap.xml`,\n * `robots.txt`, `manifest.{json,webmanifest}`) and every member's type is implied\n * by its extension. `send` skips its own detection when `Content-Type` is already\n * set (`send/index.js`, `type()`), so this wins without reaching for `opts`.\n */\nfunction setBodyFileContentType(\n  res: ShimServerResponse,\n  filePath: string,\n  getContentType: ServeStaticModule[\"getContentType\"],\n): void {\n  if (!filePath.endsWith(\".body\") || res.getHeader(\"Content-Type\")) {\n    return;\n  }\n  const ext = extname(filePath.slice(0, -\".body\".length)).slice(1);\n  if (!ext) {\n    return;\n  }\n  const contentType = getContentType(ext);\n  if (contentType) {\n    res.setHeader(\"Content-Type\", contentType);\n  }\n}\n\nfunction isMissingFile(error: unknown): boolean {\n  const code = (error as { code?: string } | null)?.code;\n  // ENOENT covers a missing file and `send`'s \"No directory access\"; ENOTDIR is\n  // what a path segment that exists as a file produces.\n  return code === \"ENOENT\" || code === \"ENOTDIR\";\n}\n\n/** Where a type without `public/` on disk finds a file it does not carry. */\nexport interface S3PublicFile {\n  /** `CDK_NEXTJS_STATIC_ASSETS_BUCKET_NAME`. */\n  readonly bucket: string;\n  /**\n   * `NextjsStaticAssets.keyPrefix`, without a leading slash; empty for a\n   * bucket-root deployment. `public/` is uploaded to the root of it.\n   */\n  readonly keyPrefix: string;\n  /** The file's path relative to `public/`, unencoded: its real name. */\n  readonly file: string;\n  readonly etag: boolean;\n}\n\n/**\n * A `public/` file from the assets bucket, for the types whose deployment\n * roots list `public/` without carrying it. Returns `false` when the object is not there,\n * which is the caller's cue to fall through to a 404 as for a file missing from\n * disk.\n *\n * What `send` would have answered, as far as S3 can say it: the object's\n * `Content-Type`, `Content-Length`, `Last-Modified` and — unless\n * `generateEtags` is off — `ETag`; a 304 for a matching `If-None-Match` or, as\n * `fresh` has it, an `If-Modified-Since` without one; and a 206 or 416 for a\n * `Range`. S3 evaluates all of them itself.\n *\n * `Cache-Control` is, in order: a `headers()` rule's, the object's own\n * `CacheControl` metadata — what the edge serves the file's own URL with, so a\n * rewrite onto it caches the same way — and `send`'s default,\n * `public, max-age=0`.\n *\n * `If-Range` is not evaluated, because S3 has no counterpart: with one present\n * the `Range` is dropped and the whole file sent with a 200, which RFC 9110\n * allows (a server may ignore `Range`) and a range client accepts.\n */\nexport async function serveS3PublicFile(\n  req: ShimIncomingMessage,\n  res: ShimServerResponse,\n  file: S3PublicFile,\n): Promise<boolean> {\n  const prefix = file.keyPrefix.replace(/^\\/+|\\/+$/g, \"\");\n  const key = prefix ? `${prefix}/${file.file}` : file.file;\n  const ifNoneMatch = file.etag\n    ? firstValue(req.headers[\"if-none-match\"])\n    : undefined;\n  // `fresh` ignores it next to an `If-None-Match`, even one it cannot match\n  // because `generateEtags` is off.\n  const ifModifiedSince = req.headers[\"if-none-match\"]\n    ? undefined\n    : httpDate(firstValue(req.headers[\"if-modified-since\"]));\n  const range = req.headers[\"if-range\"]\n    ? undefined\n    : firstValue(req.headers.range);\n  let object: Omit<GetObjectCommandOutput, \"Body\"> & { Body?: unknown };\n  try {\n    object = await s3Client().send(\n      req.method === \"HEAD\"\n        ? new HeadObjectCommand({\n            Bucket: file.bucket,\n            Key: key,\n            IfNoneMatch: ifNoneMatch,\n            IfModifiedSince: ifModifiedSince,\n            Range: range,\n          })\n        : new GetObjectCommand({\n            Bucket: file.bucket,\n            Key: key,\n            IfNoneMatch: ifNoneMatch,\n            IfModifiedSince: ifModifiedSince,\n            Range: range,\n          }),\n    );\n  } catch (error) {\n    const status = (error as { $metadata?: { httpStatusCode?: number } })\n      .$metadata?.httpStatusCode;\n    if (status === 304) {\n      if (!res.getHeader(\"Cache-Control\")) {\n        res.setHeader(\"Cache-Control\", \"public, max-age=0\");\n      }\n      // The object's own, not the client's `If-None-Match`, which can be a\n      // list or `*`.\n      const etag = (\n        error as { $response?: { headers?: Record<string, string> } }\n      ).$response?.headers?.etag;\n      if (etag) res.setHeader(\"ETag\", etag);\n      res.statusCode = 304;\n      res.end();\n      return true;\n    }\n    if (status === 416) {\n      // S3's `InvalidRange`. `send` adds `Content-Range: bytes */<size>`, which\n      // S3's error does not carry; the status is what a client acts on.\n      res.statusCode = 416;\n      res.setHeader(\"Accept-Ranges\", \"bytes\");\n      res.end();\n      return true;\n    }\n    const name = (error as { name?: string } | null)?.name;\n    if (status === 404 || name === \"NoSuchKey\" || name === \"NotFound\") {\n      return false;\n    }\n    throw error;\n  }\n\n  if (!res.getHeader(\"Content-Type\") && object.ContentType) {\n    res.setHeader(\"Content-Type\", object.ContentType);\n  }\n  if (!res.getHeader(\"Cache-Control\")) {\n    res.setHeader(\"Cache-Control\", object.CacheControl || \"public, max-age=0\");\n  }\n  if (object.AcceptRanges) res.setHeader(\"Accept-Ranges\", object.AcceptRanges);\n  if (object.ContentRange) {\n    res.statusCode = 206;\n    res.setHeader(\"Content-Range\", object.ContentRange);\n  }\n  if (file.etag && object.ETag) res.setHeader(\"ETag\", object.ETag);\n  if (object.LastModified) {\n    res.setHeader(\"Last-Modified\", object.LastModified.toUTCString());\n  }\n  if (object.ContentLength !== undefined) {\n    res.setHeader(\"Content-Length\", String(object.ContentLength));\n  }\n  const body = object.Body;\n  if (req.method === \"HEAD\" || !body) {\n    res.end();\n    return true;\n  }\n  const stream =\n    body instanceof Readable\n      ? body\n      : Readable.from(body as AsyncIterable<Uint8Array>);\n  try {\n    for await (const chunk of stream) {\n      if (!res.write(chunk) && !(await drained(res))) {\n        // The client went away; the rest of the object is not wanted.\n        return true;\n      }\n    }\n    res.end();\n  } finally {\n    // A no-op once fully read; otherwise it releases the S3 connection.\n    stream.destroy();\n  }\n  return true;\n}\n\n/** An HTTP date, or `undefined` for one that does not parse, as `fresh` treats it. */\nfunction httpDate(value: string | undefined): Date | undefined {\n  const date = value ? new Date(value) : undefined;\n  return date && !Number.isNaN(date.getTime()) ? date : undefined;\n}\n"]}

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

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

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

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable import/no-extraneous-dependencies */
+const node_stream_1 = require("node:stream");
+const client_s3_1 = require("@aws-sdk/client-s3");
+const request_1 = require("./http/request");
+const response_1 = require("./http/response");
+const static_files_1 = require("./static-files");
+const send$ = jest.spyOn(client_s3_1.S3Client.prototype, "send");
+afterEach(() => send$.mockReset());
+afterAll(() => send$.mockRestore());
+const FILE = { bucket: "assets", keyPrefix: "", file: "big.bin", etag: true };
+function serve(method, res = new response_1.ShimServerResponse(), headers = {}, file = FILE) {
+    const req = new request_1.ShimIncomingMessage({ method, url: "/big.bin", headers });
+    return { res, served: (0, static_files_1.serveS3PublicFile)(req, res, file) };
+}
+/** Chunks bigger than the response's buffer, so every write is refused. */
+const CHUNK = Buffer.alloc(64 * 1024, "a");
+describe("serveS3PublicFile", () => {
+    it("asks S3 for the head alone for a HEAD, and sends no body", async () => {
+        send$.mockImplementation((async () => ({
+            ContentType: "application/octet-stream",
+            ContentLength: 3,
+            ETag: '"e1"',
+        })));
+        const { res, served } = serve("HEAD");
+        const chunks = [];
+        res.on("data", (chunk) => chunks.push(chunk));
+        expect(await served).toBe(true);
+        expect(send$.mock.calls[0][0]).toBeInstanceOf(client_s3_1.HeadObjectCommand);
+        expect(res.getHeader("Content-Length")).toBe("3");
+        expect(res.getHeader("ETag")).toBe('"e1"');
+        expect(res.writableEnded).toBe(true);
+        expect(Buffer.concat(chunks).length).toBe(0);
+    });
+    // `generateEtags: false`: no ETag to revalidate with, only Last-Modified.
+    it("answers If-Modified-Since with a 304, as send does", async () => {
+        send$.mockImplementation((async () => {
+            throw Object.assign(new Error("Not Modified"), {
+                $metadata: { httpStatusCode: 304 },
+            });
+        }));
+        const since = "Wed, 21 Oct 2015 07:28:00 GMT";
+        const { res, served } = serve("GET", undefined, { "if-modified-since": since }, { ...FILE, etag: false });
+        expect(await served).toBe(true);
+        expect(res.statusCode).toBe(304);
+        const input = send$.mock.calls[0][0].input;
+        expect(input.IfModifiedSince).toEqual(new Date(since));
+        expect(input.IfNoneMatch).toBeUndefined();
+    });
+    // The 304's ETag is the object's, not the client's list of candidates.
+    it.each([
+        ["the object's ETag", { headers: { etag: '"e1"' } }, '"e1"'],
+        ["no ETag without one", undefined, undefined],
+    ])("answers an If-None-Match list with %s", async (_, $response, etag) => {
+        send$.mockImplementation((async () => {
+            throw Object.assign(new Error("Not Modified"), {
+                $metadata: { httpStatusCode: 304 },
+                $response,
+            });
+        }));
+        const { res, served } = serve("GET", undefined, {
+            "if-none-match": '"e0", "e1"',
+        });
+        expect(await served).toBe(true);
+        expect(res.statusCode).toBe(304);
+        expect(res.getHeader("ETag")).toBe(etag);
+    });
+    // `fresh` ignores If-Modified-Since next to an If-None-Match.
+    it("leaves If-Modified-Since out next to an If-None-Match", async () => {
+        send$.mockImplementation((async () => ({})));
+        await serve("HEAD", undefined, {
+            "if-none-match": '"e1"',
+            "if-modified-since": "Wed, 21 Oct 2015 07:28:00 GMT",
+        }).served;
+        const input = send$.mock.calls[0][0].input;
+        expect(input.IfNoneMatch).toBe('"e1"');
+        expect(input.IfModifiedSince).toBeUndefined();
+    });
+    it("rethrows an S3 error that is not a missing object", async () => {
+        send$.mockImplementation((async () => {
+            throw Object.assign(new Error("Access Denied"), {
+                name: "AccessDenied",
+                $metadata: { httpStatusCode: 403 },
+            });
+        }));
+        await expect(serve("GET").served).rejects.toThrow("Access Denied");
+    });
+    it("waits for the client to drain before reading more of the object", async () => {
+        send$.mockImplementation((async () => ({
+            Body: node_stream_1.Readable.from([CHUNK, CHUNK, CHUNK]),
+        })));
+        const { res, served } = serve("GET");
+        expect(send$.mock.calls[0][0]).toBeInstanceOf(client_s3_1.GetObjectCommand);
+        // Nothing reads the response yet, so the first write is refused and the
+        // rest of the object waits.
+        await new Promise((resolve) => setImmediate(resolve));
+        expect(res.writableEnded).toBe(false);
+        let received = 0;
+        res.on("data", (chunk) => (received += chunk.length));
+        expect(await served).toBe(true);
+        expect(res.writableEnded).toBe(true);
+        await new Promise((resolve) => res.once("end", resolve));
+        expect(received).toBe(3 * CHUNK.length);
+    });
+    it("stops reading the object when the client disconnects", async () => {
+        const body = node_stream_1.Readable.from([CHUNK, CHUNK, CHUNK]);
+        send$.mockImplementation((async () => ({ Body: body })));
+        const { res, served } = serve("GET");
+        await new Promise((resolve) => setImmediate(resolve));
+        res.destroy();
+        expect(await served).toBe(true);
+        expect(res.writableEnded).toBe(false);
+        // Destroyed, which is what releases the S3 connection.
+        expect(body.destroyed).toBe(true);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"static-files.test.js","sourceRoot":"","sources":["../../src/runtime/static-files.test.ts"],"names":[],"mappings":";;AAAA,sDAAsD;AACtD,6CAAuC;AACvC,kDAI4B;AAC5B,4CAAqD;AACrD,8CAAqD;AACrD,iDAAmD;AAEnD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,oBAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;AACrD,SAAS,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC,CAAC;AACnC,QAAQ,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,CAAC;AAEpC,MAAM,IAAI,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;AAE9E,SAAS,KAAK,CACZ,MAAc,EACd,GAAG,GAAG,IAAI,6BAAkB,EAAE,EAC9B,UAAkC,EAAE,EACpC,IAAI,GAAG,IAAI;IAEX,MAAM,GAAG,GAAG,IAAI,6BAAmB,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,UAAU,EAAE,OAAO,EAAE,CAAC,CAAC;IAC1E,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,IAAA,gCAAiB,EAAC,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,EAAE,CAAC;AAC5D,CAAC;AAED,2EAA2E;AAC3E,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,EAAE,GAAG,IAAI,EAAE,GAAG,CAAC,CAAC;AAE3C,QAAQ,CAAC,mBAAmB,EAAE,GAAG,EAAE;IACjC,EAAE,CAAC,0DAA0D,EAAE,KAAK,IAAI,EAAE;QACxE,KAAK,CAAC,kBAAkB,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC;YACrC,WAAW,EAAE,0BAA0B;YACvC,aAAa,EAAE,CAAC;YAChB,IAAI,EAAE,MAAM;SACb,CAAC,CAAU,CAAC,CAAC;QACd,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC;QACtC,MAAM,MAAM,GAAa,EAAE,CAAC;QAC5B,GAAG,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,KAAa,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;QACtD,MAAM,CAAC,MAAM,MAAM,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAChC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,6BAAiB,CAAC,CAAC;QACjE,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAClD,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC3C,MAAM,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACrC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAC/C,CAAC,CAAC,CAAC;IAEH,0EAA0E;IAC1E,EAAE,CAAC,oDAAoD,EAAE,KAAK,IAAI,EAAE;QAClE,KAAK,CAAC,kBAAkB,CAAC,CAAC,KAAK,IAAI,EAAE;YACnC,MAAM,MAAM,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,cAAc,CAAC,EAAE;gBAC7C,SAAS,EAAE,EAAE,cAAc,EAAE,GAAG,EAAE;aACnC,CAAC,CAAC;QACL,CAAC,CAAU,CAAC,CAAC;QACb,MAAM,KAAK,GAAG,+BAA+B,CAAC;QAC9C,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,KAAK,CAC3B,KAAK,EACL,SAAS,EACT,EAAE,mBAAmB,EAAE,KAAK,EAAE,EAC9B,EAAE,GAAG,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,CACzB,CAAC;QACF,MAAM,CAAC,MAAM,MAAM,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAChC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACjC,MAAM,KAAK,GAAI,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAsB,CAAC,KAAK,CAAC;QACjE,MAAM,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;QACvD,MAAM,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,aAAa,EAAE,CAAC;IAC5C,CAAC,CAAC,CAAC;IAEH,uEAAuE;IACvE,EAAE,CAAC,IAAI,CAAC;QACN,CAAC,mBAAmB,EAAE,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,CAAC;QAC5D,CAAC,qBAAqB,EAAE,SAAS,EAAE,SAAS,CAAC;KAC9C,CAAC,CAAC,uCAAuC,EAAE,KAAK,EAAE,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,EAAE;QACvE,KAAK,CAAC,kBAAkB,CAAC,CAAC,KAAK,IAAI,EAAE;YACnC,MAAM,MAAM,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,cAAc,CAAC,EAAE;gBAC7C,SAAS,EAAE,EAAE,cAAc,EAAE,GAAG,EAAE;gBAClC,SAAS;aACV,CAAC,CAAC;QACL,CAAC,CAAU,CAAC,CAAC;QACb,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC,KAAK,EAAE,SAAS,EAAE;YAC9C,eAAe,EAAE,YAAY;SAC9B,CAAC,CAAC;QACH,MAAM,CAAC,MAAM,MAAM,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAChC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACjC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC3C,CAAC,CAAC,CAAC;IAEH,8DAA8D;IAC9D,EAAE,CAAC,uDAAuD,EAAE,KAAK,IAAI,EAAE;QACrE,KAAK,CAAC,kBAAkB,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,CAAU,CAAC,CAAC;QACtD,MAAM,KAAK,CAAC,MAAM,EAAE,SAAS,EAAE;YAC7B,eAAe,EAAE,MAAM;YACvB,mBAAmB,EAAE,+BAA+B;SACrD,CAAC,CAAC,MAAM,CAAC;QACV,MAAM,KAAK,GAAI,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAuB,CAAC,KAAK,CAAC;QAClE,MAAM,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACvC,MAAM,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC,aAAa,EAAE,CAAC;IAChD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,mDAAmD,EAAE,KAAK,IAAI,EAAE;QACjE,KAAK,CAAC,kBAAkB,CAAC,CAAC,KAAK,IAAI,EAAE;YACnC,MAAM,MAAM,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,eAAe,CAAC,EAAE;gBAC9C,IAAI,EAAE,cAAc;gBACpB,SAAS,EAAE,EAAE,cAAc,EAAE,GAAG,EAAE;aACnC,CAAC,CAAC;QACL,CAAC,CAAU,CAAC,CAAC;QACb,MAAM,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC;IACrE,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,iEAAiE,EAAE,KAAK,IAAI,EAAE;QAC/E,KAAK,CAAC,kBAAkB,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC;YACrC,IAAI,EAAE,sBAAQ,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;SAC3C,CAAC,CAAU,CAAC,CAAC;QACd,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;QACrC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,4BAAgB,CAAC,CAAC;QAChE,wEAAwE;QACxE,4BAA4B;QAC5B,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC;QACtD,MAAM,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAEtC,IAAI,QAAQ,GAAG,CAAC,CAAC;QACjB,GAAG,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,KAAa,EAAE,EAAE,CAAC,CAAC,QAAQ,IAAI,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;QAC9D,MAAM,CAAC,MAAM,MAAM,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAChC,MAAM,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACrC,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC;QACzD,MAAM,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC;IAC1C,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,sDAAsD,EAAE,KAAK,IAAI,EAAE;QACpE,MAAM,IAAI,GAAG,sBAAQ,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;QAClD,KAAK,CAAC,kBAAkB,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAU,CAAC,CAAC;QAClE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;QACrC,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC;QACtD,GAAG,CAAC,OAAO,EAAE,CAAC;QACd,MAAM,CAAC,MAAM,MAAM,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAChC,MAAM,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACtC,uDAAuD;QACvD,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACpC,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC","sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\nimport { Readable } from \"node:stream\";\nimport {\n  GetObjectCommand,\n  HeadObjectCommand,\n  S3Client,\n} from \"@aws-sdk/client-s3\";\nimport { ShimIncomingMessage } from \"./http/request\";\nimport { ShimServerResponse } from \"./http/response\";\nimport { serveS3PublicFile } from \"./static-files\";\n\nconst send$ = jest.spyOn(S3Client.prototype, \"send\");\nafterEach(() => send$.mockReset());\nafterAll(() => send$.mockRestore());\n\nconst FILE = { bucket: \"assets\", keyPrefix: \"\", file: \"big.bin\", etag: true };\n\nfunction serve(\n  method: string,\n  res = new ShimServerResponse(),\n  headers: Record<string, string> = {},\n  file = FILE,\n) {\n  const req = new ShimIncomingMessage({ method, url: \"/big.bin\", headers });\n  return { res, served: serveS3PublicFile(req, res, file) };\n}\n\n/** Chunks bigger than the response's buffer, so every write is refused. */\nconst CHUNK = Buffer.alloc(64 * 1024, \"a\");\n\ndescribe(\"serveS3PublicFile\", () => {\n  it(\"asks S3 for the head alone for a HEAD, and sends no body\", async () => {\n    send$.mockImplementation((async () => ({\n      ContentType: \"application/octet-stream\",\n      ContentLength: 3,\n      ETag: '\"e1\"',\n    })) as never);\n    const { res, served } = serve(\"HEAD\");\n    const chunks: Buffer[] = [];\n    res.on(\"data\", (chunk: Buffer) => chunks.push(chunk));\n    expect(await served).toBe(true);\n    expect(send$.mock.calls[0][0]).toBeInstanceOf(HeadObjectCommand);\n    expect(res.getHeader(\"Content-Length\")).toBe(\"3\");\n    expect(res.getHeader(\"ETag\")).toBe('\"e1\"');\n    expect(res.writableEnded).toBe(true);\n    expect(Buffer.concat(chunks).length).toBe(0);\n  });\n\n  // `generateEtags: false`: no ETag to revalidate with, only Last-Modified.\n  it(\"answers If-Modified-Since with a 304, as send does\", async () => {\n    send$.mockImplementation((async () => {\n      throw Object.assign(new Error(\"Not Modified\"), {\n        $metadata: { httpStatusCode: 304 },\n      });\n    }) as never);\n    const since = \"Wed, 21 Oct 2015 07:28:00 GMT\";\n    const { res, served } = serve(\n      \"GET\",\n      undefined,\n      { \"if-modified-since\": since },\n      { ...FILE, etag: false },\n    );\n    expect(await served).toBe(true);\n    expect(res.statusCode).toBe(304);\n    const input = (send$.mock.calls[0][0] as GetObjectCommand).input;\n    expect(input.IfModifiedSince).toEqual(new Date(since));\n    expect(input.IfNoneMatch).toBeUndefined();\n  });\n\n  // The 304's ETag is the object's, not the client's list of candidates.\n  it.each([\n    [\"the object's ETag\", { headers: { etag: '\"e1\"' } }, '\"e1\"'],\n    [\"no ETag without one\", undefined, undefined],\n  ])(\"answers an If-None-Match list with %s\", async (_, $response, etag) => {\n    send$.mockImplementation((async () => {\n      throw Object.assign(new Error(\"Not Modified\"), {\n        $metadata: { httpStatusCode: 304 },\n        $response,\n      });\n    }) as never);\n    const { res, served } = serve(\"GET\", undefined, {\n      \"if-none-match\": '\"e0\", \"e1\"',\n    });\n    expect(await served).toBe(true);\n    expect(res.statusCode).toBe(304);\n    expect(res.getHeader(\"ETag\")).toBe(etag);\n  });\n\n  // `fresh` ignores If-Modified-Since next to an If-None-Match.\n  it(\"leaves If-Modified-Since out next to an If-None-Match\", async () => {\n    send$.mockImplementation((async () => ({})) as never);\n    await serve(\"HEAD\", undefined, {\n      \"if-none-match\": '\"e1\"',\n      \"if-modified-since\": \"Wed, 21 Oct 2015 07:28:00 GMT\",\n    }).served;\n    const input = (send$.mock.calls[0][0] as HeadObjectCommand).input;\n    expect(input.IfNoneMatch).toBe('\"e1\"');\n    expect(input.IfModifiedSince).toBeUndefined();\n  });\n\n  it(\"rethrows an S3 error that is not a missing object\", async () => {\n    send$.mockImplementation((async () => {\n      throw Object.assign(new Error(\"Access Denied\"), {\n        name: \"AccessDenied\",\n        $metadata: { httpStatusCode: 403 },\n      });\n    }) as never);\n    await expect(serve(\"GET\").served).rejects.toThrow(\"Access Denied\");\n  });\n\n  it(\"waits for the client to drain before reading more of the object\", async () => {\n    send$.mockImplementation((async () => ({\n      Body: Readable.from([CHUNK, CHUNK, CHUNK]),\n    })) as never);\n    const { res, served } = serve(\"GET\");\n    expect(send$.mock.calls[0][0]).toBeInstanceOf(GetObjectCommand);\n    // Nothing reads the response yet, so the first write is refused and the\n    // rest of the object waits.\n    await new Promise((resolve) => setImmediate(resolve));\n    expect(res.writableEnded).toBe(false);\n\n    let received = 0;\n    res.on(\"data\", (chunk: Buffer) => (received += chunk.length));\n    expect(await served).toBe(true);\n    expect(res.writableEnded).toBe(true);\n    await new Promise((resolve) => res.once(\"end\", resolve));\n    expect(received).toBe(3 * CHUNK.length);\n  });\n\n  it(\"stops reading the object when the client disconnects\", async () => {\n    const body = Readable.from([CHUNK, CHUNK, CHUNK]);\n    send$.mockImplementation((async () => ({ Body: body })) as never);\n    const { res, served } = serve(\"GET\");\n    await new Promise((resolve) => setImmediate(resolve));\n    res.destroy();\n    expect(await served).toBe(true);\n    expect(res.writableEnded).toBe(false);\n    // Destroyed, which is what releases the S3 connection.\n    expect(body.destroyed).toBe(true);\n  });\n});\n"]}

package/lib/runtime/util.d.ts

@@ -0,0 +1,28 @@
+/** Small helpers more than one runtime module needs. */
+import { S3Client } from "@aws-sdk/client-s3";
+import type { ShimServerResponse } from "./http/response";
+/** The first of a repeated header, or the header. */
+export declare function firstValue(value: string | string[] | undefined): string | undefined;
+/**
+ * `removePathPrefix` (`next/dist/shared/lib/router/utils/remove-path-prefix.js`):
+ * strips `prefix` on a path boundary only, so `/docsearch` is not under `/docs`.
+ * An absolute-URL `assetPrefix` never matches a pathname, so it is a no-op
+ * there, as it is in Next.
+ */
+export declare function withoutPathPrefix(pathname: string, prefix: string): string;
+/**
+ * A query back into a query string, repeats and all. A key with no value — an
+ * optional catch-all the request left unset — is left out rather than sent as
+ * `undefined`.
+ */
+export declare function toSearch(query: Readonly<Record<string, string | string[] | undefined>>): string;
+/**
+ * `decodeURIComponent`, or `value` as given when it isn't valid
+ * percent-encoding, which is what a literal `%` in a path segment or filename
+ * looks like (`/100%.png`).
+ */
+export declare function safeDecode(value: string): string;
+/** Resolves `true` on `drain`, `false` if the response closes first. */
+export declare function drained(res: ShimServerResponse): Promise<boolean>;
+/** The one S3 client, for the image optimizer and `public/` files alike. */
+export declare function s3Client(): S3Client;

package/lib/runtime/util.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.firstValue = firstValue;
+exports.withoutPathPrefix = withoutPathPrefix;
+exports.toSearch = toSearch;
+exports.safeDecode = safeDecode;
+exports.drained = drained;
+exports.s3Client = s3Client;
+/* eslint-disable import/no-extraneous-dependencies */
+/** Small helpers more than one runtime module needs. */
+const client_s3_1 = require("@aws-sdk/client-s3");
+const base_path_1 = require("../utils/base-path");
+/** The first of a repeated header, or the header. */
+function firstValue(value) {
+    return Array.isArray(value) ? value[0] : value;
+}
+/**
+ * `removePathPrefix` (`next/dist/shared/lib/router/utils/remove-path-prefix.js`):
+ * strips `prefix` on a path boundary only, so `/docsearch` is not under `/docs`.
+ * An absolute-URL `assetPrefix` never matches a pathname, so it is a no-op
+ * there, as it is in Next.
+ */
+function withoutPathPrefix(pathname, prefix) {
+    if (!(0, base_path_1.hasPathPrefix)(pathname, prefix)) {
+        return pathname;
+    }
+    return pathname.slice(prefix.length) || "/";
+}
+/**
+ * A query back into a query string, repeats and all. A key with no value — an
+ * optional catch-all the request left unset — is left out rather than sent as
+ * `undefined`.
+ */
+function toSearch(query) {
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(query)) {
+        for (const item of Array.isArray(value) ? value : [value]) {
+            if (item !== undefined)
+                search.append(key, item);
+        }
+    }
+    return search.toString();
+}
+/**
+ * `decodeURIComponent`, or `value` as given when it isn't valid
+ * percent-encoding, which is what a literal `%` in a path segment or filename
+ * looks like (`/100%.png`).
+ */
+function safeDecode(value) {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+}
+/** Resolves `true` on `drain`, `false` if the response closes first. */
+function drained(res) {
+    if (res.destroyed)
+        return Promise.resolve(false);
+    return new Promise((resolve) => {
+        const onDrain = () => settle(true);
+        const onClose = () => settle(false);
+        const settle = (value) => {
+            res.off("drain", onDrain);
+            res.off("close", onClose);
+            resolve(value);
+        };
+        res.once("drain", onDrain);
+        res.once("close", onClose);
+    });
+}
+let s3;
+/** The one S3 client, for the image optimizer and `public/` files alike. */
+function s3Client() {
+    s3 ??= new client_s3_1.S3Client({});
+    return s3;
+}
+//# sourceMappingURL=data:application/json;base64,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