@lovrozagar/honey 0.1.0

package/src/server-timing.ts

@@ -0,0 +1,66 @@
+import type { MiddlewareFn } from "./middleware.ts"
+
+export type Timing = {
+	end(name: string): void
+	start(name: string, description?: string): void
+}
+
+type TimingEntry = {
+	description?: string
+	end?: number
+	start: number
+}
+
+/** Strip characters that would break Server-Timing header syntax */
+const unsafeNameRe = /[;,="]/g
+function sanitizeName(name: string): string {
+	return name.replace(unsafeNameRe, "")
+}
+
+function escapeDescription(desc: string): string {
+	return desc.replace(/\\/g, "\\\\").replace(/"/g, '\\"')
+}
+
+export function serverTiming(): MiddlewareFn<{}, { timing: Timing }> {
+	const mw: MiddlewareFn<{}, { timing: Timing }> = async (_ctx, next) => {
+		const requestStart = performance.now()
+		const entries = new Map<string, TimingEntry>()
+
+		const timing: Timing = {
+			end(name: string) {
+				const entry = entries.get(name)
+				if (entry) {
+					entry.end = performance.now()
+				}
+			},
+			start(name: string, description?: string) {
+				entries.set(name, { description, start: performance.now() })
+			},
+		}
+
+		const response = await next({ timing })
+
+		/* auto-close any unclosed timings */
+		const now = performance.now()
+		const parts: string[] = []
+		for (const [name, entry] of entries) {
+			const dur = ((entry.end ?? now) - entry.start).toFixed(2)
+			let part = sanitizeName(name)
+			if (entry.description) {
+				part += `;desc="${escapeDescription(entry.description)}"`
+			}
+			part += `;dur=${dur}`
+			parts.push(part)
+		}
+
+		/* always include total request duration */
+		const totalDur = (performance.now() - requestStart).toFixed(2)
+		parts.push(`total;dur=${totalDur}`)
+
+		response.headers.set("server-timing", parts.join(", "))
+
+		return response
+	}
+
+	return mw
+}

package/src/static.ts

@@ -0,0 +1,60 @@
+import type { MiddlewareFn } from "./middleware.ts"
+
+type StaticConfig<TCtx> = {
+	resolve: (ctx: TCtx, filePath: string) => Response | null | Promise<Response | null>
+	prefix?: string
+	headers?: Record<string, string> | ((filePath: string) => Record<string, string>)
+	rewritePath?: (filePath: string, ctx: TCtx) => string
+}
+
+const TRAVERSAL = /(?:^|\/)\.\.\//
+
+export function staticFiles<TCtx extends { req: Request }>(
+	config: StaticConfig<TCtx>,
+): MiddlewareFn<TCtx, {}> {
+	const prefix = config.prefix ?? "/"
+
+	const mw: MiddlewareFn<TCtx, {}> = async (ctx, next) => {
+		const method = ctx.req.method
+		if (method !== "GET" && method !== "HEAD") return next()
+
+		/* fast path extraction — no new URL() */
+		const raw = ctx.req.url
+		const protoEnd = raw.indexOf("//")
+		const pathStart = protoEnd === -1 ? 0 : raw.indexOf("/", protoEnd + 2)
+		const qIdx = pathStart === -1 ? -1 : raw.indexOf("?", pathStart)
+		let path: string
+		if (pathStart === -1) {
+			path = "/"
+		} else if (qIdx === -1) {
+			path = raw.substring(pathStart)
+		} else {
+			path = raw.substring(pathStart, qIdx)
+		}
+
+		if (!path.startsWith(prefix)) return next()
+
+		const stripped = prefix === "/" ? path : path.substring(prefix.length)
+		const filePath = stripped === "" ? "/" : stripped
+
+		/* path traversal guard — reject encoded and literal .. segments */
+		const decoded = decodeURIComponent(filePath)
+		if (TRAVERSAL.test(decoded)) return next()
+
+		const resolved = config.rewritePath ? config.rewritePath(filePath, ctx) : filePath
+		const response = await config.resolve(ctx, resolved)
+		if (response === null) return next()
+
+		/* apply extra headers */
+		if (config.headers) {
+			const extra = typeof config.headers === "function" ? config.headers(filePath) : config.headers
+			for (const key in extra) {
+				response.headers.set(key, extra[key])
+			}
+		}
+
+		return response
+	}
+
+	return mw
+}

package/src/telemetry/otel.ts

@@ -0,0 +1,139 @@
+import type { HoneyError } from "../error.ts"
+
+type Span = {
+	addEvent(name: string, attributes?: Record<string, unknown>): void
+	end(): void
+	setAttribute(key: string, value: unknown): void
+}
+
+type Tracer = {
+	startSpan(name: string): Span
+}
+
+type TelemetryAdapter = {
+	onError?(ctx: { duration: number; error: HoneyError; method: string; path: string }): void
+	onHandler?(ctx: { duration: number; method: string; path: string; status: number }): void
+	onMethodNotAllowed?(ctx: { allowed: string[]; method: string; path: string; req: Request }): void
+	onMiddleware?(ctx: { duration: number; error?: unknown; name: string }): void
+	onNotFound?(ctx: { method: string; path: string; req: Request }): void
+	onRequest?(ctx: { env: unknown; req: Request }): void
+	onResponse?(ctx: { duration: number; req: Request; status: number }): void
+	onRoute?(ctx: {
+		method: string
+		params: Record<string, string>
+		path: string
+		req: Request
+	}): void
+}
+
+export function otelAdapter(options: { tracer: Tracer }): TelemetryAdapter {
+	const spans = new WeakMap<Request, Span>()
+
+	return {
+		onError(ctx) {
+			try {
+				/*
+				 * onError doesn't receive req — error details are best captured
+				 * via a standalone span. Per-request root span is in onResponse.
+				 */
+				const span = options.tracer.startSpan("http.error")
+				span.setAttribute("error.key", ctx.error.errorKey)
+				span.setAttribute("error.status", ctx.error.status)
+				span.setAttribute("http.duration_ms", ctx.duration)
+				span.end()
+			} catch {
+				/* swallow */
+			}
+		},
+
+		onHandler(ctx) {
+			try {
+				const span = options.tracer.startSpan("http.handler")
+				span.setAttribute("http.method", ctx.method)
+				span.setAttribute("http.route", ctx.path)
+				span.setAttribute("http.status_code", ctx.status)
+				span.setAttribute("http.duration_ms", ctx.duration)
+				span.end()
+			} catch {
+				/* swallow */
+			}
+		},
+
+		onMethodNotAllowed(ctx) {
+			try {
+				const span = spans.get(ctx.req)
+				if (span) {
+					span.addEvent("method_not_allowed", {
+						"http.allowed_methods": ctx.allowed.join(", "),
+						"http.method": ctx.method,
+						"http.route": ctx.path,
+					})
+				}
+			} catch {
+				/* swallow */
+			}
+		},
+
+		onMiddleware(ctx) {
+			try {
+				const span = options.tracer.startSpan(`middleware.${ctx.name}`)
+				span.setAttribute("middleware.name", ctx.name)
+				span.setAttribute("middleware.duration_ms", ctx.duration)
+				if (ctx.error) span.addEvent("error")
+				span.end()
+			} catch {
+				/* swallow */
+			}
+		},
+
+		onNotFound(ctx) {
+			try {
+				const span = spans.get(ctx.req)
+				if (span) {
+					span.addEvent("not_found", {
+						"http.method": ctx.method,
+						"http.path": ctx.path,
+					})
+				}
+			} catch {
+				/* swallow */
+			}
+		},
+
+		onRequest(ctx) {
+			try {
+				const span = options.tracer.startSpan("http.request")
+				span.setAttribute("http.url", ctx.req.url)
+				spans.set(ctx.req, span)
+			} catch {
+				/* swallow */
+			}
+		},
+
+		onResponse(ctx) {
+			try {
+				const span = spans.get(ctx.req)
+				if (span) {
+					span.setAttribute("http.status_code", ctx.status)
+					span.setAttribute("http.duration_ms", ctx.duration)
+					span.end()
+					spans.delete(ctx.req)
+				}
+			} catch {
+				/* swallow */
+			}
+		},
+
+		onRoute(ctx) {
+			try {
+				const span = spans.get(ctx.req)
+				if (span) {
+					span.setAttribute("http.method", ctx.method)
+					span.setAttribute("http.route", ctx.path)
+				}
+			} catch {
+				/* swallow */
+			}
+		},
+	}
+}

package/src/testing.ts

@@ -0,0 +1,114 @@
+import type { Honey } from "./index.ts"
+
+type TestRequestOptions = {
+	form?: Record<string, string>
+	headers?: Record<string, string>
+	json?: unknown
+	search?: Record<string, string>
+}
+
+type TestClient = {
+	delete(path: string, opts?: TestRequestOptions): Promise<Response>
+	get(path: string, opts?: TestRequestOptions): Promise<Response>
+	head(path: string, opts?: TestRequestOptions): Promise<Response>
+	options(path: string, opts?: TestRequestOptions): Promise<Response>
+	patch(path: string, opts?: TestRequestOptions): Promise<Response>
+	post(path: string, opts?: TestRequestOptions): Promise<Response>
+	put(path: string, opts?: TestRequestOptions): Promise<Response>
+	request(method: string, path: string, opts?: TestRequestOptions): Promise<Response>
+}
+
+function buildRequest(
+	method: string,
+	path: string,
+	baseUrl: string,
+	opts?: TestRequestOptions,
+): Request {
+	const url = new URL(path, baseUrl)
+
+	if (opts?.search) {
+		for (const [k, v] of Object.entries(opts.search)) {
+			url.searchParams.set(k, v)
+		}
+	}
+
+	const headers = new Headers(opts?.headers)
+	let body: BodyInit | null = null
+
+	if (opts?.json !== undefined) {
+		headers.set("content-type", "application/json")
+		body = JSON.stringify(opts.json)
+	} else if (opts?.form) {
+		const formData = new FormData()
+		for (const [k, v] of Object.entries(opts.form)) {
+			formData.append(k, v)
+		}
+		body = formData
+	}
+
+	return new Request(url.toString(), { body, headers, method })
+}
+
+type TestClientOptions<TEnv> = {
+	cookies?: boolean
+	env: TEnv
+}
+
+function parseCookieName(setCookie: string): { name: string; value: string } | null {
+	const eq = setCookie.indexOf("=")
+	if (eq === -1) return null
+	const name = setCookie.slice(0, eq).trim()
+	const semi = setCookie.indexOf(";", eq)
+	const value = semi === -1 ? setCookie.slice(eq + 1) : setCookie.slice(eq + 1, semi)
+	return { name, value }
+}
+
+export function testClient<TEnv>(
+	app: Honey<TEnv, unknown, unknown, unknown, unknown, string, string>,
+	options: TestClientOptions<TEnv>,
+): TestClient {
+	const baseUrl = "http://localhost"
+	const jar = new Map<string, string>()
+
+	async function doRequest(
+		method: string,
+		path: string,
+		opts?: TestRequestOptions,
+	): Promise<Response> {
+		const mergedHeaders = { ...opts?.headers }
+
+		if (options.cookies && jar.size > 0) {
+			const existing = mergedHeaders.cookie ?? ""
+			const jarStr = Array.from(jar.entries())
+				.map(([k, v]) => `${k}=${v}`)
+				.join("; ")
+			mergedHeaders.cookie = existing ? `${existing}; ${jarStr}` : jarStr
+		}
+
+		const req = buildRequest(method, path, baseUrl, { ...opts, headers: mergedHeaders })
+		const res = await app.fetch(req, options.env)
+
+		if (options.cookies) {
+			const setCookies = res.headers.getSetCookie()
+			for (const sc of setCookies) {
+				const parsed = parseCookieName(sc)
+				if (parsed) {
+					jar.set(parsed.name, parsed.value)
+				}
+			}
+		}
+
+		return res
+	}
+
+	return {
+		delete: (path, opts) => doRequest("DELETE", path, opts),
+		get: (path, opts) => doRequest("GET", path, opts),
+		head: (path, opts) => doRequest("HEAD", path, opts),
+		options: (path, opts) => doRequest("OPTIONS", path, opts),
+		patch: (path, opts) => doRequest("PATCH", path, opts),
+		post: (path, opts) => doRequest("POST", path, opts),
+		put: (path, opts) => doRequest("PUT", path, opts),
+		request: (method, path, opts) => doRequest(method, path, opts),
+	}
+}

package/src/timeout.ts

@@ -0,0 +1,36 @@
+import { HoneyError } from "./error.ts"
+import type { MiddlewareFn } from "./middleware.ts"
+import { EK, SK } from "./types.ts"
+
+type TimeoutOptions = {
+	duration: number
+}
+
+export function timeout(opts: TimeoutOptions): MiddlewareFn<{}, {}> {
+	const { duration } = opts
+
+	const mw: MiddlewareFn<{}, {}> = (_ctx, next) => {
+		return new Promise<Response>((resolve, reject) => {
+			const timer = setTimeout(() => {
+				reject(
+					new HoneyError({
+						errorKey: EK.request_timeout,
+						status: SK.gateway_timeout,
+					}),
+				)
+			}, duration)
+
+			Promise.resolve(next())
+				.then((res) => {
+					clearTimeout(timer)
+					resolve(res)
+				})
+				.catch((err) => {
+					clearTimeout(timer)
+					reject(err)
+				})
+		})
+	}
+
+	return mw
+}