feat(next): astro:routes:resolved

.changeset/giant-ravens-look.md

@@ -2,7 +2,7 @@
 'astro': minor
 ---
 
-Adds a new `astro:routes:resolved` hook to the Integration API, and deprecates `routes` passed to `astro:build:done`
+Adds a new `astro:routes:resolved` hook to the Integration API. Makes updates to the `astro:build:done` hook by deprecating `routes` and adding a new `assets` map
 
 When building an integration, you can now get access to routes inside the `astro:routes:resolved` hook:
 
@@ -21,7 +21,7 @@ const integration = () => {
 
 This hook runs before `astro:config:done`, and whenever a route changes in development.
 
-`routes` from `astro:build:done` is now deprecated. We recommend you use the new hook instead:
+The `routes` array from `astro:build:done` are now deprecated. Any useful property is made available on `astro:routes:resolved`, except for `distURL`. Instead, you can use the newly exposed `assets` map::
 
 ```diff
 const integration = () => {
@@ -34,7 +34,14 @@ const integration = () => {
 +            },
             'astro:build:done': ({
 -                routes
++                assets
             }) => {
++                for (const route of routes) {
++                    const distURL = assets.get(route.pattern)
++                    if (distURL) {
++                        Object.assign(route, { distURL })
++                    }
++                }
                 console.log(routes)
             }
         }

packages/astro/src/actions/integration.ts

@@ -19,10 +19,10 @@ export default function astroIntegrationActionsRouteHandler({
 		hooks: {
 			async 'astro:config:setup'(params) {
 				settings.injectedRoutes.push({
-					pattern: '/_actions/[...path]',
+					pattern: ACTION_RPC_ROUTE_PATTERN,
 					entrypoint: 'astro/actions/runtime/route.js',
 					prerender: false,
-					origin: 'core',
+					origin: 'internal',
 				});
 
 				params.addMiddleware({

packages/astro/src/assets/endpoint/config.ts

@@ -63,6 +63,6 @@ function getImageEndpointData(
 		pathname: settings.config.image.endpoint.route,
 		prerender: false,
 		fallbackRoutes: [],
-		origin: 'core',
+		origin: 'internal',
 	};
 }

packages/astro/src/container/index.ts

@@ -544,7 +544,7 @@ export class experimental_AstroContainer {
 			type,
 			fallbackRoutes: [],
 			isIndex: false,
-			origin: 'user',
+			origin: 'internal',
 		};
 	}
 

packages/astro/src/core/dev/container.ts

@@ -7,6 +7,7 @@ import * as vite from 'vite';
 import {
 	runHookConfigDone,
 	runHookConfigSetup,
+	runHookRoutesResolved,
 	runHookServerDone,
 	runHookServerStart,
 } from '../../integrations/hooks.js';
@@ -83,10 +84,11 @@ export async function createContainer({
 		.filter(Boolean) as string[];
 
 	// Create the route manifest already outside of Vite so that `runHookConfigDone` can use it to inform integrations of the build output
-	let manifest = await createRouteManifest({ settings, fsMod: fs }, logger);
+	let manifest = await createRouteManifest({ settings, fsMod: fs }, logger, { dev: true });
 	const devSSRManifest = createDevelopmentManifest(settings);
 
 	manifest = injectDefaultDevRoutes(settings, devSSRManifest, manifest);
+	await runHookRoutesResolved({ settings, logger, routes: manifest.routes });
 
 	await runHookConfigDone({ settings, logger, command: 'dev' });
 

packages/astro/src/core/routing/astro-designed-error-pages.ts

@@ -15,7 +15,7 @@ export const DEFAULT_404_ROUTE: RouteData = {
 	route: '/404',
 	fallbackRoutes: [],
 	isIndex: false,
-	origin: 'core',
+	origin: 'internal',
 };
 
 export const DEFAULT_500_ROUTE: RouteData = {
@@ -30,7 +30,7 @@ export const DEFAULT_500_ROUTE: RouteData = {
 	route: '/500',
 	fallbackRoutes: [],
 	isIndex: false,
-	origin: 'core',
+	origin: 'internal',
 };
 
 export function ensure404Route(manifest: ManifestData) {

packages/astro/src/core/routing/manifest/create.ts

@@ -256,7 +256,7 @@ function createFileBasedRoutes(
 					prerender,
 					fallbackRoutes: [],
 					distURL: [],
-					origin: 'user',
+					origin: 'project',
 				});
 			}
 		}
@@ -392,7 +392,7 @@ function createRedirectRoutes(
 			redirectRoute: routeMap.get(destination),
 			fallbackRoutes: [],
 			distURL: [],
-			origin: 'user',
+			origin: 'project',
 		});
 	}
 
@@ -484,6 +484,7 @@ function detectRouteCollision(a: RouteData, b: RouteData, _config: AstroConfig,
 export async function createRouteManifest(
 	params: CreateRouteManifestParams,
 	logger: Logger,
+	{ dev = false }: { dev?: boolean } = {},
 ): Promise<ManifestData> {
 	const { settings } = params;
 	const { config } = settings;
@@ -731,7 +732,9 @@ export async function createRouteManifest(
 		}
 	}
 
-	await runHookRoutesResolved({ routes, settings, logger });
+	if (!dev) {
+		await runHookRoutesResolved({ routes, settings, logger });
+	}
 
 	return {
 		routes,

packages/astro/src/core/server-islands/endpoint.ts

@@ -31,7 +31,7 @@ export function getServerIslandRouteData(config: ConfigFields) {
 		isIndex: false,
 		fallbackRoutes: [],
 		route: SERVER_ISLAND_ROUTE,
-		origin: 'core',
+		origin: 'internal',
 	};
 	return route;
 }

packages/astro/src/integrations/hooks.ts

@@ -206,7 +206,7 @@ export async function runHookConfigSetup({
 						);
 						injectRoute.entrypoint = injectRoute.entryPoint as string;
 					}
-					updatedSettings.injectedRoutes.push({ ...injectRoute, origin: 'integration' });
+					updatedSettings.injectedRoutes.push({ ...injectRoute, origin: 'external' });
 				},
 				addWatchFile: (path) => {
 					updatedSettings.watchFiles.push(path instanceof URL ? fileURLToPath(path) : path);
@@ -601,6 +601,9 @@ export async function runHookBuildDone({ settings, pages, routes, logging }: Run
 					pages: pages.map((p) => ({ pathname: p })),
 					dir,
 					routes: integrationRoutes,
+					assets: new Map(
+						routes.filter((r) => r.distURL !== undefined).map((r) => [r.route, r.distURL!]),
+					),
 					logger,
 				}),
 				logger: logging,
@@ -674,11 +677,20 @@ export async function runHookRoutesResolved({
 
 function toIntegrationResolvedRoute(route: RouteData): IntegrationResolvedRoute {
 	return {
-		prerendered: route.prerender,
+		isPrerendered: route.prerender,
 		entrypoint: route.component,
 		pattern: route.route,
 		params: route.params,
 		origin: route.origin,
+		generate: route.generate,
+		patternRegex: route.pattern,
+		segments: route.segments,
+		type: route.type,
+		pathname: route.pathname,
+		redirect: route.redirect,
+		redirectRoute: route.redirectRoute
+			? toIntegrationResolvedRoute(route.redirectRoute)
+			: undefined,
 	};
 }
 

packages/astro/src/types/public/integrations.ts

@@ -217,16 +217,17 @@ export interface BaseIntegrationHooks {
 	'astro:build:done': (options: {
 		pages: { pathname: string }[];
 		dir: URL;
-		/** @deprecated Use `routes` from `astro:routes:resolved` instead */
+		/** @deprecated Use the `assets` map and the new `astro:routes:resolved` hook */
 		routes: IntegrationRouteData[];
+		assets: Map<string, URL[]>;
 		logger: AstroIntegrationLogger;
 	}) => void | Promise<void>;
 	'astro:route:setup': (options: {
 		route: RouteOptions;
 		logger: AstroIntegrationLogger;
 	}) => void | Promise<void>;
 	'astro:routes:resolved': (options: {
-		routes: Array<IntegrationResolvedRoute>;
+		routes: IntegrationResolvedRoute[];
 		logger: AstroIntegrationLogger;
 	}) => void | Promise<void>;
 }
@@ -242,6 +243,7 @@ export interface AstroIntegration {
 
 /**
  * A smaller version of the {@link RouteData} that is used in the integrations.
+ * @deprecated Use {@link IntegrationResolvedRoute}
  */
 export type IntegrationRouteData = Omit<
 	RouteData,
@@ -253,33 +255,40 @@ export type IntegrationRouteData = Omit<
 	redirectRoute?: IntegrationRouteData;
 };
 
-export interface IntegrationResolvedRoute {
+export interface IntegrationResolvedRoute
+	extends Omit<
+		RouteData,
+		| 'isIndex'
+		| 'fallbackRoutes'
+		| 'redirectRoute'
+		| 'route'
+		| 'pattern'
+		| 'component'
+		| 'prerender'
+		| 'distURL'
+	> {
 	/**
-	 * The current **pattern** of the route. For example:
-	 * - `src/pages/index.astro` has a pattern of `/`
-	 * - `src/pages/blog/[...slug].astro` has a pattern of `/blog/[...slug]`
-	 * - `src/pages/site/[blog]/[...slug].astro` has a pattern of `/site/[blog]/[...slug]`
+	 * {@link RouteData.route}
 	 */
 	pattern: RouteData['route'];
 
 	/**
-	 *  Source component URL
+	 * {@link RouteData.pattern}
 	 */
-	entrypoint: RouteData['component'];
+	patternRegex: RouteData['pattern'];
 
 	/**
-	 * Whether the route is prerendered or not
+	 * {@link RouteData.component}
 	 */
-	prerendered: RouteData['prerender'];
+	entrypoint: RouteData['component'];
 
 	/**
-	 * Dynamic and spread route params
-	 * ex. "/pages/[lang]/[...slug].astro" will output the params ['lang', '...slug']
+	 * {@link RouteData.prerender}
 	 */
-	params: RouteData['params'];
+	isPrerendered: RouteData['prerender'];
 
 	/**
-	 * Whether the route comes from Astro core, an integration or the user's project
+	 * {@link RouteData.redirectRoute}
 	 */
-	origin: RouteData['origin'];
+	redirectRoute?: IntegrationResolvedRoute;
 }

packages/astro/src/types/public/internal.ts

@@ -140,7 +140,7 @@ export interface RouteData {
 	/**
 	 * Whether the route comes from Astro core, an integration or the user's project
 	 */
-	origin: 'core' | 'integration' | 'user';
+	origin: 'internal' | 'external' | 'project';
 }
 
 /**
@@ -290,6 +290,8 @@ export interface SSRMetadata {
 
 export type SSRError = Error & ViteErrorPayload['err'];
 
+// `origin` is set within the hook, but the user doesn't have access to this property. That's why
+// we need an intermediary interface
 export interface InternalInjectedRoute {
 	pattern: string;
 	entrypoint: string | URL;

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

@@ -21,6 +21,9 @@ import { recordServerError } from './error.js';
 import { DevPipeline } from './pipeline.js';
 import { handleRequest } from './request.js';
 import { setRouteError } from './server-state.js';
+import { fileURLToPath } from 'node:url';
+import { getRoutePrerenderOption } from '../core/routing/manifest/prerender.js';
+import { runHookRoutesResolved } from '../integrations/hooks.js';
 
 export interface AstroPluginOptions {
 	settings: AstroSettings;
@@ -51,13 +54,33 @@ export default function createVitePluginAstroServer({
 			const localStorage = new AsyncLocalStorage();
 
 			/** rebuild the route cache + manifest */
-			async function rebuildManifest() {
+			async function rebuildManifest(path: string | null = null) {
 				pipeline.clearRouteCache();
-				routeManifest = injectDefaultDevRoutes(
-					settings,
-					devSSRManifest,
-					await createRouteManifest({ settings, fsMod }, logger), // TODO: Handle partial updates to the manifest
-				);
+
+				// If a route changes, we check if it's part of the manifest and check for its prerender value
+				if (path !== null) {
+					const route = routeManifest.routes.find((r) => path.endsWith(r.component));
+					if (!route) {
+						return;
+					}
+					if (route.type !== 'page' && route.type !== 'endpoint') return;
+
+					const routePath = fileURLToPath(new URL(route.component, settings.config.root));
+					if (!fsMod.existsSync(routePath)) {
+						// Route was renamed so it does not exist anymore
+						return;
+					}
+					const content = await fsMod.promises.readFile(routePath, 'utf-8');
+					await getRoutePrerenderOption(content, route, settings, logger);
+				} else {
+					routeManifest = injectDefaultDevRoutes(
+						settings,
+						devSSRManifest,
+						await createRouteManifest({ settings, fsMod }, logger, { dev: true }),
+					);
+				}
+				await runHookRoutesResolved({ routes: routeManifest.routes, settings, logger });
+
 				warnMissingAdapter(logger, settings);
 				pipeline.manifest.checkOrigin =
 					settings.config.security.checkOrigin && settings.buildOutput === 'server';
@@ -67,7 +90,7 @@ export default function createVitePluginAstroServer({
 			// Rebuild route manifest on file change
 			viteServer.watcher.on('add', rebuildManifest.bind(null));
 			viteServer.watcher.on('unlink', rebuildManifest.bind(null));
-			viteServer.watcher.on('change', rebuildManifest.bind(null));
+			viteServer.watcher.on('change', rebuildManifest);
 
 			function handleUnhandledRejection(rejection: any) {
 				const error = new AstroError({