Adds support for Astro.clientAddress

.changeset/olive-dryers-sell.md

@@ -0,0 +1,18 @@
+---
+'astro': minor
+'@astrojs/cloudflare': minor
+'@astrojs/deno': minor
+'@astrojs/netlify': minor
+'@astrojs/vercel': minor
+'@astrojs/node': minor
+---
+
+Adds support for Astro.clientAddress
+
+The new `Astro.clientAddress` property allows you to get the IP address of the requested user.
+
+```astro
+<div>Your address { Astro.clientAddress }</div>
+```
+
+This property is only available when building for SSR, and only if the adapter you are using supports providing the IP address. If you attempt to access the property in a SSG app it will throw an error.

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

@@ -92,6 +92,10 @@ export interface AstroGlobal extends AstroGlobalPartial {
 	 * [Astro reference](https://docs.astro.build/en/reference/api-reference/#astrocanonicalurl)
 	 */
 	canonicalURL: URL;
+	/** The address (usually IP address) of the user. Used with SSR only.
+	 * 
+	 */
+	clientAddress: string;
 	/** Parameters passed to a dynamic page generated using [getStaticPaths](https://docs.astro.build/en/reference/api-reference/#getstaticpaths)
 	 *
 	 * Example usage:

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

@@ -97,10 +97,12 @@ export class App {
 		}
 
 		const response = await render({
+			adapterName: manifest.adapterName,
 			links,
 			logging: this.#logging,
 			markdown: manifest.markdown,
 			mod,
+			mode: 'production',
 			origin: url.origin,
 			pathname: url.pathname,
 			scripts,

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

@@ -5,13 +5,19 @@ import { IncomingMessage } from 'http';
 import { deserializeManifest } from './common.js';
 import { App } from './index.js';
 
+const clientAddressSymbol = Symbol.for('astro.clientAddress');
+
 function createRequestFromNodeRequest(req: IncomingMessage): Request {
 	let url = `http://${req.headers.host}${req.url}`;
-	const entries = Object.entries(req.headers as Record<string, any>);
+	let rawHeaders = req.headers as Record<string, any>;
+	const entries = Object.entries(rawHeaders);
 	let request = new Request(url, {
 		method: req.method || 'GET',
 		headers: new Headers(entries),
 	});
+	if(req.socket.remoteAddress) {
+		Reflect.set(request, clientAddressSymbol, req.socket.remoteAddress);
+	}
 	return request;
 }
 

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

@@ -25,6 +25,7 @@ export type SerializedRouteInfo = Omit<RouteInfo, 'routeData'> & {
 };
 
 export interface SSRManifest {
+	adapterName: string;
 	routes: RouteInfo[];
 	site?: string;
 	base?: string;

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

@@ -128,17 +128,24 @@ class AstroBuilder {
 			colors.dim(`Completed in ${getTimeStat(this.timer.init, performance.now())}.`)
 		);
 
-		await staticBuild({
-			allPages,
-			astroConfig: this.config,
-			logging: this.logging,
-			manifest: this.manifest,
-			origin: this.origin,
-			pageNames,
-			routeCache: this.routeCache,
-			viteConfig,
-			buildConfig,
-		});
+		try {
+			await staticBuild({
+				allPages,
+				astroConfig: this.config,
+				logging: this.logging,
+				manifest: this.manifest,
+				origin: this.origin,
+				pageNames,
+				routeCache: this.routeCache,
+				viteConfig,
+				buildConfig,
+			});
+		} catch(err: unknown) {
+			// If the build doesn't complete, still shutdown the Vite server so the process doesn't hang.
+			await viteServer.close();
+			throw err;
+		}
+
 
 		// Write any additionally generated assets to disk.
 		this.timer.assetsStart = performance.now();

packages/astro/src/core/build/static-build.ts

@@ -141,7 +141,7 @@ async function ssrBuild(opts: StaticBuildOptions, internals: BuildInternals, inp
 			...(viteConfig.plugins || []),
 			// SSR needs to be last
 			isBuildingToSSR(opts.astroConfig) &&
-				vitePluginSSR(opts, internals, opts.astroConfig._ctx.adapter!),
+				vitePluginSSR(internals, opts.astroConfig._ctx.adapter!),
 			vitePluginAnalyzer(opts.astroConfig, internals),
 		],
 		publicDir: ssr ? false : viteConfig.publicDir,

packages/astro/src/core/build/vite-plugin-ssr.ts

@@ -20,7 +20,6 @@ const manifestReplace = '@@ASTRO_MANIFEST_REPLACE@@';
 const replaceExp = new RegExp(`['"](${manifestReplace})['"]`, 'g');
 
 export function vitePluginSSR(
-	buildOpts: StaticBuildOptions,
 	internals: BuildInternals,
 	adapter: AstroAdapter
 ): VitePlugin {
@@ -153,6 +152,7 @@ function buildManifest(
 		'data:text/javascript;charset=utf-8,//[no before-hydration script]';
 
 	const ssrManifest: SerializedSSRManifest = {
+		adapterName: opts.astroConfig._ctx.adapter!.name,
 		routes,
 		site: astroConfig.site,
 		base: astroConfig.base,

packages/astro/src/core/render/core.ts

@@ -4,6 +4,7 @@ import type {
 	Params,
 	Props,
 	RouteData,
+	RuntimeMode,
 	SSRElement,
 	SSRLoadedRenderer,
 } from '../../@types/astro';
@@ -66,11 +67,13 @@ export async function getParamsAndProps(
 }
 
 export interface RenderOptions {
+	adapterName: string | undefined;
 	logging: LogOptions;
 	links: Set<SSRElement>;
 	styles?: Set<SSRElement>;
 	markdown: MarkdownRenderingOptions;
 	mod: ComponentInstance;
+	mode: RuntimeMode;
 	origin: string;
 	pathname: string;
 	scripts: Set<SSRElement>;
@@ -92,6 +95,7 @@ export async function render(opts: RenderOptions): Promise<Response> {
 		origin,
 		markdown,
 		mod,
+		mode,
 		pathname,
 		scripts,
 		renderers,
@@ -130,6 +134,7 @@ export async function render(opts: RenderOptions): Promise<Response> {
 		styles,
 		logging,
 		markdown,
+		mode,
 		origin,
 		params,
 		props: pageProps,

packages/astro/src/core/render/dev/index.ts

@@ -161,11 +161,13 @@ export async function render(
 	});
 
 	let response = await coreRender({
+		adapterName: astroConfig.adapter?.name,
 		links,
 		styles,
 		logging,
 		markdown: astroConfig.markdown,
 		mod,
+		mode,
 		origin,
 		pathname,
 		scripts,

packages/astro/src/core/render/result.ts

@@ -6,6 +6,7 @@ import type {
 	Page,
 	Params,
 	Props,
+	RuntimeMode,
 	SSRElement,
 	SSRLoadedRenderer,
 	SSRResult,
@@ -15,6 +16,8 @@ import { LogOptions, warn } from '../logger/core.js';
 import { isScriptRequest } from './script.js';
 import { createCanonicalURL, isCSSRequest } from './util.js';
 
+const clientAddressSymbol = Symbol.for('astro.clientAddress');
+
 function onlyAvailableInSSR(name: string) {
 	return function _onlyAvailableInSSR() {
 		// TODO add more guidance when we have docs and adapters.
@@ -28,6 +31,7 @@ export interface CreateResultArgs {
 	logging: LogOptions;
 	origin: string;
 	markdown: MarkdownRenderingOptions;
+	mode: RuntimeMode;
 	params: Params;
 	pathname: string;
 	props: Props;
@@ -151,6 +155,13 @@ export function createResult(args: CreateResultArgs): SSRResult {
 			const Astro = {
 				__proto__: astroGlobal,
 				canonicalURL,
+				get clientAddress() {
+					if(!(clientAddressSymbol in request)) {
+						throw new Error(`Astro.clientAddress is not available in your environment. Ensure that you are using an SSR adapter that supports this feature.`)
+					}
+
+					return Reflect.get(request, clientAddressSymbol);
+				},
 				params,
 				props,
 				request,

packages/astro/src/core/request.ts

@@ -7,16 +7,20 @@ type RequestBody = ArrayBuffer | Blob | ReadableStream | URLSearchParams | FormD
 
 export interface CreateRequestOptions {
 	url: URL | string;
+	clientAddress: string | undefined;
 	headers: HeaderType;
 	method?: string;
 	body?: RequestBody | undefined;
 	logging: LogOptions;
 	ssr: boolean;
 }
 
+const clientAddressSymbol = Symbol.for('astro.clientAddress');
+
 export function createRequest({
 	url,
 	headers,
+	clientAddress,
 	method = 'GET',
 	body = undefined,
 	logging,
@@ -67,6 +71,8 @@ export function createRequest({
 				return _headers;
 			},
 		});
+	} else if(clientAddress) {
+		Reflect.set(request, clientAddressSymbol, clientAddress);	
 	}
 
 	return request;

packages/astro/src/vite-plugin-astro-server/index.ts

@@ -229,6 +229,7 @@ async function handleRequest(
 		body,
 		logging,
 		ssr: buildingToSSR,
+		clientAddress: buildingToSSR ? req.socket.remoteAddress : undefined,
 	});
 
 	try {

packages/astro/test/client-address.test.js

@@ -0,0 +1,107 @@
+import { expect } from 'chai';
+import { loadFixture } from './test-utils.js';
+import testAdapter from './test-adapter.js';
+import { nodeLogDestination } from '../dist/core/logger/node.js';
+import * as cheerio from 'cheerio';
+
+describe('Astro.clientAddress', () => {
+	describe('SSR', () => {
+		/** @type {import('./test-utils').Fixture} */
+		let fixture;
+
+		before(async () => {
+			fixture = await loadFixture({
+				root: './fixtures/client-address/',
+				experimental: {
+					ssr: true,
+				},
+				adapter: testAdapter(),
+			});
+		});
+
+		describe('Production', () => {
+			before(async () => {
+				await fixture.build();
+			});
+
+			it('Can get the address', async () => {
+				const app = await fixture.loadTestAdapterApp();
+				const request = new Request('http://example.com/');
+				const response = await app.render(request);
+				const html = await response.text();
+				const $ = cheerio.load(html);
+				expect($('#address').text()).to.equal('0.0.0.0');
+			});
+		});
+
+		describe('Development', () => {
+			/** @type {import('./test-utils').DevServer} */
+			let devServer;
+
+			before(async () => {
+				devServer = await fixture.startDevServer();
+			});
+
+			after(async () => {
+				await devServer.stop();
+			});
+
+			it('Gets the address', async () => {
+				let res = await fixture.fetch('/');
+				expect(res.status).to.equal(200);
+				let html = await res.text();
+				let $ = cheerio.load(html);
+				let address = $('#address');
+
+				// Just checking that something is here. Not specifying address as it 
+				// might differ per machine.
+				expect(address.length).to.be.greaterThan(0);
+			});
+		});
+	});
+
+	describe('SSG', () => {
+		/** @type {import('./test-utils').Fixture} */
+		let fixture;
+
+		before(async () => {
+			fixture = await loadFixture({
+				root: './fixtures/client-address/',
+			});
+		});
+
+		describe('Build', () => {
+			it('throws during generation', async () => {
+				try {
+					await fixture.build();
+					expect(false).to.equal(true, 'Build should not have completed');
+				} catch(err) {
+					expect(err.message).to.match(/Astro\.clientAddress/, 'Error message mentions Astro.clientAddress');
+				}
+			})
+		});
+
+		describe('Development', () => {
+			/** @type {import('./test-utils').DevServer} */
+			let devServer;
+
+			before(async () => {
+				// We expect an error, so silence the output
+				const logging = {
+					dest: nodeLogDestination,
+					level: 'silent',
+				};
+				devServer = await fixture.startDevServer({ logging });
+			});
+
+			after(async () => {
+				await devServer.stop();
+			});
+
+			it('is not accessible', async () => {
+				let res = await fixture.fetch('/');
+				expect(res.status).to.equal(500);
+			});
+		})
+	});
+});

packages/astro/test/fixtures/client-address/src/pages/index.astro

@@ -0,0 +1,12 @@
+---
+const address = Astro.clientAddress;
+---
+<html>
+	<head>
+		<title>Astro.clientAddress</title>
+	</head>
+	<body>
+		<h1>Astro.clientAddress</h1>
+		<div id="address">{ address }</div>
+	</body>
+</html>