@ripple-ts/adapter-node 0.2.208

package/README.md

@@ -0,0 +1,106 @@
+# @ripple-ts/adapter-node
+
+Node.js adapter for Ripple metaframework apps.
+
+It bridges Node's `IncomingMessage`/`ServerResponse` API to Web
+`Request`/`Response`, so your server handler can use standard Fetch APIs.
+
+## Installation
+
+```bash
+pnpm add @ripple-ts/adapter-node
+# or
+npm install @ripple-ts/adapter-node
+# or
+yarn add @ripple-ts/adapter-node
+```
+
+## Usage
+
+```js
+import { serve } from '@ripple-ts/adapter-node';
+
+const app = serve(async (request) => {
+  const url = new URL(request.url);
+
+  if (url.pathname === '/health') {
+    return new Response('ok');
+  }
+
+  return new Response('Hello from Ripple adapter-node!', {
+    headers: { 'content-type': 'text/plain; charset=utf-8' },
+  });
+});
+
+app.listen(3000);
+```
+
+## API
+
+### `serve(fetch_handler, options?)`
+
+Creates an HTTP server adapter.
+
+- `fetch_handler`:
+  `(request: Request, platform?: any) => Response | Promise<Response>`
+- `options.port` (default: `3000`)
+- `options.hostname` (default: `localhost`)
+- `options.static` (default: `{ dir: 'public' }`): serves static files before
+  middleware/handler
+  - `options.static.dir` (default: `public`, resolved from `process.cwd()`)
+  - `options.static.prefix` (default: `/`)
+  - `options.static.maxAge` (default: `86400`)
+  - `options.static.immutable` (default: `false`)
+  - set `options.static = false` to disable automatic static serving
+- `options.middleware` (optional): Node-style middleware called before
+  `fetch_handler`
+
+Returns:
+
+- `listen(port?)`: starts the server and returns Node `Server`
+- `close()`: closes the server
+
+### `serveStatic(dir, options?)`
+
+Creates a Node middleware that serves static assets from `dir`.
+
+- `options.prefix` (default: `/`)
+- `options.maxAge` (default: `86400`)
+- `options.immutable` (default: `false`)
+
+## Middleware
+
+If middleware sends the response (`res.end()` / `res.headersSent`), the fetch
+handler is skipped.
+
+```js
+import { serve } from '@ripple-ts/adapter-node';
+
+const app = serve(async () => new Response('from handler'), {
+  middleware(req, res, next) {
+    if (req.url === '/legacy') {
+      res.statusCode = 200;
+      res.setHeader('content-type', 'text/plain; charset=utf-8');
+      res.end('from middleware');
+      return;
+    }
+
+    next();
+  },
+});
+
+app.listen(3000);
+```
+
+## Notes
+
+- Static file logic and MIME type mappings are shared from `@ripple-ts/adapter`.
+- `x-forwarded-proto` and `x-forwarded-host` are respected when constructing the
+  request URL.
+- Request bodies are streamed for non-`GET`/`HEAD` methods.
+- Multiple `set-cookie` headers are forwarded correctly.
+- Unhandled errors return `500 Internal Server Error`.
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@ripple-ts/adapter-node",
+  "description": "Node.js adapter for Ripple metaframework (Web Request/Response bridge)",
+  "license": "MIT",
+  "author": "Dominic Gannaway",
+  "version": "0.2.208",
+  "type": "module",
+  "module": "src/index.js",
+  "main": "src/index.js",
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "import": "./src/index.js",
+      "default": "./src/index.js"
+    }
+  },
+  "scripts": {
+    "test": "pnpm -w test --project adapter-node"
+  },
+  "dependencies": {
+    "@ripple-ts/adapter": "workspace:*"
+  },
+  "homepage": "https://ripplejs.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Ripple-TS/ripple.git",
+    "directory": "packages/adapter-node"
+  },
+  "bugs": {
+    "url": "https://github.com/Ripple-TS/ripple/issues"
+  }
+}

package/src/index.js

@@ -0,0 +1,290 @@
+import { createServer } from 'node:http';
+import { Readable } from 'node:stream';
+import {
+	DEFAULT_HOSTNAME,
+	DEFAULT_PORT,
+	internal_server_error_response,
+	run_next_middleware,
+	serveStatic as create_static_handler,
+} from '@ripple-ts/adapter';
+
+/**
+ * @param {string | string[] | undefined} value
+ * @returns {string | undefined}
+ */
+function first_header_value(value) {
+	if (value == null) return undefined;
+	if (Array.isArray(value)) return value[0];
+	return value;
+}
+
+/**
+ * @param {string | undefined} value
+ * @returns {string | undefined}
+ */
+function normalize_forwarded_value(value) {
+	if (!value) return undefined;
+	return value.split(',')[0].trim();
+}
+
+/**
+ * @param {import('node:http').IncomingMessage} node_request
+ * @param {AbortSignal} signal
+ * @returns {Request}
+ */
+function node_request_to_web_request(node_request, signal) {
+	const forwarded_proto = normalize_forwarded_value(
+		first_header_value(node_request.headers['x-forwarded-proto']),
+	);
+	const forwarded_host = normalize_forwarded_value(
+		first_header_value(node_request.headers['x-forwarded-host']),
+	);
+
+	const proto = forwarded_proto ?? 'http';
+	const host = forwarded_host ?? first_header_value(node_request.headers.host) ?? 'localhost';
+
+	const raw_url = node_request.url ?? '/';
+	const base = `${proto}://${host}`;
+	const url = raw_url === '*' ? new URL(base) : new URL(raw_url, base);
+
+	const headers = new Headers();
+	for (const [key, value] of Object.entries(node_request.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 = (node_request.method ?? 'GET').toUpperCase();
+	/** @type {RequestInit & { duplex?: 'half' }} */
+	const request_init = { method, headers, signal };
+
+	if (method !== 'GET' && method !== 'HEAD') {
+		request_init.body = /** @type {any} */ (Readable.toWeb(node_request));
+		request_init.duplex = 'half';
+	}
+
+	return new Request(url, request_init);
+}
+
+/**
+ * @param {Response} web_response
+ * @param {import('node:http').ServerResponse} node_response
+ * @param {string} request_method
+ * @returns {void}
+ */
+function web_response_to_node_response(web_response, node_response, request_method) {
+	node_response.statusCode = web_response.status;
+	if (web_response.statusText) {
+		node_response.statusMessage = web_response.statusText;
+	}
+
+	const get_set_cookie = /** @type {any} */ (web_response.headers).getSetCookie;
+	let set_cookie_set = false;
+	if (typeof get_set_cookie === 'function') {
+		const cookies = get_set_cookie.call(web_response.headers);
+		if (cookies.length > 0) {
+			node_response.setHeader('set-cookie', cookies);
+			set_cookie_set = true;
+		}
+	}
+	if (!set_cookie_set) {
+		const cookie = web_response.headers.get('set-cookie');
+		if (cookie) {
+			node_response.setHeader('set-cookie', cookie);
+		}
+	}
+
+	web_response.headers.forEach((value, key) => {
+		if (key.toLowerCase() === 'set-cookie') return;
+		node_response.setHeader(key, value);
+	});
+
+	if (request_method === 'HEAD' || web_response.body == null) {
+		node_response.end();
+		return;
+	}
+
+	const node_stream = Readable.fromWeb(/** @type {any} */ (web_response.body));
+	node_stream.on('error', (error) => {
+		node_response.destroy(error);
+	});
+	node_stream.pipe(node_response);
+}
+
+/** @typedef {import('@ripple-ts/adapter').ServeStaticDirectoryOptions} StaticServeOptions */
+
+/**
+ * @typedef {{
+ * 	port?: number,
+ * 	hostname?: string,
+ * 	middleware?: ((
+ * 		req: import('node:http').IncomingMessage,
+ * 		res: import('node:http').ServerResponse,
+ * 		next: (error?: any) => void
+ * 	) => void) | null,
+ * 	static?: StaticServeOptions | false,
+ * }} ServeOptions
+ */
+
+/**
+ * @param {(req: import('node:http').IncomingMessage, res: import('node:http').ServerResponse, next: (error?: any) => void) => void} middleware
+ * @param {import('node:http').IncomingMessage} node_request
+ * @param {import('node:http').ServerResponse} node_response
+ * @returns {Promise<void>}
+ */
+function run_node_middleware(middleware, node_request, node_response) {
+	return new Promise((resolve, reject) => {
+		if (node_response.writableEnded) {
+			resolve(undefined);
+			return;
+		}
+
+		const done = (/** @type {Error} */ error) => {
+			if (error) {
+				reject(error);
+				return;
+			}
+
+			resolve(undefined);
+		};
+
+		try {
+			middleware(node_request, node_response, done);
+		} catch (error) {
+			reject(error);
+		}
+	});
+}
+
+/**
+ * @param {(request: Request, platform?: any) => Response | Promise<Response>} fetch_handler
+ * @param {ServeOptions} [options]
+ * @returns {{ listen: (port?: number) => import('node:http').Server, close: () => void }}
+ */
+export function serve(fetch_handler, options = {}) {
+	const {
+		port = DEFAULT_PORT,
+		hostname = DEFAULT_HOSTNAME,
+		middleware = null,
+		static: static_options = {},
+	} = options;
+
+	/** @type {ReturnType<typeof serveStatic> | null} */
+	let static_middleware = null;
+	if (static_options !== false) {
+		const { dir = 'public', ...static_handler_options } = static_options;
+		static_middleware = serveStatic(dir, static_handler_options);
+	}
+
+	const server = createServer(async (node_request, node_response) => {
+		const abort_controller = new AbortController();
+
+		node_request.on('aborted', () => {
+			abort_controller.abort();
+		});
+		node_response.on('close', () => {
+			abort_controller.abort();
+		});
+
+		try {
+			const run_fetch_handler = async () => {
+				const request = node_request_to_web_request(node_request, abort_controller.signal);
+				return await fetch_handler(request, { node_request, node_response });
+			};
+
+			let response;
+			if (static_middleware !== null || middleware !== null) {
+				response = await run_next_middleware(
+					async (request, middleware_response, next) => {
+						if (static_middleware !== null) {
+							await run_node_middleware(static_middleware, request, middleware_response);
+							if (middleware_response.writableEnded || middleware_response.headersSent) {
+								return new Response(null, { status: 204 });
+							}
+						}
+
+						if (middleware !== null) {
+							await run_node_middleware(middleware, request, middleware_response);
+							if (middleware_response.writableEnded || middleware_response.headersSent) {
+								return new Response(null, { status: 204 });
+							}
+						}
+
+						return await next();
+					},
+					node_request,
+					node_response,
+					run_fetch_handler,
+				);
+			} else {
+				response = await run_fetch_handler();
+			}
+
+			if (node_response.writableEnded || node_response.headersSent) {
+				return;
+			}
+
+			web_response_to_node_response(
+				response,
+				node_response,
+				(node_request.method ?? 'GET').toUpperCase(),
+			);
+		} catch {
+			if (node_response.headersSent) {
+				node_response.end();
+				return;
+			}
+
+			web_response_to_node_response(
+				internal_server_error_response(),
+				node_response,
+				(node_request.method ?? 'GET').toUpperCase(),
+			);
+		}
+	});
+
+	return {
+		listen(listen_port = port) {
+			server.listen(listen_port, hostname);
+			return server;
+		},
+		close() {
+			server.close();
+		},
+	};
+}
+
+/**
+ * Create a middleware that serves static files from a directory
+ *
+ * @param {string} dir - Directory to serve files from (relative to cwd or absolute)
+ * @param {import('@ripple-ts/adapter').ServeStaticOptions} [options]
+ * @returns {(req: import('node:http').IncomingMessage, res: import('node:http').ServerResponse, next: (error?: any) => void) => void}
+ */
+export function serveStatic(dir, options = {}) {
+	const serve_static_request = create_static_handler(dir, options);
+
+	return function staticMiddleware(req, res, next) {
+		try {
+			const request_method = (req.method ?? 'GET').toUpperCase();
+			if (request_method !== 'GET' && request_method !== 'HEAD') {
+				next();
+				return;
+			}
+
+			const request = node_request_to_web_request(req, new AbortController().signal);
+			const response = serve_static_request(request);
+			if (response === null) {
+				next();
+				return;
+			}
+
+			web_response_to_node_response(response, res, request.method);
+		} catch {
+			next();
+		}
+	};
+}

package/tests/serve.test.js

@@ -0,0 +1,377 @@
+import { request as node_http_request } from 'node:http';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { describe, expect, it, vi } from 'vitest';
+import { serve, serveStatic } from '../src/index.js';
+
+/**
+ * @param {(request: Request, platform?: any) => Response | Promise<Response>} fetch_handler
+ * @param {(base_url: string) => Promise<void>} run
+ * @param {import('../types/index.d.ts').ServeOptions} [options]
+ * @returns {Promise<void>}
+ */
+async function with_server(fetch_handler, run, options = {}) {
+	const app = serve(fetch_handler, { hostname: '127.0.0.1', ...options });
+	const server = app.listen(0);
+
+	await new Promise((resolve, reject) => {
+		server.once('listening', resolve);
+		server.once('error', reject);
+	});
+
+	const address = server.address();
+	if (address == null || typeof address === 'string') {
+		throw new Error('Expected TCP server address');
+	}
+
+	try {
+		await run(`http://127.0.0.1:${address.port}`);
+	} finally {
+		await new Promise((resolve, reject) => {
+			server.close((error) => {
+				if (error) reject(error);
+				else resolve(undefined);
+			});
+		});
+	}
+}
+
+/**
+ * @param {string} cwd
+ * @param {() => Promise<void>} run
+ * @returns {Promise<void>}
+ */
+async function with_cwd(cwd, run) {
+	const previous_cwd = process.cwd();
+	process.chdir(cwd);
+	try {
+		await run();
+	} finally {
+		process.chdir(previous_cwd);
+	}
+}
+
+/**
+ * @param {string} url
+ * @param {{ method?: string, headers?: import('node:http').OutgoingHttpHeaders, body?: string }} [options]
+ * @returns {Promise<{
+ * 	status_code: number,
+ * 	headers: import('node:http').IncomingHttpHeaders,
+ * 	body: string
+ * }>}
+ */
+function send_node_request(url, options = {}) {
+	return new Promise((resolve, reject) => {
+		const request = node_http_request(
+			url,
+			{
+				method: options.method ?? 'GET',
+				headers: options.headers,
+			},
+			(response) => {
+				/** @type {string[]} */
+				const chunks = [];
+				response.setEncoding('utf8');
+				response.on('data', (chunk) => {
+					chunks.push(chunk);
+				});
+				response.on('end', () => {
+					resolve({
+						status_code: response.statusCode ?? 0,
+						headers: response.headers,
+						body: chunks.join(''),
+					});
+				});
+			},
+		);
+
+		request.on('error', reject);
+		if (options.body) {
+			request.write(options.body);
+		}
+		request.end();
+	});
+}
+
+describe('@ripple-ts/adapter-node serve()', () => {
+	it('maps node request values to a web Request and returns response values', async () => {
+		/** @type {{ method: string, url: string, body: string, custom_header: string | null } | null} */
+		let captured = null;
+
+		await with_server(
+			async (request) => {
+				captured = {
+					method: request.method,
+					url: request.url,
+					body: await request.text(),
+					custom_header: request.headers.get('x-custom'),
+				};
+
+				return new Response('created', {
+					status: 201,
+					headers: {
+						'x-response': 'ok',
+					},
+				});
+			},
+			async (base_url) => {
+				const response = await fetch(`${base_url}/users?id=1`, {
+					method: 'POST',
+					headers: {
+						'x-forwarded-proto': 'https, http',
+						'x-forwarded-host': 'example.com, proxy.local',
+						'x-custom': 'abc123',
+					},
+					body: 'payload',
+				});
+
+				expect(response.status).toBe(201);
+				expect(response.headers.get('x-response')).toBe('ok');
+				expect(await response.text()).toBe('created');
+			},
+		);
+
+		expect(captured).toEqual({
+			method: 'POST',
+			url: 'https://example.com/users?id=1',
+			body: 'payload',
+			custom_header: 'abc123',
+		});
+	});
+
+	it('runs middleware before handler when middleware calls next()', async () => {
+		/** @type {string[]} */
+		const calls = [];
+
+		await with_server(
+			() => {
+				calls.push('handler');
+				return new Response('ok');
+			},
+			async (base_url) => {
+				const response = await fetch(base_url);
+				expect(response.status).toBe(200);
+				expect(await response.text()).toBe('ok');
+			},
+			{
+				middleware(req, res, next) {
+					void req;
+					void res;
+					calls.push('middleware');
+					next();
+				},
+			},
+		);
+
+		expect(calls).toEqual(['middleware', 'handler']);
+	});
+
+	it('short-circuits the handler when middleware already handled the response', async () => {
+		const fetch_handler = vi.fn(() => new Response('from-handler'));
+
+		await with_server(
+			fetch_handler,
+			async (base_url) => {
+				const response = await fetch(base_url);
+				expect(response.status).toBe(204);
+				expect(await response.text()).toBe('');
+			},
+			{
+				middleware(req, res, next) {
+					void req;
+					res.statusCode = 204;
+					res.end();
+					next();
+				},
+			},
+		);
+
+		expect(fetch_handler).not.toHaveBeenCalled();
+	});
+
+	it('forwards multiple set-cookie headers', async () => {
+		await with_server(
+			() => {
+				const headers = new Headers();
+				headers.append('set-cookie', 'session=abc; Path=/');
+				headers.append('set-cookie', 'theme=dark; Path=/');
+				return new Response('ok', { headers });
+			},
+			async (base_url) => {
+				const response = await send_node_request(base_url);
+				const set_cookie = response.headers['set-cookie'];
+				const normalized_set_cookie = Array.isArray(set_cookie)
+					? set_cookie.join('\n')
+					: String(set_cookie ?? '');
+
+				expect(response.status_code).toBe(200);
+				expect(normalized_set_cookie).toContain('session=abc');
+				expect(normalized_set_cookie).toContain('theme=dark');
+			},
+		);
+	});
+
+	it('returns internal server error when handler throws', async () => {
+		await with_server(
+			() => {
+				throw new Error('boom');
+			},
+			async (base_url) => {
+				const response = await send_node_request(base_url);
+
+				expect(response.status_code).toBe(500);
+				expect(response.body).toBe('Internal Server Error');
+				expect(response.headers['content-type']).toBe('text/plain; charset=utf-8');
+			},
+		);
+	});
+
+	it('does not write response body for HEAD requests', async () => {
+		/** @type {string | undefined} */
+		let request_method;
+
+		await with_server(
+			(request) => {
+				request_method = request.method;
+				return new Response('body-should-not-be-sent');
+			},
+			async (base_url) => {
+				const response = await fetch(base_url, { method: 'HEAD' });
+
+				expect(response.status).toBe(200);
+				expect(await response.text()).toBe('');
+			},
+		);
+
+		expect(request_method).toBe('HEAD');
+	});
+
+	it('serveStatic middleware serves files and bypasses fetch handler', async () => {
+		const temp_dir = mkdtempSync(join(tmpdir(), 'adapter-node-static-'));
+		try {
+			writeFileSync(join(temp_dir, 'hello.txt'), 'hello static');
+
+			const fetch_handler = vi.fn(() => new Response('fallback', { status: 404 }));
+			await with_server(
+				fetch_handler,
+				async (base_url) => {
+					const response = await fetch(`${base_url}/assets/hello.txt`);
+					expect(response.status).toBe(200);
+					expect(response.headers.get('content-type')).toBe('text/plain; charset=utf-8');
+					expect(await response.text()).toBe('hello static');
+				},
+				{
+					middleware: serveStatic(temp_dir, { prefix: '/assets' }),
+				},
+			);
+
+			expect(fetch_handler).not.toHaveBeenCalled();
+		} finally {
+			rmSync(temp_dir, { recursive: true, force: true });
+		}
+	});
+
+	it('serveStatic middleware falls through when file is missing', async () => {
+		const temp_dir = mkdtempSync(join(tmpdir(), 'adapter-node-static-fallthrough-'));
+		try {
+			const fetch_handler = vi.fn(() => new Response('fallback', { status: 404 }));
+
+			await with_server(
+				fetch_handler,
+				async (base_url) => {
+					const response = await fetch(`${base_url}/assets/missing.txt`);
+					expect(response.status).toBe(404);
+					expect(await response.text()).toBe('fallback');
+				},
+				{
+					middleware: serveStatic(temp_dir, { prefix: '/assets' }),
+				},
+			);
+
+			expect(fetch_handler).toHaveBeenCalledTimes(1);
+		} finally {
+			rmSync(temp_dir, { recursive: true, force: true });
+		}
+	});
+
+	it('serves files from ./public by default', async () => {
+		const temp_dir = mkdtempSync(join(tmpdir(), 'adapter-node-default-static-'));
+		try {
+			const public_dir = join(temp_dir, 'public');
+			mkdirSync(public_dir);
+			writeFileSync(join(public_dir, 'llms.txt'), 'hello llms');
+
+			const fetch_handler = vi.fn(() => new Response('fallback', { status: 404 }));
+
+			await with_cwd(temp_dir, async () => {
+				await with_server(fetch_handler, async (base_url) => {
+					const response = await fetch(`${base_url}/llms.txt`);
+					expect(response.status).toBe(200);
+					expect(await response.text()).toBe('hello llms');
+				});
+			});
+
+			expect(fetch_handler).not.toHaveBeenCalled();
+		} finally {
+			rmSync(temp_dir, { recursive: true, force: true });
+		}
+	});
+
+	it('can disable default static serving via options.static = false', async () => {
+		const temp_dir = mkdtempSync(join(tmpdir(), 'adapter-node-default-static-disabled-'));
+		try {
+			const public_dir = join(temp_dir, 'public');
+			mkdirSync(public_dir);
+			writeFileSync(join(public_dir, 'llms.txt'), 'hello llms');
+
+			const fetch_handler = vi.fn(() => new Response('fallback', { status: 404 }));
+
+			await with_cwd(temp_dir, async () => {
+				await with_server(
+					fetch_handler,
+					async (base_url) => {
+						const response = await fetch(`${base_url}/llms.txt`);
+						expect(response.status).toBe(404);
+						expect(await response.text()).toBe('fallback');
+					},
+					{ static: false },
+				);
+			});
+
+			expect(fetch_handler).toHaveBeenCalledTimes(1);
+		} finally {
+			rmSync(temp_dir, { recursive: true, force: true });
+		}
+	});
+
+	it('serves static files via options.static with custom prefix and cache settings', async () => {
+		const temp_dir = mkdtempSync(join(tmpdir(), 'adapter-node-static-options-'));
+		try {
+			writeFileSync(join(temp_dir, 'asset.txt'), 'asset-data');
+
+			const fetch_handler = vi.fn(() => new Response('fallback', { status: 404 }));
+			await with_server(
+				fetch_handler,
+				async (base_url) => {
+					const response = await fetch(`${base_url}/public/asset.txt`);
+					expect(response.status).toBe(200);
+					expect(response.headers.get('cache-control')).toBe('public, max-age=31536000, immutable');
+					expect(await response.text()).toBe('asset-data');
+				},
+				{
+					static: {
+						dir: temp_dir,
+						prefix: '/public',
+						maxAge: 60,
+						immutable: true,
+					},
+				},
+			);
+
+			expect(fetch_handler).not.toHaveBeenCalled();
+		} finally {
+			rmSync(temp_dir, { recursive: true, force: true });
+		}
+	});
+});

package/tests/types.test.js

@@ -0,0 +1,18 @@
+import { readFileSync } from 'node:fs';
+import { describe, expect, it } from 'vitest';
+
+const types_source = readFileSync(new URL('../types/index.d.ts', import.meta.url), 'utf8');
+
+describe('@ripple-ts/adapter-node types', () => {
+	it('uses shared ServeStaticDirectoryOptions alias from @ripple-ts/adapter', () => {
+		expect(types_source).toContain(
+			'ServeStaticDirectoryOptions as BaseServeStaticDirectoryOptions',
+		);
+		expect(types_source).toContain('static?: BaseServeStaticDirectoryOptions | false;');
+		expect(types_source).toContain('export type ServeStaticOptions = BaseServeStaticOptions;');
+	});
+
+	it('does not inline static dir type shape locally', () => {
+		expect(types_source).not.toMatch(/BaseServeStaticOptions\s*&\s*\{\s*dir\?: string;\s*\}/);
+	});
+});

package/types/index.d.ts

@@ -0,0 +1,39 @@
+import type {
+	AdapterCoreOptions,
+	FetchHandler,
+	ServeResult,
+	ServeStaticOptions as BaseServeStaticOptions,
+	ServeStaticDirectoryOptions as BaseServeStaticDirectoryOptions,
+} from '@ripple-ts/adapter';
+
+export type ServeOptions = AdapterCoreOptions & {
+	middleware?:
+		| ((
+				req: import('node:http').IncomingMessage,
+				res: import('node:http').ServerResponse,
+				next: (error?: any) => void,
+		  ) => void)
+		| null;
+	static?: BaseServeStaticDirectoryOptions | false;
+};
+
+export type ServeStaticOptions = BaseServeStaticOptions;
+
+export type StaticMiddleware = (
+	req: import('node:http').IncomingMessage,
+	res: import('node:http').ServerResponse,
+	next: (error?: any) => void,
+) => void;
+
+export function serve(
+	fetch_handler: FetchHandler<{
+		node_request: import('node:http').IncomingMessage;
+		node_response: import('node:http').ServerResponse;
+	}>,
+	options?: ServeOptions,
+): ServeResult<import('node:http').Server>;
+
+/**
+ * Create a middleware that serves static files from a directory
+ */
+export function serveStatic(dir: string, options?: ServeStaticOptions): StaticMiddleware;