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

package/src/adapters/shared/render-context.ts

@@ -0,0 +1,123 @@
+import type { EcoComponent, RenderContext, RenderOptions, ResponseOptions } from '../../types/public-types.ts';
+import type {
+	IntegrationRenderer,
+	RenderToResponseContext,
+} from '../../route-renderer/orchestration/integration-renderer.ts';
+import type { IntegrationPlugin } from '../../plugins/integration-plugin.ts';
+import { invariant } from '../../utils/invariant.ts';
+
+export interface CreateRenderContextOptions {
+	integrations: IntegrationPlugin[];
+	rendererModules?: unknown;
+}
+
+/**
+ * Merges request locals into component props as a dedicated 'locals' property.
+ * This prevents naming conflicts and maintains type safety by keeping locals
+ * separate from other props.
+ *
+ * @param props - The original component props
+ * @param locals - Optional request-scoped locals from middleware
+ * @returns Props with locals merged in, or original props if no locals provided
+ */
+function mergePropsWithLocals<P>(props: P, locals: Record<string, unknown> | undefined): P {
+	if (!locals || typeof props !== 'object' || props === null) {
+		return props;
+	}
+	return { ...(props as Record<string, unknown>), locals } as P;
+}
+
+/**
+ * Creates a render context for route handlers.
+ * Provides render(), renderPartial(), json(), and html() methods that can be used
+ * within route handlers to generate responses.
+ *
+ * @param options - Configuration options including available integrations
+ * @returns A RenderContext object with methods for rendering views and creating responses
+ */
+export function createRenderContext(options: CreateRenderContextOptions): RenderContext {
+	const { integrations } = options;
+
+	/**
+	 * Resolves the appropriate renderer for a given view component based on its integration.
+	 * Throws an error if the integration cannot be determined or is not found.
+	 */
+	const getRendererForView = <P>(view: EcoComponent<P>): IntegrationRenderer => {
+		const integrationName = view.config?.integration ?? view.config?.__eco?.integration;
+		invariant(
+			!!integrationName,
+			'Cannot determine integration for view. Set view.config.integration explicitly or ensure the view is defined with eco.page() in a file with a recognized extension.',
+		);
+
+		const integration = integrations.find((i) => i.name === integrationName);
+		invariant(!!integration, `No integration found for: ${integrationName}`);
+
+		return integration.initializeRenderer({
+			rendererModules: options.rendererModules,
+		});
+	};
+
+	const renderContext: RenderContext = {
+		async render<P>(
+			this: { locals?: Record<string, unknown> } | undefined,
+			view: EcoComponent<P>,
+			props?: P,
+			renderOptions?: RenderOptions,
+		): Promise<Response> {
+			const locals = (this as { locals?: Record<string, unknown> } | undefined)?.locals;
+			const mergedProps = mergePropsWithLocals<P>(props ?? ({} as P), locals);
+
+			const renderer = getRendererForView(view);
+			const ctx: RenderToResponseContext = {
+				partial: false,
+				status: renderOptions?.status,
+				headers: renderOptions?.headers,
+			};
+			return renderer.renderToResponse(view, mergedProps, ctx);
+		},
+
+		async renderPartial<P>(
+			this: { locals?: Record<string, unknown> } | undefined,
+			view: EcoComponent<P>,
+			props: P,
+			renderOptions?: RenderOptions,
+		): Promise<Response> {
+			const locals = (this as { locals?: Record<string, unknown> } | undefined)?.locals;
+			const mergedProps = mergePropsWithLocals<P>(props, locals);
+
+			const renderer = getRendererForView(view);
+			const ctx: RenderToResponseContext = {
+				partial: true,
+				status: renderOptions?.status,
+				headers: renderOptions?.headers,
+			};
+			return renderer.renderToResponse(view, mergedProps, ctx);
+		},
+
+		json(data: unknown, responseOptions?: ResponseOptions): Response {
+			const headers = new Headers({ 'Content-Type': 'application/json; charset=utf-8' });
+			if (responseOptions?.headers) {
+				const incomingHeaders = new Headers(responseOptions.headers);
+				incomingHeaders.forEach((value, key) => headers.set(key, value));
+			}
+			return new Response(JSON.stringify(data), {
+				status: responseOptions?.status ?? 200,
+				headers,
+			});
+		},
+
+		html(content: string, responseOptions?: ResponseOptions): Response {
+			const headers = new Headers({ 'Content-Type': 'text/html; charset=utf-8' });
+			if (responseOptions?.headers) {
+				const incomingHeaders = new Headers(responseOptions.headers);
+				incomingHeaders.forEach((value, key) => headers.set(key, value));
+			}
+			return new Response(content, {
+				status: responseOptions?.status ?? 200,
+				headers,
+			});
+		},
+	};
+
+	return renderContext;
+}

package/src/adapters/shared/runtime-bootstrap.ts

@@ -0,0 +1,79 @@
+import path from 'node:path';
+import { fileSystem } from '@ecopages/file-system';
+import { getAppBrowserBuildPlugins, setupAppRuntimePlugins, type BuildExecutor } from '../../build/build-adapter.ts';
+import type { EcoBuildPlugin } from '../../build/build-types.ts';
+import { installAppRuntimeBuildExecutor } from '../../build/runtime-build-executor.ts';
+import { RESOLVED_ASSETS_DIR } from '../../config/constants.ts';
+import type { EcoPagesAppConfig, IClientBridge, IHmrManager } from '../../types/internal-types.ts';
+import { ProjectWatcher } from '../../watchers/project-watcher.ts';
+
+/**
+ * Installs and returns the app-owned runtime build executor used by adapter
+ * startup and follow-up runtime work.
+ */
+export function installSharedRuntimeBuildExecutor(
+	appConfig: EcoPagesAppConfig,
+	options: { development: boolean },
+): BuildExecutor {
+	return installAppRuntimeBuildExecutor(appConfig, options);
+}
+
+/**
+ * Copies app public assets into dist and ensures the resolved assets directory
+ * exists before request handling begins.
+ */
+export function prepareSharedRuntimePublicDir(appConfig: EcoPagesAppConfig): void {
+	const srcPublicDir = path.join(appConfig.rootDir, appConfig.srcDir, appConfig.publicDir);
+
+	if (fileSystem.exists(srcPublicDir)) {
+		fileSystem.copyDir(srcPublicDir, path.join(appConfig.rootDir, appConfig.distDir));
+	}
+
+	fileSystem.ensureDir(path.join(appConfig.absolutePaths.distDir, RESOLVED_ASSETS_DIR));
+}
+
+/**
+ * Runs runtime plugin setup against app-owned config/runtime state and optional
+ * host plugin registration hooks.
+ */
+export async function initializeSharedRuntimePlugins(options: {
+	appConfig: EcoPagesAppConfig;
+	runtimeOrigin: string;
+	hmrManager?: IHmrManager;
+	onRuntimePlugin?: (plugin: unknown) => void;
+}): Promise<void> {
+	await setupAppRuntimePlugins(options);
+}
+
+/**
+ * Starts shared project watching for runtime adapters.
+ */
+export async function startSharedProjectWatching(options: {
+	appConfig: EcoPagesAppConfig;
+	refreshRouterRoutesCallback: () => Promise<void>;
+	hmrManager: IHmrManager;
+	bridge: IClientBridge;
+}): Promise<void> {
+	const watcher = new ProjectWatcher({
+		config: options.appConfig,
+		refreshRouterRoutesCallback: options.refreshRouterRoutesCallback,
+		hmrManager: options.hmrManager,
+		bridge: options.bridge,
+	});
+
+	await watcher.createWatcherSubscription();
+}
+
+/**
+ * Binds a runtime HMR manager to app-owned plugin and integration state.
+ */
+export function bindSharedRuntimeHmrManager(appConfig: EcoPagesAppConfig, hmrManager: IHmrManager): EcoBuildPlugin[] {
+	const browserBuildPlugins = getAppBrowserBuildPlugins(appConfig);
+	hmrManager.setPlugins(browserBuildPlugins);
+
+	for (const integration of appConfig.integrations) {
+		integration.setHmrManager(hmrManager);
+	}
+
+	return browserBuildPlugins;
+}

package/src/adapters/shared/server-adapter.test.ts

@@ -0,0 +1,77 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, test } from 'vitest';
+import { ConfigBuilder } from '../../config/config-builder.ts';
+import type { ServerAdapterResult } from '../abstract/server-adapter.ts';
+import { SharedServerAdapter } from './server-adapter.ts';
+
+const tempRoots: string[] = [];
+
+function createTempRoot(prefix: string): string {
+	const root = fs.mkdtempSync(path.join(os.tmpdir(), `${prefix}-`));
+	tempRoots.push(root);
+	return root;
+}
+
+afterEach(() => {
+	for (const root of tempRoots.splice(0)) {
+		fs.rmSync(root, { recursive: true, force: true });
+	}
+});
+
+class TestSharedServerAdapter extends SharedServerAdapter<any, ServerAdapterResult> {
+	public async initialize(): Promise<void> {}
+	public getServerOptions(): Record<string, never> {
+		return {};
+	}
+	public async buildStatic(): Promise<void> {}
+	public async createAdapter(): Promise<ServerAdapterResult> {
+		return {
+			getServerOptions: () => ({}),
+			buildStatic: async () => {},
+		};
+	}
+	public async handleRequest(request: Request): Promise<Response> {
+		return await this.handleSharedRequest(request, {
+			apiHandlers: [],
+			hmrManager: {
+				getRuntimePath: () => '',
+				getDistDir: () => this.hmrDir,
+			},
+		});
+	}
+
+	constructor(
+		private readonly hmrDir: string,
+		rootDir: string,
+	) {
+		super({
+			appConfig: { rootDir } as any,
+			runtimeOrigin: 'http://localhost:3000',
+			serveOptions: {},
+			options: {},
+		});
+	}
+}
+
+test('SharedServerAdapter serves /assets/_hmr files from the HMR manager directory', async () => {
+	const rootDir = createTempRoot('ecopages-shared-server-hmr-assets');
+	const config = await new ConfigBuilder().setRootDir(rootDir).build();
+	const hmrDir = path.join(config.absolutePaths.workDir, 'assets', '_hmr');
+	const assetPath = path.join(hmrDir, 'pages', 'react-content.js');
+	fs.mkdirSync(path.dirname(assetPath), { recursive: true });
+	fs.writeFileSync(assetPath, 'export default 1;', 'utf8');
+
+	const adapter = new TestSharedServerAdapter(hmrDir, rootDir);
+	const response = await adapter.handleRequest(new Request('http://localhost/assets/_hmr/pages/react-content.js'));
+
+	assert.equal(response.status, 200);
+	assert.equal(response.headers.get('Content-Type'), 'application/javascript');
+	assert.equal(await response.text(), 'export default 1;');
+	assert.equal(
+		fs.existsSync(path.join(config.absolutePaths.distDir, 'assets', '_hmr', 'pages', 'react-content.js')),
+		false,
+	);
+});