@octanejs/vite-plugin 0.1.4 → 0.1.6

package/src/server/middleware.js

@@ -1,127 +1 @@
-// @ts-check
-/**
- * @typedef {import('@octanejs/vite-plugin').Context} Context
- * @typedef {import('@octanejs/vite-plugin').Middleware} Middleware
- * @typedef {import('@octanejs/vite-plugin').NextFunction} NextFunction
- */
-
-/**
- * Compose multiple middlewares into a single middleware
- * Follows Koa-style execution: request flows down, response flows back up
- *
- * @param {Middleware[]} middlewares
- * @returns {(context: Context, finalHandler: () => Promise<Response>) => Promise<Response>}
- */
-export function compose(middlewares) {
-	return function composed(context, finalHandler) {
-		let index = -1;
-
-		/**
-		 * @param {number} i
-		 * @returns {Promise<Response>}
-		 */
-		function dispatch(i) {
-			if (i <= index) {
-				return Promise.reject(new Error('next() called multiple times'));
-			}
-			index = i;
-
-			/** @type {Middleware | (() => Promise<Response>) | undefined} */
-			let fn;
-
-			if (i < middlewares.length) {
-				fn = middlewares[i];
-			} else if (i === middlewares.length) {
-				fn = finalHandler;
-			}
-
-			if (!fn) {
-				return Promise.reject(new Error('No handler provided'));
-			}
-
-			try {
-				// For the final handler, we don't pass next
-				if (i === middlewares.length) {
-					return Promise.resolve(/** @type {() => Promise<Response>} */ (fn)());
-				}
-				// For middlewares, pass context and next
-				return Promise.resolve(/** @type {Middleware} */ (fn)(context, () => dispatch(i + 1)));
-			} catch (err) {
-				return Promise.reject(err);
-			}
-		}
-
-		return dispatch(0);
-	};
-}
-
-/**
- * Create a context object for the request
- * @param {Request} request
- * @param {Record<string, string>} params
- * @returns {Context}
- */
-export function createContext(request, params) {
-	return {
-		request,
-		params,
-		url: new URL(request.url),
-		state: new Map(),
-	};
-}
-
-/**
- * Run middlewares with a final handler
- * Combines global middlewares, route-level before/after, and the handler
- *
- * @param {Context} context
- * @param {Middleware[]} globalMiddlewares
- * @param {Middleware[]} beforeMiddlewares
- * @param {() => Promise<Response>} handler
- * @param {Middleware[]} afterMiddlewares
- * @returns {Promise<Response>}
- */
-export async function runMiddlewareChain(
-	context,
-	globalMiddlewares,
-	beforeMiddlewares,
-	handler,
-	afterMiddlewares = [],
-) {
-	// Combine global + before middlewares
-	const allMiddlewares = [...globalMiddlewares, ...beforeMiddlewares];
-
-	// If there are after middlewares, wrap the handler to run them
-	const wrappedHandler =
-		afterMiddlewares.length > 0
-			? async () => {
-					const response = await handler();
-					// After middlewares can inspect/modify the response
-					// but have limited ability to change it in our model
-					// We run them for side-effects (logging, etc.)
-					return runAfterMiddlewares(context, afterMiddlewares, response);
-				}
-			: handler;
-
-	const composed = compose(allMiddlewares);
-	return composed(context, wrappedHandler);
-}
-
-/**
- * Run after middlewares with the response
- * After middlewares run in order and can intercept/modify the response
- *
- * @param {Context} context
- * @param {Middleware[]} middlewares
- * @param {Response} response
- * @returns {Promise<Response>}
- */
-async function runAfterMiddlewares(context, middlewares, response) {
-	let currentResponse = response;
-
-	for (const middleware of middlewares) {
-		currentResponse = await middleware(context, async () => currentResponse);
-	}
-
-	return currentResponse;
-}
+export * from '@octanejs/app-core/middleware';

package/src/server/node-http.js

@@ -1,188 +1 @@
-// @ts-check
-/**
- * Node HTTP glue — shared by the dev middleware (src/index.js), the generated
- * production server entry (its `nodeHandler` export for serverless wrappers),
- * and the built-in production server (`createNodeServer`, the no-adapter
- * default boot). Exported as '@octanejs/vite-plugin/node'.
- *
- * This module may import node builtins (unlike server/production.js, which is
- * platform-agnostic) — it IS the Node platform layer.
- */
-
-import http from 'node:http';
-import fs from 'node:fs';
-import path from 'node:path';
-import { Readable } from 'node:stream';
-
-/**
- * Convert a Node.js IncomingMessage to a Web Request.
- * @param {import('node:http').IncomingMessage} nodeRequest
- * @returns {Request}
- */
-export function nodeRequestToWebRequest(nodeRequest) {
-	const host = nodeRequest.headers.host || 'localhost';
-	const url = new URL(nodeRequest.url || '/', `http://${host}`);
-
-	const headers = new Headers();
-	for (const [key, value] of Object.entries(nodeRequest.headers)) {
-		if (value == null) continue;
-		if (Array.isArray(value)) {
-			for (const v of value) headers.append(key, v);
-		} else {
-			headers.set(key, value);
-		}
-	}
-
-	const method = (nodeRequest.method || 'GET').toUpperCase();
-	/** @type {RequestInit & { duplex?: 'half' }} */
-	const init = { method, headers };
-	if (method !== 'GET' && method !== 'HEAD') {
-		// node:stream/web's ReadableStream and the DOM lib's are structurally the
-		// same at runtime; the lib types disagree on BYOB details.
-		init.body = /** @type {ReadableStream} */ (
-			/** @type {unknown} */ (Readable.toWeb(nodeRequest))
-		);
-		init.duplex = 'half';
-	}
-	return new Request(url, init);
-}
-
-/**
- * Pipe a Web Response to a Node.js ServerResponse. Streams chunk-by-chunk so a
- * streaming SSR body flushes as it renders (no buffering).
- *
- * @param {import('node:http').ServerResponse} nodeResponse
- * @param {Response} webResponse
- */
-export async function sendWebResponse(nodeResponse, webResponse) {
-	nodeResponse.statusCode = webResponse.status;
-	if (webResponse.statusText) nodeResponse.statusMessage = webResponse.statusText;
-	webResponse.headers.forEach((value, key) => {
-		nodeResponse.setHeader(key, value);
-	});
-	if (webResponse.body) {
-		const reader = webResponse.body.getReader();
-		try {
-			while (true) {
-				const { done, value } = await reader.read();
-				if (done) break;
-				nodeResponse.write(value);
-			}
-		} finally {
-			reader.releaseLock();
-		}
-	}
-	nodeResponse.end();
-}
-
-// Static-file MIME map (the common web set; anything else falls back to
-// octet-stream, which is correct for downloads).
-/** @type {Record<string, string>} */
-const MIME_TYPES = {
-	'.html': 'text/html; charset=utf-8',
-	'.css': 'text/css; charset=utf-8',
-	'.js': 'text/javascript; charset=utf-8',
-	'.mjs': 'text/javascript; charset=utf-8',
-	'.json': 'application/json; charset=utf-8',
-	'.png': 'image/png',
-	'.jpg': 'image/jpeg',
-	'.jpeg': 'image/jpeg',
-	'.gif': 'image/gif',
-	'.svg': 'image/svg+xml',
-	'.ico': 'image/x-icon',
-	'.woff': 'font/woff',
-	'.woff2': 'font/woff2',
-	'.ttf': 'font/ttf',
-	'.otf': 'font/otf',
-	'.webp': 'image/webp',
-	'.avif': 'image/avif',
-	'.mp4': 'video/mp4',
-	'.webm': 'video/webm',
-	'.txt': 'text/plain; charset=utf-8',
-	'.xml': 'application/xml',
-	'.wasm': 'application/wasm',
-	'.map': 'application/json',
-};
-
-/**
- * Serve a static file from `staticDir` if the request path maps to one.
- * Hash-named build assets (everything under /assets/) get immutable caching;
- * other files (favicon, robots.txt, …) revalidate.
- *
- * @param {import('node:http').IncomingMessage} req
- * @param {import('node:http').ServerResponse} res
- * @param {string} staticDir
- * @returns {boolean} true when the request was handled as a static file
- */
-export function serveStaticFile(req, res, staticDir) {
-	const method = (req.method || 'GET').toUpperCase();
-	if (method !== 'GET' && method !== 'HEAD') return false;
-
-	const pathname = decodeURIComponent(new URL(req.url || '/', 'http://localhost').pathname);
-	// Resolve inside staticDir only — a `..` escape must not leave the client dir.
-	const filePath = path.normalize(path.join(staticDir, pathname));
-	if (!filePath.startsWith(path.normalize(staticDir + path.sep))) return false;
-
-	/** @type {fs.Stats} */
-	let stat;
-	try {
-		stat = fs.statSync(filePath);
-	} catch {
-		return false;
-	}
-	if (!stat.isFile()) return false;
-
-	const ext = path.extname(filePath).toLowerCase();
-	res.statusCode = 200;
-	res.setHeader('Content-Type', MIME_TYPES[ext] || 'application/octet-stream');
-	res.setHeader('Content-Length', stat.size);
-	res.setHeader(
-		'Cache-Control',
-		pathname.startsWith('/assets/')
-			? 'public, max-age=31536000, immutable'
-			: 'public, max-age=0, must-revalidate',
-	);
-	if (method === 'HEAD') {
-		res.end();
-	} else {
-		fs.createReadStream(filePath).pipe(res);
-	}
-	return true;
-}
-
-/**
- * Minimal production HTTP server: static files from `staticDir` first (built
- * client assets), then the fetch-style SSR handler. This is the DEFAULT boot
- * when octane.config.ts has no adapter — an adapter's `serve()` replaces it.
- *
- * @param {(request: Request) => Response | Promise<Response>} handler
- * @param {{ staticDir?: string }} [options]
- * @returns {{ listen: (port?: number) => import('node:http').Server, close: () => void }}
- */
-export function createNodeServer(handler, options = {}) {
-	const staticDir = options.staticDir;
-
-	const server = http.createServer((req, res) => {
-		(async () => {
-			if (staticDir && serveStaticFile(req, res, staticDir)) return;
-			const response = await handler(nodeRequestToWebRequest(req));
-			await sendWebResponse(res, response);
-		})().catch((error) => {
-			console.error('[@octanejs/vite-plugin] Request error:', error);
-			if (!res.headersSent) {
-				res.statusCode = 500;
-				res.setHeader('Content-Type', 'text/plain; charset=utf-8');
-			}
-			res.end('Internal Server Error');
-		});
-	});
-
-	return {
-		listen(port = 3000) {
-			return server.listen(port);
-		},
-		close() {
-			server.close();
-		},
-	};
-}
+export * from '@octanejs/app-core/node';

package/src/server/production.js

@@ -1,286 +1 @@
-// @ts-check
-/**
- * Production fetch-handler factory + config re-exports.
- *
- * `createHandler(manifest, deps)` is the runtime entry the generated server
- * bundle (dist/server/entry.js) calls in production. It is designed to be
- * BUNDLED: platform-agnostic (no Node imports — platform capabilities come via
- * `manifest.runtime`), and free of vite / octane-compiler imports (which is why
- * `resolveOctaneConfig` is re-exported from resolve-config.js, not
- * load-config.js).
- *
- * The render path mirrors the DEV middleware's `handleRenderRoute`
- * (server/render-route.js) byte-for-byte in everything hydration can see —
- * the same `renderToReadableStream` engine, the same `#__octane_data` payload
- * (same keys, same order), and the same template-prefix → render-stream →
- * template-suffix assembly — so `hydrateRoot()` adopts a production response
- * exactly as it adopts a dev one. Deliberate differences: the template is the
- * BUILT dist/client/index.html (hashed hydrate script already in place, so
- * nothing is injected per-request), per-route `<link rel=stylesheet/modulepreload>`
- * tags from the client manifest join the head, and render errors produce a
- * plain 500 (no dev stack page). Keep the two files in sync when the shape
- * changes.
- */
-
-import { createRouter } from './router.js';
-import { createContext, runMiddlewareChain } from './middleware.js';
-import { handleServerRoute } from './server-route.js';
-import { createLayoutWrapper, createPropsWrapper } from './component-wrappers.js';
-import {
-	get_component_export,
-	get_route_entry_export_name,
-	get_route_entry_path,
-} from '../routes.js';
-import {
-	patch_global_fetch,
-	build_rpc_lookup,
-	is_rpc_request,
-	handle_rpc_request,
-} from '@ripple-ts/adapter/rpc';
-
-export { resolveOctaneConfig } from '../resolve-config.js';
-
-/**
- * @typedef {import('@octanejs/vite-plugin').RenderRoute} RenderRoute
- * @typedef {import('@octanejs/vite-plugin').Middleware} Middleware
- * @typedef {import('@octanejs/vite-plugin').Context} Context
- */
-/**
-@import { ServerManifest, HandlerOptions, ClientAssetEntry } from '../../types/production.d.ts'
- */
-
-/**
- * Create the production request handler from a manifest.
- *
- * The returned function is a standard Web `fetch`-style handler:
- * `(request: Request) => Promise<Response>` — the generated server entry boots
- * it behind the adapter's `serve()` (or the built-in Node server), and
- * serverless wrappers import it directly.
- *
- * @param {ServerManifest} manifest
- * @param {HandlerOptions} deps
- * @returns {(request: Request) => Promise<Response>}
- */
-export function createHandler(manifest, deps) {
-	const { renderToReadableStream, prerender, htmlTemplate, executeServerFunction } = deps;
-	const router = createRouter(manifest.routes);
-	const globalMiddlewares = manifest.middlewares ?? [];
-	const trustProxy = manifest.trustProxy ?? false;
-	const runtime = manifest.runtime;
-
-	// RPC lookup for `module server` functions (hash → server function). Empty
-	// today — the octane compiler does not emit `module server` modules yet —
-	// but the wiring matches the dev middleware so it lights up when it does.
-	const rpcLookup =
-		manifest.rpcModules && runtime ? build_rpc_lookup(manifest.rpcModules, runtime.hash) : null;
-
-	// Request-scoped async context + same-origin fetch short-circuit: fetch()
-	// during SSR that resolves to this origin routes through the handler
-	// in-process instead of a network round-trip.
-	const asyncContext = runtime?.createAsyncContext();
-	const fetchHandle = asyncContext ? patch_global_fetch(asyncContext) : null;
-
-	const handler = async function handler(/** @type {Request} */ request) {
-		const url = new URL(request.url);
-		const method = request.method;
-
-		if (is_rpc_request(url.pathname)) {
-			if (!rpcLookup || !asyncContext) {
-				return new Response(JSON.stringify({ error: 'RPC is not configured' }), {
-					status: 404,
-					headers: { 'Content-Type': 'application/json' },
-				});
-			}
-			return handle_rpc_request(request, {
-				resolveFunction(/** @type {string} */ hash) {
-					const entry = rpcLookup.get(hash);
-					if (!entry) return null;
-					const fn = entry.serverObj[entry.funcName];
-					return typeof fn === 'function' ? fn : null;
-				},
-				executeServerFunction,
-				asyncContext,
-				trustProxy,
-			});
-		}
-
-		const match = router.match(method, url.pathname);
-		if (!match) {
-			// Static assets never reach here (the static layer — the built-in Node
-			// server, or the platform's file serving — runs first); an app with a
-			// catch-all RenderRoute matches everything else, so this is only hit
-			// when no catch-all exists.
-			return new Response('Not Found', { status: 404 });
-		}
-
-		const context = createContext(request, match.params);
-
-		try {
-			if (match.route.type === 'render') {
-				return await runMiddlewareChain(
-					context,
-					globalMiddlewares,
-					match.route.before || [],
-					async () => renderRoute(/** @type {RenderRoute} */ (match.route), context),
-					[],
-				);
-			}
-			return await handleServerRoute(match.route, context, globalMiddlewares);
-		} catch (error) {
-			console.error('[@octanejs/vite-plugin] Request error:', error);
-			return new Response('Internal Server Error', { status: 500 });
-		}
-	};
-
-	fetchHandle?.set_handler(handler);
-
-	/**
-	 * Render a RenderRoute — the production twin of dev's `handleRenderRoute`.
-	 *
-	 * @param {RenderRoute} route
-	 * @param {Context} context
-	 * @returns {Promise<Response>}
-	 */
-	async function renderRoute(route, context) {
-		const entryPath = get_route_entry_path(route.entry);
-		const exportName = get_route_entry_export_name(route.entry);
-		const PageComponent = entryPath
-			? get_component_export(manifest.components[entryPath] ?? {}, exportName)
-			: null;
-		if (!PageComponent) {
-			throw new Error(`Component not found for route ${route.path}`);
-		}
-
-		// Identical props to dev: `{ params, url }`, url origin-free so the client
-		// re-renders the exact string.
-		const requestUrl = context.url.pathname + context.url.search;
-		const pageProps = { params: context.params, url: requestUrl };
-
-		let RootComponent;
-		if (route.layout) {
-			const LayoutComponent = get_component_export(manifest.layouts[route.layout] ?? {}, undefined);
-			if (!LayoutComponent) {
-				throw new Error(`No layout component found for ${route.layout}`);
-			}
-			RootComponent = createLayoutWrapper(
-				/** @type {any} */ (LayoutComponent),
-				/** @type {any} */ (PageComponent),
-				pageProps,
-			);
-		} else {
-			RootComponent = createPropsWrapper(/** @type {any} */ (PageComponent), pageProps);
-		}
-
-		// The hydration payload — SAME keys, SAME order as dev render-route.js, so
-		// the data script is byte-identical between dev and production.
-		const routeData = JSON.stringify({
-			entry: entryPath,
-			exportName: exportName ?? null,
-			layout: route.layout ?? null,
-			routeIndex: getRenderRouteIndex(manifest.routes, route),
-			params: context.params,
-			url: requestUrl,
-			preHydrate: manifest.preHydrate ?? null,
-		});
-		const dataScript = `<script id="__octane_data" type="application/json">${escapeScript(routeData)}</script>`;
-
-		// Per-route asset hints from the client manifest: stylesheet links so
-		// page CSS applies before hydration, modulepreload so the page chunk
-		// downloads in parallel with the hydrate entry (which the template's own
-		// script tag already references).
-		/** @type {string[]} */
-		const preloadTags = [];
-		const entryAssets = entryPath ? manifest.clientAssets?.[entryPath] : undefined;
-		if (entryAssets) {
-			for (const cssFile of entryAssets.css) {
-				preloadTags.push(`<link rel="stylesheet" href="/${cssFile}">`);
-			}
-			if (entryAssets.js) {
-				preloadTags.push(`<link rel="modulepreload" href="/${entryAssets.js}">`);
-			}
-		}
-
-		const headContent = [...preloadTags, dataScript].join('\n');
-		const html = htmlTemplate.replace('<!--ssr-head-->', headContent);
-
-		const status = route.status ?? 200;
-		const headers = { 'Content-Type': 'text/html; charset=utf-8' };
-
-		const splitAt = html.indexOf('<!--ssr-body-->');
-		if (splitAt === -1) {
-			return new Response(html, { status, headers });
-		}
-		const prefix = html.slice(0, splitAt);
-		const suffix = html.slice(splitAt + '<!--ssr-body-->'.length);
-
-		if (manifest.render === 'buffered') {
-			// Await-everything fallback (`prerender` from octane/static): no
-			// streaming, one document. The deduped scoped-style tags lead the body
-			// markup inside #root — the same position they hold in the streamed
-			// shell — so hydrateRoot's leading-style skip applies unchanged.
-			const { html: body, css } = await prerender(RootComponent, undefined, {
-				onError(/** @type {unknown} */ error) {
-					console.error('[octane] SSR render error:', error);
-				},
-			});
-			return new Response(prefix + css + body + suffix, { status, headers });
-		}
-
-		// Streaming (default): shell flushes at first await, suspense segments
-		// stream out-of-order behind it — identical to dev.
-		/** @type {ReadableStream<Uint8Array>} */
-		const renderStream = await renderToReadableStream(RootComponent, undefined, {
-			onError(/** @type {unknown} */ error) {
-				console.error('[octane] SSR render error:', error);
-			},
-		});
-
-		const encoder = new TextEncoder();
-		const body = new ReadableStream({
-			async start(controller) {
-				controller.enqueue(encoder.encode(prefix));
-				const reader = renderStream.getReader();
-				try {
-					while (true) {
-						const { done, value } = await reader.read();
-						if (done) break;
-						controller.enqueue(value);
-					}
-					controller.enqueue(encoder.encode(suffix));
-					controller.close();
-				} catch (error) {
-					controller.error(error);
-				} finally {
-					reader.releaseLock();
-				}
-			},
-			cancel(reason) {
-				return renderStream.cancel(reason);
-			},
-		});
-
-		return new Response(body, { status, headers });
-	}
-
-	return handler;
-}
-
-/**
- * @param {import('@octanejs/vite-plugin').Route[]} routes
- * @param {RenderRoute} route
- * @returns {number | undefined}
- */
-function getRenderRouteIndex(routes, route) {
-	const renderRoutes = routes.filter((r) => r.type === 'render');
-	const index = renderRoutes.indexOf(route);
-	return index === -1 ? undefined : index;
-}
-
-/**
- * Escape script content to prevent XSS in the inline JSON data block.
- * @param {string} str
- * @returns {string}
- */
-function escapeScript(str) {
-	return str.replace(/</g, '\\u003c').replace(/>/g, '\\u003e');
-}
+export * from '@octanejs/app-core/production';