refactor: build pipeline

packages/astro/src/cli/add/index.ts

@@ -703,6 +703,7 @@ async function tryToInstallIntegrations({
 			} catch (err) {
 				spinner.fail();
 				debug('add', 'Error installing dependencies', err);
+				// eslint-disable-next-line no-console
 				console.error('\n', (err as any).stdout, '\n');
 				return UpdateResult.failure;
 			}

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

@@ -16,7 +16,7 @@ export class EndpointNotFoundError extends Error {
 }
 
 export class SSRRoutePipeline extends Pipeline {
-	encoder = new TextEncoder();
+	#encoder = new TextEncoder();
 
 	constructor(env: Environment) {
 		super(env);
@@ -40,7 +40,7 @@ export class SSRRoutePipeline extends Pipeline {
 				headers.set('Content-Type', 'text/plain;charset=utf-8');
 			}
 			const bytes =
-				response.encoding !== 'binary' ? this.encoder.encode(response.body) : response.body;
+				response.encoding !== 'binary' ? this.#encoder.encode(response.body) : response.body;
 			headers.set('Content-Length', bytes.byteLength.toString());
 
 			const newResponse = new Response(bytes, {

packages/astro/src/core/build/buildPipeline.ts

@@ -0,0 +1,211 @@
+import { Pipeline } from '../pipeline.js';
+import type { BuildInternals } from './internal';
+import type { PageBuildData, StaticBuildOptions } from './types';
+import { ASTRO_PAGE_RESOLVED_MODULE_ID } from './plugins/plugin-pages.js';
+import { RESOLVED_SPLIT_MODULE_ID } from './plugins/plugin-ssr.js';
+import { ASTRO_PAGE_EXTENSION_POST_PATTERN } from './plugins/util.js';
+import type { SSRManifest } from '../app/types';
+import type { AstroConfig, AstroSettings, RouteType, SSRLoadedRenderer } from '../../@types/astro';
+import { getOutputDirectory, isServerLikeOutput } from '../../prerender/utils.js';
+import type { EndpointCallResult } from '../endpoint';
+import { createEnvironment } from '../render/index.js';
+import { BEFORE_HYDRATION_SCRIPT_ID } from '../../vite-plugin-scripts/index.js';
+import { createAssetLink } from '../render/ssr-element.js';
+import type { BufferEncoding } from 'vfile';
+
+/**
+ * This pipeline is responsible to gather the files emitted by the SSR build and generate the pages by executing these files.
+ */
+export class BuildPipeline extends Pipeline {
+	#internals: BuildInternals;
+	#staticBuildOptions: StaticBuildOptions;
+	#manifest: SSRManifest;
+	#currentEndpointBody?: {
+		body: string | Uint8Array;
+		encoding: BufferEncoding;
+	};
+
+	constructor(
+		staticBuildOptions: StaticBuildOptions,
+		internals: BuildInternals,
+		manifest: SSRManifest
+	) {
+		const ssr = isServerLikeOutput(staticBuildOptions.settings.config);
+		super(
+			createEnvironment({
+				adapterName: manifest.adapterName,
+				logging: staticBuildOptions.logging,
+				mode: staticBuildOptions.mode,
+				renderers: manifest.renderers,
+				clientDirectives: manifest.clientDirectives,
+				compressHTML: manifest.compressHTML,
+				async resolve(specifier: string) {
+					const hashedFilePath = manifest.entryModules[specifier];
+					if (typeof hashedFilePath !== 'string') {
+						// If no "astro:scripts/before-hydration.js" script exists in the build,
+						// then we can assume that no before-hydration scripts are needed.
+						if (specifier === BEFORE_HYDRATION_SCRIPT_ID) {
+							return '';
+						}
+						throw new Error(`Cannot find the built path for ${specifier}`);
+					}
+					return createAssetLink(hashedFilePath, manifest.base, manifest.assetsPrefix);
+				},
+				routeCache: staticBuildOptions.routeCache,
+				site: manifest.site,
+				ssr,
+				streaming: true,
+			})
+		);
+		this.#internals = internals;
+		this.#staticBuildOptions = staticBuildOptions;
+		this.#manifest = manifest;
+		this.setEndpointHandler(this.#handleEndpointResult);
+	}
+
+	getInternals(): Readonly<BuildInternals> {
+		return this.#internals;
+	}
+
+	getSettings(): Readonly<AstroSettings> {
+		return this.#staticBuildOptions.settings;
+	}
+
+	getStaticBuildOptions(): Readonly<StaticBuildOptions> {
+		return this.#staticBuildOptions;
+	}
+
+	getConfig(): AstroConfig {
+		return this.#staticBuildOptions.settings.config;
+	}
+
+	getManifest(): SSRManifest {
+		return this.#manifest;
+	}
+
+	/**
+	 * The SSR build emits two important files:
+	 * - dist/server/manifest.mjs
+	 * - dist/renderers.mjs
+	 *
+	 * These two files, put together, will be used to generate the pages.
+	 *
+	 * ## Errors
+	 *
+	 * It will throw errors if the previous files can't be found in the file system.
+	 *
+	 * @param staticBuildOptions
+	 */
+	static async retrieveManifest(
+		staticBuildOptions: StaticBuildOptions,
+		internals: BuildInternals
+	): Promise<SSRManifest> {
+		const config = staticBuildOptions.settings.config;
+		const baseDirectory = getOutputDirectory(config);
+		const manifestEntryUrl = new URL(
+			`${internals.manifestFileName}?time=${Date.now()}`,
+			baseDirectory
+		);
+		const { manifest } = await import(manifestEntryUrl.toString());
+		if (!manifest) {
+			throw new Error(
+				"Astro couldn't find the emitted manifest. This is an internal error, please file an issue."
+			);
+		}
+
+		const renderersEntryUrl = new URL(`renderers.mjs?time=${Date.now()}`, baseDirectory);
+		const renderers = await import(renderersEntryUrl.toString());
+		if (!renderers) {
+			throw new Error(
+				"Astro couldn't find the emitted renderers. This is an internal error, please file an issue."
+			);
+		}
+		return {
+			...manifest,
+			renderers: renderers.renderers as SSRLoadedRenderer[],
+		};
+	}
+
+	/**
+	 * It collects the routes to generate during the build.
+	 *
+	 * It returns a map of page information and their relative entry point as a string.
+	 */
+	retrieveRoutesToGenerate(): Map<PageBuildData, string> {
+		const pages = new Map<PageBuildData, string>();
+
+		for (const [entryPoint, filePath] of this.#internals.entrySpecifierToBundleMap) {
+			// virtual pages can be emitted with different prefixes:
+			// - the classic way are pages emitted with prefix ASTRO_PAGE_RESOLVED_MODULE_ID -> plugin-pages
+			// - pages emitted using `build.split`, in this case pages are emitted with prefix RESOLVED_SPLIT_MODULE_ID
+			if (
+				entryPoint.includes(ASTRO_PAGE_RESOLVED_MODULE_ID) ||
+				entryPoint.includes(RESOLVED_SPLIT_MODULE_ID)
+			) {
+				const [, pageName] = entryPoint.split(':');
+				const pageData = this.#internals.pagesByComponent.get(
+					`${pageName.replace(ASTRO_PAGE_EXTENSION_POST_PATTERN, '.')}`
+				);
+				if (!pageData) {
+					throw new Error(
+						"Build failed. Astro couldn't find the emitted page from " + pageName + ' pattern'
+					);
+				}
+
+				pages.set(pageData, filePath);
+			}
+		}
+		for (const [path, pageData] of this.#internals.pagesByComponent.entries()) {
+			if (pageData.route.type === 'redirect') {
+				pages.set(pageData, path);
+			}
+		}
+		return pages;
+	}
+
+	async #handleEndpointResult(request: Request, response: EndpointCallResult): Promise<Response> {
+		if (response.type === 'response') {
+			if (!response.response.body) {
+				return new Response(null);
+			}
+			const ab = await response.response.arrayBuffer();
+			const body = new Uint8Array(ab);
+			this.#currentEndpointBody = {
+				body: body,
+				encoding: 'utf-8',
+			};
+			return response.response;
+		} else {
+			if (response.encoding) {
+				this.#currentEndpointBody = {
+					body: response.body,
+					encoding: response.encoding,
+				};
+				const headers = new Headers();
+				headers.set('X-Astro-Encoding', response.encoding);
+				return new Response(response.body, {
+					headers,
+				});
+			} else {
+				return new Response(response.body);
+			}
+		}
+	}
+
+	async computeBodyAndEncoding(
+		routeType: RouteType,
+		response: Response
+	): Promise<{
+		body: string | Uint8Array;
+		encoding: BufferEncoding;
+	}> {
+		const encoding = response.headers.get('X-Astro-Encoding') ?? 'utf-8';
+		if (this.#currentEndpointBody) {
+			const currentEndpointBody = this.#currentEndpointBody;
+			this.#currentEndpointBody = undefined;
+			return currentEndpointBody;
+		} else {
+			return { body: await response.text(), encoding: encoding as BufferEncoding };
+		}
+	}
+}