@lovrozagar/honey 0.1.0 → 0.2.0

package/src/context.ts

@@ -1,21 +1,21 @@
-import { isNodeOutbound } from "./honey-response.ts";
-import type { SSEOptions, SSEStream, TypedResponse } from "./response.ts";
-import { HoneyRes } from "./response.ts";
-import type { PendingTap } from "./types.ts";
-import { EMPTY_OBJ } from "./types.ts";
-import { parseCookies } from "./validation.ts";
+import { isNodeOutbound } from "./honey-response.ts"
+import type { SSEOptions, SSEStream, TypedResponse } from "./response.ts"
+import { HoneyRes } from "./response.ts"
+import type { PendingTap } from "./types.ts"
+import { EMPTY_OBJ } from "./types.ts"
+import { parseCookies } from "./validation.ts"
 
 /**
  * Per-request res with lazy lastEventId — only reads the header when SSE is actually called.
  * All non-SSE methods (json/text/html/etc) are inherited from HoneyRes with zero overhead.
  */
 class ContextRes extends HoneyRes {
-	private _req: Request;
-	private _lastEventId: string | undefined | false = false;
+	private _req: Request
+	private _lastEventId: string | undefined | false = false
 
 	constructor(req: Request) {
-		super(isNodeOutbound(req));
-		this._req = req;
+		super(isNodeOutbound(req))
+		this._req = req
 	}
 
 	override sse(
@@ -23,35 +23,35 @@ class ContextRes extends HoneyRes {
 		opts?: SSEOptions,
 	): TypedResponse<"text/event-stream", "ok"> {
 		if (this._lastEventId === false) {
-			this._lastEventId = this._req.headers.get("last-event-id") ?? undefined;
+			this._lastEventId = this._req.headers.get("last-event-id") ?? undefined
 		}
 		return super.sse(callback, {
 			...opts,
 			lastEventId: opts?.lastEventId ?? this._lastEventId,
-		});
+		})
 	}
 }
 function parseSearch(ctx: HoneyContext): void {
-	const url = ctx._lzUrlFn ? ctx._lzUrlFn() : new URL(ctx.req.url);
-	const first: Record<string, string> = {};
-	const all: Record<string, string[]> = {};
+	const url = ctx._lzUrlFn ? ctx._lzUrlFn() : new URL(ctx.req.url)
+	const first: Record<string, string> = {}
+	const all: Record<string, string[]> = {}
 	for (const [key, value] of url.searchParams) {
 		if (first[key] === undefined) {
-			first[key] = value;
-			all[key] = [value];
+			first[key] = value
+			all[key] = [value]
 		} else {
-			const values = all[key];
+			const values = all[key]
 			if (values) {
-				values.push(value);
+				values.push(value)
 			}
 		}
 	}
-	ctx._lzSearch = first;
-	ctx._lzSearchAll = all;
+	ctx._lzSearch = first
+	ctx._lzSearchAll = all
 }
 
 function bgSwallow(p: Promise<unknown>) {
-	p.catch(noop);
+	p.catch(noop)
 }
 function noop() {}
 
@@ -64,98 +64,94 @@ function noop() {}
  * works structurally for ApplyOutput type narrowing.
  */
 export class HoneyContext<TEnv = Record<string, unknown>> {
-	readonly background: (p: Promise<unknown>) => void;
-	readonly env: TEnv;
-	readonly params: Record<string, string>;
-	readonly req: Request;
-	readonly res: HoneyRes;
+	readonly background: (p: Promise<unknown>) => void
+	readonly env: TEnv
+	readonly params: Record<string, string>
+	readonly req: Request
+	readonly res: HoneyRes
 
 	/* set after construction — declare keeps them off the private brand */
-	declare readonly cookies: Record<string, string>;
-	declare readonly errors: Record<string, (...args: never[]) => unknown>;
-	declare readonly executionCtx:
-		| { waitUntil?: (p: Promise<unknown>) => void }
-		| undefined;
-	declare readonly headers: Record<string, string>;
-	declare readonly meta: Record<string, unknown>;
-	declare readonly path: string;
-	declare readonly realtime: { publish(topic: string, data: unknown): void };
-	declare readonly routePattern: string;
-	declare readonly search: Record<string, string>;
-	declare readonly searchAll: Record<string, string[]>;
+	declare readonly cookies: Record<string, string>
+	declare readonly errors: Record<string, (...args: never[]) => unknown>
+	declare readonly executionCtx: { waitUntil?: (p: Promise<unknown>) => void } | undefined
+	declare readonly headers: Record<string, string>
+	declare readonly meta: Record<string, unknown>
+	declare readonly path: string
+	declare readonly realtime: { publish(topic: string, data: unknown): void }
+	declare readonly routePattern: string
+	declare readonly search: Record<string, string>
+	declare readonly searchAll: Record<string, string[]>
 
 	/* backing state for lazy getters — stored directly on instance to avoid extra object allocation */
-	/** @internal */ _lzCookies: Record<string, string> | null;
-	/** @internal */ _lzHeaders: Record<string, string> | null;
-	/** @internal */ _lzSearch: Record<string, string> | null;
-	/** @internal */ _lzSearchAll: Record<string, string[]> | null;
-	/** @internal */ _lzUrlFn: (() => URL) | null;
+	/** @internal */ _lzCookies: Record<string, string> | null
+	/** @internal */ _lzHeaders: Record<string, string> | null
+	/** @internal */ _lzSearch: Record<string, string> | null
+	/** @internal */ _lzSearchAll: Record<string, string[]> | null
+	/** @internal */ _lzUrlFn: (() => URL) | null
 
 	/* error propagation — lets handler errors flow back through middleware chain */
-	/** @internal */ _errorToResponse:
-		| ((thrown: unknown) => Promise<Response>)
-		| null;
-	/** @internal */ _isErrorResponse: boolean;
+	/** @internal */ _errorToResponse: ((thrown: unknown) => Promise<Response>) | null
+	/** @internal */ _isErrorResponse: boolean
 
 	/* tap side-effects — queued by c.tap(), drained after handler */
-	/** @internal */ _pendingTaps: PendingTap[] | null;
+	/** @internal */ _pendingTaps: PendingTap[] | null
 
 	constructor(opts: {
-		env: TEnv;
-		executionCtx?: { waitUntil?: (p: Promise<unknown>) => void };
-		meta?: Record<string, unknown>;
-		params: Record<string, string>;
-		path?: string;
-		req: Request;
-		routePattern?: string;
-		urlFn?: () => URL;
+		env: TEnv
+		executionCtx?: { waitUntil?: (p: Promise<unknown>) => void }
+		meta?: Record<string, unknown>
+		params: Record<string, string>
+		path?: string
+		req: Request
+		routePattern?: string
+		urlFn?: () => URL
 	}) {
-		this.req = opts.req;
-		this.env = opts.env;
-		this.params = opts.params;
-		this.res = new ContextRes(opts.req);
+		this.req = opts.req
+		this.env = opts.env
+		this.params = opts.params
+		this.res = new ContextRes(opts.req)
 
 		/* direct assignment — no defineProperty */
-		(this as Record<string, unknown>)["executionCtx"] = opts.executionCtx;
-		(this as Record<string, unknown>)["path"] = opts.path ?? "";
-		(this as Record<string, unknown>)["routePattern"] = opts.routePattern ?? "";
-		(this as Record<string, unknown>)["meta"] = opts.meta ?? EMPTY_OBJ;
+		;(this as Record<string, unknown>)["executionCtx"] = opts.executionCtx
+		;(this as Record<string, unknown>)["path"] = opts.path ?? ""
+		;(this as Record<string, unknown>)["routePattern"] = opts.routePattern ?? ""
+		;(this as Record<string, unknown>)["meta"] = opts.meta ?? EMPTY_OBJ
 
 		/* invoke through executionCtx so `this` binds to the owning object — workerd's native ExecutionContext.waitUntil throws "Illegal invocation" when called detached */
-		const executionCtx = opts.executionCtx;
-		const waitUntil = executionCtx?.waitUntil;
+		const executionCtx = opts.executionCtx
+		const waitUntil = executionCtx?.waitUntil
 		this.background = waitUntil
 			? (p: Promise<unknown>) => {
-					waitUntil.call(executionCtx, p);
+					waitUntil.call(executionCtx, p)
 				}
-			: bgSwallow;
+			: bgSwallow
 
 		/* lazy getter backing — flat on instance, no extra object */
-		this._lzCookies = null;
-		this._lzHeaders = null;
-		this._lzSearch = null;
-		this._lzSearchAll = null;
-		this._lzUrlFn = opts.urlFn ?? null;
+		this._lzCookies = null
+		this._lzHeaders = null
+		this._lzSearch = null
+		this._lzSearchAll = null
+		this._lzUrlFn = opts.urlFn ?? null
 
 		/* error propagation */
-		this._errorToResponse = null;
-		this._isErrorResponse = false;
+		this._errorToResponse = null
+		this._isErrorResponse = false
 
 		/* taps */
-		this._pendingTaps = null;
+		this._pendingTaps = null
 	}
 
 	/** @internal */
 	_setErrors(errors: Record<string, (...args: never[]) => unknown>): void {
-		(this as { errors: typeof errors }).errors = errors;
+		;(this as { errors: typeof errors }).errors = errors
 	}
 
 	/** Queue a side-effect to fire after handler returns successfully */
 	tap(key: string, payload: unknown): void {
 		if (this._pendingTaps === null) {
-			this._pendingTaps = [{ key, payload }];
+			this._pendingTaps = [{ key, payload }]
 		} else {
-			this._pendingTaps.push({ key, payload });
+			this._pendingTaps.push({ key, payload })
 		}
 	}
 
@@ -167,44 +163,44 @@ export class HoneyContext<TEnv = Record<string, unknown>> {
 			enumerable: true,
 			get(this: HoneyContext): Record<string, string> {
 				if (this._lzCookies === null) {
-					this._lzCookies = parseCookies(this.req.headers.get("cookie") ?? "");
+					this._lzCookies = parseCookies(this.req.headers.get("cookie") ?? "")
 				}
-				return this._lzCookies;
+				return this._lzCookies
 			},
-		});
+		})
 		Object.defineProperty(HoneyContext.prototype, "headers", {
 			configurable: true,
 			enumerable: true,
 			get(this: HoneyContext): Record<string, string> {
 				if (this._lzHeaders === null) {
-					const h: Record<string, string> = {};
+					const h: Record<string, string> = {}
 					this.req.headers.forEach((value, key) => {
-						h[key] = value;
-					});
-					this._lzHeaders = h;
+						h[key] = value
+					})
+					this._lzHeaders = h
 				}
-				return this._lzHeaders;
+				return this._lzHeaders
 			},
-		});
+		})
 		Object.defineProperty(HoneyContext.prototype, "search", {
 			configurable: true,
 			enumerable: true,
 			get(this: HoneyContext): Record<string, string> {
 				if (this._lzSearch === null) {
-					parseSearch(this);
+					parseSearch(this)
 				}
-				return this._lzSearch as Record<string, string>;
+				return this._lzSearch as Record<string, string>
 			},
-		});
+		})
 		Object.defineProperty(HoneyContext.prototype, "searchAll", {
 			configurable: true,
 			enumerable: true,
 			get(this: HoneyContext): Record<string, string[]> {
 				if (this._lzSearchAll === null) {
-					parseSearch(this);
+					parseSearch(this)
 				}
-				return this._lzSearchAll as Record<string, string[]>;
+				return this._lzSearchAll as Record<string, string[]>
 			},
-		});
+		})
 	}
 }

package/src/cookie-sign.ts

@@ -1,13 +1,10 @@
 const encoder = new TextEncoder()
 
 function importKey(secret: string): Promise<CryptoKey> {
-	return crypto.subtle.importKey(
-		"raw",
-		encoder.encode(secret),
-		{ hash: "SHA-256", name: "HMAC" },
-		false,
-		["sign", "verify"],
-	)
+	return crypto.subtle.importKey("raw", encoder.encode(secret), { hash: "SHA-256", name: "HMAC" }, false, [
+		"sign",
+		"verify",
+	])
 }
 
 function toBase64Url(buffer: ArrayBuffer): string {
@@ -45,12 +42,7 @@ export async function verify(signed: string, secrets: string[]): Promise<string
 
 	for (const secret of secrets) {
 		const key = await importKey(secret)
-		const valid = await crypto.subtle.verify(
-			"HMAC",
-			key,
-			sig.buffer as ArrayBuffer,
-			encoder.encode(value),
-		)
+		const valid = await crypto.subtle.verify("HMAC", key, sig.buffer as ArrayBuffer, encoder.encode(value))
 		if (valid) return value
 	}
 

package/src/cookie.ts

@@ -83,7 +83,6 @@ export function serializeCookie(name: string, opts: CookieOptions): string {
 	}
 	if (opts.httpOnly) cookie += "; HttpOnly"
 	if (secure) cookie += "; Secure"
-	if (opts.sameSite)
-		cookie += `; SameSite=${opts.sameSite.charAt(0).toUpperCase()}${opts.sameSite.slice(1)}`
+	if (opts.sameSite) cookie += `; SameSite=${opts.sameSite.charAt(0).toUpperCase()}${opts.sameSite.slice(1)}`
 	return cookie
 }

package/src/cors.ts

@@ -1,3 +1,4 @@
+import { namedMiddleware } from "./middleware.ts"
 import { replaceResponse } from "./honey-response.ts"
 import type { MiddlewareFn } from "./middleware.ts"
 
@@ -25,8 +26,7 @@ export function cors(options?: CORSOptions): MiddlewareFn<{ req: Request }, {}>
 	const opts = options ?? {}
 
 	/* credentials + wildcard is a CORS spec violation — auto-narrow to echo origin */
-	const credentialWildcard =
-		opts.credentials === true && (opts.origin === undefined || opts.origin === "*")
+	const credentialWildcard = opts.credentials === true && (opts.origin === undefined || opts.origin === "*")
 
 	const mw: MiddlewareFn<{ req: Request }, {}> = async (ctx, next) => {
 		const req = ctx.req
@@ -37,9 +37,7 @@ export function cors(options?: CORSOptions): MiddlewareFn<{ req: Request }, {}>
 			return next()
 		}
 
-		const allowedOrigin = credentialWildcard
-			? requestOrigin
-			: matchOrigin(requestOrigin, opts.origin)
+		const allowedOrigin = credentialWildcard ? requestOrigin : matchOrigin(requestOrigin, opts.origin)
 
 		/* origin not allowed */
 		if (allowedOrigin === null) {
@@ -92,5 +90,5 @@ export function cors(options?: CORSOptions): MiddlewareFn<{ req: Request }, {}>
 		})
 	}
 
-	return mw
+	return namedMiddleware("cors", mw)
 }

package/src/crypto.ts

@@ -4,10 +4,7 @@ let cachedKey: CryptoKey | null = null
 
 async function getKey(): Promise<CryptoKey> {
 	if (cachedKey === null) {
-		cachedKey = await crypto.subtle.generateKey({ hash: "SHA-256", name: "HMAC" }, false, [
-			"sign",
-			"verify",
-		])
+		cachedKey = await crypto.subtle.generateKey({ hash: "SHA-256", name: "HMAC" }, false, ["sign", "verify"])
 	}
 	return cachedKey
 }

package/src/csrf.ts

@@ -1,3 +1,4 @@
+import { namedMiddleware } from "./middleware.ts"
 import { HoneyError } from "./error.ts"
 import type { MiddlewareFn } from "./middleware.ts"
 import { EK, SK } from "./types.ts"
@@ -7,8 +8,7 @@ type CSRFOptions = {
 }
 
 const safeMethodRe = /^(GET|HEAD|OPTIONS)$/
-const formContentTypeRe =
-	/^\b(application\/x-www-form-urlencoded|multipart\/form-data|text\/plain)\b/i
+const formContentTypeRe = /^\b(application\/x-www-form-urlencoded|multipart\/form-data|text\/plain)\b/i
 
 function matchOrigin(origin: string, config: CSRFOptions["origin"]): boolean {
 	if (config === undefined) return false
@@ -50,5 +50,5 @@ export function csrf(options?: CSRFOptions): MiddlewareFn<{ req: Request }, {}>
 		})
 	}
 
-	return mw
+	return namedMiddleware("csrf", mw)
 }

package/src/curl-logger.ts

@@ -1,12 +1,8 @@
+import { namedMiddleware } from "./middleware.ts"
 import type { MiddlewareFn } from "./middleware.ts"
 import type { LoggerInstance } from "./logger.ts"
 
-type BodyOmittedReason =
-	| "content-type"
-	| "disabled"
-	| "missing"
-	| "read-error"
-	| "too-large"
+type BodyOmittedReason = "content-type" | "disabled" | "missing" | "read-error" | "too-large"
 
 type CurlLogData = {
 	bodyIncluded: boolean
@@ -33,12 +29,7 @@ type CurlLoggerOptions = {
 	skip?: (data: CurlLogData) => boolean
 }
 
-const DEFAULT_BODY_CONTENT_TYPES = [
-	"application/json",
-	"application/x-www-form-urlencoded",
-	"application/xml",
-	"text/",
-]
+const DEFAULT_BODY_CONTENT_TYPES = ["application/json", "application/x-www-form-urlencoded", "application/xml", "text/"]
 
 const DEFAULT_MAX_BODY_BYTES = 16_384
 
@@ -70,7 +61,10 @@ function redactUrl(url: URL, redactQueryParam?: (name: string, value: string) =>
 	return redacted.toString()
 }
 
-async function readBodyWithinLimit(request: Request, maxBytes: number): Promise<{
+async function readBodyWithinLimit(
+	request: Request,
+	maxBytes: number,
+): Promise<{
 	body: string | null
 	omittedReason: BodyOmittedReason | null
 }> {
@@ -131,9 +125,7 @@ async function buildCurlLogData(
 	const parts: string[] = [`curl -X ${request.method}`]
 
 	for (const [name, value] of request.headers.entries()) {
-		const redactedValue = options?.redactHeader !== undefined
-			? options.redactHeader(name, value)
-			: value
+		const redactedValue = options?.redactHeader !== undefined ? options.redactHeader(name, value) : value
 		if (redactedValue === null) continue
 		parts.push(`-H '${shellEscape(name)}: ${shellEscape(redactedValue)}'`)
 	}
@@ -149,10 +141,7 @@ async function buildCurlLogData(
 		if (shouldIncludeBody(contentType, allowContentTypes) === false) {
 			bodyOmittedReason = request.body === null ? "missing" : "content-type"
 		} else {
-			const result = await readBodyWithinLimit(
-				request,
-				bodyOptions.maxBytes ?? DEFAULT_MAX_BODY_BYTES,
-			)
+			const result = await readBodyWithinLimit(request, bodyOptions.maxBytes ?? DEFAULT_MAX_BODY_BYTES)
 
 			if (result.body === null) {
 				bodyOmittedReason = result.omittedReason
@@ -174,17 +163,15 @@ async function buildCurlLogData(
 	}
 }
 
-function curlLogger(
-	options?: CurlLoggerOptions,
-): MiddlewareFn<{ path: string, req: Request }, {}> {
+function curlLogger(options?: CurlLoggerOptions): MiddlewareFn<{ path: string; req: Request }, {}> {
 	const log = options?.log ?? defaultLog
 	const skip = options?.skip
 
-	return async (ctx, next) => {
+	return namedMiddleware("curlLogger", async (ctx, next) => {
 		const start = performance.now()
 		const method = ctx.req.method
 		const path = ctx.path
-		const rid = (ctx as Record<string, unknown>)["requestId"] as string | null ?? null
+		const rid = ((ctx as Record<string, unknown>)["requestId"] as string | null) ?? null
 		const curlDataPromise = buildCurlLogData(ctx.req, options)
 
 		const response = await next()
@@ -223,13 +210,8 @@ function curlLogger(
 		}
 
 		return response
-	}
+	})
 }
 
 export { buildCurlLogData, curlLogger }
-export type {
-	BodyOmittedReason,
-	CurlLogData,
-	CurlLoggerBodyOptions,
-	CurlLoggerOptions,
-}
+export type { BodyOmittedReason, CurlLogData, CurlLoggerBodyOptions, CurlLoggerOptions }

package/src/detect-runtime.ts

@@ -13,7 +13,5 @@ export function detectRuntime(g: DetectGlobal = globalThis): ServeRuntime {
 	const ua = g.navigator?.userAgent ?? ""
 	if (ua.includes("Cloudflare-Workers") || ua.includes("workerd")) return "cloudflare"
 	if (g.process?.versions?.node) return "node"
-	throw new Error(
-		'Honey.serve() could not detect a runtime. Pass runtime: "bun" | "node" | "deno".',
-	)
+	throw new Error('Honey.serve() could not detect a runtime. Pass runtime: "bun" | "node" | "deno".')
 }

package/src/errors.ts

@@ -43,9 +43,7 @@ type ErrorFactoryResult<TMap extends Record<string, ErrorDef>, TTranslations ext
 export function defineErrors<
 	TMap extends Record<string, ErrorDef>,
 	TTranslations extends Record<string, string> = Record<string, string>,
->(
-	map: TMap,
-): ErrorFactoryResult<TMap, TTranslations> {
+>(map: TMap): ErrorFactoryResult<TMap, TTranslations> {
 	const result = Object.create(null) as Record<string, unknown>
 	const meta = Object.create(null) as Record<string, ErrorMetaEntry>
 

package/src/etag.ts

@@ -1,3 +1,4 @@
+import { namedMiddleware } from "./middleware.ts"
 import { replaceResponse } from "./honey-response.ts"
 import type { MiddlewareFn } from "./middleware.ts"
 
@@ -35,9 +36,7 @@ export function etag(options?: ETagOptions): MiddlewareFn<{ req: Request }, {}>
 		/* skip streaming responses — can't hash without buffering entire stream */
 		if (
 			response.headers.get("transfer-encoding") === "chunked" ||
-			(response.body !== null &&
-				!response.headers.has("content-length") &&
-				!response.headers.has("content-type"))
+			(response.body !== null && !response.headers.has("content-length") && !response.headers.has("content-type"))
 		) {
 			return response
 		}
@@ -70,5 +69,5 @@ export function etag(options?: ETagOptions): MiddlewareFn<{ req: Request }, {}>
 		})
 	}
 
-	return mw
+	return namedMiddleware("etag", mw)
 }