feat(i18n): domain support

.changeset/tidy-carrots-jump.md

@@ -0,0 +1,46 @@
+---
+'@astrojs/node': minor
+'astro': minor
+---
+
+Adds experimental support for a new i18n domain routing strategy (`"domains"`) that allows you to configure different domains for certain locales:
+
+```js
+// astro.config.mjs
+import { defineConfig } from "astro/config"
+export default defineConfig({
+  i18n: {
+      defaultLocale: "en",
+      locales: ["es", "en", "fr"],
+      domains: {
+          fr: "https://fr.example.com",
+          es: "https://example.es"
+      },
+      routing: {
+        prefixDefaultLocale: true,
+        strategy: "domains"
+      }
+  },
+  experimental: {
+      i18nDomains: true
+  },
+  site: "https://example.com",
+  output: "server"
+})
+```
+
+With `routing.strategy` set to `"domains"`, the URLs emitted by `getAbsoluteLocaleUrl()` and `getAbsoluteLocaleUrlList()` will use the options set in `i18n.domains`:
+
+```js
+import { getAbsoluteLocaleUrl  } from "astro:i18n";
+
+getAbsoluteLocaleUrl("en", "about"); // will return "https://example.com/en/about"
+getAbsoluteLocaleUrl("fr", "about"); // will return "https://fr.example.com/about"
+getAbsoluteLocaleUrl("es", "about"); // will return "https://example.es/about"
+```
+
+For the above configuration:
+
+- The file `/fr/about.astro` will create the URL `https://fr.example.com/about`.
+- The file `/es/about.astro` will create the URL `https://example.es/about`.
+- The file `/en/about.astro` will create the URL `https://example.com/en/about`.

packages/astro/src/@types/astro.ts

@@ -1530,8 +1530,42 @@ export interface AstroUserConfig {
 			 * @description
 			 *
 			 * - `"pathanme": The strategy is applied to the pathname of the URLs
+			 * - `"domain"`: SSR only, it enables support for different domains. When a locale is mapped to domain, all the URLs won't have the language prefix.
+			 *    You map `fr` to `fr.example.com`, if you want a to have a blog page to look like `fr.example.com/blog` instead of `example.com/fr/blog`.
+			 *    The localised folders be must in the `src/pages/` folder.
 			 */
-			strategy: 'pathname';
+			strategy: 'pathname' | 'domain';
+
+			/**
+			 * @docs
+			 * @name experimental.i18n.domains
+			 * @type {Record<string, string> }
+			 * @default '{}'
+			 * @version 4.3.0
+			 * @description
+			 *
+			 * Configures the URL pattern of one or more supported languages to use a domain (or sub-domain). When a locale is mapped to a domain, a `/[locale]/` path prefix will not be used.
+			 *
+			 *  For example, you can configure the `fr` URLs to be of the form `https://fr.example.com/blog`. If not configured in `domains`, the `defaultLocale` will default to `https://example.com/blog` and any other locale not configured will default to `https://example.com/[locale]/blog`.
+			 *
+			 * ```js
+			 * export default defineConfig({
+			 * 	output: "server",
+			 * 	site: "https://example.com",
+			 * 	i18n: {
+			 * 		defaultLocale: "en",
+			 * 		locales: ["en", "fr", "pt-br", "es"],
+			 *		domains: {
+			 *			fr: "https://fr.example.com",
+			 *    },
+			 * 		routing: {
+			 * 			strategy: "domains"
+			 *		}
+			 *  }
+			 * })
+			 * ```
+			 */
+			domains?: Record<string, string>;
 		};
 	};
 
@@ -1664,6 +1698,25 @@ export interface AstroUserConfig {
 		 * In the event of route collisions, where two routes of equal route priority attempt to build the same URL, Astro will log a warning identifying the conflicting routes.
 		 */
 		globalRoutePriority?: boolean;
+
+		/**
+		 * @docs
+		 * @name experimental.i18nDomains
+		 * @type {boolean}
+		 * @default `false`
+		 * @version 4.1.0
+		 * @description
+		 * Enables domain support for internationalization routing
+		 *
+		 * ```js
+		 * {
+		 * 	experimental: {
+		 * 		i18nDomains: true,
+		 * 	},
+		 * }
+		 * ```
+		 */
+		i18nDomains?: boolean;
 	};
 }
 
@@ -2133,7 +2186,7 @@ export type AstroFeatureMap = {
 	/**
 	 * List of features that orbit around the i18n routing
 	 */
-	i18n?: AstroInternationalizationFeature;
+	i18nDomains?: SupportsKind;
 };
 
 export interface AstroAssetsFeature {
@@ -2150,9 +2203,9 @@ export interface AstroAssetsFeature {
 
 export interface AstroInternationalizationFeature {
 	/**
-	 * Whether the adapter is able to detect the language of the browser, usually using the `Accept-Language` header.
+	 * The adapter should be able to create the proper redirects
 	 */
-	detectBrowserLanguage?: SupportsKind;
+	domains?: SupportsKind;
 }
 
 export type Locales = (string | { codes: string[]; path: string })[];

packages/astro/src/core/app/index.ts

@@ -12,7 +12,9 @@ import { consoleLogDestination } from '../logger/console.js';
 import { AstroIntegrationLogger, Logger } from '../logger/core.js';
 import { sequence } from '../middleware/index.js';
 import {
+	appendForwardSlash,
 	collapseDuplicateSlashes,
+	joinPaths,
 	prependForwardSlash,
 	removeTrailingForwardSlash,
 } from '../path.js';
@@ -27,6 +29,7 @@ import {
 import { matchRoute } from '../routing/match.js';
 import { SSRRoutePipeline } from './ssrPipeline.js';
 import type { RouteInfo } from './types.js';
+import { normalizeTheLocale } from '../../i18n/index.js';
 export { deserializeManifest } from './common.js';
 
 const localsSymbol = Symbol.for('astro.locals');
@@ -171,13 +174,83 @@ export class App {
 		const url = new URL(request.url);
 		// ignore requests matching public assets
 		if (this.#manifest.assets.has(url.pathname)) return undefined;
-		const pathname = prependForwardSlash(this.removeBase(url.pathname));
-		const routeData = matchRoute(pathname, this.#manifestData);
-		// missing routes fall-through, prerendered are handled by static layer
+		let pathname = this.#computePathnameFromDomain(request);
+		if (!pathname) {
+			pathname = prependForwardSlash(this.removeBase(url.pathname));
+		}
+		let routeData = matchRoute(pathname, this.#manifestData);
+
+		// missing routes fall-through, pre rendered are handled by static layer
 		if (!routeData || routeData.prerender) return undefined;
 		return routeData;
 	}
 
+	#computePathnameFromDomain(request: Request): string | undefined {
+		let pathname: string | undefined = undefined;
+		const url = new URL(request.url);
+
+		if (
+			this.#manifest.i18n &&
+			(this.#manifest.i18n.routing === 'domains' ||
+				this.#manifest.i18n.routing === 'domains-prefix-default')
+		) {
+			// https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Forwarded-Host
+			let host = request.headers.get('X-Forwarded-Host');
+			// https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Forwarded-Proto
+			let protocol = request.headers.get('X-Forwarded-Proto');
+			if (protocol) {
+				// this header doesn't have the colum at the end, so we added to be in line with URL#protocol, which has it
+				protocol = protocol + ':';
+			} else {
+				// we fall back to the protocol of the request
+				protocol = url.protocol;
+			}
+			if (!host) {
+				// https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Host
+				host = request.headers.get('Host');
+			}
+			// If we don't have a host and a protocol, it's impossible to proceed
+			if (host && protocol) {
+				// The header might have a port in their name, so we remove it
+				host = host.split(':')[0];
+				try {
+					let locale;
+					const hostAsUrl = new URL(`${protocol}//${host}`);
+					for (const [domainKey, localeValue] of Object.entries(
+						this.#manifest.i18n.domainLookupTable
+					)) {
+						// This operation should be safe because we force the protocol via zod inside the configuration
+						// If not, then it means that the manifest was tampered
+						const domainKeyAsUrl = new URL(domainKey);
+
+						if (
+							hostAsUrl.host === domainKeyAsUrl.host &&
+							hostAsUrl.protocol === domainKeyAsUrl.protocol
+						) {
+							locale = localeValue;
+							break;
+						}
+					}
+
+					if (locale) {
+						pathname = prependForwardSlash(
+							joinPaths(normalizeTheLocale(locale), this.removeBase(url.pathname))
+						);
+						if (url.pathname.endsWith('/')) {
+							pathname = appendForwardSlash(pathname);
+						}
+					}
+				} catch (e) {
+					// waiting to decide what to do here
+					// TODO: What kind of error should we try? This happens if we have an invalid value inside the X-Forwarded-Host and X-Forwarded-Proto headers
+					// eslint-disable-next-line no-console
+					console.error(e);
+				}
+			}
+		}
+		return pathname;
+	}
+
 	async render(request: Request, options?: RenderOptions): Promise<Response>;
 	/**
 	 * @deprecated Instead of passing `RouteData` and locals individually, pass an object with `routeData` and `locals` properties.
@@ -476,8 +549,8 @@ export class App {
 		const status = override?.status
 			? override.status
 			: originalResponse.status === 200
-				? newResponse.status
-				: originalResponse.status;
+			  ? newResponse.status
+			  : originalResponse.status;
 
 		try {
 			// this function could throw an error...

packages/astro/src/core/app/types.ts

@@ -61,6 +61,7 @@ export type SSRManifestI18n = {
 	routing?: RoutingStrategies;
 	locales: Locales;
 	defaultLocale: string;
+	domainLookupTable: Record<string, string>;
 };
 
 export type SerializedSSRManifest = Omit<

packages/astro/src/core/build/generate.ts

@@ -65,6 +65,7 @@ import type {
 	StylesheetAsset,
 } from './types.js';
 import { getTimeStat, shouldAppendForwardSlash } from './util.js';
+import { NoPrerenderedRoutesWithDomains } from '../errors/errors-data.js';
 
 function createEntryURL(filePath: string, outFolder: URL) {
 	return new URL('./' + filePath + `?time=${Date.now()}`, outFolder);
@@ -169,9 +170,18 @@ export async function generatePages(opts: StaticBuildOptions, internals: BuildIn
 	logger.info('SKIP_FORMAT', `\n${bgGreen(black(` ${verb} static routes `))}`);
 	const builtPaths = new Set<string>();
 	const pagesToGenerate = pipeline.retrieveRoutesToGenerate();
+	const config = pipeline.getConfig();
 	if (ssr) {
 		for (const [pageData, filePath] of pagesToGenerate) {
 			if (pageData.route.prerender) {
+				// i18n domains won't work with pre rendered routes at the moment, so we need to to throw an error
+				if (config.experimental.i18nDomains) {
+					throw new AstroError({
+						...NoPrerenderedRoutesWithDomains,
+						message: NoPrerenderedRoutesWithDomains.message(pageData.component),
+					});
+				}
+
 				const ssrEntryURLPage = createEntryURL(filePath, outFolder);
 				const ssrEntryPage = await import(ssrEntryURLPage.toString());
 				if (opts.settings.adapter?.adapterFeatures?.functionPerRoute) {
@@ -421,7 +431,7 @@ function getInvalidRouteSegmentError(
 					route.route,
 					JSON.stringify(invalidParam),
 					JSON.stringify(received)
-				)
+			  )
 			: `Generated path for ${route.route} is invalid.`,
 		hint,
 	});
@@ -641,6 +651,7 @@ export function createBuildManifest(
 			routing: settings.config.i18n.routing,
 			defaultLocale: settings.config.i18n.defaultLocale,
 			locales: settings.config.i18n.locales,
+			domainLookupTable: {},
 		};
 	}
 	return {

packages/astro/src/core/build/plugins/plugin-manifest.ts

@@ -16,6 +16,7 @@ import { getOutFile, getOutFolder } from '../common.js';
 import { cssOrder, mergeInlineCss, type BuildInternals } from '../internal.js';
 import type { AstroBuildPlugin } from '../plugin.js';
 import type { StaticBuildOptions } from '../types.js';
+import { normalizeTheLocale } from '../../../i18n/index.js';
 
 const manifestReplace = '@@ASTRO_MANIFEST_REPLACE@@';
 const replaceExp = new RegExp(`['"](${manifestReplace})['"]`, 'g');
@@ -159,6 +160,7 @@ function buildManifest(
 	const { settings } = opts;
 
 	const routes: SerializedRouteInfo[] = [];
+	const domainLookupTable: Record<string, string> = {};
 	const entryModules = Object.fromEntries(internals.entrySpecifierToBundleMap.entries());
 	if (settings.scripts.some((script) => script.stage === 'page')) {
 		staticFiles.push(entryModules[PAGE_SCRIPT_ID]);
@@ -235,6 +237,21 @@ function buildManifest(
 		});
 	}
 
+	/**
+	 * logic meant for i18n domain support, where we fill the lookup table
+	 */
+	const i18n = settings.config.i18n;
+	if (
+		settings.config.experimental.i18nDomains &&
+		i18n &&
+		i18n.domains &&
+		(i18n.routing === 'domains' || i18n.routing === 'domains-prefix-default')
+	) {
+		for (const [locale, domainValue] of Object.entries(i18n.domains)) {
+			domainLookupTable[domainValue] = normalizeTheLocale(locale);
+		}
+	}
+
 	// HACK! Patch this special one.
 	if (!(BEFORE_HYDRATION_SCRIPT_ID in entryModules)) {
 		// Set this to an empty string so that the runtime knows not to try and load this.
@@ -247,6 +264,7 @@ function buildManifest(
 			routing: settings.config.i18n.routing,
 			locales: settings.config.i18n.locales,
 			defaultLocale: settings.config.i18n.defaultLocale,
+			domainLookupTable,
 		};
 	}