cdk-nextjs 0.5.15 → 0.6.0

package/docs/plans/phase-0-image-function-opt-in.md

@@ -0,0 +1,295 @@
+# Phase 0 — Make the dedicated image optimization Lambda opt-in
+
+Handoff plan. Self-contained; assumes no context from the session that wrote it.
+
+## Goal
+
+Land the `feat-nextjs-img-opt` branch **with zero breaking changes** by making the
+dedicated image optimization Lambda opt-in (`dedicatedImageFunction`, default
+`false`). The default stays what `main` does today: `_next/image` is served by the
+Next.js server function.
+
+## Why
+
+The branch currently routes `_next/image` to a dedicated Lambda unconditionally.
+That Lambda is not the Next.js server, so **Next.js middleware no longer runs for
+image requests** — a real breaking change for anyone whose middleware matcher
+covers `/_next/image` (the default matcher `/:path*` does; the matcher
+`create-next-app` scaffolds does not).
+
+Making it opt-in means:
+
+- No breaking change, no migration doc.
+- The sharp fix in `40b7837` ships now. Without it the dedicated Lambda serves
+  every image as unoptimized original bytes with an HTTP 200 and nothing in the
+  logs — see "Background" below.
+- The flag is not throwaway. A later phase adds a middleware runner to the image
+  Lambda (using `outputs.middleware` from the Next.js adapters API), and *that*
+  release flips the default and deprecates the flag.
+
+## Starting state
+
+Branch `feat-nextjs-img-opt`. `HEAD` = `40b7837 fix: ship a loadable sharp to the
+image optimization Lambda`.
+
+Ten files are **uncommitted** and complete — a second batch of code-review fixes.
+All checks were green when they were written (`tsc`, `jest src/` 51 passing,
+`eslint`, `jsii`):
+
+| File | What changed |
+| --- | --- |
+| `src/image-optimization/handler-utils.ts` + `.test.ts` | S3 key derivation now *ensures* the `basePath` prefix instead of stripping it (`NextjsStaticAssets` uploads under `basePath`), and matches `basePath` only on a path boundary so `/basement/logo.png` isn't read as `/base` + `ment/...` |
+| `src/image-optimization/handler.mts` | 304 responses only write the API-Gateway-appeasing space byte on the API Gateway path (RFC 9110 forbids a body on 304); adds `isApiGatewayEvent` type guard |
+| `src/utils/get-architecture.ts` | `getNodeArchitecture()` as the single source of truth, replacing two inline `process.arch.startsWith("arm")` copies |
+| `src/nextjs-build/nextjs-build.ts` | Uses `getNodeArchitecture()` |
+| `src/root-constructs/nextjs-base-construct.ts`, `nextjs-global-functions.ts`, `nextjs-regional-functions.ts`, `src/index.ts` | New `NextjsFunctionsConstructOverrides` holds `nextjsFunctionsProps` / `nextjsImageFunctionProps`, which the Containers constructs previously accepted and silently ignored |
+| `docs/breaking-changes.md` | Two new `## 0.6.0` sections |
+
+### Step 0 — commit them first
+
+```
+git add -A && git commit
+```
+
+Suggested message: `fix: correct image optimization basePath keys, 304 bodies, and Functions-only overrides`
+
+Commit as-is even though Step 5 deletes one of the breaking-changes sections it
+adds — each commit stays internally consistent, and the sections are removed in
+the same PR.
+
+## Design decisions (already made — don't relitigate)
+
+**Flag name:** `dedicatedImageFunction?: boolean`, `@default false`.
+
+**Where it goes:** three sibling interfaces.
+
+- `NextjsBaseConstructProps` (`src/root-constructs/nextjs-base-construct.ts:124`)
+  — so `NextjsBaseConstruct` can read `this.baseProps.dedicatedImageFunction`
+  when it builds `NextjsBuild`.
+- `NextjsGlobalFunctionsProps` (`src/root-constructs/nextjs-global-functions.ts:47`)
+- `NextjsRegionalFunctionsProps` (`src/root-constructs/nextjs-regional-functions.ts:43`)
+
+**Not** on `NextjsBaseProps` — the Containers constructs would accept it and
+silently ignore it, which is the exact anti-pattern the uncommitted
+`NextjsFunctionsConstructOverrides` change fixes.
+
+> JSII note: all three interfaces extend `NextjsBaseProps` but none extends
+> another, so declaring the same member on all three is legal. Declaring it on
+> both a parent and a child interface is **not** — that produces
+> `Interface ... re-declares member`, the error documented at
+> `nextjs-base-construct.ts:120-123`.
+
+**Why a boolean and not an enum:** JSII rejects string-literal union types, so a
+`"server" | "dedicated"` choice would need a real exported enum. Not worth it for
+a flag that gets deprecated in two releases.
+
+## Tasks
+
+### 1. `src/nextjs-build/nextjs-build.ts` — the part that will bite
+
+Add `dedicatedImageFunction?: boolean` to `NextjsBuildProps`, then rework the
+constructor block at **lines 132-152**.
+
+Current logic strips whatever platform sharp binaries output file tracing
+bundled, then installs musl replacements **only for Containers**, on the
+assumption that Functions deployments never invoke sharp from the standalone
+server. That assumption is exactly what this flag breaks.
+
+```ts
+const useDedicatedImageFunction =
+  isFunctions && props.dedicatedImageFunction === true;
+
+this.removeExistingSharpBinaries(standalonePath);
+// The standalone server serves `_next/image` itself unless a dedicated image
+// Lambda takes that route, and it runs on node:24-alpine (see
+// functions.Dockerfile), so it needs musl binaries.
+if (!useDedicatedImageFunction) {
+  this.downloadAndInstallSharpBinaries();
+}
+if (useDedicatedImageFunction) {
+  this.imageOptimizationAssetPath =
+    this.prepareImageOptimizationAssets(standalonePath);
+}
+```
+
+**Get this right or Phase 0 ships broken image optimization on the default
+path.** `removeExistingSharpBinaries()` runs unconditionally and deletes the
+host's (macOS/glibc) binaries. If the musl install doesn't run for Functions
+deployments that no longer have a dedicated image Lambda, `require('sharp')`
+throws inside the server, Next.js's `imageOptimizer` catches it internally and
+returns the *original* buffer, and you get an HTTP 200 with plausible headers
+serving unoptimized images. Silent. This is the same failure the branch already
+fixed once for the dedicated Lambda; don't reintroduce it on the default path.
+
+Also update the comment at lines 137-143, which currently states the now-
+conditional claim as fact.
+
+Adding a prop to `NextjsBuildProps` means `OptionalNextjsBuildProps` must be
+regenerated — see Verification.
+
+### 2. `src/root-constructs/nextjs-base-construct.ts`
+
+- Add the prop to `NextjsBaseConstructProps`.
+- Pass it into `NextjsBuild` in `createNextjsBuild()` (line 195).
+- `createNextjsImageFunction()` (line 251) keeps throwing when
+  `imageOptimizationAssetPath` is missing — that's still a genuine invariant
+  violation, since callers only reach it when the flag is on.
+
+### 3. The two Functions root constructs
+
+Make the field optional and conditional:
+
+```ts
+nextjsImageFunction?: NextjsImageFunction;
+// ...
+if (props.dedicatedImageFunction) {
+  this.nextjsImageFunction = this.createNextjsImageFunction(
+    this.props.overrides?.nextjsImageFunction,
+  );
+}
+```
+
+- `nextjs-global-functions.ts:67` (field), `:83` (creation), `:95` — pass
+  `imageFunctionUrl: this.nextjsImageFunction?.functionUrl`.
+- `nextjs-regional-functions.ts:56` (field), `:76` (creation), `:87` — pass
+  `imageFunction: this.nextjsImageFunction?.function`.
+
+An optional class property is fine for JSII (`NextjsBuild.imageOptimizationAssetPath`
+already is one).
+
+### 4. Make the two consumers tolerate a missing image function
+
+**`src/nextjs-api.ts`** — revert this branch's tightening:
+
+- `validateProps` (line 110-114): drop the "imageFunction must be set when
+  serverFunction is set" throw.
+- Constructor (line 97-100): call `createImageIntegration` only when
+  `props.imageFunction` is set. With no image integration, `_next/image` falls
+  through to the `{proxy+}` catch-all on the server function — which is what
+  `main` does.
+- Update the `imageFunction` doc comment (line 53-62): no longer "Required if
+  `serverFunction` is set".
+
+**`src/nextjs-distribution.ts`** — `createImageOrigin()` (line 201-215) already
+falls back to `this.dynamicOrigin` for non-Functions compute. Extend that
+fallback instead of throwing:
+
+```ts
+if (!this.isFunctionCompute || !this.props.imageFunctionUrl) {
+  return this.dynamicOrigin;
+}
+```
+
+Keep the dedicated `_next/image*` behavior and its image-specific cache policy
+in both cases — pointing that behavior at the dynamic origin is strictly better
+than dropping it, because the image cache policy (`queryStringBehavior: all()`,
+`accept` in the cache key) is the right one for image requests either way. Update
+the doc comment on `imageFunctionUrl` (line 79-83) and on `createImageOrigin`.
+
+### 5. `docs/breaking-changes.md`
+
+From the `## 0.6.0` section added in Step 0:
+
+- **Delete** "`_next/image` no longer runs Next.js middleware (Functions only)".
+  It isn't true once the flag defaults off.
+- **Rewrite** "NextjsApi: `imageFunction` now required alongside
+  `serverFunction`" — it's optional again. Either delete it or restate it as a
+  non-breaking addition.
+- **Keep** "Functions-only overrides moved off the Containers constructs". That
+  one is a real (tiny) breaking change and it ships.
+
+Document the trade-off on the new prop's JSDoc, since that's what users will
+read:
+
+- **off (default)** — middleware runs for image requests; on Regional Functions
+  the response goes through API Gateway buffered (6 MB cap); images share the
+  server function's memory and concurrency; optimized images are cached via the
+  configured `cacheHandler`.
+- **on** — dedicated Lambda with response streaming and independent sizing; no
+  middleware for `_next/image`; caching relies on CloudFront.
+- Note that a future release will default this on once middleware support lands.
+
+### 6. Examples and e2e
+
+Set `dedicatedImageFunction: true` in **`examples/global-functions/app.ts`** only.
+Leave `examples/regional-functions/app.ts` on the default. That way CI covers
+both paths: `glbl-fns` exercises the dedicated Lambda, `rgnl-fns` exercises the
+server-function path.
+
+`examples/e2e-tests/src/image-optimization.test.ts` should pass unchanged on both
+— including the `content-type: image/webp` assertion added in `40b7837`, since
+the server function re-encodes with sharp too (that's what Task 1 guarantees).
+If it fails on `rgnl-fns`, suspect the musl install, not the test.
+
+### 7. Stretch — first construct test
+
+`test/` currently holds only a `tsconfig.json`; there are no CDK assertion tests.
+A worthwhile addition: with the flag off, assert the synthesized template has one
+Lambda and the `_next/image*` cache behavior targets the server origin; with it
+on, two Lambdas. The obstacle is that `NextjsBuild` runs `next build` in its
+constructor, so a test needs `skipBuild: true` plus a committed fixture `.next`
+directory. Skip if it balloons; it's not a Phase 0 blocker.
+
+## Verification
+
+```bash
+npx tsc --noEmit -p tsconfig.json
+npx jest src/                                       # 51 tests before this change
+ESLINT_USE_FLAT_CONFIG=false npx eslint --fix --ext .ts src/
+npx jsii --silence-warnings=reserved-word
+```
+
+Then, because `NextjsBuildProps` changed, in this order (the build-order quirk in
+`CLAUDE.md`):
+
+```bash
+pnpm compile      # writes .jsii
+pnpm projen       # regenerates src/generated-structs/OptionalNextjsBuildProps.ts from .jsii
+pnpm build
+npx jsii-docgen -o API.md   # API.md is committed and generated from .jsii
+```
+
+Notes:
+
+- `pnpm eslint` and `pnpm projen` shell out to `pnpm dlx projen`, which needs
+  network access to `registry.npmjs.org`. In a sandboxed session that fails with
+  `ERR_PNPM_FETCH_403`; the `npx` forms above work around it.
+- `src/image-optimization/handler.mts` cannot be linted — pre-existing, the
+  ESLint project service only covers `.ts`/`.tsx`.
+- `API.md` is 11,973 lines and committed. Forgetting to regenerate it will show
+  up as a CI self-mutation diff.
+
+## Out of scope
+
+- Any middleware execution. That's the next phase: copy
+  `ctx.outputs.middleware.filePath` + `assets` in `onBuildComplete`, match on
+  `config.matchers[].sourceRegex` with `has`/`missing`, invoke the entrypoint's
+  exported `handler(req, res, ctx)`. Node runtime only — edge is deprecated in
+  Next.js 16.
+- Replacing the server function with adapter entrypoints.
+- Widening the image cache policy's `cookieBehavior` (currently `none()` at
+  `nextjs-distribution.ts:338`). Only matters once middleware makes
+  cookie-dependent decisions for image requests.
+
+## Background: the bug that started this
+
+`next/dist/server/image-optimizer.js` reports a failed optimization by
+**returning** `{ buffer: upstreamBuffer, ..., error }` rather than throwing. The
+handler dropped `error`, so a broken sharp produced a valid HTTP 200 serving
+full-size originals forever, with clean logs. It got through four green e2e jobs
+and a live CloudFront endpoint that rendered all three test images correctly.
+
+It was caught by comparing bytes: the `_next/image` response was byte-identical
+to the raw S3 asset (31,283 bytes, md5 `ac38a73ecb20a904d52ebc9b28aa171f`),
+returned `content-type: image/png` despite `Accept: image/webp`, and carried
+S3's MD5 ETag rather than Next.js's sha256/base64url one.
+
+Root cause: `next build`'s output file tracing preserves the installer's layout,
+and under pnpm there is never a hoisted `node_modules/sharp` — only
+`node_modules/.pnpm/sharp@<version>/node_modules/sharp`. The old flat
+`existsSync` check never matched, so sharp was never bundled. Fixed in `40b7837`
+along with logging the swallowed `error`.
+
+The lesson for every later phase: the e2e suite asserts status codes, so it
+cannot see semantically wrong but syntactically fine responses. Assertions on
+bytes and headers are what caught this.

package/lib/generated-structs/OptionalNextjsDistributionProps.d.ts

@@ -9,6 +9,16 @@ export interface OptionalNextjsDistributionProps {
      * @stability stable
      */
     readonly loadBalancer?: aws_elasticloadbalancingv2.IApplicationLoadBalancer;
+    /**
+     * Function URL of the dedicated image optimization Lambda.
+     * Only applicable
+     * to `NextjsType.GLOBAL_FUNCTIONS`, and only when the dedicated image
+     * function is enabled. When omitted, the `_next/image*` behavior points at
+     * the dynamic origin, which serves image optimization from the Next.js
+     * server itself.
+     * @stability stable
+     */
+    readonly imageFunctionUrl?: aws_lambda.IFunctionUrl;
     /**
      * Required if `NextjsType.GLOBAL_FUNCTIONS`.
      * @stability stable
@@ -24,6 +34,9 @@ export interface OptionalNextjsDistributionProps {
      */
     readonly certificate?: aws_certificatemanager.ICertificate;
     /**
+     * URI path prefix the app is served at.
+     * Surrounding slashes are normalized
+     * away, so "/base", "base" and "/base/" all produce the same cache behaviors.
      * @stability stable
      */
     readonly basePath?: string;

package/lib/generated-structs/OptionalNextjsDistributionProps.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/image-optimization/handler-utils.d.ts

@@ -0,0 +1,34 @@
+import { S3Client } from "@aws-sdk/client-s3";
+/**
+ * Fetches a non-absolute (local) image referenced by an `<Image>` from S3.
+ *
+ * `url` is inconsistent: next-image-loader bakes the app's own `basePath` into
+ * the href for statically imported images, while plain string paths are passed
+ * through as literally written. So `nextBasePath` (the app's config) is stripped
+ * off, then `staticAssetsKeyPrefix` (`NextjsStaticAssets.keyPrefix`) applied.
+ * The two are separate arguments because nothing requires them to be the same
+ * value — e.g. an app whose `basePath` is an API Gateway stage, deployed without
+ * the CDK `basePath` prop.
+ */
+export declare function fetchFromS3(s3: S3Client, bucket: string, url: string, nextBasePath: string, staticAssetsKeyPrefix?: string): Promise<{
+    buffer: Buffer;
+    contentType: string | null;
+    etag: string;
+}>;
+/** Mirrors Next.js's own `getFileNameWithExtension` in image-optimizer.js. */
+export declare function getFileNameWithExtension(url: string, contentType: string | null): string;
+/**
+ * Maps an error thrown while processing an image request to the HTTP
+ * status/message it should produce, preserving the status Next.js's own
+ * `ImageError`/`fetchExternalImage` attach. A missing S3 object is mapped to
+ * the same 400 Next.js's own local-image fetch path (`fetchInternalImage` in
+ * image-optimizer.js) produces for a missing file: it never inspects the
+ * internal request's status code, so a 404 there just flows into the normal
+ * "not a valid image" content-type check as if it were malformed image
+ * bytes. This mirrors that behavior instead of surfacing a 404, so Functions
+ * and Containers deployments respond identically for this case.
+ */
+export declare function resolveErrorResponse(error: unknown): {
+    statusCode: number;
+    message: string;
+};

package/lib/image-optimization/handler-utils.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchFromS3 = fetchFromS3;
+exports.getFileNameWithExtension = getFileNameWithExtension;
+exports.resolveErrorResponse = resolveErrorResponse;
+/* eslint-disable import/no-extraneous-dependencies */
+const client_s3_1 = require("@aws-sdk/client-s3");
+const image_optimizer_js_1 = require("next/dist/server/image-optimizer.js");
+const serve_static_js_1 = require("next/dist/server/serve-static.js");
+const base_path_1 = require("../utils/base-path");
+/**
+ * Fetches a non-absolute (local) image referenced by an `<Image>` from S3.
+ *
+ * `url` is inconsistent: next-image-loader bakes the app's own `basePath` into
+ * the href for statically imported images, while plain string paths are passed
+ * through as literally written. So `nextBasePath` (the app's config) is stripped
+ * off, then `staticAssetsKeyPrefix` (`NextjsStaticAssets.keyPrefix`) applied.
+ * The two are separate arguments because nothing requires them to be the same
+ * value — e.g. an app whose `basePath` is an API Gateway stage, deployed without
+ * the CDK `basePath` prop.
+ */
+async function fetchFromS3(s3, bucket, url, nextBasePath, staticAssetsKeyPrefix = "") {
+    // Matching on a path boundary keeps a sibling like "/basement/logo.png" from
+    // being treated as nextBasePath "/base" plus "ment/logo.png". It's still
+    // indistinguishable from a real `public/base/` directory, which loses; that's
+    // the right trade, since every statically imported image carries the prefix
+    // and the alternative costs an S3 round trip per request to detect it.
+    const hasNextBasePath = !!nextBasePath &&
+        (url === nextBasePath || url.startsWith(`${nextBasePath}/`));
+    const key = (0, base_path_1.joinPath)(staticAssetsKeyPrefix, hasNextBasePath ? url.slice(nextBasePath.length) : url);
+    const response = await s3.send(new client_s3_1.GetObjectCommand({
+        Bucket: bucket,
+        Key: key,
+    }));
+    const body = response.Body;
+    if (!body) {
+        throw new Error(`Empty response from S3 for key: ${key}`);
+    }
+    const chunks = [];
+    for await (const chunk of body) {
+        chunks.push(Buffer.from(chunk));
+    }
+    return {
+        buffer: Buffer.concat(chunks),
+        contentType: response.ContentType || null,
+        etag: response.ETag || "",
+    };
+}
+/** Mirrors Next.js's own `getFileNameWithExtension` in image-optimizer.js. */
+function getFileNameWithExtension(url, contentType) {
+    const [urlWithoutQueryParams] = url.split("?", 1);
+    const fileNameWithExtension = urlWithoutQueryParams.split("/").pop();
+    if (!contentType || !fileNameWithExtension) {
+        return "image.bin";
+    }
+    const [fileName] = fileNameWithExtension.split(".", 1);
+    const extension = (0, serve_static_js_1.getExtension)(contentType);
+    return `${fileName}.${extension}`;
+}
+/**
+ * Maps an error thrown while processing an image request to the HTTP
+ * status/message it should produce, preserving the status Next.js's own
+ * `ImageError`/`fetchExternalImage` attach. A missing S3 object is mapped to
+ * the same 400 Next.js's own local-image fetch path (`fetchInternalImage` in
+ * image-optimizer.js) produces for a missing file: it never inspects the
+ * internal request's status code, so a 404 there just flows into the normal
+ * "not a valid image" content-type check as if it were malformed image
+ * bytes. This mirrors that behavior instead of surfacing a 404, so Functions
+ * and Containers deployments respond identically for this case.
+ */
+function resolveErrorResponse(error) {
+    if (error instanceof image_optimizer_js_1.ImageError) {
+        return { statusCode: error.statusCode, message: error.message };
+    }
+    if (error instanceof Error && error.name === "NoSuchKey") {
+        return {
+            statusCode: 400,
+            message: "The requested resource isn't a valid image.",
+        };
+    }
+    return { statusCode: 500, message: "Internal Server Error" };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"handler-utils.js","sourceRoot":"","sources":["../../src/image-optimization/handler-utils.ts"],"names":[],"mappings":";;AAiBA,kCA0CC;AAGD,4DAYC;AAaD,oDAcC;AArGD,sDAAsD;AACtD,kDAAgE;AAChE,4EAAiE;AACjE,sEAAgE;AAChE,kDAA8C;AAE9C;;;;;;;;;;GAUG;AACI,KAAK,UAAU,WAAW,CAC/B,EAAY,EACZ,MAAc,EACd,GAAW,EACX,YAAoB,EACpB,wBAAgC,EAAE;IAElC,6EAA6E;IAC7E,yEAAyE;IACzE,8EAA8E;IAC9E,4EAA4E;IAC5E,uEAAuE;IACvE,MAAM,eAAe,GACnB,CAAC,CAAC,YAAY;QACd,CAAC,GAAG,KAAK,YAAY,IAAI,GAAG,CAAC,UAAU,CAAC,GAAG,YAAY,GAAG,CAAC,CAAC,CAAC;IAC/D,MAAM,GAAG,GAAG,IAAA,oBAAQ,EAClB,qBAAqB,EACrB,eAAe,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,CACvD,CAAC;IAEF,MAAM,QAAQ,GAAG,MAAM,EAAE,CAAC,IAAI,CAC5B,IAAI,4BAAgB,CAAC;QACnB,MAAM,EAAE,MAAM;QACd,GAAG,EAAE,GAAG;KACT,CAAC,CACH,CAAC;IAEF,MAAM,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC;IAC3B,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,MAAM,IAAI,KAAK,CAAC,mCAAmC,GAAG,EAAE,CAAC,CAAC;IAC5D,CAAC;IAED,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,IAAiC,EAAE,CAAC;QAC5D,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;IAClC,CAAC;IAED,OAAO;QACL,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC;QAC7B,WAAW,EAAE,QAAQ,CAAC,WAAW,IAAI,IAAI;QACzC,IAAI,EAAE,QAAQ,CAAC,IAAI,IAAI,EAAE;KAC1B,CAAC;AACJ,CAAC;AAED,8EAA8E;AAC9E,SAAgB,wBAAwB,CACtC,GAAW,EACX,WAA0B;IAE1B,MAAM,CAAC,qBAAqB,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;IAClD,MAAM,qBAAqB,GAAG,qBAAqB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC;IACrE,IAAI,CAAC,WAAW,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAC3C,OAAO,WAAW,CAAC;IACrB,CAAC;IACD,MAAM,CAAC,QAAQ,CAAC,GAAG,qBAAqB,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;IACvD,MAAM,SAAS,GAAG,IAAA,8BAAY,EAAC,WAAW,CAAC,CAAC;IAC5C,OAAO,GAAG,QAAQ,IAAI,SAAS,EAAE,CAAC;AACpC,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAgB,oBAAoB,CAAC,KAAc;IAIjD,IAAI,KAAK,YAAY,+BAAU,EAAE,CAAC;QAChC,OAAO,EAAE,UAAU,EAAE,KAAK,CAAC,UAAU,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC;IAClE,CAAC;IACD,IAAI,KAAK,YAAY,KAAK,IAAI,KAAK,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;QACzD,OAAO;YACL,UAAU,EAAE,GAAG;YACf,OAAO,EAAE,6CAA6C;SACvD,CAAC;IACJ,CAAC;IACD,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,OAAO,EAAE,uBAAuB,EAAE,CAAC;AAC/D,CAAC","sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\nimport { GetObjectCommand, S3Client } from \"@aws-sdk/client-s3\";\nimport { ImageError } from \"next/dist/server/image-optimizer.js\";\nimport { getExtension } from \"next/dist/server/serve-static.js\";\nimport { joinPath } from \"../utils/base-path\";\n\n/**\n * Fetches a non-absolute (local) image referenced by an `<Image>` from S3.\n *\n * `url` is inconsistent: next-image-loader bakes the app's own `basePath` into\n * the href for statically imported images, while plain string paths are passed\n * through as literally written. So `nextBasePath` (the app's config) is stripped\n * off, then `staticAssetsKeyPrefix` (`NextjsStaticAssets.keyPrefix`) applied.\n * The two are separate arguments because nothing requires them to be the same\n * value — e.g. an app whose `basePath` is an API Gateway stage, deployed without\n * the CDK `basePath` prop.\n */\nexport async function fetchFromS3(\n  s3: S3Client,\n  bucket: string,\n  url: string,\n  nextBasePath: string,\n  staticAssetsKeyPrefix: string = \"\",\n): Promise<{ buffer: Buffer; contentType: string | null; etag: string }> {\n  // Matching on a path boundary keeps a sibling like \"/basement/logo.png\" from\n  // being treated as nextBasePath \"/base\" plus \"ment/logo.png\". It's still\n  // indistinguishable from a real `public/base/` directory, which loses; that's\n  // the right trade, since every statically imported image carries the prefix\n  // and the alternative costs an S3 round trip per request to detect it.\n  const hasNextBasePath =\n    !!nextBasePath &&\n    (url === nextBasePath || url.startsWith(`${nextBasePath}/`));\n  const key = joinPath(\n    staticAssetsKeyPrefix,\n    hasNextBasePath ? url.slice(nextBasePath.length) : url,\n  );\n\n  const response = await s3.send(\n    new GetObjectCommand({\n      Bucket: bucket,\n      Key: key,\n    }),\n  );\n\n  const body = response.Body;\n  if (!body) {\n    throw new Error(`Empty response from S3 for key: ${key}`);\n  }\n\n  const chunks: Buffer[] = [];\n  for await (const chunk of body as AsyncIterable<Uint8Array>) {\n    chunks.push(Buffer.from(chunk));\n  }\n\n  return {\n    buffer: Buffer.concat(chunks),\n    contentType: response.ContentType || null,\n    etag: response.ETag || \"\",\n  };\n}\n\n/** Mirrors Next.js's own `getFileNameWithExtension` in image-optimizer.js. */\nexport function getFileNameWithExtension(\n  url: string,\n  contentType: string | null,\n): string {\n  const [urlWithoutQueryParams] = url.split(\"?\", 1);\n  const fileNameWithExtension = urlWithoutQueryParams.split(\"/\").pop();\n  if (!contentType || !fileNameWithExtension) {\n    return \"image.bin\";\n  }\n  const [fileName] = fileNameWithExtension.split(\".\", 1);\n  const extension = getExtension(contentType);\n  return `${fileName}.${extension}`;\n}\n\n/**\n * Maps an error thrown while processing an image request to the HTTP\n * status/message it should produce, preserving the status Next.js's own\n * `ImageError`/`fetchExternalImage` attach. A missing S3 object is mapped to\n * the same 400 Next.js's own local-image fetch path (`fetchInternalImage` in\n * image-optimizer.js) produces for a missing file: it never inspects the\n * internal request's status code, so a 404 there just flows into the normal\n * \"not a valid image\" content-type check as if it were malformed image\n * bytes. This mirrors that behavior instead of surfacing a 404, so Functions\n * and Containers deployments respond identically for this case.\n */\nexport function resolveErrorResponse(error: unknown): {\n  statusCode: number;\n  message: string;\n} {\n  if (error instanceof ImageError) {\n    return { statusCode: error.statusCode, message: error.message };\n  }\n  if (error instanceof Error && error.name === \"NoSuchKey\") {\n    return {\n      statusCode: 400,\n      message: \"The requested resource isn't a valid image.\",\n    };\n  }\n  return { statusCode: 500, message: \"Internal Server Error\" };\n}\n"]}

package/lib/image-optimization/handler-utils.test.d.ts

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