withastro · matthewp · Jun 5, 2023 · May 10, 2023 · May 11, 2023 · May 11, 2023
diff --git a/.changeset/chatty-actors-stare.md b/.changeset/chatty-actors-stare.md
@@ -0,0 +1,6 @@
+---
+'@astrojs/netlify': minor
+'astro': minor
+---
+
+Implements the redirects proposal
diff --git a/packages/astro/src/@types/astro.ts b/packages/astro/src/@types/astro.ts
@@ -447,6 +447,11 @@ export interface AstroUserConfig {
 	 */
 	cacheDir?: string;
 
+	/**
+	 * TODO
+	 */
+	redirects?: Record<string, string>;
+
 	/**
 	 * @docs
 	 * @name site
@@ -1704,7 +1709,7 @@ export interface AstroPluginOptions {
 	logging: LogOptions;
 }
 
-export type RouteType = 'page' | 'endpoint';
+export type RouteType = 'page' | 'endpoint' | 'redirect';
 
 export interface RoutePart {
 	content: string;
@@ -1724,6 +1729,7 @@ export interface RouteData {
 	segments: RoutePart[][];
 	type: RouteType;
 	prerender: boolean;
+	redirect?: string;
 }
 
 export type SerializedRouteData = Omit<RouteData, 'generate' | 'pattern'> & {

diff --git a/packages/astro/src/core/build/common.ts b/packages/astro/src/core/build/common.ts
@@ -26,6 +26,7 @@ export function getOutFolder(
 		case 'endpoint':
 			return new URL('.' + appendForwardSlash(npath.dirname(pathname)), outRoot);
 		case 'page':
+		case 'redirect':
 			switch (astroConfig.build.format) {
 				case 'directory': {
 					if (STATUS_CODE_PAGES.has(pathname)) {
@@ -51,6 +52,7 @@ export function getOutFile(
 		case 'endpoint':
 			return new URL(npath.basename(pathname), outFolder);
 		case 'page':
+		case 'redirect':
 			switch (astroConfig.build.format) {
 				case 'directory': {
 					if (STATUS_CODE_PAGES.has(pathname)) {

diff --git a/packages/astro/src/core/build/generate.ts b/packages/astro/src/core/build/generate.ts
@@ -33,7 +33,7 @@ import {
 	createAPIContext,
 	throwIfRedirectNotAllowed,
 } from '../endpoint/index.js';
-import { AstroError } from '../errors/index.js';
+import { AstroError, AstroErrorData } from '../errors/index.js';
 import { debug, info } from '../logger/core.js';
 import { callMiddleware } from '../middleware/callMiddleware.js';
 import { createEnvironment, createRenderContext, renderPage } from '../render/index.js';
@@ -72,6 +72,12 @@ export function rootRelativeFacadeId(facadeId: string, settings: AstroSettings):
 	return facadeId.slice(fileURLToPath(settings.config.root).length);
 }
 
+function redirectWithNoLocation() {
+	throw new AstroError({
+		...AstroErrorData.RedirectWithNoLocation
+	});
+}
+
 // Determines of a Rollup chunk is an entrypoint page.
 export function chunkIsPage(
 	settings: AstroSettings,
@@ -172,13 +178,17 @@ async function generatePage(
 		.map(({ sheet }) => sheet)
 		.reduce(mergeInlineCss, []);
 
-	const pageModule = ssrEntry.pageMap?.get(pageData.component);
+	let pageModule = ssrEntry.pageMap?.get(pageData.component);
 	const middleware = ssrEntry.middleware;
 
 	if (!pageModule) {
-		throw new Error(
-			`Unable to find the module for ${pageData.component}. This is unexpected and likely a bug in Astro, please report.`
-		);
+		if(pageData.route.type === 'redirect') {
+			pageModule = { 'default': Function.prototype as any };
+		} else {
+			throw new Error(
+				`Unable to find the module for ${pageData.component}. This is unexpected and likely a bug in Astro, please report.`
+			);
+		}
 	}
 
 	if (shouldSkipDraft(pageModule, opts.settings)) {
@@ -510,10 +520,24 @@ async function generatePath(
 			}
 			throw err;
 		}
-		throwIfRedirectNotAllowed(response, opts.settings.config);
-		// If there's no body, do nothing
-		if (!response.body) return;
-		body = await response.text();
+
+		switch(response.status) {
+			case 301:
+			case 302: {
+				const location = response.headers.get("location");
+				if(!location) {
+					return void redirectWithNoLocation();
+				}
+				body = `<!doctype html><meta http-equiv="refresh" content="0;url=${location}" />`;
+				pageData.route.redirect = location;
+				break;
+			}
+			default: {
+				// If there's no body, do nothing
+				if (!response.body) return;
+				body = await response.text();
+			}
+		}
 	}
 
 	const outFolder = getOutFolder(settings.config, pathname, pageData.route.type);

diff --git a/packages/astro/src/core/build/plugins/plugin-pages.ts b/packages/astro/src/core/build/plugins/plugin-pages.ts
@@ -35,6 +35,9 @@ export function vitePluginPages(opts: StaticBuildOptions, internals: BuildIntern
 				let imports = [];
 				let i = 0;
 				for (const pageData of eachPageData(internals)) {
+					if(pageData.route.type === 'redirect') {
+						continue;
+					}
 					const variable = `_page${i}`;
 					imports.push(`import * as ${variable} from ${JSON.stringify(pageData.moduleSpecifier)};`);
 					importMap += `[${JSON.stringify(pageData.component)}, ${variable}],`;

diff --git a/packages/astro/src/core/config/schema.ts b/packages/astro/src/core/config/schema.ts
@@ -36,6 +36,7 @@ const ASTRO_CONFIG_DEFAULTS: AstroUserConfig & any = {
 	},
 	vite: {},
 	legacy: {},
+	redirects: {},
 	experimental: {
 		assets: false,
 		inlineStylesheets: 'never',
@@ -133,6 +134,7 @@ export const AstroConfigSchema = z.object({
 			.optional()
 			.default({})
 	),
+	redirects: z.record(z.string(), z.string()).default(ASTRO_CONFIG_DEFAULTS.redirects),
 	image: z
 		.object({
 			service: z.object({

diff --git a/packages/astro/src/core/errors/errors-data.ts b/packages/astro/src/core/errors/errors-data.ts
@@ -45,6 +45,7 @@ export const AstroErrorData = {
 	 * To redirect on a static website, the [meta refresh attribute](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/meta) can be used. Certain hosts also provide config-based redirects (ex: [Netlify redirects](https://docs.netlify.com/routing/redirects/)).
 	 */
 	StaticRedirectNotAvailable: {
+		// TODO remove
 		title: '`Astro.redirect` is not available in static mode.',
 		code: 3001,
 		message:
@@ -717,6 +718,18 @@ See https://docs.astro.build/en/guides/server-side-rendering/ for more informati
 			return `The information stored in \`Astro.locals\` for the path "${href}" is not serializable.\nMake sure you store only serializable data.`;
 		},
 	},
+	/**
+		 * @docs
+		 * @see
+		 * - [Astro.redirect](https://docs.astro.build/en/guides/server-side-rendering/#astroredirect)
+		 * @description
+		 * A redirect must be given a location with the `Location` header.
+		 */
+	RedirectWithNoLocation: {
+		// TODO remove
+		title: 'A redirect must be given a location with the `Location` header.',
+		code: 3035,
+	},
 	// No headings here, that way Vite errors are merged with Astro ones in the docs, which makes more sense to users.
 	// Vite Errors - 4xxx
 	/**

diff --git a/packages/astro/src/core/render/core.ts b/packages/astro/src/core/render/core.ts
@@ -111,6 +111,15 @@ export type RenderPage = {
 };
 
 export async function renderPage({ mod, renderContext, env, apiContext }: RenderPage) {
+	if(renderContext.route?.type === 'redirect') {
+		return new Response(null, {
+			status: 301,
+			headers: {
+				'location': renderContext.route.redirect!
+			}
+		});
+	}
+
 	// Validate the page component before rendering the page
 	const Component = mod.default;
 	if (!Component)

diff --git a/packages/astro/src/core/render/result.ts b/packages/astro/src/core/render/result.ts
@@ -204,23 +204,21 @@ export function createResult(args: CreateResultArgs): SSRResult {
 				locals,
 				request,
 				url,
-				redirect: args.ssr
-					? (path, status) => {
-							// If the response is already sent, error as we cannot proceed with the redirect.
-							if ((request as any)[responseSentSymbol]) {
-								throw new AstroError({
-									...AstroErrorData.ResponseSentError,
-								});
-							}
+				redirect(path, status) {
+					// If the response is already sent, error as we cannot proceed with the redirect.
+					if ((request as any)[responseSentSymbol]) {
+						throw new AstroError({
+							...AstroErrorData.ResponseSentError,
+						});
+					}
 
-							return new Response(null, {
-								status: status || 302,
-								headers: {
-									Location: path,
-								},
-							});
-					  }
-					: onlyAvailableInSSR('Astro.redirect'),
+					return new Response(null, {
+						status: status || 302,
+						headers: {
+							Location: path,
+						},
+					});
+				},
 				response: response as AstroGlobal['response'],
 				slots: astroSlots as unknown as AstroGlobal['slots'],
 			};

diff --git a/packages/astro/src/core/routing/manifest/create.ts b/packages/astro/src/core/routing/manifest/create.ts
@@ -412,6 +412,45 @@ export function createRouteManifest(
 			});
 		});
 
+	Object.entries(settings.config.redirects).forEach(([from, to]) => {
+		const trailingSlash = config.trailingSlash;
+
+		const segments = removeLeadingForwardSlash(from)
+		.split(path.posix.sep)
+		.filter(Boolean)
+		.map((s: string) => {
+			validateSegment(s);
+			return getParts(s, from);
+		});
+
+		const pattern = getPattern(segments, settings.config.base, trailingSlash);
+		const generate = getRouteGenerator(segments, trailingSlash);
+		const pathname = segments.every((segment) => segment.length === 1 && !segment[0].dynamic)
+			? `/${segments.map((segment) => segment[0].content).join('/')}`
+			: null;
+		const params = segments
+			.flat()
+			.filter((p) => p.dynamic)
+			.map((p) => p.content);
+		const route = `/${segments
+			.map(([{ dynamic, content }]) => (dynamic ? `[${content}]` : content))
+			.join('/')}`.toLowerCase();
+
+
+		routes.unshift({
+			type: 'redirect',
+			route,
+			pattern,
+			segments,
+			params,
+			component: '',
+			generate,
+			pathname: pathname || void 0,
+			prerender: false,
+			redirect: to
+		});
+	});
+
 	return {
 		routes,
 	};

diff --git a/packages/astro/src/runtime/server/render/common.ts b/packages/astro/src/runtime/server/render/common.ts
@@ -57,6 +57,12 @@ export function stringifyChunk(
 				}
 				return renderAllHeadContent(result);
 			}
+			default: {
+				if(chunk instanceof Response) {
+					return '';
+				}
+				throw new Error(`Unknown chunk type: ${(chunk as any).type}`);
+			}
 		}
 	} else {
 		if (isSlotString(chunk as string)) {
@@ -102,6 +108,7 @@ export function chunkToByteArray(
 	if (chunk instanceof Uint8Array) {
 		return chunk as Uint8Array;
 	}
+
 	// stringify chunk might return a HTMLString
 	let stringified = stringifyChunk(result, chunk);
 	return encoder.encode(stringified.toString());

diff --git a/packages/astro/test/redirects.test.js b/packages/astro/test/redirects.test.js
@@ -0,0 +1,57 @@
+import { expect } from 'chai';
+import { loadFixture } from './test-utils.js';
+import testAdapter from './test-adapter.js';
+
+describe('Astro.redirect', () => {
+	/** @type {import('./test-utils').Fixture} */
+	let fixture;
+
+	describe('output: "server"', () => {
+		before(async () => {
+			fixture = await loadFixture({
+				root: './fixtures/ssr-redirect/',
+				output: 'server',
+				adapter: testAdapter(),
+			});
+			await fixture.build();
+		});
+
+		it('Returns a 302 status', async () => {
+			const app = await fixture.loadTestAdapterApp();
+			const request = new Request('http://example.com/secret');
+			const response = await app.render(request);
+			expect(response.status).to.equal(302);
+			expect(response.headers.get('location')).to.equal('/login');
+		});
+
+		it('Warns when used inside a component', async () => {
+			const app = await fixture.loadTestAdapterApp();
+			const request = new Request('http://example.com/late');
+			const response = await app.render(request);
+			try {
+				const text = await response.text();
+				expect(false).to.equal(true);
+			} catch (e) {
+				expect(e.message).to.equal(
+					'The response has already been sent to the browser and cannot be altered.'
+				);
+			}
+		});
+	});
+
+	describe('output: "static"', () => {
+		before(async () => {
+			fixture = await loadFixture({
+				root: './fixtures/ssr-redirect/',
+				output: 'static',
+			});
+			await fixture.build();
+		});
+
+		it('Includes the meta refresh tag.', async () => {
+			const html = await fixture.readFile('/secret/index.html');
+			expect(html).to.include('http-equiv="refresh');
+			expect(html).to.include('url=/login');
+		});
+	});
+});
diff --git a/packages/astro/test/ssr-redirect.test.js b/packages/astro/test/ssr-redirect.test.js