createVitePluginAstroServer() — astro Function Reference

Source Code

packages/astro/src/vite-plugin-astro-server/plugin.ts lines 41–126

export default function createVitePluginAstroServer({
	settings,
	logger,
}: AstroPluginOptions): vite.Plugin {
	return {
		name: 'astro:server',
		applyToEnvironment(environment) {
			return environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr;
		},
		async configureServer(viteServer) {
			// Cloudflare handles its own requests
			// TODO: let this handle non-runnable environments that don't intercept requests
			if (!isRunnableDevEnvironment(viteServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr])) {
				return;
			}
			const environment = viteServer.environments[
				ASTRO_VITE_ENVIRONMENT_NAMES.ssr
			] as RunnableDevEnvironment;
			const loader = createViteLoader(viteServer, environment);
			const { default: createAstroServerApp } =
				await environment.runner.import<
					typeof import('../vite-plugin-app/createAstroServerApp.js')
				>(ASTRO_DEV_SERVER_APP_ID);
			const controller = createController({ loader });
			const { handler } = await createAstroServerApp(controller, settings, loader, logger);
			const { manifest } = await environment.runner.import<{
				manifest: SSRManifest;
			}>(SERIALIZED_MANIFEST_ID);
			const localStorage = new AsyncLocalStorage();

			function handleUnhandledRejection(rejection: any) {
				const error = AstroError.is(rejection)
					? rejection
					: new AstroError({
							...AstroErrorData.UnhandledRejection,
							message: AstroErrorData.UnhandledRejection.message(rejection?.stack || rejection),
						});
				const store = localStorage.getStore();
				if (store instanceof IncomingMessage) {
					setRouteError(controller.state, store.url!, error);
				}
				const { errorWithMetadata } = recordServerError(loader, manifest, logger, error);
				setTimeout(
					async () => loader.webSocketSend(await getViteErrorPayload(errorWithMetadata)),
					200,
				);
			}

			process.on('unhandledRejection', handleUnhandledRejection);
			viteServer.httpServer?.on('close', () => {
				process.off('unhandledRejection', handleUnhandledRejection);
			});

			return () => {
				// Push this middleware to the front of the stack so that it can intercept responses.
				// fix(#6067): always inject this to ensure zombie base handling is killed after restarts
				viteServer.middlewares.stack.unshift({
					route: '',
					handle: baseMiddleware(settings, logger),
				});
				viteServer.middlewares.stack.unshift({
					route: '',
					handle: trailingSlashMiddleware(settings),
				});
				// Prevent serving files outside srcDir/publicDir (e.g., /README.md at project root)
				viteServer.middlewares.stack.unshift({
					route: '',
					handle: routeGuardMiddleware(settings),
				});

				// Note that this function has a name so other middleware can find it.
				viteServer.middlewares.use(async function astroDevHandler(request, response) {
					if (request.url === undefined || !request.method) {
						response.writeHead(500, 'Incomplete request');
						response.end();
						return;
					}

					localStorage.run(request, () => {
						handler(request, response);
					});