@opennextjs/aws 3.5.0 → 3.5.1

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.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) {
@@ -215,6 +215,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.1",
   "bin": {
     "open-next": "./dist/index.js"
   },