cdk-nextjs 0.6.1 → 0.7.0

package/lib/utils/base-path.js

@@ -1,11 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_API_GATEWAY_PREFIX = void 0;
 exports.normalizeBasePath = normalizeBasePath;
+exports.hasPathPrefix = hasPathPrefix;
+exports.basePathPrefix = basePathPrefix;
+exports.wholeAppInvalidationPaths = wholeAppInvalidationPaths;
 exports.joinPath = joinPath;
-exports.readNextConfigBasePath = readNextConfigBasePath;
+exports.prefixWithBasePath = prefixWithBasePath;
+exports.relativeAssetPrefix = relativeAssetPrefix;
+exports.isAssetPrefixUnserved = isAssetPrefixUnserved;
+exports.assetPrefixPath = assetPrefixPath;
 exports.resolveBasePath = resolveBasePath;
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
+/**
+ * Pure `basePath` and URL path helpers. Nothing here imports `aws-cdk-lib` or
+ * touches the filesystem, so the adapter and runtime bundles can import it as
+ * well as the constructs.
+ */
 const constants_1 = require("../constants");
 /**
  * Reduces a `basePath` to a bare path segment so values that address the same
@@ -15,6 +25,39 @@ const constants_1 = require("../constants");
 function normalizeBasePath(basePath) {
     return (basePath || "").replace(/^\/+/, "").replace(/\/+$/, "");
 }
+/**
+ * Whether `path` is `prefix` or under it on a segment boundary, so `/docsearch`
+ * is not under `/docs`. An empty `prefix` matches nothing. Both sides must be in
+ * the same form (both with or both without the leading `/`).
+ */
+function hasPathPrefix(path, prefix) {
+    return !!prefix && (path === prefix || path.startsWith(`${prefix}/`));
+}
+/**
+ * A `basePath` as Next.js spells it and URLs start with it: one leading slash,
+ * no trailing one ("/base"), `""` for none. Accepts any spelling
+ * {@link normalizeBasePath} does.
+ */
+function basePathPrefix(basePath) {
+    const bare = normalizeBasePath(basePath);
+    return bare ? `/${bare}` : "";
+}
+/**
+ * Invalidation paths covering every URI of the app: what a deploy invalidates,
+ * and what the cache handler's oversized batches, retries after a quota error,
+ * and tags whose routes could not all be named fall back to.
+ *
+ * `/*` is the whole app only without a `basePath`. `/base/*` matches neither the
+ * app's root, `/base`, nor its RSC payload, `/base?_rsc=…` - the same root the
+ * `revalidatePath("/")` that overflowed may have named - so those are spelled
+ * out. `/base*` would cover them for one wildcard, but also every sibling
+ * prefix (`/base2`, `/basement`), which may be another app on the same
+ * distribution.
+ */
+function wholeAppInvalidationPaths(basePath) {
+    const prefix = basePathPrefix(basePath);
+    return prefix ? [prefix, `${prefix}?*`, `${prefix}/*`] : ["/*"];
+}
 /**
  * Joins path parts with a single "/", normalizing each (so no leading or
  * trailing slash survives, including on the result) and dropping the empty
@@ -24,36 +67,181 @@ function joinPath(...parts) {
     return parts.map(normalizeBasePath).filter(Boolean).join("/");
 }
 /**
- * Read the Next.js app's own `basePath` out of `required-server-files.json`,
- * which `next build` writes into `.next` with the fully resolved config (so
- * this picks up a `basePath` computed in `next.config.js`, not only a literal
- * one). Normalized, empty when the app sets none.
+ * Prefixes an absolute app path (a health check path, say) with `basePath`,
+ * always returning a leading slash. An empty or unset `basePath` only
+ * normalizes that leading slash. Anything after the first segment is passed
+ * through as given, trailing slash included, since a `trailingSlash` app
+ * answers "/api/health" and "/api/health/" differently.
+ *
+ * Use this for paths handed to something that talks to the app directly — an ALB
+ * target group health check, the container's own health probe — since the app
+ * only answers under its own `basePath`.
+ *
+ * Prefixes unconditionally, so `path` has to arrive as the app routes it,
+ * without `basePath`: for an app based at "/base", "/base/api/health" becomes
+ * "/base/base/api/health". Deliberately not special-cased — an app can route
+ * "/base/base/..." legitimately, and accepting both spellings would give the
+ * path two meanings. See `docs/breaking-changes.md` (0.6.0), which tells users
+ * who prefixed `healthCheckPath` by hand to drop the prefix.
+ */
+function prefixWithBasePath(basePath, path) {
+    const normalized = normalizeBasePath(basePath);
+    const absolute = path.startsWith("/") ? path : `/${path}`;
+    return normalized ? `/${normalized}${absolute}` : absolute;
+}
+/** Whether an `assetPrefix` names an origin rather than a path on this one. */
+function isAbsoluteAssetPrefix(assetPrefix) {
+    return /^([a-z][a-z0-9+.-]*:)?\/\//i.test(assetPrefix);
+}
+/**
+ * The app's own `assetPrefix` as a path with a leading and no trailing slash
+ * ("/cdn"), or `""` when the app sets none.
+ *
+ * Returns `""` for an absolute `assetPrefix` ("https://cdn.example.com", or the
+ * protocol-relative "//cdn.example.com") too: that names an origin cdk-nextjs
+ * does not control, and it is the supported way to serve assets from elsewhere,
+ * so nothing about it is worth warning about. Use {@link assetPrefixPath} for
+ * what the *distribution* has to answer on, which includes the path an absolute
+ * prefix carries.
+ *
+ * Next.js applies `assetPrefix` on top of, not under, `basePath`, so the result
+ * is the whole prefix of a `_next/static` URL and must not be joined with
+ * `basePath`.
+ */
+function relativeAssetPrefix(assetPrefix) {
+    return isAbsoluteAssetPrefix(assetPrefix) ? "" : basePathPrefix(assetPrefix);
+}
+/**
+ * Whether a path-style `assetPrefix` would go unanswered on this `NextjsType`,
+ * i.e. whether every bundle would 404.
+ *
+ * `assetPrefix` moves every bundle URL to `<assetPrefix>/_next/static/...` while
+ * the objects keep their `<basePath>/_next/static/...` S3 keys. The Global
+ * `NextjsType`s answer that with a cache behavior of their own
+ * (`NextjsDistribution`); the regional ones have nothing that maps the prefix
+ * back — API Gateway's `_next/static` resource and the container's own files are
+ * both under the unprefixed path.
+ *
+ * A prefix equal to the app's own `basePath` is **not** unserved, because that is
+ * the value Next.js resolves `assetPrefix` to when `basePath` is set and
+ * `assetPrefix` is not: `.next/required-server-files.json` comes back as
+ * `{"assetPrefix":"/prod","basePath":"/prod"}` for an app that only ever set
+ * `basePath`. Without that exemption the warning fired on every regional
+ * deployment that sets a `basePath` at all — including `examples/regional-functions`
+ * — telling users their bundles would 404 at the one path that does serve them.
+ * `NextjsDistribution.resolveAssetPrefix` drops the prefix for the same reason.
  *
- * Degrades to `""` rather than throwing, since an unreadable file shouldn't
- * fail a deployment that would otherwise work. It warns because `""` is
- * indistinguishable from an app that genuinely sets no `basePath`: the
- * `NextjsType`s that derive `basePath` from the app would quietly not derive
- * it and 404 every static asset.
+ * Both sides go through `normalizeBasePath` because they arrive in different
+ * shapes: `nextConfigAssetPrefix` carries a leading slash (`"/prod"`),
+ * `nextConfigBasePath` does not (`"prod"`).
  */
-function readNextConfigBasePath(dotNextPath) {
-    const requiredServerFiles = (0, node_path_1.join)(dotNextPath, "required-server-files.json");
-    const fallback = (reason) => {
-        console.warn(`${constants_1.LOG_PREFIX} ${reason}. Assuming your Next.js app sets no \`basePath\`: ` +
-            "if it does set one, static assets will 404 and any `basePath` prop " +
-            "mismatch reported at synth will name the wrong value.");
+function isAssetPrefixUnserved(nextjsType, nextConfigAssetPrefix, nextConfigBasePath) {
+    if (!nextConfigAssetPrefix)
+        return false;
+    if (nextjsType === constants_1.NextjsType.GLOBAL_FUNCTIONS ||
+        nextjsType === constants_1.NextjsType.GLOBAL_CONTAINERS) {
+        return false;
+    }
+    return (normalizeBasePath(nextConfigAssetPrefix) !==
+        normalizeBasePath(nextConfigBasePath));
+}
+/**
+ * The *path* every bundle URL carries, whichever form `assetPrefix` takes: "/cdn"
+ * for `assetPrefix: "/cdn"` and for `assetPrefix:
+ * "https://cdn.example.com/cdn"` alike, `""` when there is none (an absolute
+ * prefix with no path, or no prefix at all).
+ *
+ * An absolute prefix's path counts because `next build` compiles a `beforeFiles`
+ * rewrite of its own for it — `/cdn/_next/:path+ → /_next/:path+` — so `next
+ * start` serves every bundle under that path as well as under `/_next`. A CDN
+ * fronting this deployment at that path therefore has to be answered, and the
+ * distribution's `assetPrefix` behavior is what answers it. Measured against
+ * `test/e2e/app-dir/asset-prefix-absolute`; see `docs/harness-coverage.md`.
+ * Shared with `NextjsDistribution`, whose `assetPrefix` prop a user can also
+ * set by hand.
+ */
+function assetPrefixPath(assetPrefix) {
+    if (!assetPrefix)
         return "";
-    };
-    if (!(0, node_fs_1.existsSync)(requiredServerFiles)) {
-        return fallback(`"required-server-files.json" not found at ${requiredServerFiles}`);
+    let path = assetPrefix;
+    if (isAbsoluteAssetPrefix(assetPrefix)) {
+        try {
+            // `//cdn.example.com/cdn` is protocol-relative, which `URL` only parses
+            // with a base — any base, since only the path is read off it.
+            path = new URL(assetPrefix, "https://asset-prefix.invalid").pathname;
+        }
+        catch {
+            return "";
+        }
+    }
+    return basePathPrefix(path);
+}
+/** `RestApi`'s own defaults: the `prod` stage, no custom domain. */
+exports.DEFAULT_API_GATEWAY_PREFIX = {
+    strippedPrefix: "prod",
+    customDomain: false,
+};
+/**
+ * The resource path an app's `basePath` needs on `REGIONAL_FUNCTIONS` when the
+ * `basePath` prop is unset: the app's `basePath` with the prefix API Gateway
+ * strips taken off the front, or the whole of it when it does not start with
+ * that prefix.
+ *
+ * An app at the `prod` stage emits `/prod/...` and API Gateway strips `/prod`
+ * before matching, so `basePath: "/prod"` needs resources at the root and
+ * `basePath: "/prod/base"` needs them under `base`. An app whose `basePath` API
+ * Gateway does not strip — a custom domain mapped at the root, serving
+ * `basePath: "/docs"` — needs them under `docs`. Leaving that one at the root is
+ * what used to happen: `_next/static` and `public/` fell through to the
+ * `{proxy+}` catch-all, and every bundle 404'd with nothing said at synth.
+ */
+function deriveApiGatewayBasePath(config, { strippedPrefix, customDomain }) {
+    if (!config || strippedPrefix === undefined) {
+        return undefined;
+    }
+    const stripped = normalizeBasePath(strippedPrefix);
+    if (hasPathPrefix(config, stripped)) {
+        return config.slice(stripped.length + 1) || undefined;
+    }
+    warnUnstrippedBasePath(config, { strippedPrefix, customDomain });
+    return config;
+}
+/**
+ * Warn that an app mounted under its whole `basePath` is served somewhere its
+ * own links don't reach, when API Gateway strips a prefix that `basePath` lacks.
+ * Both ways of arriving there warn: the prop left unset (derived to the whole
+ * `basePath`) and the prop set to the same value.
+ */
+function warnUnstrippedBasePath(config, { strippedPrefix, customDomain }) {
+    const stripped = normalizeBasePath(strippedPrefix);
+    if (strippedPrefix === undefined || !stripped) {
+        // A token, or a custom domain mapped at the root: nothing is stripped that
+        // the app's links could miss.
+        return;
     }
-    try {
-        const { config } = JSON.parse((0, node_fs_1.readFileSync)(requiredServerFiles, "utf-8"));
-        return normalizeBasePath(config?.basePath);
+    if (customDomain) {
+        // The same miss through a custom domain's base path mapping: served at
+        // `/<mapping>/<basePath>`, linking to `/<basePath>/...`, which no mapping
+        // covers.
+        console.warn(`${constants_1.LOG_PREFIX} your Next.js app's \`basePath\` is ${quote(config)}, which does not start with the custom domain's base path mapping "/${stripped}". ` +
+            "Its links and bundle URLs will be requested without the mapping, which the custom domain answers with 403. " +
+            `Set \`basePath: "/${joinPath(stripped, config)}"\` in your next.config, or map the domain at the root.`);
     }
-    catch (error) {
-        return fallback(`Could not read basePath from ${requiredServerFiles}: ${error}`);
+    else {
+        // Resources under the app's basePath serve it at `/<stage>/<basePath>`, but
+        // the app's own links are `/<basePath>/...`, which misses the stage. A
+        // warning, not an error: a domain attached after synth (`addDomainName`)
+        // makes it right, and synth cannot see that.
+        console.warn(`${constants_1.LOG_PREFIX} your Next.js app's \`basePath\` is ${quote(config)}, which does not start with the API Gateway stage "/${stripped}". ` +
+            "Its links and bundle URLs will be requested without the stage, which the execute-api endpoint answers with 403. " +
+            `Set \`basePath: "/${joinPath(stripped, config)}"\` in your next.config, or serve the app from a custom domain mapped at the root.`);
     }
 }
+/** Whether API Gateway strips the front of `basePath` before matching resources. */
+function startsWithStrippedPrefix(basePath, { strippedPrefix }) {
+    const stripped = normalizeBasePath(strippedPrefix);
+    return !!basePath && hasPathPrefix(basePath, stripped);
+}
 function quote(basePath) {
     return basePath ? `"/${basePath}"` : "unset";
 }
@@ -69,15 +257,43 @@ function quote(basePath) {
  * land under), the config is the prefix the app emits its own links and asset
  * hrefs under — so how strictly they have to line up, and whether one can stand
  * in for the other, depends on how the `NextjsType` routes static requests.
+ *
+ * `apiGateway` is only read for `REGIONAL_FUNCTIONS`, and only when the prop is
+ * unset: see `deriveApiGatewayBasePath`.
  */
-function resolveBasePath(nextjsType, propBasePath, nextConfigBasePath) {
+function resolveBasePath(nextjsType, propBasePath, nextConfigBasePath, apiGateway = exports.DEFAULT_API_GATEWAY_PREFIX) {
     const prop = normalizeBasePath(propBasePath);
     const config = normalizeBasePath(nextConfigBasePath);
+    const mismatch = `${constants_1.LOG_PREFIX} basePath mismatch for NextjsType.${nextjsType}: the \`basePath\` prop is ${quote(prop)} ` +
+        `but your Next.js app's config sets \`basePath\` to ${quote(config)}. `;
     if (prop === config) {
+        if (nextjsType === constants_1.NextjsType.REGIONAL_FUNCTIONS &&
+            startsWithStrippedPrefix(prop, apiGateway)) {
+            // Agreeing is not enough here: API Gateway strips the stage (or base path
+            // mapping) before matching, so resources under the prop's "prod" are only
+            // reached at `/prod/prod/...`, and every link the app emits 403s.
+            const problem = `API Gateway strips "/${normalizeBasePath(apiGateway.strippedPrefix)}" before matching resources, so a prop that repeats it nests every resource under a path no request reaches. ` +
+                "Leave the prop unset: it is derived from your app's `basePath` with that prefix taken off.";
+            if (apiGateway.customDomain) {
+                throw new Error(mismatch + problem);
+            }
+            // On the execute-api endpoint that is certain, but an explicit prop wins:
+            // a domain attached with `addDomainName()`, invisible here, can map the
+            // stage at its root, and then `/prod/...` does reach resources under
+            // "prod".
+            console.warn(mismatch +
+                problem +
+                " (Ignore this if a domain attached with `addDomainName()` serves the app without stripping that prefix.)");
+            return prop;
+        }
+        if (nextjsType === constants_1.NextjsType.REGIONAL_FUNCTIONS && prop) {
+            // Agreeing the other way round has the unset case's problem: resources
+            // under "docs" are reached at `/prod/docs/...`, the app links to
+            // `/docs/...`.
+            warnUnstrippedBasePath(config, apiGateway);
+        }
         return prop || undefined;
     }
-    const mismatch = `${constants_1.LOG_PREFIX} basePath mismatch for NextjsType.${nextjsType}: the \`basePath\` prop is ${quote(prop)} ` +
-        `but your Next.js app's config sets \`basePath\` to ${quote(config)}. `;
     switch (nextjsType) {
         case constants_1.NextjsType.GLOBAL_FUNCTIONS:
         case constants_1.NextjsType.GLOBAL_CONTAINERS:
@@ -93,26 +309,47 @@ function resolveBasePath(nextjsType, propBasePath, nextConfigBasePath) {
                 "CloudFront serves static assets straight from S3 using the request path as the object key, so a mismatch means every `_next/static` and `public/` request 404s. " +
                 "Either set both to the same value, or drop the prop — left unset, it follows your app's `basePath`.");
         case constants_1.NextjsType.REGIONAL_FUNCTIONS:
-            // Deliberately not derived: API Gateway mounts resources below the stage
-            // and strips it before invoking the app, so an app whose basePath is the
-            // stage name (or a custom domain base path mapping that gets stripped the
-            // same way) is correct precisely because the prop stays unset.
             if (!prop) {
-                return undefined;
+                // A prop that is set but names no path ("/") is an explicit root
+                // mount, not "unset": it is how an app says the prefix is stripped by
+                // something synth can't see — a domain attached later with
+                // `addDomainName({ basePath })`, say — so deriving here would nest the
+                // resources under a path the stripped requests never reach.
+                if (propBasePath !== undefined) {
+                    return undefined;
+                }
+                return deriveApiGatewayBasePath(config, apiGateway);
             }
             // The prop only has to be the tail of what the app emits, not all of it,
             // because the stripped prefix is part of the app's `basePath` but never
             // part of the resource path: an app at the `prod` stage nested under
-            // "/base" sets `basePath: "/prod/base"` and the prop to "/base". Checked
-            // on a path boundary so "/prod/base" doesn't accept a prop of "se".
-            if (config.endsWith(`/${prop}`)) {
+            // "/base" sets `basePath: "/prod/base"` and the prop to "/base". Exactly
+            // the stripped prefix and then the prop, not any tail: with a prop of
+            // "/base" an app at "/foo/base" is served at `/prod/base/...` and links
+            // to `/foo/base/...`, which 403s. Only a token stage, which synth can't
+            // read, falls back to a tail on a path boundary.
+            if (apiGateway.strippedPrefix === undefined
+                ? config.endsWith(`/${prop}`)
+                : config === joinPath(apiGateway.strippedPrefix, prop)) {
+                return prop;
+            }
+            // Any tail on a path boundary is also what a domain attached with
+            // `addDomainName({ basePath: "v1" })` needs for an app at "/v1/base":
+            // synth only sees the stage, so it can't tell that setup from a mistake.
+            // An explicit prop wins, so that warns; a custom domain configured in
+            // `restApiProps.domainName` is visible, so there it still throws below.
+            if (!apiGateway.customDomain && config.endsWith(`/${prop}`)) {
+                const leading = config.slice(0, -prop.length - 1);
+                console.warn(`${constants_1.LOG_PREFIX} the \`basePath\` prop is ${quote(prop)} and your Next.js app's \`basePath\` is ${quote(config)}, ` +
+                    `so the app is served at "/${joinPath(normalizeBasePath(apiGateway.strippedPrefix), prop)}" on the execute-api endpoint and links to "/${config}". ` +
+                    `That only works through a custom domain whose base path mapping strips "/${leading}" (\`addDomainName({ basePath: "${leading}" })\`); otherwise every request 403s.`);
                 return prop;
             }
             // Anything else never works: the prop moves every resource, including the
             // `ANY` catch-all, under a path the app never links to.
             throw new Error(mismatch +
                 "The `basePath` prop nests every API Gateway resource under that path, including the catch-all, so the app has to emit its links under the same prefix or every request 404s. " +
-                'Either set your app\'s `basePath` to end with the prop (optionally prefixed by the stage or base path mapping API Gateway strips, e.g. `basePath: "/prod/base"` with a prop of "/base"), or leave the prop unset — unset is what you want when the app\'s `basePath` is the API Gateway stage name, since the stage isn\'t part of the resource path.');
+                'Either set your app\'s `basePath` to the prop, or to the prop prefixed by the stage or base path mapping API Gateway strips (e.g. `basePath: "/prod/base"` with a prop of "/base"), or leave the prop unset — unset is what you want when the app\'s `basePath` is the API Gateway stage name, since the stage isn\'t part of the resource path.');
         case constants_1.NextjsType.REGIONAL_CONTAINERS:
             // The ALB forwards every path to the container, which serves its own
             // static assets, so here `basePath` only namespaces the S3 bucket and has
@@ -120,4 +357,4 @@ function resolveBasePath(nextjsType, propBasePath, nextConfigBasePath) {
             return prop || undefined;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-path.js","sourceRoot":"","sources":["../../src/utils/base-path.ts"],"names":[],"mappings":"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","sourcesContent":["import { existsSync, readFileSync } from \"node:fs\";\nimport { join } from \"node:path\";\nimport { LOG_PREFIX, NextjsType } from \"../constants\";\n\n/**\n * Reduces a `basePath` to a bare path segment so values that address the same\n * path (\"/base\", \"base\", \"/base/\") compare equal and can be concatenated\n * without doubling separators.\n */\nexport function normalizeBasePath(basePath?: string): string {\n  return (basePath || \"\").replace(/^\\/+/, \"\").replace(/\\/+$/, \"\");\n}\n\n/**\n * Joins path parts with a single \"/\", normalizing each (so no leading or\n * trailing slash survives, including on the result) and dropping the empty\n * ones, so an unset `basePath` or key prefix leaves the rest untouched.\n */\nexport function joinPath(...parts: (string | undefined)[]): string {\n  return parts.map(normalizeBasePath).filter(Boolean).join(\"/\");\n}\n\n/**\n * Read the Next.js app's own `basePath` out of `required-server-files.json`,\n * which `next build` writes into `.next` with the fully resolved config (so\n * this picks up a `basePath` computed in `next.config.js`, not only a literal\n * one). Normalized, empty when the app sets none.\n *\n * Degrades to `\"\"` rather than throwing, since an unreadable file shouldn't\n * fail a deployment that would otherwise work. It warns because `\"\"` is\n * indistinguishable from an app that genuinely sets no `basePath`: the\n * `NextjsType`s that derive `basePath` from the app would quietly not derive\n * it and 404 every static asset.\n */\nexport function readNextConfigBasePath(dotNextPath: string): string {\n  const requiredServerFiles = join(dotNextPath, \"required-server-files.json\");\n  const fallback = (reason: string) => {\n    console.warn(\n      `${LOG_PREFIX} ${reason}. Assuming your Next.js app sets no \\`basePath\\`: ` +\n        \"if it does set one, static assets will 404 and any `basePath` prop \" +\n        \"mismatch reported at synth will name the wrong value.\",\n    );\n    return \"\";\n  };\n  if (!existsSync(requiredServerFiles)) {\n    return fallback(\n      `\"required-server-files.json\" not found at ${requiredServerFiles}`,\n    );\n  }\n  try {\n    const { config } = JSON.parse(readFileSync(requiredServerFiles, \"utf-8\"));\n    return normalizeBasePath(config?.basePath);\n  } catch (error) {\n    return fallback(\n      `Could not read basePath from ${requiredServerFiles}: ${error}`,\n    );\n  }\n}\n\nfunction quote(basePath: string): string {\n  return basePath ? `\"/${basePath}\"` : \"unset\";\n}\n\n/**\n * Settles on the single `basePath` the infrastructure should be built around,\n * given the CDK `basePath` prop and the Next.js app's own `basePath`\n * (`NextjsBuild.nextConfigBasePath`), throwing at synth if the two can't serve\n * the app together. Returns a normalized value, or `undefined` for no\n * `basePath` at all; consumers that need a leading slash add their own.\n *\n * The two inputs are genuinely different things — the prop is where the\n * infrastructure serves the app from (and which S3 key prefix the static assets\n * land under), the config is the prefix the app emits its own links and asset\n * hrefs under — so how strictly they have to line up, and whether one can stand\n * in for the other, depends on how the `NextjsType` routes static requests.\n */\nexport function resolveBasePath(\n  nextjsType: NextjsType,\n  propBasePath?: string,\n  nextConfigBasePath?: string,\n): string | undefined {\n  const prop = normalizeBasePath(propBasePath);\n  const config = normalizeBasePath(nextConfigBasePath);\n  if (prop === config) {\n    return prop || undefined;\n  }\n\n  const mismatch =\n    `${LOG_PREFIX} basePath mismatch for NextjsType.${nextjsType}: the \\`basePath\\` prop is ${quote(prop)} ` +\n    `but your Next.js app's config sets \\`basePath\\` to ${quote(config)}. `;\n\n  switch (nextjsType) {\n    case NextjsType.GLOBAL_FUNCTIONS:\n    case NextjsType.GLOBAL_CONTAINERS:\n      // `NextjsDistribution` builds its behaviors as `/${basePath}/_next/static*`\n      // and CloudFront hands an S3 origin the request path verbatim as the\n      // object key, so the only value that can serve the app is the prefix the\n      // app itself emits. That leaves the prop no room to differ, which makes\n      // the app's config the single source of truth worth deriving from.\n      if (!prop) {\n        return config;\n      }\n      throw new Error(\n        mismatch +\n          \"CloudFront serves static assets straight from S3 using the request path as the object key, so a mismatch means every `_next/static` and `public/` request 404s. \" +\n          \"Either set both to the same value, or drop the prop — left unset, it follows your app's `basePath`.\",\n      );\n    case NextjsType.REGIONAL_FUNCTIONS:\n      // Deliberately not derived: API Gateway mounts resources below the stage\n      // and strips it before invoking the app, so an app whose basePath is the\n      // stage name (or a custom domain base path mapping that gets stripped the\n      // same way) is correct precisely because the prop stays unset.\n      if (!prop) {\n        return undefined;\n      }\n      // The prop only has to be the tail of what the app emits, not all of it,\n      // because the stripped prefix is part of the app's `basePath` but never\n      // part of the resource path: an app at the `prod` stage nested under\n      // \"/base\" sets `basePath: \"/prod/base\"` and the prop to \"/base\". Checked\n      // on a path boundary so \"/prod/base\" doesn't accept a prop of \"se\".\n      if (config.endsWith(`/${prop}`)) {\n        return prop;\n      }\n      // Anything else never works: the prop moves every resource, including the\n      // `ANY` catch-all, under a path the app never links to.\n      throw new Error(\n        mismatch +\n          \"The `basePath` prop nests every API Gateway resource under that path, including the catch-all, so the app has to emit its links under the same prefix or every request 404s. \" +\n          'Either set your app\\'s `basePath` to end with the prop (optionally prefixed by the stage or base path mapping API Gateway strips, e.g. `basePath: \"/prod/base\"` with a prop of \"/base\"), or leave the prop unset — unset is what you want when the app\\'s `basePath` is the API Gateway stage name, since the stage isn\\'t part of the resource path.',\n      );\n    case NextjsType.REGIONAL_CONTAINERS:\n      // The ALB forwards every path to the container, which serves its own\n      // static assets, so here `basePath` only namespaces the S3 bucket and has\n      // no routing meaning that could disagree with the app.\n      return prop || undefined;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-path.js","sourceRoot":"","sources":["../../src/utils/base-path.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Pure `basePath` and URL path helpers. Nothing here imports `aws-cdk-lib` or\n * touches the filesystem, so the adapter and runtime bundles can import it as\n * well as the constructs.\n */\nimport { LOG_PREFIX, NextjsType } from \"../constants\";\n\n/**\n * Reduces a `basePath` to a bare path segment so values that address the same\n * path (\"/base\", \"base\", \"/base/\") compare equal and can be concatenated\n * without doubling separators.\n */\nexport function normalizeBasePath(basePath?: string): string {\n  return (basePath || \"\").replace(/^\\/+/, \"\").replace(/\\/+$/, \"\");\n}\n\n/**\n * Whether `path` is `prefix` or under it on a segment boundary, so `/docsearch`\n * is not under `/docs`. An empty `prefix` matches nothing. Both sides must be in\n * the same form (both with or both without the leading `/`).\n */\nexport function hasPathPrefix(path: string, prefix: string): boolean {\n  return !!prefix && (path === prefix || path.startsWith(`${prefix}/`));\n}\n\n/**\n * A `basePath` as Next.js spells it and URLs start with it: one leading slash,\n * no trailing one (\"/base\"), `\"\"` for none. Accepts any spelling\n * {@link normalizeBasePath} does.\n */\nexport function basePathPrefix(basePath?: string): string {\n  const bare = normalizeBasePath(basePath);\n  return bare ? `/${bare}` : \"\";\n}\n\n/**\n * Invalidation paths covering every URI of the app: what a deploy invalidates,\n * and what the cache handler's oversized batches, retries after a quota error,\n * and tags whose routes could not all be named fall back to.\n *\n * `/*` is the whole app only without a `basePath`. `/base/*` matches neither the\n * app's root, `/base`, nor its RSC payload, `/base?_rsc=…` - the same root the\n * `revalidatePath(\"/\")` that overflowed may have named - so those are spelled\n * out. `/base*` would cover them for one wildcard, but also every sibling\n * prefix (`/base2`, `/basement`), which may be another app on the same\n * distribution.\n */\nexport function wholeAppInvalidationPaths(basePath?: string): string[] {\n  const prefix = basePathPrefix(basePath);\n  return prefix ? [prefix, `${prefix}?*`, `${prefix}/*`] : [\"/*\"];\n}\n\n/**\n * Joins path parts with a single \"/\", normalizing each (so no leading or\n * trailing slash survives, including on the result) and dropping the empty\n * ones, so an unset `basePath` or key prefix leaves the rest untouched.\n */\nexport function joinPath(...parts: (string | undefined)[]): string {\n  return parts.map(normalizeBasePath).filter(Boolean).join(\"/\");\n}\n\n/**\n * Prefixes an absolute app path (a health check path, say) with `basePath`,\n * always returning a leading slash. An empty or unset `basePath` only\n * normalizes that leading slash. Anything after the first segment is passed\n * through as given, trailing slash included, since a `trailingSlash` app\n * answers \"/api/health\" and \"/api/health/\" differently.\n *\n * Use this for paths handed to something that talks to the app directly — an ALB\n * target group health check, the container's own health probe — since the app\n * only answers under its own `basePath`.\n *\n * Prefixes unconditionally, so `path` has to arrive as the app routes it,\n * without `basePath`: for an app based at \"/base\", \"/base/api/health\" becomes\n * \"/base/base/api/health\". Deliberately not special-cased — an app can route\n * \"/base/base/...\" legitimately, and accepting both spellings would give the\n * path two meanings. See `docs/breaking-changes.md` (0.6.0), which tells users\n * who prefixed `healthCheckPath` by hand to drop the prefix.\n */\nexport function prefixWithBasePath(\n  basePath: string | undefined,\n  path: string,\n): string {\n  const normalized = normalizeBasePath(basePath);\n  const absolute = path.startsWith(\"/\") ? path : `/${path}`;\n  return normalized ? `/${normalized}${absolute}` : absolute;\n}\n\n/** Whether an `assetPrefix` names an origin rather than a path on this one. */\nfunction isAbsoluteAssetPrefix(assetPrefix: string): boolean {\n  return /^([a-z][a-z0-9+.-]*:)?\\/\\//i.test(assetPrefix);\n}\n\n/**\n * The app's own `assetPrefix` as a path with a leading and no trailing slash\n * (\"/cdn\"), or `\"\"` when the app sets none.\n *\n * Returns `\"\"` for an absolute `assetPrefix` (\"https://cdn.example.com\", or the\n * protocol-relative \"//cdn.example.com\") too: that names an origin cdk-nextjs\n * does not control, and it is the supported way to serve assets from elsewhere,\n * so nothing about it is worth warning about. Use {@link assetPrefixPath} for\n * what the *distribution* has to answer on, which includes the path an absolute\n * prefix carries.\n *\n * Next.js applies `assetPrefix` on top of, not under, `basePath`, so the result\n * is the whole prefix of a `_next/static` URL and must not be joined with\n * `basePath`.\n */\nexport function relativeAssetPrefix(assetPrefix: string): string {\n  return isAbsoluteAssetPrefix(assetPrefix) ? \"\" : basePathPrefix(assetPrefix);\n}\n\n/**\n * Whether a path-style `assetPrefix` would go unanswered on this `NextjsType`,\n * i.e. whether every bundle would 404.\n *\n * `assetPrefix` moves every bundle URL to `<assetPrefix>/_next/static/...` while\n * the objects keep their `<basePath>/_next/static/...` S3 keys. The Global\n * `NextjsType`s answer that with a cache behavior of their own\n * (`NextjsDistribution`); the regional ones have nothing that maps the prefix\n * back — API Gateway's `_next/static` resource and the container's own files are\n * both under the unprefixed path.\n *\n * A prefix equal to the app's own `basePath` is **not** unserved, because that is\n * the value Next.js resolves `assetPrefix` to when `basePath` is set and\n * `assetPrefix` is not: `.next/required-server-files.json` comes back as\n * `{\"assetPrefix\":\"/prod\",\"basePath\":\"/prod\"}` for an app that only ever set\n * `basePath`. Without that exemption the warning fired on every regional\n * deployment that sets a `basePath` at all — including `examples/regional-functions`\n * — telling users their bundles would 404 at the one path that does serve them.\n * `NextjsDistribution.resolveAssetPrefix` drops the prefix for the same reason.\n *\n * Both sides go through `normalizeBasePath` because they arrive in different\n * shapes: `nextConfigAssetPrefix` carries a leading slash (`\"/prod\"`),\n * `nextConfigBasePath` does not (`\"prod\"`).\n */\nexport function isAssetPrefixUnserved(\n  nextjsType: NextjsType,\n  nextConfigAssetPrefix: string,\n  nextConfigBasePath?: string,\n): boolean {\n  if (!nextConfigAssetPrefix) return false;\n  if (\n    nextjsType === NextjsType.GLOBAL_FUNCTIONS ||\n    nextjsType === NextjsType.GLOBAL_CONTAINERS\n  ) {\n    return false;\n  }\n  return (\n    normalizeBasePath(nextConfigAssetPrefix) !==\n    normalizeBasePath(nextConfigBasePath)\n  );\n}\n\n/**\n * The *path* every bundle URL carries, whichever form `assetPrefix` takes: \"/cdn\"\n * for `assetPrefix: \"/cdn\"` and for `assetPrefix:\n * \"https://cdn.example.com/cdn\"` alike, `\"\"` when there is none (an absolute\n * prefix with no path, or no prefix at all).\n *\n * An absolute prefix's path counts because `next build` compiles a `beforeFiles`\n * rewrite of its own for it — `/cdn/_next/:path+ → /_next/:path+` — so `next\n * start` serves every bundle under that path as well as under `/_next`. A CDN\n * fronting this deployment at that path therefore has to be answered, and the\n * distribution's `assetPrefix` behavior is what answers it. Measured against\n * `test/e2e/app-dir/asset-prefix-absolute`; see `docs/harness-coverage.md`.\n * Shared with `NextjsDistribution`, whose `assetPrefix` prop a user can also\n * set by hand.\n */\nexport function assetPrefixPath(assetPrefix: string): string {\n  if (!assetPrefix) return \"\";\n  let path = assetPrefix;\n  if (isAbsoluteAssetPrefix(assetPrefix)) {\n    try {\n      // `//cdn.example.com/cdn` is protocol-relative, which `URL` only parses\n      // with a base — any base, since only the path is read off it.\n      path = new URL(assetPrefix, \"https://asset-prefix.invalid\").pathname;\n    } catch {\n      return \"\";\n    }\n  }\n  return basePathPrefix(path);\n}\n\n/**\n * The path prefix API Gateway strips before matching resources, as far as synth\n * can tell. Only read by `resolveBasePath` for `REGIONAL_FUNCTIONS`.\n */\nexport interface ApiGatewayPrefix {\n  /**\n   * The stage name on the execute-api endpoint, or the base path mapping on a\n   * custom domain (`\"\"` when mapped at the root). `undefined` when it is not\n   * known at synth — a token — in which case nothing is derived.\n   */\n  readonly strippedPrefix?: string;\n  /** Whether a custom domain is configured through `restApiProps.domainName`. */\n  readonly customDomain: boolean;\n}\n\n/** `RestApi`'s own defaults: the `prod` stage, no custom domain. */\nexport const DEFAULT_API_GATEWAY_PREFIX: ApiGatewayPrefix = {\n  strippedPrefix: \"prod\",\n  customDomain: false,\n};\n\n/**\n * The resource path an app's `basePath` needs on `REGIONAL_FUNCTIONS` when the\n * `basePath` prop is unset: the app's `basePath` with the prefix API Gateway\n * strips taken off the front, or the whole of it when it does not start with\n * that prefix.\n *\n * An app at the `prod` stage emits `/prod/...` and API Gateway strips `/prod`\n * before matching, so `basePath: \"/prod\"` needs resources at the root and\n * `basePath: \"/prod/base\"` needs them under `base`. An app whose `basePath` API\n * Gateway does not strip — a custom domain mapped at the root, serving\n * `basePath: \"/docs\"` — needs them under `docs`. Leaving that one at the root is\n * what used to happen: `_next/static` and `public/` fell through to the\n * `{proxy+}` catch-all, and every bundle 404'd with nothing said at synth.\n */\nfunction deriveApiGatewayBasePath(\n  config: string,\n  { strippedPrefix, customDomain }: ApiGatewayPrefix,\n): string | undefined {\n  if (!config || strippedPrefix === undefined) {\n    return undefined;\n  }\n  const stripped = normalizeBasePath(strippedPrefix);\n  if (hasPathPrefix(config, stripped)) {\n    return config.slice(stripped.length + 1) || undefined;\n  }\n  warnUnstrippedBasePath(config, { strippedPrefix, customDomain });\n  return config;\n}\n\n/**\n * Warn that an app mounted under its whole `basePath` is served somewhere its\n * own links don't reach, when API Gateway strips a prefix that `basePath` lacks.\n * Both ways of arriving there warn: the prop left unset (derived to the whole\n * `basePath`) and the prop set to the same value.\n */\nfunction warnUnstrippedBasePath(\n  config: string,\n  { strippedPrefix, customDomain }: ApiGatewayPrefix,\n): void {\n  const stripped = normalizeBasePath(strippedPrefix);\n  if (strippedPrefix === undefined || !stripped) {\n    // A token, or a custom domain mapped at the root: nothing is stripped that\n    // the app's links could miss.\n    return;\n  }\n  if (customDomain) {\n    // The same miss through a custom domain's base path mapping: served at\n    // `/<mapping>/<basePath>`, linking to `/<basePath>/...`, which no mapping\n    // covers.\n    console.warn(\n      `${LOG_PREFIX} your Next.js app's \\`basePath\\` is ${quote(config)}, which does not start with the custom domain's base path mapping \"/${stripped}\". ` +\n        \"Its links and bundle URLs will be requested without the mapping, which the custom domain answers with 403. \" +\n        `Set \\`basePath: \"/${joinPath(stripped, config)}\"\\` in your next.config, or map the domain at the root.`,\n    );\n  } else {\n    // Resources under the app's basePath serve it at `/<stage>/<basePath>`, but\n    // the app's own links are `/<basePath>/...`, which misses the stage. A\n    // warning, not an error: a domain attached after synth (`addDomainName`)\n    // makes it right, and synth cannot see that.\n    console.warn(\n      `${LOG_PREFIX} your Next.js app's \\`basePath\\` is ${quote(config)}, which does not start with the API Gateway stage \"/${stripped}\". ` +\n        \"Its links and bundle URLs will be requested without the stage, which the execute-api endpoint answers with 403. \" +\n        `Set \\`basePath: \"/${joinPath(stripped, config)}\"\\` in your next.config, or serve the app from a custom domain mapped at the root.`,\n    );\n  }\n}\n\n/** Whether API Gateway strips the front of `basePath` before matching resources. */\nfunction startsWithStrippedPrefix(\n  basePath: string,\n  { strippedPrefix }: ApiGatewayPrefix,\n): boolean {\n  const stripped = normalizeBasePath(strippedPrefix);\n  return !!basePath && hasPathPrefix(basePath, stripped);\n}\n\nfunction quote(basePath: string): string {\n  return basePath ? `\"/${basePath}\"` : \"unset\";\n}\n\n/**\n * Settles on the single `basePath` the infrastructure should be built around,\n * given the CDK `basePath` prop and the Next.js app's own `basePath`\n * (`NextjsBuild.nextConfigBasePath`), throwing at synth if the two can't serve\n * the app together. Returns a normalized value, or `undefined` for no\n * `basePath` at all; consumers that need a leading slash add their own.\n *\n * The two inputs are genuinely different things — the prop is where the\n * infrastructure serves the app from (and which S3 key prefix the static assets\n * land under), the config is the prefix the app emits its own links and asset\n * hrefs under — so how strictly they have to line up, and whether one can stand\n * in for the other, depends on how the `NextjsType` routes static requests.\n *\n * `apiGateway` is only read for `REGIONAL_FUNCTIONS`, and only when the prop is\n * unset: see `deriveApiGatewayBasePath`.\n */\nexport function resolveBasePath(\n  nextjsType: NextjsType,\n  propBasePath?: string,\n  nextConfigBasePath?: string,\n  apiGateway: ApiGatewayPrefix = DEFAULT_API_GATEWAY_PREFIX,\n): string | undefined {\n  const prop = normalizeBasePath(propBasePath);\n  const config = normalizeBasePath(nextConfigBasePath);\n  const mismatch =\n    `${LOG_PREFIX} basePath mismatch for NextjsType.${nextjsType}: the \\`basePath\\` prop is ${quote(prop)} ` +\n    `but your Next.js app's config sets \\`basePath\\` to ${quote(config)}. `;\n  if (prop === config) {\n    if (\n      nextjsType === NextjsType.REGIONAL_FUNCTIONS &&\n      startsWithStrippedPrefix(prop, apiGateway)\n    ) {\n      // Agreeing is not enough here: API Gateway strips the stage (or base path\n      // mapping) before matching, so resources under the prop's \"prod\" are only\n      // reached at `/prod/prod/...`, and every link the app emits 403s.\n      const problem =\n        `API Gateway strips \"/${normalizeBasePath(apiGateway.strippedPrefix)}\" before matching resources, so a prop that repeats it nests every resource under a path no request reaches. ` +\n        \"Leave the prop unset: it is derived from your app's `basePath` with that prefix taken off.\";\n      if (apiGateway.customDomain) {\n        throw new Error(mismatch + problem);\n      }\n      // On the execute-api endpoint that is certain, but an explicit prop wins:\n      // a domain attached with `addDomainName()`, invisible here, can map the\n      // stage at its root, and then `/prod/...` does reach resources under\n      // \"prod\".\n      console.warn(\n        mismatch +\n          problem +\n          \" (Ignore this if a domain attached with `addDomainName()` serves the app without stripping that prefix.)\",\n      );\n      return prop;\n    }\n    if (nextjsType === NextjsType.REGIONAL_FUNCTIONS && prop) {\n      // Agreeing the other way round has the unset case's problem: resources\n      // under \"docs\" are reached at `/prod/docs/...`, the app links to\n      // `/docs/...`.\n      warnUnstrippedBasePath(config, apiGateway);\n    }\n    return prop || undefined;\n  }\n\n  switch (nextjsType) {\n    case NextjsType.GLOBAL_FUNCTIONS:\n    case NextjsType.GLOBAL_CONTAINERS:\n      // `NextjsDistribution` builds its behaviors as `/${basePath}/_next/static*`\n      // and CloudFront hands an S3 origin the request path verbatim as the\n      // object key, so the only value that can serve the app is the prefix the\n      // app itself emits. That leaves the prop no room to differ, which makes\n      // the app's config the single source of truth worth deriving from.\n      if (!prop) {\n        return config;\n      }\n      throw new Error(\n        mismatch +\n          \"CloudFront serves static assets straight from S3 using the request path as the object key, so a mismatch means every `_next/static` and `public/` request 404s. \" +\n          \"Either set both to the same value, or drop the prop — left unset, it follows your app's `basePath`.\",\n      );\n    case NextjsType.REGIONAL_FUNCTIONS:\n      if (!prop) {\n        // A prop that is set but names no path (\"/\") is an explicit root\n        // mount, not \"unset\": it is how an app says the prefix is stripped by\n        // something synth can't see — a domain attached later with\n        // `addDomainName({ basePath })`, say — so deriving here would nest the\n        // resources under a path the stripped requests never reach.\n        if (propBasePath !== undefined) {\n          return undefined;\n        }\n        return deriveApiGatewayBasePath(config, apiGateway);\n      }\n      // The prop only has to be the tail of what the app emits, not all of it,\n      // because the stripped prefix is part of the app's `basePath` but never\n      // part of the resource path: an app at the `prod` stage nested under\n      // \"/base\" sets `basePath: \"/prod/base\"` and the prop to \"/base\". Exactly\n      // the stripped prefix and then the prop, not any tail: with a prop of\n      // \"/base\" an app at \"/foo/base\" is served at `/prod/base/...` and links\n      // to `/foo/base/...`, which 403s. Only a token stage, which synth can't\n      // read, falls back to a tail on a path boundary.\n      if (\n        apiGateway.strippedPrefix === undefined\n          ? config.endsWith(`/${prop}`)\n          : config === joinPath(apiGateway.strippedPrefix, prop)\n      ) {\n        return prop;\n      }\n      // Any tail on a path boundary is also what a domain attached with\n      // `addDomainName({ basePath: \"v1\" })` needs for an app at \"/v1/base\":\n      // synth only sees the stage, so it can't tell that setup from a mistake.\n      // An explicit prop wins, so that warns; a custom domain configured in\n      // `restApiProps.domainName` is visible, so there it still throws below.\n      if (!apiGateway.customDomain && config.endsWith(`/${prop}`)) {\n        const leading = config.slice(0, -prop.length - 1);\n        console.warn(\n          `${LOG_PREFIX} the \\`basePath\\` prop is ${quote(prop)} and your Next.js app's \\`basePath\\` is ${quote(config)}, ` +\n            `so the app is served at \"/${joinPath(normalizeBasePath(apiGateway.strippedPrefix), prop)}\" on the execute-api endpoint and links to \"/${config}\". ` +\n            `That only works through a custom domain whose base path mapping strips \"/${leading}\" (\\`addDomainName({ basePath: \"${leading}\" })\\`); otherwise every request 403s.`,\n        );\n        return prop;\n      }\n      // Anything else never works: the prop moves every resource, including the\n      // `ANY` catch-all, under a path the app never links to.\n      throw new Error(\n        mismatch +\n          \"The `basePath` prop nests every API Gateway resource under that path, including the catch-all, so the app has to emit its links under the same prefix or every request 404s. \" +\n          'Either set your app\\'s `basePath` to the prop, or to the prop prefixed by the stage or base path mapping API Gateway strips (e.g. `basePath: \"/prod/base\"` with a prop of \"/base\"), or leave the prop unset — unset is what you want when the app\\'s `basePath` is the API Gateway stage name, since the stage isn\\'t part of the resource path.',\n      );\n    case NextjsType.REGIONAL_CONTAINERS:\n      // The ALB forwards every path to the container, which serves its own\n      // static assets, so here `basePath` only namespaces the S3 bucket and has\n      // no routing meaning that could disagree with the app.\n      return prop || undefined;\n  }\n}\n"]}