@lovrozagar/honey 0.1.0 → 0.2.0

package/src/response.ts

@@ -1,114 +1,103 @@
-import type { CookieOptions } from "./cookie.ts";
-import { serializeCookie } from "./cookie.ts";
-import type { HoneyError } from "./error.ts";
-import { createHoneyResponse } from "./honey-response.ts";
-import type { StatusKey } from "./types.ts";
-import { statusKeyToCode } from "./types.ts";
+import type { CookieOptions } from "./cookie.ts"
+import { serializeCookie } from "./cookie.ts"
+import type { HoneyError } from "./error.ts"
+import { createHoneyResponse } from "./honey-response.ts"
+import type { StatusKey } from "./types.ts"
+import { statusKeyToCode } from "./types.ts"
 
-export type { CookieOptions } from "./cookie.ts";
-export { serializeCookie } from "./cookie.ts";
+export type { CookieOptions } from "./cookie.ts"
+export { serializeCookie } from "./cookie.ts"
 
 export type ResponseOptions = {
-	cookies?: Record<string, CookieOptions>;
-	headers?: Record<string, string>;
-	status?: number;
-};
+	cookies?: Record<string, CookieOptions>
+	headers?: Record<string, string>
+	status?: number
+}
 
 export type SSEEvent = {
-	data: object | string;
-	event: string;
-	id?: string;
-	retry?: number;
-};
+	data: object | string
+	event: string
+	id?: string
+	retry?: number
+}
 
 export type SSEOptions = ResponseOptions & {
-	defaultRetry?: number;
-	keepalive?: number;
-	lastEventId?: string;
-};
+	defaultRetry?: number
+	keepalive?: number
+	lastEventId?: string
+}
 
 export type SSEStream = {
-	close(): void;
-	lastEventId: string | undefined;
-	send(event: SSEEvent): Promise<void>;
-};
+	close(): void
+	lastEventId: string | undefined
+	send(event: SSEEvent): Promise<void>
+}
 
-export type ErrorFormatter = (
-	error: HoneyError,
-	defaultShape: Record<string, unknown>,
-) => Record<string, unknown>;
+export type ErrorFormatter = (error: HoneyError, defaultShape: Record<string, unknown>) => Record<string, unknown>
 
 function applyResponseOptions(headers: Headers, opts?: ResponseOptions): void {
 	if (opts?.headers) {
 		for (const [k, v] of Object.entries(opts.headers)) {
-			headers.set(k, v);
+			headers.set(k, v)
 		}
 	}
 	if (opts?.cookies) {
 		for (const [name, cookieOpts] of Object.entries(opts.cookies)) {
-			headers.append("set-cookie", serializeCookie(name, cookieOpts));
+			headers.append("set-cookie", serializeCookie(name, cookieOpts))
 		}
 	}
 }
 
-function applyPlainOptions(
-	headers: Record<string, string | string[]>,
-	opts?: ResponseOptions,
-): void {
+function applyPlainOptions(headers: Record<string, string | string[]>, opts?: ResponseOptions): void {
 	if (opts?.headers) {
 		for (const [k, v] of Object.entries(opts.headers)) {
-			headers[k.toLowerCase()] = v;
+			headers[k.toLowerCase()] = v
 		}
 	}
 	if (opts?.cookies) {
-		const cookies: string[] = [];
+		const cookies: string[] = []
 		for (const [name, cookieOpts] of Object.entries(opts.cookies)) {
-			cookies.push(serializeCookie(name, cookieOpts));
+			cookies.push(serializeCookie(name, cookieOpts))
 		}
-		headers["set-cookie"] = cookies;
+		headers["set-cookie"] = cookies
 	}
 }
 
 /* phantom brands — exist only at type level, never assigned at runtime */
-declare const CONTENT_TYPE: unique symbol;
-declare const STATUS_KEY: unique symbol;
+declare const CONTENT_TYPE: unique symbol
+declare const STATUS_KEY: unique symbol
 
 /** Branded Response — phantom content-type + status-key at type level, native Response at runtime */
-export type TypedResponse<
-	CT extends string = string,
-	SK extends string = string,
-> = Response & {
-	readonly [CONTENT_TYPE]: CT;
-	readonly [STATUS_KEY]: SK;
-};
+export type TypedResponse<CT extends string = string, SK extends string = string> = Response & {
+	readonly [CONTENT_TYPE]: CT
+	readonly [STATUS_KEY]: SK
+}
 
 /** Cast a native Response to TypedResponse — zero runtime cost */
-function typed<CT extends string, SK extends string>(
-	response: Response,
-): TypedResponse<CT, SK> {
-	return response as TypedResponse<CT, SK>;
+function typed<CT extends string, SK extends string>(response: Response): TypedResponse<CT, SK> {
+	return response as TypedResponse<CT, SK>
 }
 
 /** Node adapter reads this to `res.end(payload)` without draining the Fetch body. */
-const RAW_BODY = Symbol.for("honey.rawBody");
+const RAW_BODY = Symbol.for("honey.rawBody")
 
 function withRawBody(response: Response, body: string | Uint8Array): Response {
-	Object.defineProperty(response, RAW_BODY, { value: body });
-	return response;
+	Object.defineProperty(response, RAW_BODY, { value: body })
+	return response
 }
 
 /* pre-allocated header objects — Bun optimizes plain objects better than Headers instances */
-const JSON_HEADERS = { "content-type": "application/json" };
-const TEXT_HEADERS = { "content-type": "text/plain; charset=utf-8" };
-const HTML_HEADERS = { "content-type": "text/html; charset=utf-8" };
-const CSV_HEADERS = { "content-type": "text/csv; charset=utf-8" };
-const BINARY_HEADERS = { "content-type": "application/octet-stream" };
+const JSON_HEADERS = { "content-type": "application/json" }
+const TEXT_HEADERS = { "content-type": "text/plain; charset=utf-8" }
+const HTML_HEADERS = { "content-type": "text/html; charset=utf-8" }
+const CSV_HEADERS = { "content-type": "text/csv; charset=utf-8" }
+const BINARY_HEADERS = { "content-type": "application/octet-stream" }
 
 export class HoneyRes {
-	protected readonly _nodeOut: boolean;
+	protected readonly _nodeOut: boolean
 
 	constructor(nodeOut = false) {
-		this._nodeOut = nodeOut;
+		this._nodeOut = nodeOut
 	}
 
 	private _known<CT extends string, SK extends string>(
@@ -119,18 +108,18 @@ export class HoneyRes {
 	): TypedResponse<CT, SK> {
 		if (this._nodeOut) {
 			if (!opts?.headers && !opts?.cookies) {
-				return typed(createHoneyResponse({ headers, raw, status }));
+				return typed(createHoneyResponse({ headers, raw, status }))
 			}
-			const plain: Record<string, string | string[]> = { ...headers };
-			applyPlainOptions(plain, opts);
-			return typed(createHoneyResponse({ headers: plain, raw, status }));
+			const plain: Record<string, string | string[]> = { ...headers }
+			applyPlainOptions(plain, opts)
+			return typed(createHoneyResponse({ headers: plain, raw, status }))
 		}
 		if (!opts?.headers && !opts?.cookies) {
-			return typed(withRawBody(new Response(raw as BodyInit, { headers, status }), raw));
+			return typed(withRawBody(new Response(raw as BodyInit, { headers, status }), raw))
 		}
-		const native = new Headers(headers);
-		applyResponseOptions(native, opts);
-		return typed(withRawBody(new Response(raw as BodyInit, { headers: native, status }), raw));
+		const native = new Headers(headers)
+		applyResponseOptions(native, opts)
+		return typed(withRawBody(new Response(raw as BodyInit, { headers: native, status }), raw))
 	}
 
 	binary<SK extends StatusKey>(
@@ -138,24 +127,16 @@ export class HoneyRes {
 		body: ArrayBuffer | Uint8Array<ArrayBuffer>,
 		opts?: ResponseOptions,
 	): TypedResponse<"application/octet-stream", SK> {
-		const raw = body instanceof Uint8Array ? body : new Uint8Array(body);
-		return this._known(statusKeyToCode[statusKey], BINARY_HEADERS, raw, opts);
+		const raw = body instanceof Uint8Array ? body : new Uint8Array(body)
+		return this._known(statusKeyToCode[statusKey], BINARY_HEADERS, raw, opts)
 	}
 
-	csv<SK extends StatusKey>(
-		statusKey: SK,
-		body: string,
-		opts?: ResponseOptions,
-	): TypedResponse<"text/csv", SK> {
-		return this._known(statusKeyToCode[statusKey], CSV_HEADERS, body, opts);
+	csv<SK extends StatusKey>(statusKey: SK, body: string, opts?: ResponseOptions): TypedResponse<"text/csv", SK> {
+		return this._known(statusKeyToCode[statusKey], CSV_HEADERS, body, opts)
 	}
 
-	html<SK extends StatusKey>(
-		statusKey: SK,
-		body: string,
-		opts?: ResponseOptions,
-	): TypedResponse<"text/html", SK> {
-		return this._known(statusKeyToCode[statusKey], HTML_HEADERS, body, opts);
+	html<SK extends StatusKey>(statusKey: SK, body: string, opts?: ResponseOptions): TypedResponse<"text/html", SK> {
+		return this._known(statusKeyToCode[statusKey], HTML_HEADERS, body, opts)
 	}
 
 	json<SK extends StatusKey>(
@@ -163,220 +144,190 @@ export class HoneyRes {
 		data: unknown,
 		opts?: ResponseOptions,
 	): TypedResponse<"application/json", SK> {
-		return this._known(statusKeyToCode[statusKey], JSON_HEADERS, JSON.stringify(data), opts);
+		return this._known(statusKeyToCode[statusKey], JSON_HEADERS, JSON.stringify(data), opts)
 	}
 
 	noContent(opts?: ResponseOptions): TypedResponse<"none", "no_content"> {
 		if (this._nodeOut) {
-			const headers: Record<string, string | string[]> = {};
-			applyPlainOptions(headers, opts);
-			return typed(createHoneyResponse({ headers, raw: null, status: 204 }));
+			const headers: Record<string, string | string[]> = {}
+			applyPlainOptions(headers, opts)
+			return typed(createHoneyResponse({ headers, raw: null, status: 204 }))
 		}
-		const headers = new Headers();
-		applyResponseOptions(headers, opts);
-		return typed(new Response(null, { headers, status: 204 }));
+		const headers = new Headers()
+		applyResponseOptions(headers, opts)
+		return typed(new Response(null, { headers, status: 204 }))
 	}
 
 	raw(response: Response): TypedResponse {
-		return typed(response);
+		return typed(response)
 	}
 
-	redirect(
-		url: string,
-		opts?: ResponseOptions,
-	): TypedResponse<"none", "found"> {
+	redirect(url: string, opts?: ResponseOptions): TypedResponse<"none", "found"> {
 		if (this._nodeOut) {
-			const headers: Record<string, string | string[]> = { location: url };
-			applyPlainOptions(headers, opts);
-			return typed(createHoneyResponse({ headers, raw: null, status: opts?.status ?? 302 }));
+			const headers: Record<string, string | string[]> = { location: url }
+			applyPlainOptions(headers, opts)
+			return typed(createHoneyResponse({ headers, raw: null, status: opts?.status ?? 302 }))
 		}
-		const headers = new Headers({ location: url });
-		applyResponseOptions(headers, opts);
-		return typed(new Response(null, { headers, status: opts?.status ?? 302 }));
+		const headers = new Headers({ location: url })
+		applyResponseOptions(headers, opts)
+		return typed(new Response(null, { headers, status: opts?.status ?? 302 }))
 	}
 
-	sse(
-		callback: (stream: SSEStream) => Promise<void>,
-		opts?: SSEOptions,
-	): TypedResponse<"text/event-stream", "ok"> {
-		const { readable, writable } = new TransformStream();
-		const writer = writable.getWriter();
-		const encoder = new TextEncoder();
-		let keepaliveTimer: ReturnType<typeof setInterval> | undefined;
+	sse(callback: (stream: SSEStream) => Promise<void>, opts?: SSEOptions): TypedResponse<"text/event-stream", "ok"> {
+		const { readable, writable } = new TransformStream()
+		const writer = writable.getWriter()
+		const encoder = new TextEncoder()
+		let keepaliveTimer: ReturnType<typeof setInterval> | undefined
 
-		let closed = false;
+		let closed = false
 		const sseStream: SSEStream = {
 			close() {
-				if (closed) return;
-				closed = true;
-				if (keepaliveTimer !== undefined) clearInterval(keepaliveTimer);
-				writer.close();
+				if (closed) return
+				closed = true
+				if (keepaliveTimer !== undefined) clearInterval(keepaliveTimer)
+				writer.close()
 			},
 			lastEventId: opts?.lastEventId,
 			send(event) {
 				if (/[\r\n]/.test(event.event)) {
-					throw new Error("SSE event name must not contain newlines");
+					throw new Error("SSE event name must not contain newlines")
 				}
 				if (event.id && /[\r\n]/.test(event.id)) {
-					throw new Error("SSE id must not contain newlines");
+					throw new Error("SSE id must not contain newlines")
 				}
-				const dataStr =
-					typeof event.data === "string"
-						? event.data
-						: JSON.stringify(event.data);
+				const dataStr = typeof event.data === "string" ? event.data : JSON.stringify(event.data)
 				const dataLines = dataStr
 					.split(/\r\n|\r|\n/)
 					.map((line) => `data: ${line}`)
-					.join("\n");
-				let msg = `event: ${event.event}\n${dataLines}\n`;
-				if (event.id) msg += `id: ${event.id}\n`;
+					.join("\n")
+				let msg = `event: ${event.event}\n${dataLines}\n`
+				if (event.id) msg += `id: ${event.id}\n`
 				/** SSE retry must be a non-negative integer per spec — skip if invalid */
-				if (
-					event.retry !== undefined &&
-					Number.isFinite(event.retry) &&
-					event.retry >= 0
-				) {
-					msg += `retry: ${Math.floor(event.retry)}\n`;
+				if (event.retry !== undefined && Number.isFinite(event.retry) && event.retry >= 0) {
+					msg += `retry: ${Math.floor(event.retry)}\n`
 				}
-				msg += "\n";
-				return writer.write(encoder.encode(msg));
+				msg += "\n"
+				return writer.write(encoder.encode(msg))
 			},
-		};
+		}
 
 		if (opts?.defaultRetry !== undefined) {
-			writer.write(encoder.encode(`retry: ${opts.defaultRetry}\n\n`));
+			writer.write(encoder.encode(`retry: ${opts.defaultRetry}\n\n`))
 		}
 
 		if (opts?.keepalive !== undefined && opts.keepalive > 0) {
 			keepaliveTimer = setInterval(() => {
 				writer.write(encoder.encode(": heartbeat\n\n")).catch(() => {
-					if (keepaliveTimer !== undefined) clearInterval(keepaliveTimer);
-				});
-			}, opts.keepalive);
+					if (keepaliveTimer !== undefined) clearInterval(keepaliveTimer)
+				})
+			}, opts.keepalive)
 		}
 
 		void callback(sseStream).then(
 			async () => {
-				if (closed) return;
-				closed = true;
-				if (keepaliveTimer !== undefined) clearInterval(keepaliveTimer);
+				if (closed) return
+				closed = true
+				if (keepaliveTimer !== undefined) clearInterval(keepaliveTimer)
 				try {
-					await writer.close();
+					await writer.close()
 				} catch {}
 			},
 			async () => {
-				if (closed) return;
-				closed = true;
-				if (keepaliveTimer !== undefined) clearInterval(keepaliveTimer);
+				if (closed) return
+				closed = true
+				if (keepaliveTimer !== undefined) clearInterval(keepaliveTimer)
 				try {
-					await writer.close();
+					await writer.close()
 				} catch {}
 			},
-		);
+		)
 
 		const headers = new Headers({
 			"cache-control": "no-cache",
 			connection: "keep-alive",
 			"content-type": "text/event-stream",
-		});
-		applyResponseOptions(headers, opts);
-		return typed(new Response(readable, { headers, status: 200 }));
+		})
+		applyResponseOptions(headers, opts)
+		return typed(new Response(readable, { headers, status: 200 }))
 	}
 
 	generate(
-		generator:
-			| AsyncGenerator<string, void, unknown>
-			| Generator<string, void, unknown>,
+		generator: AsyncGenerator<string, void, unknown> | Generator<string, void, unknown>,
 		opts?: { contentType?: string; status?: number },
 	): TypedResponse<string, "ok"> {
-		const encoder = new TextEncoder();
-		const gen = generator;
+		const encoder = new TextEncoder()
+		const gen = generator
 		const readable = new ReadableStream({
 			async pull(controller) {
 				try {
-					const { done, value } = await gen.next();
+					const { done, value } = await gen.next()
 					if (done) {
-						controller.close();
-						return;
+						controller.close()
+						return
 					}
-					controller.enqueue(encoder.encode(value));
+					controller.enqueue(encoder.encode(value))
 				} catch {
-					controller.close();
+					controller.close()
 				}
 			},
-		});
+		})
 		const headers = new Headers({
 			"content-type": opts?.contentType ?? "application/octet-stream",
-		});
-		return typed(
-			new Response(readable, { headers, status: opts?.status ?? 200 }),
-		);
+		})
+		return typed(new Response(readable, { headers, status: opts?.status ?? 200 }))
 	}
 
 	stream(
 		callback: (writable: WritableStream) => Promise<void>,
 		opts?: ResponseOptions,
 	): TypedResponse<"application/octet-stream", "ok"> {
-		const { readable, writable } = new TransformStream();
+		const { readable, writable } = new TransformStream()
 		void callback(writable).then(
 			async () => {
 				try {
-					await writable.close();
+					await writable.close()
 				} catch {}
 			},
 			async () => {
 				try {
-					await writable.close();
+					await writable.close()
 				} catch {}
 			},
-		);
-		const headers = new Headers();
-		applyResponseOptions(headers, opts);
-		return typed(
-			new Response(readable, { headers, status: opts?.status ?? 200 }),
-		);
+		)
+		const headers = new Headers()
+		applyResponseOptions(headers, opts)
+		return typed(new Response(readable, { headers, status: opts?.status ?? 200 }))
 	}
 
-	text<SK extends StatusKey>(
-		statusKey: SK,
-		body: string,
-		opts?: ResponseOptions,
-	): TypedResponse<"text/plain", SK> {
-		return this._known(statusKeyToCode[statusKey], TEXT_HEADERS, body, opts);
+	text<SK extends StatusKey>(statusKey: SK, body: string, opts?: ResponseOptions): TypedResponse<"text/plain", SK> {
+		return this._known(statusKeyToCode[statusKey], TEXT_HEADERS, body, opts)
 	}
 
-	xml<SK extends StatusKey>(
-		statusKey: SK,
-		body: string,
-		opts?: ResponseOptions,
-	): TypedResponse<"application/xml", SK> {
-		return this._known(statusKeyToCode[statusKey], { "content-type": "application/xml" }, body, opts);
+	xml<SK extends StatusKey>(statusKey: SK, body: string, opts?: ResponseOptions): TypedResponse<"application/xml", SK> {
+		return this._known(statusKeyToCode[statusKey], { "content-type": "application/xml" }, body, opts)
 	}
 }
 
-export type CustomErrorFormatter = (
-	error: HoneyError,
-	data: Record<string, unknown>,
-) => Record<string, unknown>;
+export type CustomErrorFormatter = (error: HoneyError, data: Record<string, unknown>) => Record<string, unknown>
 
 export function createErrorResponse(
 	error: HoneyError,
 	defaultFormatter: ErrorFormatter,
 	customFormatter?: CustomErrorFormatter | null,
 ): Response {
-	let body: Record<string, unknown>;
+	let body: Record<string, unknown>
 
 	if (error.data !== undefined) {
 		/* custom schema error — apply customErrorFormatter if set, else use data as-is */
-		const rawData = error.data as Record<string, unknown>;
+		const rawData = error.data as Record<string, unknown>
 		if (customFormatter) {
 			try {
-				body = customFormatter(error, rawData);
+				body = customFormatter(error, rawData)
 			} catch {
-				body = rawData;
+				body = rawData
 			}
 		} else {
-			body = rawData;
+			body = rawData
 		}
 	} else {
 		/* standard error — build default shape, apply defaultErrorFormatter */
@@ -388,12 +339,12 @@ export function createErrorResponse(
 			status_key: error.statusKey,
 			success: false,
 			...(error.vars ? { vars: error.vars } : {}),
-		};
+		}
 		try {
-			body = defaultFormatter(error, defaultShape);
+			body = defaultFormatter(error, defaultShape)
 		} catch {
 			/* formatter crashed — fall back to default shape */
-			body = defaultShape;
+			body = defaultShape
 		}
 	}
 
@@ -403,12 +354,12 @@ export function createErrorResponse(
 			headers[k] = v
 		}
 	}
-	const payload = JSON.stringify(body);
+	const payload = JSON.stringify(body)
 	return withRawBody(
 		new Response(payload, {
 			headers,
 			status: error.status,
 		}),
 		payload,
-	);
+	)
 }

package/src/rust-type-emitter.ts

@@ -5,14 +5,58 @@ import type { IRSchema } from "./codegen-ir.ts"
 import { goPascal } from "./go-type-emitter.ts"
 
 export const RUST_KEYWORDS = new Set([
-	"as", "break", "const", "continue", "crate", "else", "enum", "extern",
-	"false", "fn", "for", "if", "impl", "in", "let", "loop", "match", "mod",
-	"move", "mut", "pub", "ref", "return", "self", "Self", "static", "struct",
-	"super", "trait", "true", "type", "unsafe", "use", "where", "while",
-	"async", "await", "dyn",
+	"as",
+	"break",
+	"const",
+	"continue",
+	"crate",
+	"else",
+	"enum",
+	"extern",
+	"false",
+	"fn",
+	"for",
+	"if",
+	"impl",
+	"in",
+	"let",
+	"loop",
+	"match",
+	"mod",
+	"move",
+	"mut",
+	"pub",
+	"ref",
+	"return",
+	"self",
+	"Self",
+	"static",
+	"struct",
+	"super",
+	"trait",
+	"true",
+	"type",
+	"unsafe",
+	"use",
+	"where",
+	"while",
+	"async",
+	"await",
+	"dyn",
 	/* reserved / future */
-	"abstract", "become", "box", "do", "final", "macro", "override", "priv",
-	"typeof", "unsized", "virtual", "yield", "try",
+	"abstract",
+	"become",
+	"box",
+	"do",
+	"final",
+	"macro",
+	"override",
+	"priv",
+	"typeof",
+	"unsized",
+	"virtual",
+	"yield",
+	"try",
 ])
 
 export function rustPascal(name: string): string {
@@ -97,11 +141,16 @@ function hoistEnumName(parentName: string, fieldName: string): string {
 
 function primitiveFor(t: string | undefined): string | null {
 	switch (t) {
-		case "string": return "String"
-		case "integer": return "i64"
-		case "number": return "f64"
-		case "boolean": return "bool"
-		default: return null
+		case "string":
+			return "String"
+		case "integer":
+			return "i64"
+		case "number":
+			return "f64"
+		case "boolean":
+			return "bool"
+		default:
+			return null
 	}
 }
 
@@ -231,10 +280,9 @@ export function irRenderTopLevelRust(
 	if (ir.kind === "const") {
 		const rawType = raw?.type as string | undefined
 		const base = rawType ? (primitiveFor(rawType) ?? "String") : constBaseType(ir.value)
-		return [
-			`#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]`,
-			`pub struct ${typeName}(pub ${base});`,
-		].join("\n")
+		return [`#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]`, `pub struct ${typeName}(pub ${base});`].join(
+			"\n",
+		)
 	}
 
 	if (ir.kind === "allOf") {
@@ -396,17 +444,10 @@ export function irRenderTopLevelRust(
  * Render a schema as a Rust type expression for a struct field position.
  * Mutates `ctx.decls` when hoisting enums or anonymous structs.
  */
-export function renderUseRust(
-	schema: Record<string, unknown> | undefined,
-	ctx: RustRenderUseCtx,
-): string {
+export function renderUseRust(schema: Record<string, unknown> | undefined, ctx: RustRenderUseCtx): string {
 	return irRenderUseRust(schemaToIR(schema), ctx, ctx.depth ?? 0)
 }
 
-export function renderTopLevelRust(
-	name: string,
-	schema: Record<string, unknown>,
-	decls: Map<string, string>,
-): string {
+export function renderTopLevelRust(name: string, schema: Record<string, unknown>, decls: Map<string, string>): string {
 	return irRenderTopLevelRust(name, schemaToIR(schema), decls, schema)
 }