@ecopages/core 0.2.0-alpha.54 → 0.2.0-alpha.55

package/src/adapters/create-app.ts

@@ -1,91 +0,0 @@
-import type { EcoPagesAppConfig } from '../types/internal-types.ts';
-import { AbstractApplicationAdapter } from './abstract/application-adapter.ts';
-import type { ApiHandler } from '../types/public-types.ts';
-import type { ApplicationAdapterOptions } from './abstract/application-adapter.ts';
-import { SharedApplicationAdapter } from './shared/application-adapter.ts';
-import { createApp as createBunApp } from './bun/create-app.ts';
-import { createNodeApp } from './node/create-app.ts';
-
-export interface EcopagesAppOptions extends ApplicationAdapterOptions {
-	appConfig: EcoPagesAppConfig;
-	serverOptions?: Record<string, any>;
-}
-
-export type UniversalEcopagesApp = AbstractApplicationAdapter<EcopagesAppOptions, unknown, Request>;
-
-async function createRuntimeApp<WebSocketData = undefined>(options: EcopagesAppOptions): Promise<UniversalEcopagesApp> {
-	const bun = (globalThis as { Bun?: unknown }).Bun;
-
-	if (bun) {
-		return (await createBunApp<WebSocketData>(options)) as unknown as UniversalEcopagesApp;
-	}
-
-	return (await createNodeApp(options)) as unknown as UniversalEcopagesApp;
-}
-
-export async function createApp<WebSocketData = undefined>(options: EcopagesAppOptions): Promise<UniversalEcopagesApp> {
-	return createRuntimeApp<WebSocketData>(options);
-}
-
-export class EcopagesApp extends SharedApplicationAdapter<EcopagesAppOptions, unknown, Request> {
-	private readonly appOptions: EcopagesAppOptions;
-	private runtimeApp: UniversalEcopagesApp | null = null;
-	private runtimeAppPromise: Promise<UniversalEcopagesApp> | null = null;
-
-	constructor(options: EcopagesAppOptions) {
-		super(options);
-		this.appOptions = options;
-	}
-
-	private async getRuntimeApp(): Promise<UniversalEcopagesApp> {
-		if (this.runtimeApp) {
-			return this.runtimeApp;
-		}
-
-		if (!this.runtimeAppPromise) {
-			this.runtimeAppPromise = createRuntimeApp({
-				...this.appOptions,
-				clearOutput: false,
-			}).then((app) => {
-				for (const handler of this.apiHandlers) {
-					app.add(handler as ApiHandler<string, Request, any>);
-				}
-
-				for (const route of this.staticRoutes) {
-					app.static(route.path, route.loader);
-				}
-
-				if (this.errorHandler) {
-					app.onError(this.errorHandler);
-				}
-
-				this.runtimeApp = app;
-				return app;
-			});
-		}
-
-		return this.runtimeAppPromise;
-	}
-
-	protected async initializeServerAdapter(): Promise<UniversalEcopagesApp> {
-		return this.getRuntimeApp();
-	}
-
-	async start(): Promise<unknown> {
-		const runtimeApp = await this.getRuntimeApp();
-		return runtimeApp.start();
-	}
-
-	async fetch(request: Request): Promise<Response> {
-		const runtimeApp = await this.getRuntimeApp();
-		const candidate = runtimeApp as UniversalEcopagesApp & {
-			fetch?: (request: Request) => Promise<Response>;
-		};
-
-		if (!candidate.fetch) {
-			throw new Error('The selected runtime adapter does not expose fetch()');
-		}
-
-		return candidate.fetch(request);
-	}
-}

package/src/adapters/index.ts

@@ -1,2 +0,0 @@
-export { EcopagesApp, createApp } from './create-app.ts';
-export { defineApiHandler, defineGroupHandler, type GroupHandler } from './shared/define-api-handler.ts';

package/src/adapters/node/create-app.test.ts

@@ -1,76 +0,0 @@
-import assert from 'node:assert/strict';
-import { afterEach, describe, it, vi } from 'vitest';
-import type { NodeServerAdapterParams, NodeServerAdapterResult } from './server-adapter.ts';
-import { NodeEcopagesApp } from './create-app.ts';
-import { NodeHttpRequestBridge } from './http-request-bridge.ts';
-import { NodeRuntimeHost } from './runtime-host.ts';
-
-class TestNodeEcopagesApp extends NodeEcopagesApp {
-	public capturedParams: NodeServerAdapterParams | undefined;
-
-	constructor(options: ConstructorParameters<typeof NodeEcopagesApp>[0]) {
-		super(options, {
-			runtimeHost: new NodeRuntimeHost(new NodeHttpRequestBridge()),
-		});
-	}
-
-	protected override async createServerAdapter(params: NodeServerAdapterParams): Promise<NodeServerAdapterResult> {
-		this.capturedParams = params;
-		return {
-			getServerOptions: () => params.serveOptions,
-			completeInitialization: async () => {},
-			handleRequest: async () => new Response(null, { status: 204 }),
-			buildStatic: async () => {},
-		};
-	}
-
-	public async initializeForTest(): Promise<void> {
-		await this.initializeServerAdapter();
-	}
-}
-
-afterEach(() => {
-	process.env.NODE_ENV = undefined;
-	process.env.ECOPAGES_INTERNAL_EMBEDDED_RUNTIME = undefined;
-	process.env.ECOPAGES_PORT = '';
-	process.env.ECOPAGES_HOSTNAME = '';
-	vi.restoreAllMocks();
-});
-
-describe('node embedded app bootstrap', () => {
-	it('keeps watch mode enabled for embedded development runtimes', async () => {
-		process.env.NODE_ENV = 'development';
-
-		const app = new TestNodeEcopagesApp({
-			appConfig: {
-				runtime: {},
-			} as any,
-			runtime: {
-				embedded: true,
-			},
-		});
-
-		await app.initializeForTest();
-
-		assert.equal(app.capturedParams?.options?.watch, true);
-		assert.deepEqual(app.capturedParams?.serveOptions, {
-			port: 3000,
-			hostname: 'localhost',
-		});
-	});
-
-	it('preserves the configured hostname in the reported runtime origin', () => {
-		const runtimeHost = new NodeRuntimeHost(new NodeHttpRequestBridge());
-		const server = {
-			address: () => ({ address: '::1', port: 3000, family: 'IPv6' }),
-		} as any;
-
-		assert.equal(
-			runtimeHost.getOrigin(server, {
-				hostname: 'localhost',
-				port: 3000,
-			}),
-			'http://localhost:3000',
-		);
-	});
-});

package/src/adapters/node/create-app.ts

@@ -1,116 +0,0 @@
-import { appLogger } from '../../global/app-logger.ts';
-import type { StaticRoute } from '../../types/public-types.ts';
-import { SharedApplicationAdapter } from '../shared/application-adapter.ts';
-import { resolveRuntimeBinding } from '../shared/runtime-app-bootstrap.ts';
-import type { RuntimeHost } from '../shared/runtime-host.ts';
-import type { EcopagesAppOptions } from '../create-app.ts';
-import { type NodeServerAdapterResult, createNodeServerAdapter } from './server-adapter.ts';
-import { NodeHttpRequestBridge } from './http-request-bridge.ts';
-import type { NodeServerInstance } from './server-adapter.ts';
-import { NodeRuntimeHost } from './runtime-host.ts';
-
-export class NodeEcopagesApp extends SharedApplicationAdapter<EcopagesAppOptions, NodeServerInstance, Request> {
-	serverAdapter: NodeServerAdapterResult | undefined;
-	private server: NodeServerInstance | null = null;
-	private runtimeOrigin = '';
-	private readonly runtimeHost: RuntimeHost<NodeServerInstance, { port?: number; hostname?: string }>;
-
-	constructor(
-		options: EcopagesAppOptions,
-		dependencies: {
-			runtimeHost: RuntimeHost<NodeServerInstance, { port?: number; hostname?: string }>;
-		},
-	) {
-		super(options);
-		this.runtimeHost = dependencies.runtimeHost;
-	}
-
-	protected createServerAdapter(
-		params: Parameters<typeof createNodeServerAdapter>[0],
-	): Promise<NodeServerAdapterResult> {
-		return createNodeServerAdapter(params);
-	}
-
-	public async stop(force = true): Promise<void> {
-		if (!this.server) {
-			return;
-		}
-
-		const activeServer = this.server;
-		this.server = null;
-		await this.runtimeHost.stop(activeServer, { force });
-	}
-
-	protected async initializeServerAdapter(): Promise<NodeServerAdapterResult> {
-		const binding = resolveRuntimeBinding({
-			cliArgs: this.cliArgs,
-			serverOptions: this.serverOptions,
-		});
-		this.runtimeOrigin = binding.runtimeOrigin;
-
-		return this.createServerAdapter({
-			runtimeOrigin: this.runtimeOrigin,
-			appConfig: this.appConfig,
-			apiHandlers: this.apiHandlers,
-			staticRoutes: this.staticRoutes as StaticRoute[],
-			errorHandler: this.errorHandler,
-			options: { watch: binding.watch },
-			serveOptions: binding.serveOptions,
-		});
-	}
-
-	public async start(): Promise<NodeServerInstance | void> {
-		if (!this.serverAdapter) {
-			this.serverAdapter = await this.initializeServerAdapter();
-		}
-
-		if (this.server) {
-			return this.server;
-		}
-
-		const { build, preview } = this.cliArgs;
-
-		if (build || preview) {
-			appLogger.debugTime('Building static pages');
-			await this.serverAdapter.buildStatic({ preview });
-			await this.stop(true);
-			appLogger.debugTimeEnd('Building static pages');
-
-			if (build) {
-				process.exit(0);
-			}
-			return;
-		}
-
-		const serveOptions = this.serverAdapter.getServerOptions();
-		this.server = await this.runtimeHost.start({
-			serveOptions,
-			handleRequest: async (request) => await this.serverAdapter!.handleRequest(request),
-			onError: async () => {},
-		});
-		this.runtimeOrigin = this.runtimeHost.getOrigin(this.server, serveOptions);
-
-		await this.serverAdapter.completeInitialization(this.server);
-		appLogger.info(`Node server running at ${this.runtimeOrigin}`);
-
-		return this.server;
-	}
-
-	public async fetch(request: Request): Promise<Response> {
-		if (!this.serverAdapter) {
-			this.serverAdapter = await this.initializeServerAdapter();
-		}
-
-		return this.serverAdapter.handleRequest(request);
-	}
-}
-
-export async function createNodeApp(options: EcopagesAppOptions): Promise<NodeEcopagesApp> {
-	return new NodeEcopagesApp(options, {
-		runtimeHost: new NodeRuntimeHost(new NodeHttpRequestBridge()),
-	});
-}
-
-export async function createApp(options: EcopagesAppOptions): Promise<NodeEcopagesApp> {
-	return createNodeApp(options);
-}

package/src/adapters/node/http-request-bridge.test.ts

@@ -1,146 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import { PassThrough, Writable } from 'node:stream';
-import { describe, expect, it, vi } from 'vitest';
-import { NodeClientAbortError, NodeHttpRequestBridge } from './http-request-bridge.ts';
-
-class MockIncomingMessage extends PassThrough {
-	public url = '/submit?ok=1';
-	public method = 'POST';
-	public headers: Record<string, string | string[] | undefined> = {
-		'content-type': 'application/json',
-		'x-test': 'one',
-	};
-
-	public emitAbort(): void {
-		this.emit('aborted');
-	}
-
-	public emitNodeError(code: string): void {
-		const error = new Error(code) as NodeJS.ErrnoException;
-		error.code = code;
-		this.emit('error', error);
-	}
-}
-
-/**
- * Writable test double that captures streamed response output and headers for
- * bridge assertions.
- */
-class MockServerResponse extends Writable {
-	public statusCode = 200;
-	public headers = new Map<string, string>();
-	public chunks: Buffer[] = [];
-
-	public setHeader(name: string, value: string): void {
-		this.headers.set(name, value);
-	}
-
-	public override _write(
-		chunk: string | Buffer,
-		_encoding: BufferEncoding,
-		callback: (error?: Error | null) => void,
-	): void {
-		this.chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-		callback();
-	}
-}
-
-describe('NodeHttpRequestBridge', () => {
-	it('creates a streaming Web Request for non-GET request bodies', async () => {
-		const bridge = new NodeHttpRequestBridge();
-		const req = new MockIncomingMessage();
-
-		const request = bridge.createWebRequest(req as unknown as IncomingMessage, 'http://localhost:3000');
-		const bodyRead = request.text();
-
-		req.end('{"hello":"world"}');
-
-		expect(request.method).toBe('POST');
-		expect(request.url).toBe('http://localhost:3000/submit?ok=1');
-		expect(request.headers.get('content-type')).toBe('application/json');
-		expect(request.headers.get('x-test')).toBe('one');
-		await expect(bodyRead).resolves.toBe('{"hello":"world"}');
-	});
-
-	it('does not attach a body for GET requests', () => {
-		const bridge = new NodeHttpRequestBridge();
-		const req = new MockIncomingMessage();
-		req.method = 'GET';
-
-		const request = bridge.createWebRequest(req as unknown as IncomingMessage, 'http://localhost:3000');
-
-		expect(request.method).toBe('GET');
-		expect(request.body).toBeNull();
-	});
-
-	it('normalizes aborted request bodies into NodeClientAbortError', async () => {
-		const bridge = new NodeHttpRequestBridge();
-		const req = new MockIncomingMessage();
-
-		const request = bridge.createWebRequest(req as unknown as IncomingMessage, 'http://localhost:3000');
-		const bodyRead = request.text();
-
-		req.emitAbort();
-
-		await expect(bodyRead).rejects.toBeInstanceOf(NodeClientAbortError);
-	});
-
-	it('normalizes ECONNRESET request stream errors into NodeClientAbortError', async () => {
-		const bridge = new NodeHttpRequestBridge();
-		const req = new MockIncomingMessage();
-
-		const request = bridge.createWebRequest(req as unknown as IncomingMessage, 'http://localhost:3000');
-		const bodyRead = request.text();
-
-		req.emitNodeError('ECONNRESET');
-
-		await expect(bodyRead).rejects.toBeInstanceOf(NodeClientAbortError);
-	});
-
-	it('streams response bodies to the Node response without buffering through arrayBuffer', async () => {
-		const bridge = new NodeHttpRequestBridge();
-		const response = new Response(
-			new ReadableStream({
-				start(controller) {
-					controller.enqueue(new TextEncoder().encode('hello '));
-					controller.enqueue(new TextEncoder().encode('world'));
-					controller.close();
-				},
-			}),
-			{
-				status: 206,
-				headers: {
-					'content-type': 'text/plain; charset=utf-8',
-				},
-			},
-		);
-
-		const arrayBufferSpy = vi.spyOn(response, 'arrayBuffer');
-		const res = new MockServerResponse();
-
-		await bridge.sendNodeResponse(res as unknown as ServerResponse, response);
-
-		expect(res.statusCode).toBe(206);
-		expect(res.headers.get('content-type')).toBe('text/plain; charset=utf-8');
-		expect(Buffer.concat(res.chunks).toString('utf8')).toBe('hello world');
-		expect(arrayBufferSpy).not.toHaveBeenCalled();
-	});
-
-	it('normalizes closed response streams into NodeClientAbortError', async () => {
-		const bridge = new NodeHttpRequestBridge();
-		const response = new Response(
-			new ReadableStream({
-				start(controller) {
-					controller.enqueue(new TextEncoder().encode('hello world'));
-					controller.close();
-				},
-			}),
-		);
-		const res = new MockServerResponse();
-		res.destroy();
-
-		await expect(bridge.sendNodeResponse(res as unknown as ServerResponse, response)).rejects.toBeInstanceOf(
-			NodeClientAbortError,
-		);
-	});
-});

package/src/adapters/node/http-request-bridge.ts

@@ -1,176 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import { Readable } from 'node:stream';
-import { pipeline } from 'node:stream/promises';
-
-/**
- * Signals that the remote client closed the HTTP exchange before the Node
- * adapter finished reading or writing the body.
- *
- * @remarks
- * This error represents a transport-level disconnect, not an application
- * failure. Higher layers may safely suppress logging for this error when the
- * client socket is already gone and no meaningful response can still be sent.
- */
-export class NodeClientAbortError extends Error {
-	/**
-	 * Creates the canonical Node transport abort error used across request-body
-	 * reads and response-body writes.
-	 */
-	constructor() {
-		super('Client closed the request');
-		this.name = 'ClientAbortError';
-	}
-}
-
-/**
- * Returns whether a Node stream error code corresponds to a normal client-side
- * disconnect rather than a server fault.
- *
- * @remarks
- * The allowlist is intentionally narrow. Only socket and stream shutdown codes
- * that are expected after browser aborts or navigation churn are treated as
- * suppressible client disconnects.
- */
-function isNodeClientDisconnectCode(code: string | undefined): boolean {
-	return [
-		'ECONNRESET',
-		'EPIPE',
-		'ERR_STREAM_DESTROYED',
-		'ERR_STREAM_PREMATURE_CLOSE',
-		'ERR_STREAM_UNABLE_TO_PIPE',
-	].includes(code ?? '');
-}
-
-/**
- * Type guard for the canonical client-abort error used by the Node adapter.
- *
- * @remarks
- * Runtime hosts use this guard before logging so only explicitly classified
- * client disconnects are muted. All other failures continue through the normal
- * error-reporting path.
- */
-export function isNodeClientAbortError(error: unknown): error is NodeClientAbortError {
-	return error instanceof NodeClientAbortError;
-}
-
-/**
- * Normalizes low-level Node socket and stream shutdown errors into the shared
- * `NodeClientAbortError` abstraction used by the adapter stack.
- *
- * @remarks
- * This normalization exists at the transport boundary because Node exposes
- * several host-specific error codes for the same underlying event: the client
- * disappeared before the response stream finished. Converting them here keeps
- * the rest of the adapter stack independent from those Node-specific details.
- */
-function toNodeClientAbortError(error: unknown): NodeClientAbortError | null {
-	if (error instanceof NodeClientAbortError) {
-		return error;
-	}
-
-	if (typeof error === 'object' && error !== null && 'code' in error) {
-		const code = typeof error.code === 'string' ? error.code : undefined;
-		if (isNodeClientDisconnectCode(code)) {
-			return new NodeClientAbortError();
-		}
-	}
-
-	return null;
-}
-
-/**
- * Bridges Node's `IncomingMessage` / `ServerResponse` pair to the Web
- * `Request` / `Response` contract used by the shared routing pipeline.
- *
- * @remarks
- * This class is the Node transport boundary. It owns the translation of request
- * headers and bodies into Web primitives and the reverse translation of Web
- * responses back onto Node streams, including client-abort normalization.
- */
-export class NodeHttpRequestBridge {
-	/**
-	 * Converts one incoming Node request into the Web `Request` shape consumed by
-	 * the shared server adapter.
-	 *
-	 * @remarks
-	 * Non-GET/HEAD requests retain streaming semantics via a `ReadableStream` so
-	 * large request bodies do not need to be buffered before route handling begins.
-	 */
-	public createWebRequest(req: IncomingMessage, runtimeOrigin: string): Request {
-		const url = new URL(req.url ?? '/', runtimeOrigin);
-		const headers = new Headers();
-
-		for (const [key, value] of Object.entries(req.headers)) {
-			if (Array.isArray(value)) {
-				for (const item of value) {
-					headers.append(key, item);
-				}
-				continue;
-			}
-
-			if (value !== undefined) {
-				headers.set(key, value);
-			}
-		}
-
-		const method = (req.method ?? 'GET').toUpperCase();
-		const requestInit: RequestInit & { duplex?: 'half' } = {
-			method,
-			headers,
-		};
-
-		if (method !== 'GET' && method !== 'HEAD') {
-			const body = new ReadableStream({
-				start(controller) {
-					req.on('data', (chunk: Buffer) => controller.enqueue(chunk));
-					req.once('end', () => controller.close());
-					req.once('aborted', () => {
-						controller.error(new NodeClientAbortError());
-					});
-					req.once('error', (err) => {
-						const isClientAbort = (err as NodeJS.ErrnoException).code === 'ECONNRESET';
-						controller.error(isClientAbort ? new NodeClientAbortError() : err);
-					});
-				},
-				cancel() {
-					req.destroy();
-				},
-			});
-
-			requestInit.body = body;
-			requestInit.duplex = 'half';
-		}
-
-		return new Request(url, requestInit);
-	}
-
-	/**
-	 * Sends a Web `Response` through Node's `ServerResponse` without buffering the
-	 * full body in memory first.
-	 *
-	 * @remarks
-	 * Streaming responses matter for large payloads and long-lived transports such
-	 * as server-sent events. The bridge therefore forwards the `ReadableStream`
-	 * directly into the Node writable response instead of materializing an
-	 * intermediate `ArrayBuffer`.
-	 */
-	public async sendNodeResponse(res: ServerResponse, response: Response): Promise<void> {
-		res.statusCode = response.status;
-
-		response.headers.forEach((value, key) => {
-			res.setHeader(key, value);
-		});
-
-		if (!response.body) {
-			res.end();
-			return;
-		}
-
-		const responseBody = response.body as unknown as Parameters<typeof Readable.fromWeb>[0];
-		try {
-			await pipeline(Readable.fromWeb(responseBody), res);
-		} catch (error) {
-			throw toNodeClientAbortError(error) ?? error;
-		}
-	}
-}