NodeApp Class — astro Architecture

Source Code

packages/astro/src/core/app/node.ts lines 22–240

export class NodeApp extends App {
	headersMap: NodeAppHeadersJson | undefined = undefined;

	public setHeadersMap(headers: NodeAppHeadersJson) {
		this.headersMap = headers;
	}

	match(req: NodeRequest | Request, allowPrerenderedRoutes = false) {
		if (!(req instanceof Request)) {
			req = NodeApp.createRequest(req, {
				skipBody: true,
				allowedDomains: this.manifest.allowedDomains,
			});
		}
		return super.match(req, allowPrerenderedRoutes);
	}

	render(request: NodeRequest | Request, options?: RenderOptions): Promise<Response> {
		if (!(request instanceof Request)) {
			request = NodeApp.createRequest(request, {
				allowedDomains: this.manifest.allowedDomains,
			});
		}
		return super.render(request, options);
	}

	/**
	 * Converts a NodeJS IncomingMessage into a web standard Request.
	 * ```js
	 * import { NodeApp } from 'astro/app/node';
	 * import { createServer } from 'node:http';
	 *
	 * const server = createServer(async (req, res) => {
	 *     const request = NodeApp.createRequest(req);
	 *     const response = await app.render(request);
	 *     await NodeApp.writeResponse(response, res);
	 * })
	 * ```
	 */
	static createRequest(
		req: NodeRequest,
		{
			skipBody = false,
			allowedDomains = [],
		}: { skipBody?: boolean; allowedDomains?: Partial<RemotePattern>[] } = {},
	): Request {
		const controller = new AbortController();

		const isEncrypted = 'encrypted' in req.socket && req.socket.encrypted;

		// Parses multiple header and returns first value if available.
		const getFirstForwardedValue = (multiValueHeader?: string | string[]) => {
			return multiValueHeader
				?.toString()
				?.split(',')
				.map((e) => e.trim())?.[0];
		};

		const providedProtocol = isEncrypted ? 'https' : 'http';
		const providedHostname = req.headers.host ?? req.headers[':authority'];

		// Validate forwarded headers
		// NOTE: Header values may have commas/spaces from proxy chains, extract first value
		const validated = validateForwardedHeaders(
			getFirstForwardedValue(req.headers['x-forwarded-proto']),
			getFirstForwardedValue(req.headers['x-forwarded-host']),
			getFirstForwardedValue(req.headers['x-forwarded-port']),
			allowedDomains,
		);

		const protocol = validated.protocol ?? providedProtocol;
		// validated.host is already sanitized, only sanitize providedHostname
		const sanitizedProvidedHostname = sanitizeHost(
			typeof providedHostname === 'string' ? providedHostname : undefined,
		);
		const hostname = validated.host ?? sanitizedProvidedHostname;
		const port = validated.port;

		let url: URL;
		try {
			const hostnamePort = getHostnamePort(hostname, port);