@ecopages/core 0.2.0-alpha.8 → 0.2.1

package/src/adapters/node/bootstrap-dependency-resolver.ts

@@ -1,301 +0,0 @@
-import path from 'node:path';
-import { existsSync, mkdirSync, readFileSync, symlinkSync } from 'node:fs';
-import { createRequire } from 'node:module';
-import type { EcoBuildOnResolveArgs, EcoBuildOnResolveResult, EcoBuildPlugin } from '../../build/build-types.ts';
-import type { EcoPagesAppConfig } from '../../internal-types.ts';
-import type { NodeRuntimeManifest } from '../../services/runtime-manifest/node-runtime-manifest.service.ts';
-import { resolveInternalExecutionDir } from '../../utils/resolve-work-dir.ts';
-
-/**
- * Returns the runtime-local node_modules directory used by the Node thin-host
- * bootstrap output.
- */
-export function getNodeRuntimeNodeModulesDir(manifest: NodeRuntimeManifest): string {
-	return path.join(
-		resolveInternalExecutionDir({
-			rootDir: manifest.appRootDir,
-			workDir: manifest.workDir,
-			absolutePaths: {
-				workDir: manifest.workDir,
-				distDir: manifest.distDir,
-			},
-		}),
-		'node_modules',
-	);
-}
-
-/**
- * Returns the app-local node_modules directory used by framework-owned Node
- * bootstrap loads outside the thin-host manifest path.
- */
-export function getAppRuntimeNodeModulesDir(
-	appConfig: Pick<EcoPagesAppConfig, 'rootDir' | 'workDir' | 'absolutePaths'>,
-): string {
-	return path.join(resolveInternalExecutionDir(appConfig), 'node_modules');
-}
-
-/**
- * Derives the package root segment from a bare specifier.
- */
-function getPackageNameFromSpecifier(specifier: string): string {
-	if (specifier.startsWith('@')) {
-		const [scope, name] = specifier.split('/');
-		return `${scope}/${name}`;
-	}
-
-	return specifier.split('/')[0] ?? specifier;
-}
-
-/**
- * Walks upward from a resolved file until it finds the owning package root.
- */
-function findPackageRoot(resolvedPath: string): string {
-	let currentPath = path.dirname(resolvedPath);
-
-	while (true) {
-		const packageJsonPath = path.join(currentPath, 'package.json');
-		if (existsSync(packageJsonPath)) {
-			return currentPath;
-		}
-
-		const parentPath = path.dirname(currentPath);
-		if (parentPath === currentPath) {
-			throw new Error(`Could not find package root for resolved dependency path: ${resolvedPath}`);
-		}
-
-		currentPath = parentPath;
-	}
-}
-
-/**
- * Creates a runtime-local symlink for one external dependency package.
- *
- * @remarks
- * Node thin-host bootstrap bundles externalize third-party packages but still
- * need those packages to resolve from a deterministic runtime-local
- * `node_modules` directory. Symlinking the package root preserves that lookup
- * without copying package contents into the app cache.
- */
-function ensureRuntimePackageLink(nodeModulesDir: string, specifier: string, resolvedPath: string): void {
-	const packageName = getPackageNameFromSpecifier(specifier);
-	const packageRoot = findPackageRoot(resolvedPath);
-	const linkPath = path.join(nodeModulesDir, packageName);
-
-	if (existsSync(linkPath)) {
-		return;
-	}
-
-	mkdirSync(path.dirname(linkPath), { recursive: true });
-	symlinkSync(packageRoot, linkPath, 'dir');
-}
-
-export interface NodeBootstrapResolutionOptions {
-	projectDir: string;
-	runtimeNodeModulesDir: string;
-	preserveImportMetaPaths?: string[];
-}
-
-/**
- * Builds the user-facing error for Bun-native imports that cannot run on the
- * Node thin-host bootstrap path.
- */
-export function getNodeUnsupportedBuiltinError(specifier: string, importer?: string): string {
-	return `Node thin-host bootstrap does not support Bun builtin specifier ${JSON.stringify(specifier)}${importer ? ` imported from ${importer}` : ''}.`;
-}
-
-/**
- * Returns whether a dependency should be resolved relative to the importing
- * package instead of the app root.
- */
-function shouldResolveFromImporter(importer: string | undefined): importer is string {
-	return Boolean(importer && importer.includes(`${path.sep}node_modules${path.sep}`));
-}
-
-/**
- * Selects the build loader used when bootstrap-time source rewriting emits a
- * synthetic in-memory file.
- */
-function getBootstrapBuildLoaderForPath(filePath: string): 'js' | 'jsx' | 'json' | 'ts' | 'tsx' {
-	switch (path.extname(filePath).toLowerCase()) {
-		case '.ts':
-		case '.mts':
-		case '.cts':
-			return 'ts';
-		case '.tsx':
-			return 'tsx';
-		case '.jsx':
-			return 'jsx';
-		case '.json':
-			return 'json';
-		default:
-			return 'js';
-	}
-}
-
-const REEXPORT_FROM_STATEMENT_PATTERN =
-	/^\s*export\s+(?!type\b)(?:\*|\{[\s\S]*?\})\s+from\s+(['"][^'"]+['"])\s*;?\s*$/gm;
-
-/**
- * Prepends side-effect imports for re-export barrels during bootstrap bundling.
- *
- * @remarks
- * This keeps async module initialization observable even when the bootstrap
- * bundle only referenced the file through re-export syntax.
- */
-function injectBootstrapReexportImports(source: string): string {
-	const sideEffectImports: string[] = [];
-	const importedSpecifiers = new Set<string>();
-	let importIndex = 0;
-
-	const rewrittenSource = source.replace(REEXPORT_FROM_STATEMENT_PATTERN, (statement, specifierLiteral: string) => {
-		if (!importedSpecifiers.has(specifierLiteral)) {
-			importedSpecifiers.add(specifierLiteral);
-			const importBinding = `__eco_bootstrap_reexport_${importIndex++}`;
-			sideEffectImports.push(`import * as ${importBinding} from ${specifierLiteral};`);
-			sideEffectImports.push(`void ${importBinding};`);
-		}
-
-		return statement;
-	});
-
-	if (sideEffectImports.length === 0) {
-		return source;
-	}
-
-	return `${sideEffectImports.join('\n')}\n${rewrittenSource}`;
-}
-
-/**
- * Returns whether bootstrap source rewriting is allowed for the given file.
- *
- * @remarks
- * Re-export and `import.meta` rewrites are limited to project-owned sources so
- * third-party packages keep their original semantics.
- */
-function shouldRewriteBootstrapSource(filePath: string, projectDir: string): boolean {
-	const normalizedPath = path.resolve(filePath);
-	const normalizedProjectDir = path.resolve(projectDir);
-
-	return (
-		normalizedPath.startsWith(`${normalizedProjectDir}${path.sep}`) &&
-		!normalizedPath.includes(`${path.sep}node_modules${path.sep}`)
-	);
-}
-
-/**
- * Resolves one bare specifier encountered while bundling Node thin-host
- * bootstrap modules.
- *
- * Workspace-owned `@ecopages/*` packages stay in the bundle graph so Node does
- * not execute their source files directly. Third-party packages stay external,
- * but are linked into the runtime-local `node_modules` tree so the generated
- * bootstrap output resolves them from a deterministic location.
- */
-export function resolveNodeBootstrapDependency(
-	args: Pick<EcoBuildOnResolveArgs, 'path' | 'importer'>,
-	options: NodeBootstrapResolutionOptions,
-): EcoBuildOnResolveResult | undefined {
-	if (
-		args.path.startsWith('./') ||
-		args.path.startsWith('../') ||
-		args.path.startsWith('@/') ||
-		args.path.startsWith('/') ||
-		args.path.startsWith('node:')
-	) {
-		return undefined;
-	}
-
-	const projectRequire = createRequire(path.join(options.projectDir, 'package.json'));
-	const requireFromImporter =
-		args.importer && path.isAbsolute(args.importer) && shouldResolveFromImporter(args.importer)
-			? createRequire(args.importer)
-			: projectRequire;
-
-	if (args.path.startsWith('@ecopages/')) {
-		return {
-			path: requireFromImporter.resolve(args.path),
-		};
-	}
-
-	const resolvedPath = requireFromImporter.resolve(args.path);
-
-	ensureRuntimePackageLink(options.runtimeNodeModulesDir, args.path, resolvedPath);
-
-	return {
-		path: args.path,
-		external: true,
-	};
-}
-
-/**
- * Creates the bootstrap-time resolver plugin used by the Node thin-host
- * adapter for config and entry module loading.
- */
-export function createNodeBootstrapPlugin(options: NodeBootstrapResolutionOptions): EcoBuildPlugin {
-	const projectDir = path.resolve(options.projectDir);
-	const importMetaRewritePaths = new Set(
-		(options.preserveImportMetaPaths ?? []).map((filePath) => path.resolve(filePath)),
-	);
-
-	return {
-		name: 'node-thin-host-bundle-workspace-packages',
-		setup(build) {
-			build.onResolve({ filter: /^bun:/ }, (args) => {
-				throw new Error(getNodeUnsupportedBuiltinError(args.path, args.importer));
-			});
-
-			build.onLoad({ filter: /\.[cm]?[jt]sx?$/ }, async (args) => {
-				const absolutePath = path.resolve(args.path);
-				const shouldPreserveImportMeta = importMetaRewritePaths.has(absolutePath);
-				const shouldRewriteReexports = shouldRewriteBootstrapSource(absolutePath, projectDir);
-
-				if (!shouldPreserveImportMeta && !shouldRewriteReexports) {
-					return undefined;
-				}
-
-				const originalContents = readFileSync(args.path, 'utf8');
-				let contents = originalContents;
-
-				if (shouldPreserveImportMeta) {
-					contents = contents
-						.replaceAll('import.meta.dirname', JSON.stringify(path.dirname(args.path)))
-						.replaceAll('import.meta.filename', JSON.stringify(args.path));
-				}
-
-				if (shouldRewriteReexports) {
-					contents = injectBootstrapReexportImports(contents);
-				}
-
-				if (contents === originalContents) {
-					return undefined;
-				}
-
-				return {
-					contents,
-					loader: getBootstrapBuildLoaderForPath(args.path),
-					resolveDir: path.dirname(args.path),
-				};
-			});
-
-			build.onResolve({ filter: /^[@A-Za-z0-9][^:]*$/ }, (args) => {
-				return resolveNodeBootstrapDependency(args, options);
-			});
-		},
-	};
-}
-
-/**
- * Creates the standard Node bootstrap plugin for one finalized app config.
- */
-export function createAppNodeBootstrapPlugin(
-	appConfig: Pick<EcoPagesAppConfig, 'rootDir' | 'workDir' | 'absolutePaths'>,
-	options?: {
-		preserveImportMetaPaths?: string[];
-	},
-): EcoBuildPlugin {
-	return createNodeBootstrapPlugin({
-		projectDir: appConfig.rootDir,
-		runtimeNodeModulesDir: getAppRuntimeNodeModulesDir(appConfig),
-		preserveImportMetaPaths: options?.preserveImportMetaPaths,
-	});
-}

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

@@ -1,179 +0,0 @@
-import { createServer, type IncomingMessage, type Server as NodeServerInstance, type ServerResponse } from 'node:http';
-import { Readable } from 'node:stream';
-import { DEFAULT_ECOPAGES_HOSTNAME, DEFAULT_ECOPAGES_PORT } from '../../constants.ts';
-import { appLogger } from '../../global/app-logger.ts';
-import type { EcoPagesAppConfig } from '../../internal-types.ts';
-import type { StaticRoute } from '../../public-types.ts';
-import { type ApplicationAdapterOptions } from '../abstract/application-adapter.ts';
-import { SharedApplicationAdapter } from '../shared/application-adapter.ts';
-import { type NodeServerAdapterResult, createNodeServerAdapter } from './server-adapter.ts';
-
-export interface EcopagesAppOptions extends ApplicationAdapterOptions {
-	appConfig: EcoPagesAppConfig;
-	serverOptions?: Record<string, any>;
-}
-
-export class EcopagesApp extends SharedApplicationAdapter<EcopagesAppOptions, NodeServerInstance, Request> {
-	serverAdapter: NodeServerAdapterResult | undefined;
-	private server: NodeServerInstance | null = null;
-	private runtimeOrigin = '';
-
-	public async stop(force = true): Promise<void> {
-		if (!this.server) {
-			return;
-		}
-
-		const activeServer = this.server;
-		this.server = null;
-
-		await new Promise<void>((resolve, reject) => {
-			activeServer.close((error) => {
-				if (error) {
-					reject(error);
-					return;
-				}
-
-				resolve();
-			});
-
-			if (force) {
-				activeServer.closeAllConnections();
-			}
-		});
-	}
-
-	protected async initializeServerAdapter(): Promise<NodeServerAdapterResult> {
-		const { dev } = this.cliArgs;
-		const { port: cliPort, hostname: cliHostname } = this.cliArgs;
-
-		const envPort = process.env.ECOPAGES_PORT;
-		const envHostname = process.env.ECOPAGES_HOSTNAME;
-
-		const preferredPort = cliPort ?? (envPort ? Number(envPort) : undefined) ?? DEFAULT_ECOPAGES_PORT;
-		const preferredHostname = cliHostname ?? envHostname ?? DEFAULT_ECOPAGES_HOSTNAME;
-		this.runtimeOrigin = `http://${preferredHostname}:${preferredPort}`;
-
-		return createNodeServerAdapter({
-			runtimeOrigin: this.runtimeOrigin,
-			appConfig: this.appConfig,
-			apiHandlers: this.apiHandlers,
-			staticRoutes: this.staticRoutes as StaticRoute[],
-			errorHandler: this.errorHandler,
-			options: { watch: dev },
-			serveOptions: {
-				port: preferredPort,
-				hostname: preferredHostname,
-				...this.serverOptions,
-			},
-		});
-	}
-
-	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();
-		const hostname = String(serveOptions.hostname ?? DEFAULT_ECOPAGES_HOSTNAME);
-		const port = Number(serveOptions.port ?? DEFAULT_ECOPAGES_PORT);
-		this.runtimeOrigin = `http://${hostname}:${port}`;
-
-		this.server = createServer(async (req, res) => {
-			try {
-				const webRequest = this.createWebRequest(req);
-				const response = await this.serverAdapter!.handleRequest(webRequest);
-				await this.sendNodeResponse(res, response);
-			} catch (error) {
-				appLogger.error('Node server adapter request failed', error as Error);
-				res.statusCode = 500;
-				res.end('Internal Server Error');
-			}
-		});
-
-		await new Promise<void>((resolve) => {
-			this.server!.listen(port, hostname, () => resolve());
-		});
-
-		await this.serverAdapter.completeInitialization(this.server);
-		appLogger.info(`Node server running at ${this.runtimeOrigin}`);
-
-		return this.server;
-	}
-
-	private createWebRequest(req: IncomingMessage): Request {
-		const url = new URL(req.url ?? '/', this.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') {
-			requestInit.body = Readable.toWeb(req) as unknown as BodyInit;
-			requestInit.duplex = 'half';
-		}
-
-		return new Request(url, requestInit);
-	}
-
-	private 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 body = Buffer.from(await response.arrayBuffer());
-		res.end(body);
-	}
-
-	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<EcopagesApp> {
-	return new EcopagesApp(options);
-}

package/src/adapters/node/index.d.ts

@@ -1,6 +0,0 @@
-export { NodeServerAdapter, createNodeServerAdapter } from './server-adapter.js';
-export { EcopagesApp, createNodeApp } from './create-app.js';
-export { assertNodeRuntimeManifest, createNodeRuntimeAdapter } from './runtime-adapter.js';
-export type { EcopagesAppOptions } from './create-app.js';
-export type { LoadedAppRuntime, NodeRuntimeAdapter, NodeRuntimeSession, NodeRuntimeStartOptions, } from './runtime-adapter.js';
-export type { NodeServerAdapterParams, NodeServerAdapterResult, NodeServerInstance, NodeServeAdapterServerOptions, } from './server-adapter.js';

package/src/adapters/node/index.js

@@ -1,11 +0,0 @@
-import { NodeServerAdapter, createNodeServerAdapter } from "./server-adapter.js";
-import { EcopagesApp, createNodeApp } from "./create-app.js";
-import { assertNodeRuntimeManifest, createNodeRuntimeAdapter } from "./runtime-adapter.js";
-export {
-  EcopagesApp,
-  NodeServerAdapter,
-  assertNodeRuntimeManifest,
-  createNodeApp,
-  createNodeRuntimeAdapter,
-  createNodeServerAdapter
-};

package/src/adapters/node/index.ts

@@ -1,16 +0,0 @@
-export { NodeServerAdapter, createNodeServerAdapter } from './server-adapter.ts';
-export { EcopagesApp, createNodeApp } from './create-app.ts';
-export { assertNodeRuntimeManifest, createNodeRuntimeAdapter } from './runtime-adapter.ts';
-export type { EcopagesAppOptions } from './create-app.ts';
-export type {
-	LoadedAppRuntime,
-	NodeRuntimeAdapter,
-	NodeRuntimeSession,
-	NodeRuntimeStartOptions,
-} from './runtime-adapter.ts';
-export type {
-	NodeServerAdapterParams,
-	NodeServerAdapterResult,
-	NodeServerInstance,
-	NodeServeAdapterServerOptions,
-} from './server-adapter.ts';

package/src/adapters/node/node-client-bridge.ts

@@ -1,79 +0,0 @@
-import type { WebSocket } from 'ws';
-import type { ClientBridgeEvent, IClientBridge } from '../../public-types.ts';
-
-const HEARTBEAT_INTERVAL_MS = 30_000;
-
-export class NodeClientBridge implements IClientBridge {
-	private subscribers = new Set<WebSocket>();
-	private heartbeatTimer: ReturnType<typeof setInterval> | null = null;
-
-	constructor() {
-		this.heartbeatTimer = setInterval(() => this.sweep(), HEARTBEAT_INTERVAL_MS);
-		/* Allow the process to exit even if the timer is still active */
-		this.heartbeatTimer.unref?.();
-	}
-
-	/**
-	 * Pings all open subscribers and removes any that are no longer in OPEN state.
-	 * This prevents a slow memory leak caused by zombie connections that never
-	 * send a close event (e.g. abruptly killed browsers, orphaned tabs, network drops).
-	 */
-	private sweep(): void {
-		for (const ws of this.subscribers) {
-			if (ws.readyState !== 1 /* OPEN */) {
-				this.subscribers.delete(ws);
-				continue;
-			}
-			ws.ping();
-		}
-	}
-
-	subscribe(ws: WebSocket): void {
-		this.subscribers.add(ws);
-	}
-
-	unsubscribe(ws: WebSocket): void {
-		this.subscribers.delete(ws);
-	}
-
-	broadcast(event: ClientBridgeEvent): void {
-		const payload = JSON.stringify(event);
-		for (const ws of this.subscribers) {
-			if (ws.readyState === 1) {
-				ws.send(payload);
-			}
-		}
-	}
-
-	reload(): void {
-		this.broadcast({ type: 'reload' });
-	}
-
-	cssUpdate(path: string): void {
-		this.broadcast({ type: 'css-update', path, timestamp: Date.now() });
-	}
-
-	update(path: string): void {
-		this.broadcast({ type: 'update', path, timestamp: Date.now() });
-	}
-
-	error(message: string): void {
-		this.broadcast({ type: 'error', message });
-	}
-
-	get subscriberCount(): number {
-		return this.subscribers.size;
-	}
-
-	/**
-	 * Stops the heartbeat timer and clears all subscribers.
-	 * Call this when the dev server is shutting down.
-	 */
-	destroy(): void {
-		if (this.heartbeatTimer !== null) {
-			clearInterval(this.heartbeatTimer);
-			this.heartbeatTimer = null;
-		}
-		this.subscribers.clear();
-	}
-}