cdk-nextjs 0.5.16 → 0.6.0

package/lib/utils/base-path.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeBasePath = normalizeBasePath;
+exports.joinPath = joinPath;
+exports.readNextConfigBasePath = readNextConfigBasePath;
+exports.resolveBasePath = resolveBasePath;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const constants_1 = require("../constants");
+/**
+ * Reduces a `basePath` to a bare path segment so values that address the same
+ * path ("/base", "base", "/base/") compare equal and can be concatenated
+ * without doubling separators.
+ */
+function normalizeBasePath(basePath) {
+    return (basePath || "").replace(/^\/+/, "").replace(/\/+$/, "");
+}
+/**
+ * Joins path parts with a single "/", normalizing each (so no leading or
+ * trailing slash survives, including on the result) and dropping the empty
+ * ones, so an unset `basePath` or key prefix leaves the rest untouched.
+ */
+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.
+ *
+ * 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.
+ */
+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.");
+        return "";
+    };
+    if (!(0, node_fs_1.existsSync)(requiredServerFiles)) {
+        return fallback(`"required-server-files.json" not found at ${requiredServerFiles}`);
+    }
+    try {
+        const { config } = JSON.parse((0, node_fs_1.readFileSync)(requiredServerFiles, "utf-8"));
+        return normalizeBasePath(config?.basePath);
+    }
+    catch (error) {
+        return fallback(`Could not read basePath from ${requiredServerFiles}: ${error}`);
+    }
+}
+function quote(basePath) {
+    return basePath ? `"/${basePath}"` : "unset";
+}
+/**
+ * Settles on the single `basePath` the infrastructure should be built around,
+ * given the CDK `basePath` prop and the Next.js app's own `basePath`
+ * (`NextjsBuild.nextConfigBasePath`), throwing at synth if the two can't serve
+ * the app together. Returns a normalized value, or `undefined` for no
+ * `basePath` at all; consumers that need a leading slash add their own.
+ *
+ * The two inputs are genuinely different things — the prop is where the
+ * infrastructure serves the app from (and which S3 key prefix the static assets
+ * 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.
+ */
+function resolveBasePath(nextjsType, propBasePath, nextConfigBasePath) {
+    const prop = normalizeBasePath(propBasePath);
+    const config = normalizeBasePath(nextConfigBasePath);
+    if (prop === config) {
+        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:
+            // `NextjsDistribution` builds its behaviors as `/${basePath}/_next/static*`
+            // and CloudFront hands an S3 origin the request path verbatim as the
+            // object key, so the only value that can serve the app is the prefix the
+            // app itself emits. That leaves the prop no room to differ, which makes
+            // the app's config the single source of truth worth deriving from.
+            if (!prop) {
+                return config;
+            }
+            throw new Error(mismatch +
+                "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;
+            }
+            // 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}`)) {
+                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.');
+        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
+            // no routing meaning that could disagree with the app.
+            return prop || undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-path.js","sourceRoot":"","sources":["../../src/utils/base-path.ts"],"names":[],"mappings":";;AASA,8CAEC;AAOD,4BAEC;AAcD,wDAuBC;AAmBD,0CA4DC;AAxID,qCAAmD;AACnD,yCAAiC;AACjC,4CAAsD;AAEtD;;;;GAIG;AACH,SAAgB,iBAAiB,CAAC,QAAiB;IACjD,OAAO,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;AAClE,CAAC;AAED;;;;GAIG;AACH,SAAgB,QAAQ,CAAC,GAAG,KAA6B;IACvD,OAAO,KAAK,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAChE,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAgB,sBAAsB,CAAC,WAAmB;IACxD,MAAM,mBAAmB,GAAG,IAAA,gBAAI,EAAC,WAAW,EAAE,4BAA4B,CAAC,CAAC;IAC5E,MAAM,QAAQ,GAAG,CAAC,MAAc,EAAE,EAAE;QAClC,OAAO,CAAC,IAAI,CACV,GAAG,sBAAU,IAAI,MAAM,oDAAoD;YACzE,qEAAqE;YACrE,uDAAuD,CAC1D,CAAC;QACF,OAAO,EAAE,CAAC;IACZ,CAAC,CAAC;IACF,IAAI,CAAC,IAAA,oBAAU,EAAC,mBAAmB,CAAC,EAAE,CAAC;QACrC,OAAO,QAAQ,CACb,6CAA6C,mBAAmB,EAAE,CACnE,CAAC;IACJ,CAAC;IACD,IAAI,CAAC;QACH,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,IAAA,sBAAY,EAAC,mBAAmB,EAAE,OAAO,CAAC,CAAC,CAAC;QAC1E,OAAO,iBAAiB,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAC7C,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,QAAQ,CACb,gCAAgC,mBAAmB,KAAK,KAAK,EAAE,CAChE,CAAC;IACJ,CAAC;AACH,CAAC;AAED,SAAS,KAAK,CAAC,QAAgB;IAC7B,OAAO,QAAQ,CAAC,CAAC,CAAC,KAAK,QAAQ,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC;AAC/C,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,eAAe,CAC7B,UAAsB,EACtB,YAAqB,EACrB,kBAA2B;IAE3B,MAAM,IAAI,GAAG,iBAAiB,CAAC,YAAY,CAAC,CAAC;IAC7C,MAAM,MAAM,GAAG,iBAAiB,CAAC,kBAAkB,CAAC,CAAC;IACrD,IAAI,IAAI,KAAK,MAAM,EAAE,CAAC;QACpB,OAAO,IAAI,IAAI,SAAS,CAAC;IAC3B,CAAC;IAED,MAAM,QAAQ,GACZ,GAAG,sBAAU,qCAAqC,UAAU,8BAA8B,KAAK,CAAC,IAAI,CAAC,GAAG;QACxG,sDAAsD,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC;IAE1E,QAAQ,UAAU,EAAE,CAAC;QACnB,KAAK,sBAAU,CAAC,gBAAgB,CAAC;QACjC,KAAK,sBAAU,CAAC,iBAAiB;YAC/B,4EAA4E;YAC5E,qEAAqE;YACrE,yEAAyE;YACzE,wEAAwE;YACxE,mEAAmE;YACnE,IAAI,CAAC,IAAI,EAAE,CAAC;gBACV,OAAO,MAAM,CAAC;YAChB,CAAC;YACD,MAAM,IAAI,KAAK,CACb,QAAQ;gBACN,kKAAkK;gBAClK,qGAAqG,CACxG,CAAC;QACJ,KAAK,sBAAU,CAAC,kBAAkB;YAChC,yEAAyE;YACzE,yEAAyE;YACzE,0EAA0E;YAC1E,+DAA+D;YAC/D,IAAI,CAAC,IAAI,EAAE,CAAC;gBACV,OAAO,SAAS,CAAC;YACnB,CAAC;YACD,yEAAyE;YACzE,wEAAwE;YACxE,qEAAqE;YACrE,yEAAyE;YACzE,oEAAoE;YACpE,IAAI,MAAM,CAAC,QAAQ,CAAC,IAAI,IAAI,EAAE,CAAC,EAAE,CAAC;gBAChC,OAAO,IAAI,CAAC;YACd,CAAC;YACD,0EAA0E;YAC1E,wDAAwD;YACxD,MAAM,IAAI,KAAK,CACb,QAAQ;gBACN,+KAA+K;gBAC/K,uVAAuV,CAC1V,CAAC;QACJ,KAAK,sBAAU,CAAC,mBAAmB;YACjC,qEAAqE;YACrE,0EAA0E;YAC1E,uDAAuD;YACvD,OAAO,IAAI,IAAI,SAAS,CAAC;IAC7B,CAAC;AACH,CAAC","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"]}

package/lib/utils/base-path.test.d.ts

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

package/lib/utils/base-path.test.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const constants_1 = require("../constants");
+const base_path_1 = require("./base-path");
+const GLOBAL = [constants_1.NextjsType.GLOBAL_FUNCTIONS, constants_1.NextjsType.GLOBAL_CONTAINERS];
+describe("normalizeBasePath", () => {
+    it("reduces values addressing the same path to the same segment", () => {
+        expect((0, base_path_1.normalizeBasePath)("/base")).toBe("base");
+        expect((0, base_path_1.normalizeBasePath)("base")).toBe("base");
+        expect((0, base_path_1.normalizeBasePath)("/base/")).toBe("base");
+        expect((0, base_path_1.normalizeBasePath)("//base//")).toBe("base");
+    });
+    it("maps undefined and empty values to an empty string", () => {
+        expect((0, base_path_1.normalizeBasePath)(undefined)).toBe("");
+        expect((0, base_path_1.normalizeBasePath)("")).toBe("");
+        expect((0, base_path_1.normalizeBasePath)("/")).toBe("");
+    });
+    it("keeps interior slashes of a nested basePath", () => {
+        expect((0, base_path_1.normalizeBasePath)("/team/app/")).toBe("team/app");
+    });
+});
+describe("joinPath", () => {
+    const origin = "https://d111111abcdef8.cloudfront.net";
+    it("drops empty parts", () => {
+        expect((0, base_path_1.joinPath)(origin)).toBe(origin);
+        expect((0, base_path_1.joinPath)(origin, "")).toBe(origin);
+        expect((0, base_path_1.joinPath)(origin, undefined)).toBe(origin);
+        expect((0, base_path_1.joinPath)(origin, "/")).toBe(origin);
+        expect((0, base_path_1.joinPath)("", "base", undefined, "_next/static")).toBe("base/_next/static");
+    });
+    it("joins with exactly one slash regardless of each part's slashes", () => {
+        expect((0, base_path_1.joinPath)(origin, "/base")).toBe(`${origin}/base`);
+        expect((0, base_path_1.joinPath)(origin, "base/")).toBe(`${origin}/base`);
+        expect((0, base_path_1.joinPath)(origin, "/team/app/")).toBe(`${origin}/team/app`);
+        expect((0, base_path_1.joinPath)("/base/", "/_next/static/{key}")).toBe("base/_next/static/{key}");
+    });
+    it("returns an empty string when every part is empty", () => {
+        expect((0, base_path_1.joinPath)()).toBe("");
+        expect((0, base_path_1.joinPath)(undefined, "", "/")).toBe("");
+    });
+});
+describe("readNextConfigBasePath", () => {
+    let dotNextPath;
+    let warn;
+    beforeEach(() => {
+        dotNextPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "base-path-"));
+        warn = jest.spyOn(console, "warn").mockImplementation(() => { });
+    });
+    afterEach(() => {
+        warn.mockRestore();
+        (0, node_fs_1.rmSync)(dotNextPath, { recursive: true, force: true });
+    });
+    function writeRequiredServerFiles(contents) {
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(dotNextPath, "required-server-files.json"), contents);
+    }
+    it("reads the app's basePath and strips the leading slash", () => {
+        writeRequiredServerFiles(JSON.stringify({ config: { basePath: "/prod" } }));
+        expect((0, base_path_1.readNextConfigBasePath)(dotNextPath)).toBe("prod");
+        expect(warn).not.toHaveBeenCalled();
+    });
+    it("returns an empty string when the app sets no basePath", () => {
+        // `next build` writes basePath: "" rather than omitting it.
+        writeRequiredServerFiles(JSON.stringify({ config: { basePath: "" } }));
+        expect((0, base_path_1.readNextConfigBasePath)(dotNextPath)).toBe("");
+        expect(warn).not.toHaveBeenCalled();
+    });
+    // Degrading to "" is deliberate, but it's indistinguishable from an app that
+    // sets no basePath, so it has to be visible: the Global constructs derive
+    // their basePath from this value and would otherwise 404 every static asset
+    // with nothing but a silent fallback to explain it.
+    it("warns when required-server-files.json is missing", () => {
+        expect((0, base_path_1.readNextConfigBasePath)(dotNextPath)).toBe("");
+        expect(warn).toHaveBeenCalledWith(expect.stringContaining("required-server-files.json"));
+    });
+    it("warns when the file isn't valid JSON", () => {
+        writeRequiredServerFiles("not json");
+        expect((0, base_path_1.readNextConfigBasePath)(dotNextPath)).toBe("");
+        expect(warn).toHaveBeenCalledWith(expect.stringContaining("Could not read basePath"));
+    });
+    it("returns an empty string when the file has no config key", () => {
+        writeRequiredServerFiles(JSON.stringify({ files: [] }));
+        expect((0, base_path_1.readNextConfigBasePath)(dotNextPath)).toBe("");
+    });
+});
+describe("resolveBasePath", () => {
+    describe.each(Object.values(constants_1.NextjsType))("%s", (nextjsType) => {
+        it("resolves to undefined when both are unset", () => {
+            expect((0, base_path_1.resolveBasePath)(nextjsType)).toBeUndefined();
+            expect((0, base_path_1.resolveBasePath)(nextjsType, "", "")).toBeUndefined();
+            // Normalizes to empty, so it's the same as unset rather than a prefix.
+            expect((0, base_path_1.resolveBasePath)(nextjsType, "/")).toBeUndefined();
+        });
+        // One shape out, whatever shape came in: consumers that need a leading
+        // slash (only `NextjsDistribution`'s path patterns) add their own, so
+        // nothing downstream has to re-normalize.
+        it("normalizes the prop when it matches the app", () => {
+            expect((0, base_path_1.resolveBasePath)(nextjsType, "/base", "/base")).toBe("base");
+            expect((0, base_path_1.resolveBasePath)(nextjsType, "base", "/base")).toBe("base");
+            expect((0, base_path_1.resolveBasePath)(nextjsType, "/base/", "/base")).toBe("base");
+            expect((0, base_path_1.resolveBasePath)(nextjsType, "base//", "/base")).toBe("base");
+        });
+    });
+    describe.each(GLOBAL)("%s", (nextjsType) => {
+        // CloudFront uses the request path verbatim as the S3 object key, so the
+        // prop has to be the prefix the app emits — there's exactly one valid value,
+        // which makes the app's config the source of truth.
+        it("derives the prop from the app's basePath", () => {
+            expect((0, base_path_1.resolveBasePath)(nextjsType, undefined, "/base")).toBe("base");
+            expect((0, base_path_1.resolveBasePath)(nextjsType, "", "base")).toBe("base");
+            expect((0, base_path_1.resolveBasePath)(nextjsType, undefined, "/team/app/")).toBe("team/app");
+        });
+        it("rejects the prop setting a basePath the app doesn't", () => {
+            expect(() => (0, base_path_1.resolveBasePath)(nextjsType, "/base")).toThrow(/CloudFront serves static assets straight from S3/);
+        });
+        it("rejects two different values", () => {
+            expect(() => (0, base_path_1.resolveBasePath)(nextjsType, "/a", "/b")).toThrow('prop is "/a" but your Next.js app\'s config sets `basePath` to "/b"');
+        });
+    });
+    describe(constants_1.NextjsType.REGIONAL_FUNCTIONS, () => {
+        // API Gateway strips the stage before matching resources, so an app served
+        // at the default `prod` stage sets basePath: "/prod" and leaves the prop
+        // unset. Same shape as a custom domain base path mapping. Deriving here
+        // would nest every resource under a path the stage already consumed.
+        it("does not derive the app's basePath", () => {
+            expect((0, base_path_1.resolveBasePath)(constants_1.NextjsType.REGIONAL_FUNCTIONS, undefined, "/prod")).toBeUndefined();
+        });
+        // The stripped prefix is part of what the app emits but never part of the
+        // resource path, so an app at the `prod` stage nested under "/base" sets
+        // basePath: "/prod/base" and the prop to "/base".
+        it("accepts an app basePath that ends with the prop", () => {
+            expect((0, base_path_1.resolveBasePath)(constants_1.NextjsType.REGIONAL_FUNCTIONS, "/base", "/prod/base")).toBe("base");
+        });
+        it("only accepts the prop as a whole trailing path segment", () => {
+            expect(() => (0, base_path_1.resolveBasePath)(constants_1.NextjsType.REGIONAL_FUNCTIONS, "/se", "/prod/base")).toThrow(/nests every API Gateway resource under that path/);
+            // Leading, not trailing: API Gateway strips the stage, so the app would
+            // emit "/prod/..." while the resources live under "/prod/base/...".
+            expect(() => (0, base_path_1.resolveBasePath)(constants_1.NextjsType.REGIONAL_FUNCTIONS, "/prod", "/prod/base")).toThrow(/nests every API Gateway resource under that path/);
+        });
+        // The reverse is never right: the prop nests every resource, including the
+        // catch-all, under a path the app never links to.
+        it("rejects the prop setting a basePath the app doesn't", () => {
+            expect(() => (0, base_path_1.resolveBasePath)(constants_1.NextjsType.REGIONAL_FUNCTIONS, "/base")).toThrow(/nests every API Gateway resource under that path/);
+        });
+        it("rejects two different values", () => {
+            expect(() => (0, base_path_1.resolveBasePath)(constants_1.NextjsType.REGIONAL_FUNCTIONS, "/a", "/b")).toThrow(/nests every API Gateway resource under that path/);
+        });
+    });
+    describe(constants_1.NextjsType.REGIONAL_CONTAINERS, () => {
+        // basePath only namespaces the S3 bucket here: the ALB forwards every path
+        // to the container, which serves its own static assets. So any combination
+        // is valid, and the app's basePath is never derived into the bucket prefix.
+        it("accepts any combination, always keeping the prop", () => {
+            const nextjsType = constants_1.NextjsType.REGIONAL_CONTAINERS;
+            expect((0, base_path_1.resolveBasePath)(nextjsType, "/a", "/b")).toBe("a");
+            expect((0, base_path_1.resolveBasePath)(nextjsType, "/a")).toBe("a");
+            expect((0, base_path_1.resolveBasePath)(nextjsType, undefined, "/b")).toBeUndefined();
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-path.test.js","sourceRoot":"","sources":["../../src/utils/base-path.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { mkdtempSync, rmSync, writeFileSync } from \"node:fs\";\nimport { tmpdir } from \"node:os\";\nimport { join } from \"node:path\";\nimport { NextjsType } from \"../constants\";\nimport {\n  joinPath,\n  normalizeBasePath,\n  readNextConfigBasePath,\n  resolveBasePath,\n} from \"./base-path\";\n\nconst GLOBAL = [NextjsType.GLOBAL_FUNCTIONS, NextjsType.GLOBAL_CONTAINERS];\n\ndescribe(\"normalizeBasePath\", () => {\n  it(\"reduces values addressing the same path to the same segment\", () => {\n    expect(normalizeBasePath(\"/base\")).toBe(\"base\");\n    expect(normalizeBasePath(\"base\")).toBe(\"base\");\n    expect(normalizeBasePath(\"/base/\")).toBe(\"base\");\n    expect(normalizeBasePath(\"//base//\")).toBe(\"base\");\n  });\n\n  it(\"maps undefined and empty values to an empty string\", () => {\n    expect(normalizeBasePath(undefined)).toBe(\"\");\n    expect(normalizeBasePath(\"\")).toBe(\"\");\n    expect(normalizeBasePath(\"/\")).toBe(\"\");\n  });\n\n  it(\"keeps interior slashes of a nested basePath\", () => {\n    expect(normalizeBasePath(\"/team/app/\")).toBe(\"team/app\");\n  });\n});\n\ndescribe(\"joinPath\", () => {\n  const origin = \"https://d111111abcdef8.cloudfront.net\";\n\n  it(\"drops empty parts\", () => {\n    expect(joinPath(origin)).toBe(origin);\n    expect(joinPath(origin, \"\")).toBe(origin);\n    expect(joinPath(origin, undefined)).toBe(origin);\n    expect(joinPath(origin, \"/\")).toBe(origin);\n    expect(joinPath(\"\", \"base\", undefined, \"_next/static\")).toBe(\n      \"base/_next/static\",\n    );\n  });\n\n  it(\"joins with exactly one slash regardless of each part's slashes\", () => {\n    expect(joinPath(origin, \"/base\")).toBe(`${origin}/base`);\n    expect(joinPath(origin, \"base/\")).toBe(`${origin}/base`);\n    expect(joinPath(origin, \"/team/app/\")).toBe(`${origin}/team/app`);\n    expect(joinPath(\"/base/\", \"/_next/static/{key}\")).toBe(\n      \"base/_next/static/{key}\",\n    );\n  });\n\n  it(\"returns an empty string when every part is empty\", () => {\n    expect(joinPath()).toBe(\"\");\n    expect(joinPath(undefined, \"\", \"/\")).toBe(\"\");\n  });\n});\n\ndescribe(\"readNextConfigBasePath\", () => {\n  let dotNextPath: string;\n  let warn: jest.SpyInstance;\n\n  beforeEach(() => {\n    dotNextPath = mkdtempSync(join(tmpdir(), \"base-path-\"));\n    warn = jest.spyOn(console, \"warn\").mockImplementation(() => {});\n  });\n\n  afterEach(() => {\n    warn.mockRestore();\n    rmSync(dotNextPath, { recursive: true, force: true });\n  });\n\n  function writeRequiredServerFiles(contents: string) {\n    writeFileSync(join(dotNextPath, \"required-server-files.json\"), contents);\n  }\n\n  it(\"reads the app's basePath and strips the leading slash\", () => {\n    writeRequiredServerFiles(JSON.stringify({ config: { basePath: \"/prod\" } }));\n\n    expect(readNextConfigBasePath(dotNextPath)).toBe(\"prod\");\n    expect(warn).not.toHaveBeenCalled();\n  });\n\n  it(\"returns an empty string when the app sets no basePath\", () => {\n    // `next build` writes basePath: \"\" rather than omitting it.\n    writeRequiredServerFiles(JSON.stringify({ config: { basePath: \"\" } }));\n\n    expect(readNextConfigBasePath(dotNextPath)).toBe(\"\");\n    expect(warn).not.toHaveBeenCalled();\n  });\n\n  // Degrading to \"\" is deliberate, but it's indistinguishable from an app that\n  // sets no basePath, so it has to be visible: the Global constructs derive\n  // their basePath from this value and would otherwise 404 every static asset\n  // with nothing but a silent fallback to explain it.\n  it(\"warns when required-server-files.json is missing\", () => {\n    expect(readNextConfigBasePath(dotNextPath)).toBe(\"\");\n    expect(warn).toHaveBeenCalledWith(\n      expect.stringContaining(\"required-server-files.json\"),\n    );\n  });\n\n  it(\"warns when the file isn't valid JSON\", () => {\n    writeRequiredServerFiles(\"not json\");\n\n    expect(readNextConfigBasePath(dotNextPath)).toBe(\"\");\n    expect(warn).toHaveBeenCalledWith(\n      expect.stringContaining(\"Could not read basePath\"),\n    );\n  });\n\n  it(\"returns an empty string when the file has no config key\", () => {\n    writeRequiredServerFiles(JSON.stringify({ files: [] }));\n\n    expect(readNextConfigBasePath(dotNextPath)).toBe(\"\");\n  });\n});\n\ndescribe(\"resolveBasePath\", () => {\n  describe.each(Object.values(NextjsType))(\"%s\", (nextjsType) => {\n    it(\"resolves to undefined when both are unset\", () => {\n      expect(resolveBasePath(nextjsType)).toBeUndefined();\n      expect(resolveBasePath(nextjsType, \"\", \"\")).toBeUndefined();\n      // Normalizes to empty, so it's the same as unset rather than a prefix.\n      expect(resolveBasePath(nextjsType, \"/\")).toBeUndefined();\n    });\n\n    // One shape out, whatever shape came in: consumers that need a leading\n    // slash (only `NextjsDistribution`'s path patterns) add their own, so\n    // nothing downstream has to re-normalize.\n    it(\"normalizes the prop when it matches the app\", () => {\n      expect(resolveBasePath(nextjsType, \"/base\", \"/base\")).toBe(\"base\");\n      expect(resolveBasePath(nextjsType, \"base\", \"/base\")).toBe(\"base\");\n      expect(resolveBasePath(nextjsType, \"/base/\", \"/base\")).toBe(\"base\");\n      expect(resolveBasePath(nextjsType, \"base//\", \"/base\")).toBe(\"base\");\n    });\n  });\n\n  describe.each(GLOBAL)(\"%s\", (nextjsType) => {\n    // CloudFront uses the request path verbatim as the S3 object key, so the\n    // prop has to be the prefix the app emits — there's exactly one valid value,\n    // which makes the app's config the source of truth.\n    it(\"derives the prop from the app's basePath\", () => {\n      expect(resolveBasePath(nextjsType, undefined, \"/base\")).toBe(\"base\");\n      expect(resolveBasePath(nextjsType, \"\", \"base\")).toBe(\"base\");\n      expect(resolveBasePath(nextjsType, undefined, \"/team/app/\")).toBe(\n        \"team/app\",\n      );\n    });\n\n    it(\"rejects the prop setting a basePath the app doesn't\", () => {\n      expect(() => resolveBasePath(nextjsType, \"/base\")).toThrow(\n        /CloudFront serves static assets straight from S3/,\n      );\n    });\n\n    it(\"rejects two different values\", () => {\n      expect(() => resolveBasePath(nextjsType, \"/a\", \"/b\")).toThrow(\n        'prop is \"/a\" but your Next.js app\\'s config sets `basePath` to \"/b\"',\n      );\n    });\n  });\n\n  describe(NextjsType.REGIONAL_FUNCTIONS, () => {\n    // API Gateway strips the stage before matching resources, so an app served\n    // at the default `prod` stage sets basePath: \"/prod\" and leaves the prop\n    // unset. Same shape as a custom domain base path mapping. Deriving here\n    // would nest every resource under a path the stage already consumed.\n    it(\"does not derive the app's basePath\", () => {\n      expect(\n        resolveBasePath(NextjsType.REGIONAL_FUNCTIONS, undefined, \"/prod\"),\n      ).toBeUndefined();\n    });\n\n    // The stripped prefix is part of what the app emits but never part of the\n    // resource path, so an app at the `prod` stage nested under \"/base\" sets\n    // basePath: \"/prod/base\" and the prop to \"/base\".\n    it(\"accepts an app basePath that ends with the prop\", () => {\n      expect(\n        resolveBasePath(NextjsType.REGIONAL_FUNCTIONS, \"/base\", \"/prod/base\"),\n      ).toBe(\"base\");\n    });\n\n    it(\"only accepts the prop as a whole trailing path segment\", () => {\n      expect(() =>\n        resolveBasePath(NextjsType.REGIONAL_FUNCTIONS, \"/se\", \"/prod/base\"),\n      ).toThrow(/nests every API Gateway resource under that path/);\n      // Leading, not trailing: API Gateway strips the stage, so the app would\n      // emit \"/prod/...\" while the resources live under \"/prod/base/...\".\n      expect(() =>\n        resolveBasePath(NextjsType.REGIONAL_FUNCTIONS, \"/prod\", \"/prod/base\"),\n      ).toThrow(/nests every API Gateway resource under that path/);\n    });\n\n    // The reverse is never right: the prop nests every resource, including the\n    // catch-all, under a path the app never links to.\n    it(\"rejects the prop setting a basePath the app doesn't\", () => {\n      expect(() =>\n        resolveBasePath(NextjsType.REGIONAL_FUNCTIONS, \"/base\"),\n      ).toThrow(/nests every API Gateway resource under that path/);\n    });\n\n    it(\"rejects two different values\", () => {\n      expect(() =>\n        resolveBasePath(NextjsType.REGIONAL_FUNCTIONS, \"/a\", \"/b\"),\n      ).toThrow(/nests every API Gateway resource under that path/);\n    });\n  });\n\n  describe(NextjsType.REGIONAL_CONTAINERS, () => {\n    // basePath only namespaces the S3 bucket here: the ALB forwards every path\n    // to the container, which serves its own static assets. So any combination\n    // is valid, and the app's basePath is never derived into the bucket prefix.\n    it(\"accepts any combination, always keeping the prop\", () => {\n      const nextjsType = NextjsType.REGIONAL_CONTAINERS;\n      expect(resolveBasePath(nextjsType, \"/a\", \"/b\")).toBe(\"a\");\n      expect(resolveBasePath(nextjsType, \"/a\")).toBe(\"a\");\n      expect(resolveBasePath(nextjsType, undefined, \"/b\")).toBeUndefined();\n    });\n  });\n});\n"]}

package/package.json

@@ -81,7 +81,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.5.16",
+  "version": "0.6.0",
   "jest": {
     "coverageProvider": "v8",
     "testPathIgnorePatterns": [