Merge branch 'next' into export-js-api

.changeset/neat-mugs-end.md

@@ -0,0 +1,8 @@
+---
+'astro': minor
+---
+
+
+`astro:`namespace aliases for middleware and components
+
+This adds aliases of `astro:middleware` and `astro:components` for the middleware and components modules. This is to make our documentation consistent between are various modules, where some are virtual modules and others are not. Going forward new built-in modules will use this namespace.

examples/middleware/src/middleware.ts

@@ -1,4 +1,4 @@
-import { defineMiddleware, sequence } from 'astro/middleware';
+import { defineMiddleware, sequence } from 'astro:middleware';
 import htmlMinifier from 'html-minifier';
 
 const limit = 50;

packages/astro/client.d.ts

@@ -119,6 +119,14 @@ declare module 'astro:transitions' {
 	export const ViewTransitions: ViewTransitionsModule['default'];
 }
 
+declare module 'astro:middleware' {
+	export * from 'astro/middleware/namespace';
+}
+
+declare module 'astro:components' {
+	export * from 'astro/components';
+}
+
 type MD = import('./dist/@types/astro').MarkdownInstance<Record<string, any>>;
 interface ExportedMarkdownModuleEntities {
 	frontmatter: MD['frontmatter'];

packages/astro/package.json

@@ -23,6 +23,9 @@
       ],
       "middleware": [
         "./dist/core/middleware/index.d.ts"
+      ],
+      "middleware/namespace": [
+        "./dist/core/middleware/namespace.d.ts"
       ]
     }
   },
@@ -70,6 +73,10 @@
       "types": "./dist/core/middleware/index.d.ts",
       "default": "./dist/core/middleware/index.js"
     },
+    "./middleware/namespace": {
+      "types": "./dist/core/middleware/namespace.d.ts",
+      "default": "./dist/core/middleware/namespace.js"
+    },
     "./transitions": "./dist/transitions/index.js"
   },
   "imports": {

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

@@ -1946,7 +1946,7 @@ export interface APIContext<Props extends Record<string, any> = Record<string, a
 	 *
 	 * ```ts
 	 * // src/middleware.ts
-	 * import {defineMiddleware} from "astro/middleware";
+	 * import {defineMiddleware} from "astro:middleware";
 	 *
 	 * export const onRequest = defineMiddleware((context, next) => {
 	 *   context.locals.greeting = "Hello!";

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

@@ -16,12 +16,7 @@ import {
 	removeTrailingForwardSlash,
 } from '../path.js';
 import { RedirectSinglePageBuiltModule } from '../redirects/index.js';
-import {
-	createEnvironment,
-	createRenderContext,
-	tryRenderRoute,
-	type RenderContext,
-} from '../render/index.js';
+import { createEnvironment, createRenderContext, type RenderContext } from '../render/index.js';
 import { RouteCache } from '../render/route-cache.js';
 import {
 	createAssetLink,
@@ -282,11 +277,7 @@ export class App {
 					status
 				);
 				const page = (await mod.page()) as any;
-				const response = (await tryRenderRoute(
-					newRenderContext,
-					this.#pipeline.env,
-					page
-				)) as Response;
+				const response = await this.#pipeline.renderRoute(newRenderContext, page);
 				return this.#mergeResponses(response, originalResponse);
 			} catch {}
 		}

packages/astro/src/core/create-vite.ts

@@ -170,6 +170,14 @@ export async function createVite(
 					find: /^astro$/,
 					replacement: fileURLToPath(new URL('../@types/astro', import.meta.url)),
 				},
+				{
+					find: 'astro:middleware',
+					replacement: 'astro/middleware/namespace',
+				},
+				{
+					find: 'astro:components',
+					replacement: 'astro/components',
+				},
 			],
 			conditions: ['astro'],
 			// Astro imports in third-party packages should use the same version as root

packages/astro/src/core/errors/errors-data.ts

@@ -658,7 +658,7 @@ export const ResponseSentError = {
  *
  * For example:
  * ```ts
- * import {defineMiddleware} from "astro/middleware";
+ * import {defineMiddleware} from "astro:middleware";
  * export const onRequest = defineMiddleware((context, _) => {
  * 	// doesn't return anything or call `next`
  * 	context.locals.someData = false;
@@ -678,7 +678,7 @@ export const MiddlewareNoDataOrNextCalled = {
  *
  * For example:
  * ```ts
- * import {defineMiddleware} from "astro/middleware";
+ * import {defineMiddleware} from "astro:middleware";
  * export const onRequest = defineMiddleware(() => {
  *   return "string"
  * });
@@ -698,7 +698,7 @@ export const MiddlewareNotAResponse = {
  *
  * For example:
  * ```ts
- * import {defineMiddleware} from "astro/middleware";
+ * import {defineMiddleware} from "astro:middleware";
  * export const onRequest = defineMiddleware((context, next) => {
  *   context.locals = 1541;
  *   return next();

packages/astro/src/core/middleware/namespace.ts

@@ -0,0 +1,4 @@
+export {
+	defineMiddleware,
+	sequence,
+} from './index.js';

packages/astro/src/core/pipeline.ts

@@ -59,7 +59,7 @@ export class Pipeline {
 	/**
 	 * Returns the current environment
 	 */
-	getEnvironment() {
+	getEnvironment(): Readonly<Environment> {
 		return this.env;
 	}
 

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

@@ -1,6 +1,5 @@
-import type { AstroSettings, RuntimeMode, SSRLoadedRenderer } from '../../@types/astro';
+import type { RuntimeMode, SSRLoadedRenderer } from '../../@types/astro';
 import type { LogOptions } from '../logger/core.js';
-import type { ModuleLoader } from '../module-loader';
 import type { RouteCache } from './route-cache.js';
 
 /**
@@ -38,8 +37,3 @@ export type CreateEnvironmentArgs = Environment;
 export function createEnvironment(options: CreateEnvironmentArgs): Environment {
 	return options;
 }
-
-export type DevelopmentEnvironment = Environment & {
-	loader: ModuleLoader;
-	settings: AstroSettings;
-};

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

@@ -1,18 +1,17 @@
 import type { AstroMiddlewareInstance, ComponentInstance, RouteData } from '../../@types/astro';
-import type { DevelopmentEnvironment } from './environment';
-
 export { createRenderContext } from './context.js';
 export type { RenderContext } from './context.js';
 export { tryRenderRoute } from './core.js';
-export type { Environment } from './environment';
+import type { Environment } from './environment';
 export { createEnvironment } from './environment.js';
 export { getParamsAndProps } from './params-and-props.js';
-export { loadRenderer, loadRenderers } from './renderer.js';
-export type { DevelopmentEnvironment };
+export { loadRenderer } from './renderer.js';
+
+export type { Environment };
 
 export interface SSROptions {
 	/** The environment instance */
-	env: DevelopmentEnvironment;
+	env: Environment;
 	/** location of file on disk */
 	filePath: URL;
 	/** the web request (needed for dynamic routes) */

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

@@ -1,14 +1,6 @@
-import type { AstroRenderer, AstroSettings, SSRLoadedRenderer } from '../../@types/astro';
+import type { AstroRenderer, SSRLoadedRenderer } from '../../@types/astro';
 import type { ModuleLoader } from '../module-loader/index.js';
 
-export async function loadRenderers(
-	settings: AstroSettings,
-	moduleLoader: ModuleLoader
-): Promise<SSRLoadedRenderer[]> {
-	const renderers = await Promise.all(settings.renderers.map((r) => loadRenderer(r, moduleLoader)));
-	return renderers.filter(Boolean) as SSRLoadedRenderer[];
-}
-
 export async function loadRenderer(
 	renderer: AstroRenderer,
 	moduleLoader: ModuleLoader

packages/astro/src/prerender/routing.ts

@@ -1,30 +1,30 @@
 import type { AstroSettings, ComponentInstance, RouteData } from '../@types/astro';
 import { RedirectComponentInstance, routeIsRedirect } from '../core/redirects/index.js';
-import type { DevelopmentEnvironment } from '../core/render';
 import { preload } from '../vite-plugin-astro-server/index.js';
 import { getPrerenderStatus } from './metadata.js';
+import type DevPipeline from '../vite-plugin-astro-server/devPipeline';
 
 type GetSortedPreloadedMatchesParams = {
-	env: DevelopmentEnvironment;
+	pipeline: DevPipeline;
 	matches: RouteData[];
 	settings: AstroSettings;
 };
 export async function getSortedPreloadedMatches({
-	env,
+	pipeline,
 	matches,
 	settings,
 }: GetSortedPreloadedMatchesParams) {
 	return (
 		await preloadAndSetPrerenderStatus({
-			env,
+			pipeline,
 			matches,
 			settings,
 		})
 	).sort((a, b) => prioritizePrerenderedMatchesComparator(a.route, b.route));
 }
 
 type PreloadAndSetPrerenderStatusParams = {
-	env: DevelopmentEnvironment;
+	pipeline: DevPipeline;
 	matches: RouteData[];
 	settings: AstroSettings;
 };
@@ -36,7 +36,7 @@ type PreloadAndSetPrerenderStatusResult = {
 };
 
 async function preloadAndSetPrerenderStatus({
-	env,
+	pipeline,
 	matches,
 	settings,
 }: PreloadAndSetPrerenderStatusParams): Promise<PreloadAndSetPrerenderStatusResult[]> {
@@ -52,12 +52,12 @@ async function preloadAndSetPrerenderStatus({
 				};
 			}
 
-			const preloadedComponent = await preload({ env, filePath });
+			const preloadedComponent = await preload({ pipeline, filePath });
 
 			// gets the prerender metadata set by the `astro:scanner` vite plugin
 			const prerenderStatus = getPrerenderStatus({
 				filePath,
-				loader: env.loader,
+				loader: pipeline.getModuleLoader(),
 			});
 
 			if (prerenderStatus !== undefined) {

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

@@ -0,0 +1,128 @@
+import { Pipeline } from '../core/pipeline.js';
+import type { AstroConfig, AstroSettings, RouteData } from '../@types/astro';
+import type { ModuleLoader } from '../core/module-loader';
+import type { Environment } from '../core/render';
+import { createEnvironment, loadRenderer } from '../core/render/index.js';
+import { createResolve } from './resolve.js';
+import { RouteCache } from '../core/render/route-cache.js';
+import { isServerLikeOutput } from '../prerender/utils.js';
+import type { RuntimeMode, SSRManifest, SSRLoadedRenderer } from '../@types/astro';
+import type { LogOptions } from '../core/logger/core';
+import { Logger } from '../core/logger/core.js';
+import type { EndpointCallResult } from '../core/endpoint/index.js';
+import mime from 'mime';
+import { attachCookiesToResponse } from '../core/cookies/index.js';
+
+export default class DevPipeline extends Pipeline {
+	#settings: AstroSettings;
+	#loader: ModuleLoader;
+	#devLogger: Logger;
+	#currentMatchedRoute: RouteData | undefined;
+
+	constructor({
+		manifest,
+		logging,
+		settings,
+		loader,
+	}: {
+		manifest: SSRManifest;
+		logging: LogOptions;
+		settings: AstroSettings;
+		loader: ModuleLoader;
+	}) {
+		const env = DevPipeline.createDevelopmentEnvironment(manifest, settings, logging, loader);
+		super(env);
+		this.#devLogger = new Logger(logging);
+		this.#settings = settings;
+		this.#loader = loader;
+		this.setEndpointHandler(this.#handleEndpointResult);
+	}
+
+	setCurrentMatchedRoute(route: RouteData) {
+		this.#currentMatchedRoute = route;
+	}
+
+	clearRouteCache() {
+		this.env.routeCache.clearAll();
+	}
+
+	getSettings(): Readonly<AstroSettings> {
+		return this.#settings;
+	}
+
+	getConfig(): Readonly<AstroConfig> {
+		return this.#settings.config;
+	}
+
+	getModuleLoader(): Readonly<ModuleLoader> {
+		return this.#loader;
+	}
+
+	get logger(): Readonly<Logger> {
+		return this.#devLogger;
+	}
+
+	async loadRenderers() {
+		const renderers = await Promise.all(
+			this.#settings.renderers.map((r) => loadRenderer(r, this.#loader))
+		);
+		this.env.renderers = renderers.filter(Boolean) as SSRLoadedRenderer[];
+	}
+
+	static createDevelopmentEnvironment(
+		manifest: SSRManifest,
+		settings: AstroSettings,
+		logging: LogOptions,
+		loader: ModuleLoader
+	): Environment {
+		const mode: RuntimeMode = 'development';
+
+		return createEnvironment({
+			adapterName: manifest.adapterName,
+			logging,
+			mode,
+			// This will be overridden in the dev server
+			renderers: [],
+			clientDirectives: manifest.clientDirectives,
+			compressHTML: manifest.compressHTML,
+			resolve: createResolve(loader, settings.config.root),
+			routeCache: new RouteCache(logging, mode),
+			site: manifest.site,
+			ssr: isServerLikeOutput(settings.config),
+			streaming: true,
+		});
+	}
+
+	async #handleEndpointResult(_: Request, result: EndpointCallResult): Promise<Response> {
+		if (result.type === 'simple') {
+			if (!this.#currentMatchedRoute) {
+				throw new Error(
+					'In development mode, you must set the current matched route before handling a endpoint.'
+				);
+			}
+			let contentType = 'text/plain';
+			// Dynamic routes don't include `route.pathname`, so synthesize a path for these (e.g. 'src/pages/[slug].svg')
+			const filepath =
+				this.#currentMatchedRoute.pathname ||
+				this.#currentMatchedRoute.segments
+					.map((segment) => segment.map((p) => p.content).join(''))
+					.join('/');
+			const computedMimeType = mime.getType(filepath);
+			if (computedMimeType) {
+				contentType = computedMimeType;
+			}
+			const response = new Response(
+				result.encoding !== 'binary' ? Buffer.from(result.body, result.encoding) : result.body,
+				{
+					status: 200,
+					headers: {
+						'Content-Type': `${contentType};charset=utf-8`,
+					},
+				}
+			);
+			attachCookiesToResponse(response, result.cookies);
+			return response;
+		}
+		return result.response;
+	}
+}