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

package/src/route-renderer/orchestration/render-execution.service.ts

@@ -1,182 +0,0 @@
-import { inspectBoundaryArtifactHtml } from './render-output.utils.ts';
-import type {
-	IntegrationRendererRenderOptions,
-	RouteRendererBody,
-	RouteRendererOptions,
-	RouteRenderResult,
-} from '../../types/public-types.ts';
-
-export interface CapturedHtmlRenderResult {
-	body: RouteRendererBody;
-	html: string;
-}
-
-export interface FinalizeHtmlRenderOptions {
-	html: string;
-	componentRootAttributes?: Record<string, string>;
-	documentAttributes?: Record<string, string>;
-}
-
-export interface RenderExecutionCallbacks<C> {
-	prepareRenderOptions(options: RouteRendererOptions): Promise<IntegrationRendererRenderOptions<C>>;
-	render(renderOptions: IntegrationRendererRenderOptions<C>): Promise<RouteRendererBody>;
-	getDocumentAttributes(renderOptions: IntegrationRendererRenderOptions<C>): Record<string, string> | undefined;
-	applyAttributesToHtmlElement(html: string, attributes: Record<string, string>): string;
-	applyAttributesToFirstBodyElement(html: string, attributes: Record<string, string>): string;
-	transformResponse(response: Response): Promise<RouteRendererBody>;
-}
-
-/**
- * Executes the main post-preparation rendering flow for integration renderers.
- *
- * This service owns the orchestration that happens after normalized render
- * options have been prepared: one render pass, unresolved boundary-marker
- * enforcement, root-attribute application, and final HTML transformation into
- * a response body stream.
- */
-export class RenderExecutionService {
-	async captureHtmlRender(render: () => Promise<RouteRendererBody>): Promise<CapturedHtmlRenderResult> {
-		const renderedBody = await render();
-		const capturedRender = await this.captureRenderedBody(renderedBody);
-
-		return {
-			body: capturedRender.body,
-			html: capturedRender.html,
-		};
-	}
-
-	/**
-	 * Executes one integration render pass and returns the final route render
-	 * result.
-	 *
-	 * @typeParam C Integration render output element type.
-	 * @param options Route-level render options.
-	 * @param currentIntegrationName Active integration name for this render pass.
-	 * @param callbacks Renderer-specific hooks required during execution.
-	 * @returns Final route render output with body and cache strategy.
-	 */
-	async execute<C = unknown>(
-		options: RouteRendererOptions,
-		callbacks: RenderExecutionCallbacks<C>,
-	): Promise<RouteRenderResult> {
-		const renderOptions = await callbacks.prepareRenderOptions(options);
-		const shouldApplyComponentRootAttributes =
-			renderOptions.componentRender?.canAttachAttributes &&
-			renderOptions.componentRender.rootAttributes &&
-			Object.keys(renderOptions.componentRender.rootAttributes).length > 0;
-
-		const renderExecution = await this.captureHtmlRender(async () => callbacks.render(renderOptions));
-		const boundaryArtifacts = inspectBoundaryArtifactHtml(renderExecution.html);
-		const documentAttributes = callbacks.getDocumentAttributes(renderOptions);
-		const hasBoundaryMarkerHtml = boundaryArtifacts.hasUnresolvedBoundaryArtifacts;
-
-		if (hasBoundaryMarkerHtml) {
-			throw new Error(
-				'[ecopages] Route render returned unresolved boundary artifact HTML. Full-route unresolved-boundary fallback has been removed; resolve mixed boundaries inside renderComponentBoundary().',
-			);
-		}
-
-		const canReuseCapturedBody =
-			!hasBoundaryMarkerHtml &&
-			!shouldApplyComponentRootAttributes &&
-			!(documentAttributes && Object.keys(documentAttributes).length > 0);
-
-		if (canReuseCapturedBody) {
-			const body = await callbacks.transformResponse(
-				new Response(renderExecution.body as BodyInit, {
-					headers: {
-						'Content-Type': 'text/html',
-					},
-				}),
-			);
-
-			return {
-				body,
-				cacheStrategy: renderOptions.cacheStrategy,
-			};
-		}
-
-		const finalization = await this.finalizeHtmlRender(
-			{
-				html: boundaryArtifacts.normalizedHtml,
-				componentRootAttributes: shouldApplyComponentRootAttributes
-					? (renderOptions.componentRender?.rootAttributes as Record<string, string>)
-					: undefined,
-				documentAttributes,
-			},
-			{
-				applyAttributesToHtmlElement: callbacks.applyAttributesToHtmlElement,
-				applyAttributesToFirstBodyElement: callbacks.applyAttributesToFirstBodyElement,
-			},
-		);
-
-		const body = await callbacks.transformResponse(
-			new Response(finalization, {
-				headers: {
-					'Content-Type': 'text/html',
-				},
-			}),
-		);
-
-		return {
-			body,
-			cacheStrategy: renderOptions.cacheStrategy,
-		};
-	}
-
-	private async captureRenderedBody(body: RouteRendererBody): Promise<{ body: RouteRendererBody; html: string }> {
-		const response = new Response(body as BodyInit);
-
-		if (typeof body === 'string') {
-			return {
-				body,
-				html: await response.text(),
-			};
-		}
-
-		if (!response.body) {
-			return {
-				body,
-				html: await response.text(),
-			};
-		}
-
-		const [capturedBody, replayBody] = response.body.tee();
-
-		return {
-			body: replayBody,
-			html: await new Response(capturedBody).text(),
-		};
-	}
-
-	async finalizeHtmlRender(
-		options: FinalizeHtmlRenderOptions,
-		callbacks: Pick<
-			RenderExecutionCallbacks<unknown>,
-			'applyAttributesToHtmlElement' | 'applyAttributesToFirstBodyElement'
-		>,
-	): Promise<string> {
-		return this.applyFinalHtmlAttributes(options.html, options, callbacks);
-	}
-
-	private applyFinalHtmlAttributes(
-		html: string,
-		options: FinalizeHtmlRenderOptions,
-		callbacks: Pick<
-			RenderExecutionCallbacks<unknown>,
-			'applyAttributesToHtmlElement' | 'applyAttributesToFirstBodyElement'
-		>,
-	): string {
-		let renderedHtml = html;
-
-		if (options.componentRootAttributes && Object.keys(options.componentRootAttributes).length > 0) {
-			renderedHtml = callbacks.applyAttributesToFirstBodyElement(renderedHtml, options.componentRootAttributes);
-		}
-
-		if (options.documentAttributes && Object.keys(options.documentAttributes).length > 0) {
-			renderedHtml = callbacks.applyAttributesToHtmlElement(renderedHtml, options.documentAttributes);
-		}
-
-		return renderedHtml;
-	}
-}

package/src/route-renderer/orchestration/route-shell-composer.service.ts

@@ -1,162 +0,0 @@
-import type {
-	BaseIntegrationContext,
-	ComponentRenderInput,
-	ComponentRenderResult,
-	EcoComponent,
-	HtmlTemplateProps,
-	PageMetadataProps,
-} from '../../types/public-types.ts';
-import type { ProcessedAsset } from '../../services/assets/asset-processing-service/index.ts';
-import type { RenderToResponseContext } from './integration-renderer.ts';
-
-type ShellRendererCache = BaseIntegrationContext['rendererCache'];
-
-export interface RouteShellComposerCallbacks {
-	hasForeignBoundaryDescendants(component: EcoComponent): boolean;
-	createHtmlResponse(body: BodyInit, ctx: RenderToResponseContext): Response;
-	renderComponentBoundary(input: ComponentRenderInput): Promise<ComponentRenderResult>;
-	prepareViewDependencies(view: EcoComponent, layout?: EcoComponent): Promise<ProcessedAsset[]>;
-	getHtmlTemplate(): Promise<EcoComponent<HtmlTemplateProps>>;
-	resolveViewMetadata<P>(view: EcoComponent<P>, props: P): Promise<PageMetadataProps>;
-	appendProcessedDependencies(...assetGroups: Array<readonly ProcessedAsset[] | undefined>): ProcessedAsset[];
-	finalizeResolvedHtml(options: {
-		html: string;
-		partial?: boolean;
-		componentRootAttributes?: Record<string, string>;
-		documentAttributes?: Record<string, string>;
-		transformHtml?: boolean;
-	}): Promise<string>;
-	docType: string;
-}
-
-export class RouteShellComposer {
-	async renderPartialViewResponse<P>(
-		input: {
-			view: EcoComponent<P>;
-			props: P;
-			ctx: RenderToResponseContext;
-			renderInline?: () => Promise<BodyInit>;
-			transformHtml?: (html: string) => string;
-		},
-		callbacks: RouteShellComposerCallbacks,
-	): Promise<Response> {
-		if (input.renderInline && !callbacks.hasForeignBoundaryDescendants(input.view as EcoComponent)) {
-			return callbacks.createHtmlResponse(await input.renderInline(), input.ctx);
-		}
-
-		const rendererCache = new Map<string, unknown>() as ShellRendererCache;
-		const viewRender = await callbacks.renderComponentBoundary({
-			component: input.view as EcoComponent,
-			props: (input.props ?? {}) as Record<string, unknown>,
-			integrationContext: { rendererCache },
-		});
-		const html = input.transformHtml ? input.transformHtml(viewRender.html) : viewRender.html;
-
-		return callbacks.createHtmlResponse(html, input.ctx);
-	}
-
-	async renderViewWithDocumentShell<P>(
-		input: {
-			view: EcoComponent<P>;
-			props: P;
-			ctx: RenderToResponseContext;
-			layout?: EcoComponent;
-		},
-		callbacks: RouteShellComposerCallbacks,
-	): Promise<Response> {
-		const normalizedProps = (input.props ?? {}) as Record<string, unknown>;
-
-		if (input.ctx.partial) {
-			return this.renderPartialViewResponse(input, callbacks);
-		}
-
-		await callbacks.prepareViewDependencies(input.view, input.layout);
-
-		const HtmlTemplate = await callbacks.getHtmlTemplate();
-		const metadata = await callbacks.resolveViewMetadata(input.view, input.props);
-		const rendererCache = new Map<string, unknown>() as ShellRendererCache;
-		const viewRender = await callbacks.renderComponentBoundary({
-			component: input.view as EcoComponent,
-			props: normalizedProps,
-			integrationContext: { rendererCache },
-		});
-		const layoutRender = input.layout
-			? await callbacks.renderComponentBoundary({
-					component: input.layout,
-					props: {},
-					children: viewRender.html,
-					integrationContext: { rendererCache },
-				})
-			: undefined;
-		const documentRender = await callbacks.renderComponentBoundary({
-			component: HtmlTemplate as EcoComponent,
-			props: {
-				metadata,
-				pageProps: normalizedProps,
-			},
-			children: layoutRender?.html ?? viewRender.html,
-			integrationContext: { rendererCache },
-		});
-
-		callbacks.appendProcessedDependencies(viewRender.assets, layoutRender?.assets, documentRender.assets);
-
-		const html = await callbacks.finalizeResolvedHtml({
-			html: `${callbacks.docType}${documentRender.html}`,
-			partial: false,
-		});
-
-		return callbacks.createHtmlResponse(html, input.ctx);
-	}
-
-	async renderPageWithDocumentShell(
-		input: {
-			page: {
-				component: EcoComponent;
-				props: Record<string, unknown>;
-			};
-			layout?: {
-				component: EcoComponent;
-				props?: Record<string, unknown>;
-			};
-			htmlTemplate: EcoComponent;
-			metadata: PageMetadataProps;
-			pageProps: Record<string, unknown>;
-			documentProps?: Record<string, unknown>;
-			transformDocumentHtml?: (html: string) => string;
-		},
-		callbacks: RouteShellComposerCallbacks,
-	): Promise<string> {
-		const rendererCache = new Map<string, unknown>() as ShellRendererCache;
-		const pageRender = await callbacks.renderComponentBoundary({
-			component: input.page.component,
-			props: input.page.props,
-			integrationContext: { rendererCache },
-		});
-		const layoutRender = input.layout
-			? await callbacks.renderComponentBoundary({
-					component: input.layout.component,
-					props: input.layout.props ?? {},
-					children: pageRender.html,
-					integrationContext: { rendererCache },
-				})
-			: undefined;
-		const documentRender = await callbacks.renderComponentBoundary({
-			component: input.htmlTemplate,
-			props: {
-				metadata: input.metadata,
-				pageProps: input.pageProps,
-				...(input.documentProps ?? {}),
-			},
-			children: layoutRender?.html ?? pageRender.html,
-			integrationContext: { rendererCache },
-		});
-
-		callbacks.appendProcessedDependencies(pageRender.assets, layoutRender?.assets, documentRender.assets);
-
-		const documentHtml = input.transformDocumentHtml
-			? input.transformDocumentHtml(documentRender.html)
-			: documentRender.html;
-
-		return `${callbacks.docType}${documentHtml}`;
-	}
-}

package/src/router/server/fs-router-scanner.test.ts

@@ -1,83 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { test } from 'vitest';
-import type { EcoPagesAppConfig } from '../../types/internal-types.ts';
-import { FSRouterScanner } from './fs-router-scanner.ts';
-
-test('FSRouterScanner scans dynamic routes in Node when module graph needs transpilation', async () => {
-	if (typeof Bun !== 'undefined') {
-		// This test expects Node's missing Bun global to trigger Esbuild transpilation. Skip in Bun runner.
-		return;
-	}
-
-	const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ecopages-fs-router-scanner-node-'));
-	const pagesDir = path.join(rootDir, 'src', 'pages');
-	const dynamicDir = path.join(pagesDir, 'dynamic');
-	const distDir = path.join(rootDir, 'dist');
-	const workDir = path.join(rootDir, '.eco');
-
-	try {
-		fs.mkdirSync(dynamicDir, { recursive: true });
-		fs.mkdirSync(path.join(rootDir, 'src'), { recursive: true });
-
-		fs.writeFileSync(
-			path.join(rootDir, 'src', 'decorated.ts'),
-			[
-				'function sealed<T extends new (...args: never[]) => object>(target: T) {',
-				'\treturn target;',
-				'}',
-				'@sealed',
-				'export class DecoratedModule {}',
-			].join('\n'),
-		);
-
-		fs.writeFileSync(
-			path.join(dynamicDir, '[slug].kita.tsx'),
-			[
-				"import '../../decorated.ts';",
-				'',
-				'export const getStaticPaths = async () => ({',
-				"\tpaths: [{ params: { slug: 'hello-world' } }],",
-				'});',
-				'',
-				'export const getStaticProps = async () => ({ props: {} });',
-				'',
-				'export default async function Page() {',
-				"\treturn '<div>Hello</div>';",
-				'}',
-			].join('\n'),
-		);
-
-		const scanner = new FSRouterScanner({
-			dir: pagesDir,
-			origin: 'http://localhost:3000',
-			templatesExt: ['.kita.tsx'],
-			options: {
-				buildMode: false,
-			},
-			appConfig: {
-				rootDir,
-				workDir: '.eco',
-				absolutePaths: {
-					distDir,
-					workDir,
-				},
-			} as unknown as EcoPagesAppConfig,
-		});
-
-		const routes = await scanner.scan();
-
-		assert.equal(routes['http://localhost:3000/dynamic/hello-world']?.kind, 'dynamic');
-		assert.equal(routes['http://localhost:3000/dynamic/hello-world']?.pathname, '/dynamic/[slug]');
-
-		const transpiledModulesDir = path.join(workDir, '.server-route-modules');
-		assert.equal(fs.existsSync(transpiledModulesDir), true);
-
-		const transpiledFiles = fs.readdirSync(transpiledModulesDir).filter((file) => file.endsWith('.js'));
-		assert.ok(transpiledFiles.length > 0);
-	} finally {
-		fs.rmSync(rootDir, { recursive: true, force: true });
-	}
-});

package/src/router/server/fs-router-scanner.ts

@@ -1,224 +0,0 @@
-import path from 'node:path';
-import { appLogger } from '../../global/app-logger.ts';
-import type { EcoPagesAppConfig, RouteKind, Routes } from '../../types/internal-types.ts';
-import type { EcoPageFile, GetStaticPaths } from '../../types/public-types.ts';
-import { fileSystem } from '@ecopages/file-system';
-import { invariant } from '../../utils/invariant.ts';
-import { existsSync } from 'node:fs';
-import { getAppServerModuleTranspiler } from '../../services/module-loading/app-server-module-transpiler.service.ts';
-import type { ServerModuleTranspiler } from '../../services/module-loading/server-module-transpiler.service.ts';
-import { resolveInternalExecutionDir } from '../../utils/resolve-work-dir.ts';
-
-type CreateRouteArgs = {
-	routePath: string;
-	filePath: string;
-	route: string;
-};
-
-type FSRouterScannerOptions = {
-	buildMode: boolean;
-};
-
-/**
- * @class FSRouterScanner
- * @description
- * This class is responsible for scanning the file system for routes.
- * It uses the glob package to scan the file system for files with the specified file extensions.
- * It then creates a map of the routes with the pathname as the key.
- * The pathname is the route without the file extension.
- * For example, if the file is "index.tsx", the pathname will be "/index".
- * If the file is "blog/[slug].tsx", the pathname will be "/blog/[slug]".
- * If the file is "blog/[...slug].tsx", the pathname will be "/blog/[...slug]".
- */
-export class FSRouterScanner {
-	private dir: string;
-	private origin = '';
-	private templatesExt: string[];
-	private options: FSRouterScannerOptions;
-	readonly appConfig: EcoPagesAppConfig;
-	routes: Routes = {};
-	private serverModuleTranspiler: ServerModuleTranspiler;
-
-	constructor({
-		dir,
-		origin,
-		templatesExt,
-		options,
-		appConfig,
-	}: {
-		dir: string;
-		origin: string;
-		templatesExt: string[];
-		options: FSRouterScannerOptions;
-		appConfig: EcoPagesAppConfig;
-	}) {
-		this.dir = dir;
-		this.origin = origin;
-		this.templatesExt = templatesExt;
-		this.options = options;
-		this.appConfig = appConfig;
-		this.serverModuleTranspiler = getAppServerModuleTranspiler(appConfig);
-	}
-
-	private getRoutePath(path: string): string {
-		const cleanedRoute = this.templatesExt
-			.reduce((route, ext) => route.replace(ext, ''), path)
-			.replace(/\/?index$/, '');
-		return `/${cleanedRoute}`;
-	}
-
-	private getDynamicParamsNames(route: string): string[] {
-		const matches = route.match(/\[.*?\]/g);
-		return matches ? matches.map((match) => match.slice(1, -1)) : [];
-	}
-
-	private async getStaticPathsFromDynamicRoute({
-		route,
-		filePath,
-		getStaticPaths,
-	}: {
-		route: string;
-		filePath: string;
-		getStaticPaths: GetStaticPaths;
-	}): Promise<string[]> {
-		const staticPaths = await getStaticPaths({
-			appConfig: this.appConfig,
-			runtimeOrigin: this.origin,
-		});
-		return staticPaths.paths.map((path) => {
-			const dynamicParamsNames = this.getDynamicParamsNames(filePath);
-			let routeWithParams = route;
-
-			for (const param of dynamicParamsNames) {
-				routeWithParams = routeWithParams.replace(`[${param}]`, (path.params as Record<string, string>)[param]);
-			}
-
-			return routeWithParams;
-		});
-	}
-
-	private async createStaticRoutes({
-		filePath,
-		route,
-		routePath,
-		getStaticPaths,
-	}: CreateRouteArgs & { getStaticPaths: GetStaticPaths }): Promise<void> {
-		try {
-			const routesWithParams = await this.getStaticPathsFromDynamicRoute({
-				route,
-				filePath,
-				getStaticPaths,
-			});
-
-			for (const routeWithParams of routesWithParams) {
-				this.createRoute('dynamic', { filePath, route: routeWithParams, routePath });
-			}
-		} catch (error) {
-			appLogger.error(`[ecopages] Error creating static routes for ${filePath}: ${error}`);
-		}
-	}
-
-	private async handleDynamicRouteCreation({ filePath, route, routePath }: CreateRouteArgs): Promise<void> {
-		const module = (await this.importPageModule(filePath)) as EcoPageFile;
-		const Page = module.default;
-
-		/**
-		 * Check for attached static functions (consolidated API) or named exports (legacy)
-		 */
-		const getStaticPaths = Page?.staticPaths ?? module.getStaticPaths;
-		const getStaticProps = Page?.staticProps ?? module.getStaticProps;
-
-		if (this.options.buildMode) {
-			invariant(getStaticProps !== undefined, `[ecopages] Missing getStaticProps in ${filePath}`);
-			invariant(getStaticPaths !== undefined, `[ecopages] Missing getStaticPaths in ${filePath}`);
-		}
-
-		if (getStaticPaths) {
-			return this.createStaticRoutes({
-				filePath,
-				route,
-				routePath,
-				getStaticPaths,
-			});
-		}
-
-		return this.createRoute('dynamic', { filePath, route, routePath });
-	}
-
-	private async importPageModule(filePath: string): Promise<unknown> {
-		return this.serverModuleTranspiler.importModule({
-			filePath,
-			outdir: path.join(resolveInternalExecutionDir(this.appConfig), '.server-route-modules'),
-			externalPackages: false,
-			transpileErrorMessage: (details) => `Error transpiling route module: ${details}`,
-			noOutputMessage: (targetFilePath) => `No transpiled output generated for route module: ${targetFilePath}`,
-		});
-	}
-
-	private createRoute(kind: RouteKind, { filePath, route, routePath }: CreateRouteArgs): void {
-		this.routes[route] = {
-			kind,
-			pathname: routePath,
-			filePath,
-		};
-	}
-
-	private getRouteData(file: string): CreateRouteArgs & {
-		kind: RouteKind;
-	} {
-		const routePath = this.getRoutePath(file);
-		const route = `${this.origin}${routePath}`;
-		const filePath = path.join(this.dir, file);
-		const isCatchAll = filePath.includes('[...');
-		const isDynamic = !isCatchAll && filePath.includes('[') && filePath.includes(']');
-		let kind: RouteKind = 'exact';
-		if (isCatchAll) {
-			kind = 'catch-all';
-		} else if (isDynamic) {
-			kind = 'dynamic';
-		}
-
-		return { route, routePath, filePath, kind };
-	}
-
-	async scan(): Promise<Routes> {
-		this.routes = {};
-
-		if (!existsSync(this.dir)) {
-			return this.routes;
-		}
-
-		const scannedFiles = await fileSystem.glob(
-			this.templatesExt.map((ext) => `**/*${ext}`),
-			{ cwd: this.dir },
-		);
-
-		for await (const file of scannedFiles) {
-			if (file.includes('.ecopages-node.')) {
-				continue;
-			}
-
-			const { kind, ...routeData } = this.getRouteData(file);
-
-			switch (kind) {
-				case 'dynamic':
-					await this.handleDynamicRouteCreation(routeData);
-					break;
-				case 'catch-all':
-					if (this.options.buildMode) {
-						appLogger.warn(
-							'Catch-all routes are not supported in static generation, they will not be included in the bundle\n',
-							`➤ ${routeData.filePath}`,
-						);
-					}
-					this.createRoute(kind, routeData);
-					break;
-				default:
-					this.createRoute(kind, routeData);
-					break;
-			}
-		}
-
-		return this.routes;
-	}
-}