@lovrozagar/honey 0.7.2 → 1.0.0-rc.1

package/src/client/sse.ts

@@ -1,128 +0,0 @@
-export type SSEEvent = {
-	data: string
-	event?: string
-	/** The last event ID (sticky across events, as `EventSource.lastEventId`). Absent while empty. */
-	id?: string
-	retry?: number
-}
-
-const DEFAULT_MAX_BUFFER = 1024 * 1024
-
-/**
- * Parse a `text/event-stream` body per the WHATWG HTML "event stream interpretation" rules:
- *
- * - lines end at CRLF, LF or CR (a CR at a chunk boundary waits for a possible LF);
- * - a leading BOM is skipped;
- * - `id` persists across events until changed, and an `id` containing NUL is ignored;
- * - `retry` is accepted only when it is all ASCII digits;
- * - an event still open when the stream ends is discarded, never dispatched.
- *
- * `maxBufferSize` caps both an unterminated line and the data of one event (UTF-16 code
- * units); exceeding it throws.
- */
-export async function* parseSSEStream(
-	stream: ReadableStream<Uint8Array>,
-	opts?: { maxBufferSize?: number },
-): AsyncGenerator<SSEEvent, void, undefined> {
-	const decoder = new TextDecoder()
-	const reader = stream.getReader()
-	const maxBuffer = opts?.maxBufferSize ?? DEFAULT_MAX_BUFFER
-
-	let pending = ""
-	let first = true
-	let data: string[] = []
-	let dataSize = 0
-	let hasData = false
-	let event: string | undefined
-	let lastId = ""
-	let retry: number | undefined
-
-	const dispatch = (): SSEEvent | undefined => {
-		const out = hasData ? ({ data: data.join("\n") } as SSEEvent) : undefined
-		if (out) {
-			if (event !== undefined && event !== "") out.event = event
-			if (lastId !== "") out.id = lastId
-			if (retry !== undefined) out.retry = retry
-			retry = undefined
-		}
-		data = []
-		dataSize = 0
-		hasData = false
-		event = undefined
-		return out
-	}
-
-	const processLine = (line: string): void => {
-		if (line.charCodeAt(0) === 58 /* : */) return
-		const colon = line.indexOf(":")
-		const field = colon === -1 ? line : line.slice(0, colon)
-		let value = colon === -1 ? "" : line.slice(colon + 1)
-		if (value.charCodeAt(0) === 32) value = value.slice(1)
-		switch (field) {
-			case "data":
-				dataSize += value.length + 1
-				if (dataSize > maxBuffer) throw new Error(`SSE event exceeded ${maxBuffer} characters`)
-				data.push(value)
-				hasData = true
-				break
-			case "event":
-				event = value
-				break
-			case "id":
-				if (!value.includes("\0")) lastId = value
-				break
-			case "retry":
-				if (/^\d+$/.test(value)) retry = Number(value)
-				break
-		}
-	}
-
-	try {
-		while (true) {
-			const { done, value } = await reader.read()
-			if (done) break
-			pending += decoder.decode(value, { stream: true })
-			if (first && pending.length > 0) {
-				if (pending.charCodeAt(0) === 0xfeff) pending = pending.slice(1)
-				first = false
-			}
-
-			let start = 0
-			while (start < pending.length) {
-				let end = start
-				while (end < pending.length) {
-					const c = pending.charCodeAt(end)
-					if (c === 10 || c === 13) break
-					end++
-				}
-				if (end === pending.length) break
-				/* A CR as the last character may be the first half of CRLF. */
-				if (pending.charCodeAt(end) === 13 && end === pending.length - 1) break
-				const line = pending.slice(start, end)
-				start = end + (pending.charCodeAt(end) === 13 && pending.charCodeAt(end + 1) === 10 ? 2 : 1)
-				if (line === "") {
-					const out = dispatch()
-					if (out) yield out
-				} else {
-					processLine(line)
-				}
-			}
-			pending = pending.slice(start)
-			if (pending.length > maxBuffer) {
-				throw new Error(`SSE buffer exceeded ${maxBuffer} characters`)
-			}
-		}
-		/* A lone CR held back at the end of the stream still terminates its line. */
-		if (pending.endsWith("\r")) {
-			const line = pending.slice(0, -1)
-			if (line === "") {
-				const out = dispatch()
-				if (out) yield out
-			}
-		}
-		/* Anything else still open is an incomplete event: discard it. */
-	} finally {
-		await reader.cancel().catch(() => {})
-		reader.releaseLock()
-	}
-}

package/src/client/types.ts

@@ -1,206 +0,0 @@
-import type { FieldError, InferOutput, ParamsFromPath, StandardSchemaLike } from "../types.ts"
-import type { SSEEvent } from "./sse.ts"
-import type { TypedWebSocket } from "./ws.ts"
-
-/** Extract paths that have a specific method registered */
-export type PathsForMethod<TRoutes, M extends string> = {
-	[P in keyof TRoutes & string]: M extends keyof TRoutes[P] ? P : never
-}[keyof TRoutes & string]
-
-/** Extract input type for a route */
-export type InputFor<TRoutes, P extends string, M extends string> = P extends keyof TRoutes
-	? M extends keyof TRoutes[P]
-		? TRoutes[P][M] extends { input: infer I }
-			? I
-			: {}
-		: {}
-	: {}
-
-/** Extract output schema definition for a route */
-export type OutputDefFor<TRoutes, P extends string, M extends string> = P extends keyof TRoutes
-	? M extends keyof TRoutes[P]
-		? TRoutes[P][M] extends { output: infer O }
-			? O
-			: never
-		: never
-	: never
-
-/** Check if output definition is empty (no .output() declared) */
-type IsEmptyOutput<O> = keyof O extends never ? true : false
-
-/** Content-type to return type mapping for non-JSON outputs */
-type ContentTypeReturn<O> = O extends { "text/plain": unknown }
-	? string
-	: O extends { "text/html": unknown }
-		? string
-		: O extends { "text/csv": unknown }
-			? string
-			: O extends { "application/xml": unknown }
-				? string
-				: O extends { "application/octet-stream": unknown }
-					? ArrayBuffer
-					: null
-
-/** Extract the resolved output type — infer from schema validators in the output definition */
-export type OutputFor<TRoutes, P extends string, M extends string> =
-	OutputDefFor<TRoutes, P, M> extends infer O
-		? [O] extends [never]
-			? null
-			: IsEmptyOutput<O> extends true
-				? null
-				: O extends { "application/json": infer JsonMap }
-					? JsonMap extends Record<string, StandardSchemaLike>
-						? InferOutput<JsonMap[keyof JsonMap]>
-						: null
-					: ContentTypeReturn<O>
-		: null
-
-/** Check if a route returns SSE (text/event-stream in output) */
-export type IsSSE<TRoutes, P extends string, M extends string> =
-	OutputDefFor<TRoutes, P, M> extends infer O ? (O extends { "text/event-stream": unknown } ? true : false) : false
-
-/** Extract errorsByStatus from route record if available */
-type ErrorsByStatusFor<TRoutes, P extends string, M extends string> = P extends keyof TRoutes
-	? M extends keyof TRoutes[P]
-		? TRoutes[P][M] extends { errorsByStatus: infer S }
-			? S
-			: never
-		: never
-	: never
-
-/** Default Honey error envelope — used when errorsByStatus lists `null` (standard errors) */
-export type ErrorEnvelope<TStatus extends number = number, TKey extends string = string> = {
-	error_key: TKey
-	fields: Record<string, FieldError[]>
-	message: string
-	status: TStatus
-	status_key: string
-	success: false
-}
-
-/** `null` in a route's errorsByStatus means the default envelope, not a null body */
-type ResolveErrorBody<S extends number, T> = T extends null ? ErrorEnvelope<S> : T
-
-/** Object keys of `{ 400: ... }` are `400` or `"400"` depending on TS version */
-type StatusCode<K> = K extends number ? K : K extends `${infer N extends number}` ? N : never
-
-type HasStatusErrors<T> = [StatusCode<keyof T>] extends [never] ? false : true
-
-type ErrorVariants<TErrorsByStatus> = {
-	[K in keyof TErrorsByStatus]: StatusCode<K> extends never
-		? never
-		: {
-				data: null
-				error: ResolveErrorBody<StatusCode<K>, TErrorsByStatus[K]>
-				response: Response
-				status: StatusCode<K>
-			}
-}[keyof TErrorsByStatus]
-
-/**
- * Result tuple for safe (non-throwing) mode — error is the raw parsed body, not ClientError.
- * When TErrorsByStatus is known, the typed branch covers every declared error status
- * (no unknown fallback) so `if (error)` / `if (!error)` narrow.
- */
-export type ClientResult<TData, TErrorsByStatus = never> =
-	| { data: TData; error: null; response: Response; status: number }
-	| (HasStatusErrors<TErrorsByStatus> extends false
-			? { data: null; error: unknown; response: Response; status: number }
-			: ErrorVariants<TErrorsByStatus>)
-
-/** Resolve return type based on transport + throw mode */
-export type ReturnFor<TRoutes, P extends string, M extends string, TThrow extends boolean = true> =
-	IsSSE<TRoutes, P, M> extends true
-		? AsyncIterable<SSEEvent>
-		: TThrow extends true
-			? Promise<OutputFor<TRoutes, P, M>>
-			: Promise<ClientResult<OutputFor<TRoutes, P, M>, ErrorsByStatusFor<TRoutes, P, M>>>
-
-/** Build the client input type — merge route input with params from path */
-export type ClientInput<TRoutes, P extends string, M extends string> = InputFor<TRoutes, P, M> & ParamsInput<P>
-
-/** Extract params input if path has params */
-type ParamsInput<P extends string> =
-	ParamsFromPath<P> extends Record<string, string>
-		? HasParams<P> extends true
-			? { params: ParamsFromPath<P> }
-			: {}
-		: {}
-
-/** Check if path has any param segments */
-type HasParams<P extends string> = P extends `${string}:${string}` ? true : false
-
-/** Extract error keys for a route */
-export type ErrorsFor<TRoutes, P extends string, M extends string> = P extends keyof TRoutes
-	? M extends keyof TRoutes[P]
-		? TRoutes[P][M] extends { errors: infer E extends string }
-			? E
-			: never
-		: never
-	: never
-
-/** The typed client interface — TThrow controls return type */
-export type HoneyClient<TRoutes, TThrow extends boolean = false> = {
-	$isClientError: (e: unknown) => e is import("./error.ts").ClientError
-
-	$path<P extends keyof TRoutes & string>(
-		path: P,
-		input?: { params?: Record<string, string>; search?: Record<string, unknown> },
-	): string
-
-	$url<P extends keyof TRoutes & string>(
-		path: P,
-		input?: { params?: Record<string, string>; search?: Record<string, unknown> },
-	): string
-
-	delete<P extends PathsForMethod<TRoutes, "delete">>(
-		path: P,
-		...input: OptionalInput<ClientInput<TRoutes, P, "delete">>
-	): ReturnFor<TRoutes, P, "delete", TThrow>
-
-	get<P extends PathsForMethod<TRoutes, "get">>(
-		path: P,
-		...input: OptionalInput<ClientInput<TRoutes, P, "get">>
-	): ReturnFor<TRoutes, P, "get", TThrow>
-
-	patch<P extends PathsForMethod<TRoutes, "patch">>(
-		path: P,
-		...input: OptionalInput<ClientInput<TRoutes, P, "patch">>
-	): ReturnFor<TRoutes, P, "patch", TThrow>
-
-	post<P extends PathsForMethod<TRoutes, "post">>(
-		path: P,
-		...input: OptionalInput<ClientInput<TRoutes, P, "post">>
-	): ReturnFor<TRoutes, P, "post", TThrow>
-
-	put<P extends PathsForMethod<TRoutes, "put">>(
-		path: P,
-		...input: OptionalInput<ClientInput<TRoutes, P, "put">>
-	): ReturnFor<TRoutes, P, "put", TThrow>
-
-	ws(
-		path: string,
-		input?: {
-			params?: Record<string, string>
-			protocols?: string | string[]
-			reconnectToken?: string
-			search?: Record<string, unknown>
-		},
-	): TypedWebSocket
-}
-
-/** Make input optional when it's an empty object */
-type OptionalInput<T> = keyof T extends never
-	? [input?: T]
-	: [RequiresAllOptional<T>] extends [true]
-		? [input?: T]
-		: [input: T]
-
-/** Check if all keys in T are optional */
-type RequiresAllOptional<T> = {
-	[K in keyof T]-?: undefined extends T[K] ? true : false
-}[keyof T] extends true
-	? true
-	: Partial<T> extends T
-		? true
-		: false

package/src/client/ws.ts

@@ -1,149 +0,0 @@
-export type TypedWebSocket = {
-	close(code?: number, reason?: string): void
-	off(event: "binary" | "close" | "error" | "message" | "open", handler: (...args: never[]) => void): void
-	/** Binary frames, as `ArrayBuffer`. Text frames go to `"message"`. */
-	on(event: "binary", handler: (data: ArrayBuffer) => void): void
-	on(event: "close", handler: (code: number, reason: string) => void): void
-	on(event: "error", handler: (error: unknown) => void): void
-	/** Text frames. */
-	on(event: "message", handler: (data: string) => void): void
-	on(event: "open", handler: () => void): void
-	readonly readyState: number
-	/**
-	 * Strings, `ArrayBuffer`, typed arrays and `Blob` are sent as-is; any other value is
-	 * JSON-encoded. Sends before the socket opens are queued; after it closes they are dropped.
-	 */
-	send(data: ArrayBuffer | ArrayBufferView | Blob | object | string): void
-}
-
-export type WSOptions = {
-	protocols?: string | string[]
-}
-
-type Payload = Blob | string | Uint8Array<ArrayBuffer>
-
-const EVENTS = new Set(["binary", "close", "error", "message", "open"])
-
-export function createTypedWebSocket(
-	url: string,
-	opts?: WSOptions,
-	WebSocketImpl: typeof WebSocket = WebSocket,
-): TypedWebSocket {
-	const ws = opts?.protocols ? new WebSocketImpl(url, opts.protocols) : new WebSocketImpl(url)
-	ws.binaryType = "arraybuffer"
-
-	/* user handler → wrapped listener, per event, so one handler can be registered for several events */
-	const listeners = new Map<string, WeakMap<(...args: never[]) => void, EventListener>>()
-	/* queue sends until OPEN; stop queueing for good once the socket closes or fails */
-	const sendBuffer: Payload[] = []
-	let state: "closed" | "connecting" | "open" = "connecting"
-
-	ws.addEventListener("open", () => {
-		state = "open"
-		for (const msg of sendBuffer) {
-			ws.send(msg)
-		}
-		sendBuffer.length = 0
-	})
-	ws.addEventListener("close", () => {
-		state = "closed"
-		sendBuffer.length = 0
-	})
-
-	function close(code?: number, reason?: string) {
-		state = "closed"
-		sendBuffer.length = 0
-		ws.close(code, reason)
-	}
-
-	function on(event: "binary", handler: (data: ArrayBuffer) => void): void
-	function on(event: "close", handler: (code: number, reason: string) => void): void
-	function on(event: "error", handler: (error: unknown) => void): void
-	function on(event: "message", handler: (data: string) => void): void
-	function on(event: "open", handler: () => void): void
-	function on(event: string, handler: (...args: never[]) => void): void {
-		if (!EVENTS.has(event)) return
-		let wrapped: EventListener
-		switch (event) {
-			case "message":
-				wrapped = (e: Event) => {
-					const data = (e as MessageEvent).data
-					if (typeof data === "string") (handler as (data: string) => void)(data)
-				}
-				break
-			case "binary":
-				wrapped = (e: Event) => {
-					const data = (e as MessageEvent).data
-					if (data instanceof ArrayBuffer) (handler as (data: ArrayBuffer) => void)(data)
-				}
-				break
-			case "open":
-				wrapped = () => (handler as () => void)()
-				break
-			case "close":
-				wrapped = (e: Event) =>
-					(handler as (code: number, reason: string) => void)((e as CloseEvent).code, (e as CloseEvent).reason)
-				break
-			default:
-				wrapped = (e: Event) => (handler as (error: unknown) => void)(e)
-				break
-		}
-		let byHandler = listeners.get(event)
-		if (byHandler === undefined) {
-			byHandler = new WeakMap()
-			listeners.set(event, byHandler)
-		}
-		const previous = byHandler.get(handler)
-		if (previous) ws.removeEventListener(event === "binary" ? "message" : event, previous)
-		byHandler.set(handler, wrapped)
-		ws.addEventListener(event === "binary" ? "message" : event, wrapped)
-	}
-
-	function off(event: string, handler: (...args: never[]) => void): void {
-		const byHandler = listeners.get(event)
-		const wrapped = byHandler?.get(handler)
-		if (wrapped) {
-			ws.removeEventListener(event === "binary" ? "message" : event, wrapped)
-			byHandler?.delete(handler)
-		}
-	}
-
-	function toPayload(data: ArrayBuffer | ArrayBufferView | Blob | object | string): Payload {
-		if (typeof data === "string") return data
-		if (typeof Blob !== "undefined" && data instanceof Blob) return data
-		if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
-			const view =
-				data instanceof ArrayBuffer
-					? new Uint8Array(data)
-					: new Uint8Array(data.buffer, data.byteOffset, data.byteLength)
-			const copy = new Uint8Array(view.byteLength)
-			copy.set(view)
-			return copy
-		}
-		return JSON.stringify(data)
-	}
-
-	function send(data: ArrayBuffer | ArrayBufferView | Blob | object | string) {
-		if (state === "closed") return
-		const payload = toPayload(data)
-		if (state === "connecting") {
-			sendBuffer.push(payload)
-		} else {
-			ws.send(payload)
-		}
-	}
-
-	const typed: TypedWebSocket = {
-		close,
-		off,
-		on,
-		get readyState() {
-			return ws.readyState
-		},
-		send,
-	}
-
-	Object.defineProperty(typed, "_ws", { enumerable: false, value: ws })
-
-	return typed
-}