@ripple-ts/adapter-bun 0.2.213 → 0.2.214

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @ripple-ts/adapter-bun
 
+## 0.2.214
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @ripple-ts/adapter@0.2.214
+
 ## 0.2.213
 
 ### Patch Changes

package/package.json

@@ -3,7 +3,7 @@
   "description": "Bun adapter for Ripple metaframework (Web Request/Response bridge)",
   "license": "MIT",
   "author": "Dominic Gannaway",
-  "version": "0.2.213",
+  "version": "0.2.214",
   "type": "module",
   "module": "src/index.js",
   "main": "src/index.js",
@@ -15,9 +15,12 @@
     }
   },
   "dependencies": {
-    "@ripple-ts/adapter": "0.2.213"
+    "@ripple-ts/adapter": "0.2.214"
   },
-  "homepage": "https://ripplejs.com",
+  "devDependencies": {
+    "@types/bun": "^1.3.9"
+  },
+  "homepage": "https://ripple-ts.com",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Ripple-TS/ripple.git",

package/src/index.js

@@ -4,13 +4,46 @@
 import {
 	DEFAULT_HOSTNAME,
 	DEFAULT_PORT,
+	DEFAULT_STATIC_PREFIX,
+	DEFAULT_STATIC_MAX_AGE,
+	get_mime_type,
+	get_static_cache_control,
 	internal_server_error_response,
 	run_next_middleware,
-	serveStatic as create_static_handler,
 } from '@ripple-ts/adapter';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { resolve, sep } from 'node:path';
 
 /** @typedef {import('@ripple-ts/adapter').ServeStaticDirectoryOptions} StaticServeOptions */
 
+// ============================================================================
+// Runtime primitives — platform-specific capabilities for Ripple's server runtime
+// ============================================================================
+
+/**
+ * Bun runtime primitives for the Ripple adapter contract.
+ *
+ * Provides:
+ * - `hash`: SHA-256 hex digest truncated to 8 chars via Bun.CryptoHasher
+ * - `createAsyncContext`: AsyncLocalStorage-backed request-scoped context
+ *
+ * @type {import('@ripple-ts/adapter').RuntimePrimitives}
+ */
+export const runtime = {
+	hash(str) {
+		const hasher = new globalThis.Bun.CryptoHasher('sha256');
+		hasher.update(str);
+		return hasher.digest('hex').slice(0, 8);
+	},
+	createAsyncContext() {
+		const als = new AsyncLocalStorage();
+		return {
+			run: (store, fn) => als.run(store, fn),
+			getStore: () => als.getStore(),
+		};
+	},
+};
+
 /**
  * @typedef {{
  * 	port?: number,
@@ -40,7 +73,7 @@ export function serve(fetch_handler, options = {}) {
 	/** @type {ReturnType<typeof serveStatic> | null} */
 	let static_middleware = null;
 	if (static_options !== false) {
-		const { dir = 'public', ...static_handler_options } = static_options;
+		const { dir = '.', ...static_handler_options } = static_options;
 		static_middleware = serveStatic(dir, static_handler_options);
 	}
 
@@ -104,16 +137,63 @@ export function serve(fetch_handler, options = {}) {
  * @returns {(request: Request, server: Server, next: () => Promise<Response>) => Promise<Response>}
  */
 export function serveStatic(dir, options = {}) {
-	const serve_static_request = create_static_handler(dir, options);
+	const {
+		prefix = DEFAULT_STATIC_PREFIX,
+		maxAge = DEFAULT_STATIC_MAX_AGE,
+		immutable = false,
+	} = options;
+
+	const base_dir = resolve(dir);
 
 	return async function static_middleware(request, server, next) {
 		void server;
 
-		const response = serve_static_request(request);
-		if (response !== null) {
-			return response;
+		const request_method = (request.method || 'GET').toUpperCase();
+		if (request_method !== 'GET' && request_method !== 'HEAD') {
+			return await next();
+		}
+
+		let pathname;
+		try {
+			pathname = decodeURIComponent(new URL(request.url, 'http://localhost').pathname);
+		} catch {
+			return await next();
+		}
+
+		if (!pathname.startsWith(prefix)) {
+			return await next();
+		}
+
+		pathname = pathname.slice(prefix.length) || '/';
+		if (!pathname.startsWith('/')) {
+			pathname = '/' + pathname;
+		}
+
+		const file_path = resolve(base_dir, `.${pathname}`);
+		const is_within_base_dir = file_path === base_dir || file_path.startsWith(base_dir + sep);
+		if (!is_within_base_dir) {
+			return await next();
+		}
+
+		const bun_file = globalThis.Bun.file(file_path);
+		if (!(await bun_file.exists())) {
+			return await next();
+		}
+
+		// Bun.file().size is 0 for directories; skip them
+		if (bun_file.size === 0) {
+			return await next();
+		}
+
+		const headers = new Headers();
+		headers.set('Content-Type', get_mime_type(file_path));
+		headers.set('Content-Length', String(bun_file.size));
+		headers.set('Cache-Control', get_static_cache_control(pathname, maxAge, immutable));
+
+		if (request_method === 'HEAD') {
+			return new Response(null, { status: 200, headers });
 		}
 
-		return await next();
+		return new Response(bun_file, { status: 200, headers });
 	};
 }

package/tests/serve.test.js

@@ -1,17 +1,86 @@
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import {
+	existsSync,
+	mkdirSync,
+	mkdtempSync,
+	readFileSync,
+	rmSync,
+	statSync,
+	writeFileSync,
+} from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { afterEach, describe, expect, it, vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { serve, serveStatic } from '../src/index.js';
 
-/** @type {any} */
-const original_bun = globalThis.Bun;
+const original_bun = Reflect.get(globalThis, 'Bun');
+
+/**
+ * Create a mock for Bun.file() that uses node:fs under the hood.
+ * Returns a Blob-like object so `new Response(bun_file)` works correctly.
+ *
+ * @param {string | URL} file_path
+ */
+function mock_bun_file(file_path) {
+	file_path = String(file_path);
+	const file_exists = existsSync(file_path);
+	const stats = file_exists ? statSync(file_path) : null;
+	const is_dir = stats?.isDirectory() ?? false;
+
+	if (!file_exists || is_dir) {
+		return {
+			exists: async () => false,
+			size: 0,
+		};
+	}
+
+	const content = readFileSync(file_path);
+	const blob = new Blob([content]);
+
+	// Attach Bun.file-specific methods onto the Blob so it can act as both
+	// a BodyInit (Blob) and a BunFile (exists/size).
+	const bun_file = Object.assign(blob, {
+		exists: /** @returns {Promise<boolean>} */ async () => true,
+	});
+	const file_size = /** @type {import('node:fs').Stats} */ (stats).size;
+	Object.defineProperty(bun_file, 'size', { value: file_size });
+	return bun_file;
+}
+
+/**
+ * Ensure globalThis.Bun has at least the `file` mock.
+ */
+function ensure_bun_file_mock() {
+	const bun = Reflect.get(globalThis, 'Bun');
+	if (!bun) {
+		Object.defineProperty(globalThis, 'Bun', {
+			value: { file: mock_bun_file },
+			writable: true,
+			configurable: true,
+		});
+		return;
+	}
+	if (!bun.file) {
+		Object.defineProperty(bun, 'file', {
+			value: mock_bun_file,
+			writable: true,
+			configurable: true,
+		});
+	}
+}
+
+beforeEach(() => {
+	ensure_bun_file_mock();
+});
 
 afterEach(() => {
 	if (original_bun === undefined) {
 		Reflect.deleteProperty(globalThis, 'Bun');
 	} else {
-		globalThis.Bun = original_bun;
+		Object.defineProperty(globalThis, 'Bun', {
+			value: original_bun,
+			writable: true,
+			configurable: true,
+		});
 	}
 	vi.restoreAllMocks();
 });
@@ -33,9 +102,11 @@ function create_bun_mock() {
 		return server;
 	});
 
-	globalThis.Bun = {
-		serve: serve_spy,
-	};
+	Object.defineProperty(globalThis, 'Bun', {
+		value: { serve: serve_spy, file: mock_bun_file },
+		writable: true,
+		configurable: true,
+	});
 
 	return {
 		serve_spy,
@@ -165,7 +236,7 @@ describe('@ripple-ts/adapter-bun serve()', () => {
 
 			const response = await static_middleware(
 				new Request('http://localhost/assets/app.js'),
-				/** @type {any} */ ({}),
+				/** @type {import('bun').Server<undefined>} */ ({}),
 				next,
 			);
 
@@ -186,7 +257,7 @@ describe('@ripple-ts/adapter-bun serve()', () => {
 
 			const response = await static_middleware(
 				new Request('http://localhost/assets/missing.js'),
-				/** @type {any} */ ({}),
+				/** @type {import('bun').Server<undefined>} */ ({}),
 				next,
 			);
 
@@ -197,12 +268,10 @@ describe('@ripple-ts/adapter-bun serve()', () => {
 		}
 	});
 
-	it('serves files from ./public by default', async () => {
-		const temp_dir = mkdtempSync(join(tmpdir(), 'adapter-bun-default-static-'));
+	it('serves files from ./ by default', async () => {
+		const temp_dir = mkdtempSync(join(tmpdir(), 'adapter-bun-default-static-dir'));
 		try {
-			const public_dir = join(temp_dir, 'public');
-			mkdirSync(public_dir);
-			writeFileSync(join(public_dir, 'llms.txt'), 'hello llms');
+			writeFileSync(join(temp_dir, 'llms.txt'), 'hello llms');
 
 			await with_cwd(temp_dir, async () => {
 				const { server, get_fetch } = create_bun_mock();
@@ -221,11 +290,9 @@ describe('@ripple-ts/adapter-bun serve()', () => {
 	});
 
 	it('can disable default static serving via options.static = false', async () => {
-		const temp_dir = mkdtempSync(join(tmpdir(), 'adapter-bun-default-static-disabled-'));
+		const temp_dir = mkdtempSync(join(tmpdir(), 'adapter-bun-default-static-disabled-dir'));
 		try {
-			const public_dir = join(temp_dir, 'public');
-			mkdirSync(public_dir);
-			writeFileSync(join(public_dir, 'llms.txt'), 'hello llms');
+			writeFileSync(join(temp_dir, 'llms.txt'), 'hello llms');
 
 			await with_cwd(temp_dir, async () => {
 				const { server, get_fetch } = create_bun_mock();

package/types/index.d.ts

@@ -1,11 +1,20 @@
 import type {
 	AdapterCoreOptions,
 	NextMiddleware,
+	RuntimePrimitives,
 	ServeFunction,
 	ServeStaticOptions as BaseServeStaticOptions,
 	ServeStaticDirectoryOptions as BaseServeStaticDirectoryOptions,
 } from '@ripple-ts/adapter';
 
+/**
+ * Bun runtime primitives for the Ripple adapter contract.
+ *
+ * - `hash`: SHA-256 (truncated to 8 hex chars) via `Bun.CryptoHasher`
+ * - `createAsyncContext`: `AsyncLocalStorage` from `node:async_hooks` (Bun-compatible)
+ */
+export const runtime: RuntimePrimitives;
+
 export type ServeOptions = AdapterCoreOptions & {
 	middleware?: NextMiddleware<Request, any> | null;
 	static?: BaseServeStaticDirectoryOptions | false;