@ecopages/core 0.2.0-alpha.25 → 0.2.0-alpha.27

package/src/static-site-generator/static-site-generator.ts

@@ -2,10 +2,31 @@ import path from 'node:path';
 import { appLogger } from '../global/app-logger.ts';
 import type { EcoPagesAppConfig } from '../types/internal-types.ts';
 import type { EcoPageComponent, StaticRoute } from '../types/public-types.ts';
-import type { RouteRendererFactory } from '../route-renderer/route-renderer.ts';
-import type { FSRouter } from '../router/server/fs-router.ts';
+import type {
+	ExplicitViewRenderer,
+	ExplicitViewRendererResolver,
+	PageRendererResolver,
+	StaticGenerationRendererResolver,
+} from '../route-renderer/route-renderer.ts';
+import type { StaticGenerationRoute } from '../router/server/route-registry.ts';
 import { fileSystem } from '@ecopages/file-system';
 import { PathUtils } from '../utils/path-utils.module.ts';
+import { prepareExplicitStaticRender } from '../adapters/shared/explicit-static-render-preparation.ts';
+
+type StaticGenerationRouteSource = {
+	listStaticGenerationRoutes(input: { runtimeOrigin: string }): Promise<readonly StaticGenerationRoute[]>;
+};
+
+type StaticPageRouteRendererFactory = PageRendererResolver;
+
+type ExplicitStaticRouteRendererFactory = ExplicitViewRendererResolver;
+
+type StaticGenerationRendererFactory = StaticGenerationRendererResolver;
+
+type ExplicitStaticRouteEntry = {
+	pathname: string;
+	params: Record<string, string | string[]>;
+};
 
 export const STATIC_SITE_GENERATOR_ERRORS = {
 	ROUTE_RENDERER_FACTORY_REQUIRED: 'RouteRendererFactory is required for render strategy',
@@ -56,9 +77,9 @@ export class StaticSiteGenerator {
 	 */
 	private async shouldSkipStaticPageFile(
 		filePath: string,
-		routeRendererFactory: RouteRendererFactory,
+		routeRendererFactory: StaticPageRouteRendererFactory,
 	): Promise<boolean> {
-		const module = (await routeRendererFactory.createRenderer(filePath).loadPageModule(filePath, {
+		const module = (await routeRendererFactory.getPageRenderer(filePath).loadPageModule(filePath, {
 			cacheScope: 'static-page-probe',
 		})) as {
 			default?: EcoPageComponent<any>;
@@ -131,27 +152,65 @@ export class StaticSiteGenerator {
 		return Array.from(directories);
 	}
 
-	/**
-	 * Extracts dynamic parameters from the actual path based on the template path.
-	 *
-	 * @param templatePath - The template path (e.g., "/blog/[slug]")
-	 * @param actualPath - The actual path (e.g., "/blog/my-post")
-	 * @returns A record of extracted parameters (e.g., { slug: "my-post" })
-	 */
-	private extractParams(templatePath: string, actualPath: string): Record<string, string> {
-		const templateSegments = templateSegmentsFromPath(templatePath);
-		const actualSegments = templateSegmentsFromPath(actualPath);
-		const params: Record<string, string> = {};
-
-		for (let i = 0; i < templateSegments.length; i++) {
-			const segment = templateSegments[i];
-			if (segment.startsWith('[') && segment.endsWith(']')) {
-				const paramName = segment.slice(1, -1).replace('...', '');
-				params[paramName] = actualSegments[i];
+	private writeStaticOutput(routePath: string, contents: string | Buffer, directories: string[] = []): string {
+		const outputPath = this.getOutputPath(routePath, directories);
+		fileSystem.ensureDir(path.dirname(outputPath));
+		fileSystem.write(outputPath, contents);
+		return outputPath;
+	}
+
+	private getStaticBuildStrategy(filePath: string): 'fetch' | 'render' {
+		const ext = PathUtils.getEcoTemplateExtension(filePath);
+		const integration = this.appConfig.integrations.find((plugin) => plugin.extensions.includes(ext));
+		return integration?.staticBuildStep || 'render';
+	}
+
+	private async createFilesystemStaticContents(
+		route: StaticGenerationRoute,
+		baseUrl: string,
+		routeRendererFactory?: StaticPageRouteRendererFactory,
+	): Promise<string | Buffer | null> {
+		const {
+			templateRoute: { filePath },
+			params,
+		} = route;
+
+		if (this.getStaticBuildStrategy(filePath) === 'fetch') {
+			const fetchUrl = this.resolveStaticFetchUrl(route.requestUrl, baseUrl);
+			const response = await fetch(fetchUrl);
+
+			if (!response.ok) {
+				appLogger.error(`Failed to fetch ${fetchUrl}. Status: ${response.status}`);
+				return null;
 			}
+
+			return response.text();
+		}
+
+		if (!routeRendererFactory) {
+			throw new Error(STATIC_SITE_GENERATOR_ERRORS.ROUTE_RENDERER_FACTORY_REQUIRED);
+		}
+
+		if (await this.shouldSkipStaticPageFile(filePath, routeRendererFactory)) {
+			return null;
+		}
+
+		const renderer = routeRendererFactory.getPageRenderer(filePath);
+		const result = await renderer.execute({
+			file: filePath,
+			params: params as Record<string, string>,
+		});
+
+		const body = result.body;
+		if (typeof body === 'string' || Buffer.isBuffer(body)) {
+			return body;
 		}
 
-		return params;
+		if (body instanceof ReadableStream) {
+			return new Response(body).text();
+		}
+
+		throw new Error(STATIC_SITE_GENERATOR_ERRORS.unsupportedBodyType(typeof body));
 	}
 
 	/**
@@ -162,95 +221,31 @@ export class StaticSiteGenerator {
 	 * issuing a request against the running server origin. Render-strategy routes
 	 * go through the normal route renderer directly.
 	 */
-	async generateStaticPages(router: FSRouter, baseUrl: string, routeRendererFactory?: RouteRendererFactory) {
-		const routes = Object.keys(router.routes).filter((route) => !route.includes('['));
+	async generateStaticPages(
+		router: StaticGenerationRouteSource,
+		baseUrl: string,
+		routeRendererFactory?: StaticPageRouteRendererFactory,
+	) {
+		const routes = await router.listStaticGenerationRoutes({ runtimeOrigin: baseUrl });
 
-		appLogger.debug('Static Pages', routes);
-
-		const directories = this.getDirectories(routes);
+		appLogger.debug(
+			'Static Pages',
+			routes.map((route) => route.requestUrl),
+		);
 
-		for (const directory of directories) {
-			fileSystem.ensureDir(path.join(this.getExportDir(), directory));
-		}
+		const directories = this.getDirectories(routes.map((route) => route.requestUrl));
 
 		for (const route of routes) {
 			try {
-				const { filePath, pathname: routePathname } = router.routes[route];
-
-				const ext = PathUtils.getEcoTemplateExtension(filePath);
-				const integration = this.appConfig.integrations.find((plugin) => plugin.extensions.includes(ext));
-				const strategy = integration?.staticBuildStep || 'render';
-
-				let contents: string | Buffer;
-
-				if (strategy === 'fetch') {
-					const fetchUrl = this.resolveStaticFetchUrl(route, baseUrl);
-					const response = await fetch(fetchUrl);
-
-					if (!response.ok) {
-						appLogger.error(`Failed to fetch ${fetchUrl}. Status: ${response.status}`);
-						continue;
-					}
-					contents = await response.text();
-				} else {
-					if (!routeRendererFactory) {
-						throw new Error(STATIC_SITE_GENERATOR_ERRORS.ROUTE_RENDERER_FACTORY_REQUIRED);
-					}
-
-					if (await this.shouldSkipStaticPageFile(filePath, routeRendererFactory)) {
-						continue;
-					}
-
-					let pathname = routePathname;
-					const pathnameSegments = pathname.split('/').filter(Boolean);
-
-					if (pathname === '/') {
-						pathname = '/index.html';
-					} else if (pathnameSegments.join('/').includes('[')) {
-						pathname = `${route.replace(router.origin, '')}.html`;
-					} else if (pathnameSegments.length >= 1 && directories.includes(`/${pathnameSegments.join('/')}`)) {
-						pathname = `${pathname.endsWith('/') ? pathname : `${pathname}/`}index.html`;
-					} else {
-						pathname += '.html';
-					}
-
-					const renderer = routeRendererFactory.createRenderer(filePath);
-					const params = this.extractParams(routePathname, pathname.replace('.html', ''));
-
-					const result = await renderer.createRoute({
-						file: filePath,
-						params,
-					});
-
-					const body = result.body;
-
-					if (typeof body === 'string' || Buffer.isBuffer(body)) {
-						contents = body;
-					} else if (body instanceof ReadableStream) {
-						contents = await new Response(body).text();
-					} else {
-						throw new Error(STATIC_SITE_GENERATOR_ERRORS.unsupportedBodyType(typeof body));
-					}
-				}
-
-				let pathname = routePathname;
-				const pathnameSegments = pathname.split('/').filter(Boolean);
-
-				if (pathname === '/') {
-					pathname = '/index.html';
-				} else if (pathnameSegments.join('/').includes('[')) {
-					pathname = `${route.replace(router.origin, '')}.html`;
-				} else if (pathnameSegments.length >= 1 && directories.includes(`/${pathnameSegments.join('/')}`)) {
-					pathname = `${pathname.endsWith('/') ? pathname : `${pathname}/`}index.html`;
-				} else {
-					pathname += '.html';
+				const contents = await this.createFilesystemStaticContents(route, baseUrl, routeRendererFactory);
+				if (contents === null) {
+					continue;
 				}
 
-				const outputPath = path.join(this.getExportDir(), pathname);
-				fileSystem.write(outputPath, contents);
+				this.writeStaticOutput(route.pathname, contents, directories);
 			} catch (error) {
 				appLogger.error(
-					`Error generating static page for ${route}:`,
+					`Error generating static page for ${route.requestUrl}:`,
 					error instanceof Error ? error : String(error),
 				);
 			}
@@ -280,9 +275,9 @@ export class StaticSiteGenerator {
 		routeRendererFactory,
 		staticRoutes,
 	}: {
-		router: FSRouter;
+		router: StaticGenerationRouteSource;
 		baseUrl: string;
-		routeRendererFactory?: RouteRendererFactory;
+		routeRendererFactory?: StaticGenerationRendererFactory;
 		staticRoutes?: StaticRoute[];
 	}) {
 		this.generateRobotsTxt();
@@ -299,7 +294,7 @@ export class StaticSiteGenerator {
 	 */
 	private async generateExplicitStaticPages(
 		staticRoutes: StaticRoute[],
-		routeRendererFactory: RouteRendererFactory,
+		routeRendererFactory: ExplicitStaticRouteRendererFactory,
 	): Promise<void> {
 		appLogger.debug(
 			'Generating explicit static routes',
@@ -314,13 +309,7 @@ export class StaticSiteGenerator {
 					continue;
 				}
 
-				const isDynamic = route.path.includes(':') || route.path.includes('[');
-
-				if (isDynamic) {
-					await this.generateDynamicStaticRoute(route.path, view, routeRendererFactory);
-				} else {
-					await this.generateSingleStaticRoute(route.path, view, routeRendererFactory);
-				}
+				await this.generateExplicitStaticRoute(route.path, view, routeRendererFactory);
 			} catch (error) {
 				appLogger.error(
 					`Error generating explicit static page for ${route.path}:`,
@@ -330,64 +319,81 @@ export class StaticSiteGenerator {
 		}
 	}
 
-	/**
-	 * Generate a single static page for a non-dynamic route.
-	 */
-	private async generateSingleStaticRoute(
+	private async generateExplicitStaticRoute(
 		routePath: string,
 		view: EcoPageComponent<any>,
-		routeRendererFactory: RouteRendererFactory,
+		routeRendererFactory: ExplicitStaticRouteRendererFactory,
 	): Promise<void> {
-		const integrationName = view.config?.__eco?.integration;
-		if (!integrationName) {
-			throw new Error(STATIC_SITE_GENERATOR_ERRORS.missingIntegration(routePath));
-		}
+		const { renderer, routeEntries } = await this.planExplicitStaticRoute(routePath, view, routeRendererFactory);
 
-		const renderer = routeRendererFactory.getRendererByIntegration(integrationName);
-		if (!renderer) {
-			throw new Error(STATIC_SITE_GENERATOR_ERRORS.noRendererForIntegration(integrationName));
-		}
+		for (const { pathname, params } of routeEntries) {
+			const contents = await this.createExplicitStaticContents(
+				routePath,
+				view,
+				params,
+				routeRendererFactory,
+				renderer,
+			);
 
-		const props = view.staticProps
-			? (
-					await view.staticProps({
-						pathname: { params: {} },
-						appConfig: this.appConfig,
-						runtimeOrigin: this.appConfig.baseUrl,
-					})
-				).props
-			: {};
+			const outputPath = this.writeStaticOutput(pathname, contents);
 
-		const response = await renderer.renderToResponse(view, props, {});
-		const contents = await response.text();
+			appLogger.debug(`Generated static page: ${pathname} -> ${outputPath}`);
+		}
+	}
 
-		const outputPath = this.getOutputPath(routePath);
-		fileSystem.ensureDir(path.dirname(outputPath));
-		fileSystem.write(outputPath, contents);
+	private async planExplicitStaticRoute(
+		routePath: string,
+		view: EcoPageComponent<any>,
+		routeRendererFactory: ExplicitStaticRouteRendererFactory,
+	): Promise<{ renderer: ExplicitViewRenderer; routeEntries: ExplicitStaticRouteEntry[] }> {
+		const { renderer } = await prepareExplicitStaticRender({
+			routePath,
+			view,
+			params: {},
+			appConfig: this.appConfig,
+			runtimeOrigin: this.appConfig.baseUrl,
+			routeRendererFactory,
+			errors: STATIC_SITE_GENERATOR_ERRORS,
+		});
 
-		appLogger.debug(`Generated static page: ${routePath} -> ${outputPath}`);
+		return {
+			renderer,
+			routeEntries: await this.listExplicitStaticRouteEntries(routePath, view),
+		};
 	}
 
-	/**
-	 * Generate static pages for a dynamic route using staticPaths.
-	 */
-	private async generateDynamicStaticRoute(
+	private async createExplicitStaticContents(
 		routePath: string,
 		view: EcoPageComponent<any>,
-		routeRendererFactory: RouteRendererFactory,
-	): Promise<void> {
-		if (!view.staticPaths) {
-			throw new Error(STATIC_SITE_GENERATOR_ERRORS.dynamicRouteRequiresStaticPaths(routePath));
-		}
+		params: Record<string, string | string[]>,
+		routeRendererFactory: ExplicitStaticRouteRendererFactory,
+		renderer: ExplicitViewRenderer,
+	): Promise<string> {
+		const { props, view: renderableView } = await prepareExplicitStaticRender({
+			routePath,
+			view,
+			params,
+			appConfig: this.appConfig,
+			runtimeOrigin: this.appConfig.baseUrl,
+			routeRendererFactory,
+			errors: STATIC_SITE_GENERATOR_ERRORS,
+		});
+
+		const response = await renderer.renderToResponse(renderableView, props, {});
+		return response.text();
+	}
 
-		const integrationName = view.config?.__eco?.integration;
-		if (!integrationName) {
-			throw new Error(STATIC_SITE_GENERATOR_ERRORS.missingIntegration(routePath));
+	private async listExplicitStaticRouteEntries(
+		routePath: string,
+		view: EcoPageComponent<any>,
+	): Promise<ExplicitStaticRouteEntry[]> {
+		const isDynamic = routePath.includes(':') || routePath.includes('[');
+		if (!isDynamic) {
+			return [{ pathname: routePath, params: {} }];
 		}
 
-		const renderer = routeRendererFactory.getRendererByIntegration(integrationName);
-		if (!renderer) {
-			throw new Error(STATIC_SITE_GENERATOR_ERRORS.noRendererForIntegration(integrationName));
+		if (!view.staticPaths) {
+			throw new Error(STATIC_SITE_GENERATOR_ERRORS.dynamicRouteRequiresStaticPaths(routePath));
 		}
 
 		const { paths } = await view.staticPaths({
@@ -395,28 +401,10 @@ export class StaticSiteGenerator {
 			runtimeOrigin: this.appConfig.baseUrl,
 		});
 
-		for (const { params } of paths) {
-			const resolvedPath = this.resolveRoutePath(routePath, params);
-
-			const props = view.staticProps
-				? (
-						await view.staticProps({
-							pathname: { params },
-							appConfig: this.appConfig,
-							runtimeOrigin: this.appConfig.baseUrl,
-						})
-					).props
-				: {};
-
-			const response = await renderer.renderToResponse(view, props, {});
-			const contents = await response.text();
-
-			const outputPath = this.getOutputPath(resolvedPath);
-			fileSystem.ensureDir(path.dirname(outputPath));
-			fileSystem.write(outputPath, contents);
-
-			appLogger.debug(`Generated static page: ${resolvedPath} -> ${outputPath}`);
-		}
+		return paths.map(({ params }) => ({
+			pathname: this.resolveRoutePath(routePath, params),
+			params,
+		}));
 	}
 
 	/**
@@ -439,11 +427,13 @@ export class StaticSiteGenerator {
 	/**
 	 * Get the output file path for a given route.
 	 */
-	private getOutputPath(routePath: string): string {
+	private getOutputPath(routePath: string, directories: string[] = []): string {
 		let outputName: string;
 
 		if (routePath === '/') {
 			outputName = 'index.html';
+		} else if (directories.includes(routePath)) {
+			outputName = `${routePath}/index.html`;
 		} else if (routePath.endsWith('/')) {
 			outputName = `${routePath}index.html`;
 		} else {
@@ -453,10 +443,3 @@ export class StaticSiteGenerator {
 		return path.join(this.getExportDir(), outputName);
 	}
 }
-
-/**
- * Splits a path into segments, filtering out empty strings.
- */
-function templateSegmentsFromPath(path: string) {
-	return path.split('/').filter(Boolean);
-}

package/src/types/internal-types.ts

@@ -1,17 +1,16 @@
 import type { EcoBuildPlugin } from '../build/build-types.ts';
 import type { AppBuildManifest } from '../build/build-manifest.ts';
 import type { BuildAdapter, BuildExecutor, BuildOwnership } from '../build/build-adapter.ts';
-import type { IntegrationPlugin } from '../plugins/integration-plugin.ts';
+import type { AnyIntegrationPlugin } from '../plugins/integration-plugin.ts';
 import type { Processor } from '../plugins/processor.ts';
 import type { EcoSourceTransform } from '../plugins/source-transform.ts';
 import type { PageMetadataProps } from './public-types.ts';
-import type { FSRouter } from '../router/server/fs-router.ts';
+import type { RouteRegistry } from '../router/server/route-registry.ts';
 import type { CacheConfig } from '../services/cache/cache.types.ts';
 import type { DevGraphService } from '../services/runtime-state/dev-graph.service.ts';
 import type { AppModuleLoader } from '../services/module-loading/app-module-loader.service.ts';
 import type { SourceModuleLoader } from '../services/module-loading/module-loading-types.ts';
 import type { EntrypointDependencyGraph } from '../services/runtime-state/entrypoint-dependency-graph.service.ts';
-import type { RuntimeSpecifierRegistry } from '../services/runtime-state/runtime-specifier-registry.service.ts';
 import type { ServerInvalidationState } from '../services/runtime-state/server-invalidation-state.service.ts';
 import type { ServerModuleTranspiler } from '../services/module-loading/server-module-transpiler.service.ts';
 
@@ -104,7 +103,7 @@ export type EcoPagesAppConfig = {
 	 */
 	defaultMetadata: PageMetadataProps;
 	/** Integrations plugins */
-	integrations: IntegrationPlugin[];
+	integrations: AnyIntegrationPlugin[];
 	/** Integrations dependencies */
 	integrationsDependencies: IntegrationDependencyConfig[];
 	/** Derived Paths */
@@ -157,7 +156,6 @@ export type EcoPagesAppConfig = {
 		entrypointDependencyGraph?: EntrypointDependencyGraph;
 		hostModuleLoader?: SourceModuleLoader;
 		rendererModuleContext?: unknown;
-		runtimeSpecifierRegistry?: RuntimeSpecifierRegistry;
 		serverInvalidationState?: ServerInvalidationState;
 		serverModuleTranspiler?: ServerModuleTranspiler;
 	};
@@ -189,11 +187,14 @@ export type RouteKind = 'exact' | 'catch-all' | 'dynamic';
  * Represents the result of a route match.
  */
 export type MatchResult = {
-	filePath: string;
-	kind: RouteKind;
-	pathname: string;
-	query?: Record<string, string>;
-	params?: Record<string, string | string[]>;
+	requestedPathname: string;
+	templateRoute: {
+		filePath: string;
+		kind: RouteKind;
+		pathname: string;
+	};
+	query: Record<string, string>;
+	params: Record<string, string | string[]>;
 };
 
 /**
@@ -224,10 +225,10 @@ export type FileSystemServerOptions = {
 export interface EcoPagesFileSystemServerAdapter<ServerInstanceOptions = unknown> {
 	startServer(serverOptions: ServerInstanceOptions):
 		| {
-				router: FSRouter;
+				router: RouteRegistry;
 				server: unknown;
 		  }
-		| Promise<{ router: FSRouter; server: unknown }>;
+		| Promise<{ router: RouteRegistry; server: unknown }>;
 }
 
 export interface ProcessorPlugin {