@opennextjs/aws 3.5.0 → 3.5.2

package/dist/build/copyTracedFiles.js

@@ -2,9 +2,21 @@ import url from "node:url";
 import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, readlinkSync, statSync, symlinkSync, writeFileSync, } from "node:fs";
 import path from "node:path";
 import { loadConfig, loadPrerenderManifest } from "../adapters/config/util.js";
+import { getCrossPlatformPathRegex } from "../utils/regex.js";
 import logger from "../logger.js";
 import { MIDDLEWARE_TRACE_FILE } from "./constant.js";
 const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
+//TODO: we need to figure which packages we could safely remove
+const EXCLUDED_PACKAGES = [
+    "caniuse-lite",
+    "sharp",
+    // This seems to be only in Next 15
+    // Some of sharp deps are under the @img scope
+    "@img",
+];
+function isExcluded(srcPath) {
+    return EXCLUDED_PACKAGES.some((excluded) => srcPath.match(getCrossPlatformPathRegex(`/node_modules/${excluded}/`)));
+}
 function copyPatchFile(outputDir) {
     const patchFile = path.join(__dirname, "patch", "patchedAsyncStorage.js");
     const outputPatchFile = path.join(outputDir, "patchedAsyncStorage.cjs");
@@ -119,11 +131,8 @@ File ${fullFilePath} does not exist
     });
     //Actually copy the files
     filesToCopy.forEach((to, from) => {
-        if (
-        //TODO: we need to figure which packages we could safely remove
-        from.includes(path.join("node_modules", "caniuse-lite")) ||
-            // from.includes("jest-worker") || This ones seems necessary for next 12
-            from.includes(path.join("node_modules", "sharp"))) {
+        // We don't want to copy excluded packages (i.e sharp)
+        if (isExcluded(from)) {
             return;
         }
         mkdirSync(path.dirname(to), { recursive: true });

package/dist/core/routing/i18n/index.d.ts

@@ -1,4 +1,30 @@
-import type { i18nConfig } from "../../../types/next-types";
-import type { InternalEvent } from "../../../types/open-next";
+import type { DomainLocale, i18nConfig } from "../../../types/next-types";
+import type { InternalEvent, InternalResult } from "../../../types/open-next";
+/**
+ * @param arg an object containing the hostname and detectedLocale
+ * @returns The `DomainLocale` object if a domain is detected, `undefined` otherwise
+ */
+export declare function detectDomainLocale({ hostname, detectedLocale, }: {
+    hostname?: string;
+    detectedLocale?: string;
+}): DomainLocale | undefined;
+/**
+ *
+ * @param internalEvent
+ * @param i18n
+ * @returns The detected locale, if `localeDetection` is set to `false` it will return the default locale **or** the domain default locale if a domain is detected.
+ */
 export declare function detectLocale(internalEvent: InternalEvent, i18n: i18nConfig): string;
+/**
+ * This function is used for OpenNext internal routing to localize the path for next config rewrite/redirects/headers and the middleware
+ * @param internalEvent
+ * @returns The localized path
+ */
 export declare function localizePath(internalEvent: InternalEvent): string;
+/**
+ *
+ * @param internalEvent
+ * In this function, for domain locale redirect we need to rely on the host to be present and correct
+ * @returns `false` if no redirect is needed, `InternalResult` if a redirect is needed
+ */
+export declare function handleLocaleRedirect(internalEvent: InternalEvent): false | InternalResult;

package/dist/core/routing/i18n/index.js

@@ -1,5 +1,7 @@
 import { NextConfig } from "../../../adapters/config/index.js";
+import { emptyReadableStream } from "../../../utils/stream.js";
 import { debug } from "../../../adapters/logger.js";
+import { constructNextUrl } from "../util.js";
 import { acceptLanguage } from "./accept-header";
 function isLocalizedPath(path) {
     return (NextConfig.i18n?.locales.includes(path.split("/")[1].toLowerCase()) ?? false);
@@ -12,9 +14,40 @@ function getLocaleFromCookie(cookies) {
         ? i18n?.locales.find((locale) => nextLocale === locale.toLowerCase())
         : undefined;
 }
+// Inspired by https://github.com/vercel/next.js/blob/6d93d652e0e7ba72d9a3b66e78746dce2069db03/packages/next/src/shared/lib/i18n/detect-domain-locale.ts#L3-L25
+/**
+ * @param arg an object containing the hostname and detectedLocale
+ * @returns The `DomainLocale` object if a domain is detected, `undefined` otherwise
+ */
+export function detectDomainLocale({ hostname, detectedLocale, }) {
+    const i18n = NextConfig.i18n;
+    const domains = i18n?.domains;
+    if (!domains) {
+        return;
+    }
+    const lowercasedLocale = detectedLocale?.toLowerCase();
+    for (const domain of domains) {
+        // We remove the port if present
+        const domainHostname = domain.domain.split(":", 1)[0].toLowerCase();
+        if (hostname === domainHostname ||
+            lowercasedLocale === domain.defaultLocale.toLowerCase() ||
+            domain.locales?.some((locale) => lowercasedLocale === locale.toLowerCase())) {
+            return domain;
+        }
+    }
+}
+/**
+ *
+ * @param internalEvent
+ * @param i18n
+ * @returns The detected locale, if `localeDetection` is set to `false` it will return the default locale **or** the domain default locale if a domain is detected.
+ */
 export function detectLocale(internalEvent, i18n) {
+    const domainLocale = detectDomainLocale({
+        hostname: internalEvent.headers.host,
+    });
     if (i18n.localeDetection === false) {
-        return i18n.defaultLocale;
+        return domainLocale?.defaultLocale ?? i18n.defaultLocale;
     }
     const cookiesLocale = getLocaleFromCookie(internalEvent.cookies);
     const preferredLocale = acceptLanguage(internalEvent.headers["accept-language"], i18n?.locales);
@@ -22,18 +55,79 @@ export function detectLocale(internalEvent, i18n) {
         cookiesLocale,
         preferredLocale,
         defaultLocale: i18n.defaultLocale,
+        domainLocale,
     });
-    return cookiesLocale ?? preferredLocale ?? i18n.defaultLocale;
-    // TODO: handle domain based locale detection
+    return (domainLocale?.defaultLocale ??
+        cookiesLocale ??
+        preferredLocale ??
+        i18n.defaultLocale);
 }
+/**
+ * This function is used for OpenNext internal routing to localize the path for next config rewrite/redirects/headers and the middleware
+ * @param internalEvent
+ * @returns The localized path
+ */
 export function localizePath(internalEvent) {
     const i18n = NextConfig.i18n;
     if (!i18n) {
         return internalEvent.rawPath;
     }
+    // When the path is already localized we don't need to do anything
     if (isLocalizedPath(internalEvent.rawPath)) {
         return internalEvent.rawPath;
     }
     const detectedLocale = detectLocale(internalEvent, i18n);
     return `/${detectedLocale}${internalEvent.rawPath}`;
 }
+/**
+ *
+ * @param internalEvent
+ * In this function, for domain locale redirect we need to rely on the host to be present and correct
+ * @returns `false` if no redirect is needed, `InternalResult` if a redirect is needed
+ */
+export function handleLocaleRedirect(internalEvent) {
+    const i18n = NextConfig.i18n;
+    if (!i18n ||
+        i18n.localeDetection === false ||
+        internalEvent.rawPath !== "/") {
+        return false;
+    }
+    const preferredLocale = acceptLanguage(internalEvent.headers["accept-language"], i18n?.locales);
+    const detectedLocale = detectLocale(internalEvent, i18n);
+    const domainLocale = detectDomainLocale({
+        hostname: internalEvent.headers.host,
+    });
+    const preferredDomain = detectDomainLocale({
+        detectedLocale: preferredLocale,
+    });
+    if (domainLocale && preferredDomain) {
+        const isPDomain = preferredDomain.domain === domainLocale.domain;
+        const isPLocale = preferredDomain.defaultLocale === preferredLocale;
+        if (!isPDomain || !isPLocale) {
+            const scheme = `http${preferredDomain.http ? "" : "s"}`;
+            const rlocale = isPLocale ? "" : preferredLocale;
+            return {
+                type: "core",
+                statusCode: 307,
+                headers: {
+                    Location: `${scheme}://${preferredDomain.domain}/${rlocale}`,
+                },
+                body: emptyReadableStream(),
+                isBase64Encoded: false,
+            };
+        }
+    }
+    const defaultLocale = domainLocale?.defaultLocale ?? i18n.defaultLocale;
+    if (detectedLocale.toLowerCase() !== defaultLocale.toLowerCase()) {
+        return {
+            type: "core",
+            statusCode: 307,
+            headers: {
+                Location: constructNextUrl(internalEvent.url, `/${detectedLocale}`),
+            },
+            body: emptyReadableStream(),
+            isBase64Encoded: false,
+        };
+    }
+    return false;
+}

package/dist/core/routing/matcher.d.ts

@@ -3,12 +3,12 @@ import type { InternalEvent, InternalResult } from "../../types/open-next";
 export declare function getNextConfigHeaders(event: InternalEvent, configHeaders?: Header[] | undefined): Record<string, string | undefined>;
 export declare function handleRewrites<T extends RewriteDefinition>(event: InternalEvent, rewrites: T[]): {
     internalEvent: {
+        query: Record<string, string | string[]>;
         rawPath: string;
         url: string;
         method: string;
         body?: Buffer;
         headers: Record<string, string>;
-        query: Record<string, string | string[]>;
         cookies: Record<string, string>;
         remoteAddress: string;
         type: "core";

package/dist/core/routing/matcher.js

@@ -2,7 +2,7 @@ import { NextConfig } from "../../adapters/config/index";
 import { compile, match } from "path-to-regexp";
 import { emptyReadableStream, toReadableStream } from "../../utils/stream";
 import { debug } from "../../adapters/logger";
-import { localizePath } from "./i18n";
+import { handleLocaleRedirect, localizePath } from "./i18n";
 import { constructNextUrl, convertFromQueryString, convertToQueryString, escapeRegex, getUrlParts, isExternal, unescapeRegex, } from "./util";
 const routeHasMatcher = (headers, cookies, query) => (redirect) => {
     switch (redirect.type) {
@@ -145,10 +145,17 @@ export function handleRewrites(event, rewrites) {
             rewrittenHost = unescapeRegex(toDestinationHost(params));
             rewrittenQuery = unescapeRegex(toDestinationQuery(params));
         }
+        // We need to strip the locale from the path if it's a local api route
+        if (NextConfig.i18n && !isExternalRewrite) {
+            const strippedPathLocale = rewrittenPath.replace(new RegExp(`^/(${NextConfig.i18n.locales.join("|")})`), "");
+            if (strippedPathLocale.startsWith("/api/")) {
+                rewrittenPath = strippedPathLocale;
+            }
+        }
         rewrittenUrl = isExternalRewrite
             ? `${protocol}//${rewrittenHost}${rewrittenPath}`
             : new URL(rewrittenPath, event.url).href;
-        // Should we merge the query params or use only the ones from the rewrite?
+        // We merge query params from the source and the destination
         finalQuery = {
             ...query,
             ...convertFromQueryString(rewrittenQuery),
@@ -159,6 +166,7 @@ export function handleRewrites(event, rewrites) {
     return {
         internalEvent: {
             ...event,
+            query: finalQuery,
             rawPath: new URL(rewrittenUrl).pathname,
             url: rewrittenUrl,
         },
@@ -215,6 +223,9 @@ export function handleRedirects(event, redirects) {
     const trailingSlashRedirect = handleTrailingSlashRedirect(event);
     if (trailingSlashRedirect)
         return trailingSlashRedirect;
+    const localeRedirect = handleLocaleRedirect(event);
+    if (localeRedirect)
+        return localeRedirect;
     const { internalEvent, __rewrite } = handleRewrites(event, redirects.filter((r) => !r.internal));
     if (__rewrite && !__rewrite.internal) {
         return {

package/dist/core/routing/util.js

@@ -67,7 +67,8 @@ export function getUrlParts(url, isExternal) {
  * @__PURE__
  */
 export function constructNextUrl(baseUrl, path) {
-    const nextBasePath = NextConfig.basePath;
+    // basePath is generated as "" if not provided on Next.js 15 (not sure about older versions)
+    const nextBasePath = NextConfig.basePath ?? "";
     const url = new URL(`${nextBasePath}${path}`, baseUrl);
     return url.href;
 }

package/dist/types/next-types.d.ts

@@ -52,9 +52,16 @@ export type Header = {
     has?: RouteHas[];
     missing?: RouteHas[];
 };
+export interface DomainLocale {
+    defaultLocale: string;
+    domain: string;
+    http?: true;
+    locales: readonly string[];
+}
 export interface i18nConfig {
     locales: string[];
     defaultLocale: string;
+    domains?: DomainLocale[];
     localeDetection?: false;
 }
 export interface NextConfig {

package/package.json

@@ -3,7 +3,7 @@
     "access": "public"
   },
   "name": "@opennextjs/aws",
-  "version": "3.5.0",
+  "version": "3.5.2",
   "bin": {
     "open-next": "./dist/index.js"
   },