@lovrozagar/honey 0.7.3 → 1.0.0-rc.1

package/src/ip.ts

@@ -1,194 +0,0 @@
-/**
- * IP addresses in canonical numeric form. Every comparison the framework makes (`ipRestrict`
- * rules, trusted proxy ranges) parses both sides here first, so `::ffff:203.0.113.7`,
- * `203.0.113.7` and `203.0.113.7:51234` are one address and `2001:DB8::1` equals `2001:db8::1`.
- */
-
-export type IpAddress = { readonly v: 4; readonly n: number } | { readonly v: 6; readonly n: bigint }
-
-export type IpRange =
-	| { readonly v: 4; readonly base: number; readonly mask: number }
-	| { readonly v: 6; readonly base: bigint; readonly mask: bigint }
-
-const V4_MAPPED_PREFIX = 0xffffn << 32n
-const V4_MAPPED_MASK = ~0xffffffffn & ((1n << 128n) - 1n)
-
-function parseIpv4(s: string): number | null {
-	const parts = s.split(".")
-	if (parts.length !== 4) return null
-	let n = 0
-	for (const part of parts) {
-		/* digits only, no leading zeros (`010` is octal to some parsers, decimal to others) */
-		if (part.length === 0 || part.length > 3 || !/^\d+$/.test(part)) return null
-		if (part.length > 1 && part.charCodeAt(0) === 48) return null
-		const octet = Number(part)
-		if (octet > 255) return null
-		n = n * 256 + octet
-	}
-	return n
-}
-
-/** The `:`-separated hex groups of one side of `::`; `null` when a group is not 1–4 hex digits. */
-function groupsOf(part: string): string[] | null {
-	if (part === "") return []
-	const groups = part.split(":")
-	for (const g of groups) {
-		if (!/^[0-9A-Fa-f]{1,4}$/.test(g)) return null
-	}
-	return groups
-}
-
-function parseIpv6(s: string): bigint | null {
-	let addr = s
-	let tail: number[] = []
-	const lastColon = addr.lastIndexOf(":")
-	if (lastColon !== -1 && addr.indexOf(".", lastColon) !== -1) {
-		const v4 = parseIpv4(addr.slice(lastColon + 1))
-		if (v4 === null) return null
-		tail = [Math.floor(v4 / 65536), v4 % 65536]
-		addr = addr.slice(0, lastColon + 1)
-		/* "::1.2.3.4" leaves "::", "a::1.2.3.4" leaves "a::"; "a:1.2.3.4" leaves "a:" */
-		if (addr.endsWith(":") && !addr.endsWith("::")) addr = addr.slice(0, -1)
-	}
-	const halves = addr.split("::")
-	if (halves.length > 2) return null
-	const left = groupsOf(halves[0])
-	if (left === null) return null
-	let groups: number[]
-	if (halves.length === 2) {
-		const right = groupsOf(halves[1])
-		if (right === null) return null
-		const fill = 8 - left.length - right.length - tail.length
-		if (fill < 1) return null
-		groups = [...left.map(hex), ...Array.from({ length: fill }, () => 0), ...right.map(hex), ...tail]
-	} else {
-		groups = [...left.map(hex), ...tail]
-	}
-	if (groups.length !== 8) return null
-	let n = 0n
-	for (const g of groups) n = (n << 16n) | BigInt(g)
-	return n
-}
-
-function hex(g: string): number {
-	return Number.parseInt(g, 16)
-}
-
-/** An IPv4-mapped IPv6 address (`::ffff:a.b.c.d`) is the IPv4 address it maps. */
-function fromV6(n: bigint): IpAddress {
-	if ((n & V4_MAPPED_MASK) === V4_MAPPED_PREFIX) return { n: Number(n & 0xffffffffn), v: 4 }
-	return { n, v: 6 }
-}
-
-/**
- * Parses an address as a peer or a forwarding header writes it: brackets, an IPv6 zone
- * (`%eth0`) and a port (`1.2.3.4:5678`, `[::1]:5678`) are accepted and dropped. Returns
- * `null` for anything that is not exactly one address.
- */
-export function parseIp(input: string): IpAddress | null {
-	let s = input.trim()
-	if (s.startsWith("[")) {
-		const close = s.indexOf("]")
-		if (close === -1) return null
-		const after = s.slice(close + 1)
-		if (after !== "" && !/^:\d{1,5}$/.test(after)) return null
-		s = s.slice(1, close)
-	} else if (s.indexOf(":") !== -1 && s.indexOf(":") === s.lastIndexOf(":") && s.includes(".")) {
-		/* "1.2.3.4:5678" — one colon and a dot can only be IPv4 with a port */
-		const [host, port] = s.split(":")
-		if (!/^\d{1,5}$/.test(port)) return null
-		s = host
-	}
-	const zone = s.indexOf("%")
-	if (zone !== -1) {
-		if (!s.includes(":")) return null
-		s = s.slice(0, zone)
-	}
-	if (s.includes(":")) {
-		const n = parseIpv6(s)
-		return n === null ? null : fromV6(n)
-	}
-	const n = parseIpv4(s)
-	return n === null ? null : { n, v: 4 }
-}
-
-/** Canonical text: dotted IPv4, or RFC 5952 IPv6 (lowercase, longest zero run compressed). */
-export function formatIp(addr: IpAddress): string {
-	if (addr.v === 4) {
-		const n = addr.n
-		return `${Math.floor(n / 16777216)}.${Math.floor(n / 65536) % 256}.${Math.floor(n / 256) % 256}.${n % 256}`
-	}
-	const groups: number[] = []
-	for (let i = 7; i >= 0; i--) groups.push(Number((addr.n >> BigInt(i * 16)) & 0xffffn))
-	let bestStart = -1
-	let bestLen = 1
-	for (let i = 0; i < 8;) {
-		if (groups[i] !== 0) {
-			i++
-			continue
-		}
-		let j = i
-		while (j < 8 && groups[j] === 0) j++
-		if (j - i > bestLen) {
-			bestStart = i
-			bestLen = j - i
-		}
-		i = j
-	}
-	const text = groups.map((g) => g.toString(16))
-	if (bestStart === -1) return text.join(":")
-	const head = text.slice(0, bestStart).join(":")
-	const tail = text.slice(bestStart + bestLen).join(":")
-	return `${head}::${tail}`
-}
-
-/** `canonicalIp("::ffff:127.0.0.1")` is `"127.0.0.1"`; `null` when the input is not an address. */
-export function canonicalIp(input: string): string | null {
-	const addr = parseIp(input)
-	return addr === null ? null : formatIp(addr)
-}
-
-/**
- * Parses an address or CIDR rule (`10.0.0.0/8`, `2001:db8::/32`, `203.0.113.7`). Strict: no
- * port, no zone, a prefix length that fits the family. An IPv4-mapped IPv6 range of `/96` or
- * longer is the IPv4 range it maps. Returns `null` when the rule is invalid.
- */
-export function parseIpRange(rule: string): IpRange | null {
-	const s = rule.trim()
-	const slash = s.indexOf("/")
-	const ipText = slash === -1 ? s : s.slice(0, slash)
-	if (ipText.startsWith("[") || ipText.includes("%")) return null
-	let bits: number | null = null
-	if (slash !== -1) {
-		const bitsText = s.slice(slash + 1)
-		if (!/^\d{1,3}$/.test(bitsText)) return null
-		bits = Number(bitsText)
-	}
-	if (ipText.includes(":")) {
-		const n = parseIpv6(ipText)
-		if (n === null) return null
-		const prefix = bits ?? 128
-		if (prefix > 128) return null
-		if ((n & V4_MAPPED_MASK) === V4_MAPPED_PREFIX && prefix >= 96) {
-			return v4Range(Number(n & 0xffffffffn), prefix - 96)
-		}
-		const mask = prefix === 0 ? 0n : (((1n << BigInt(prefix)) - 1n) << BigInt(128 - prefix)) & ((1n << 128n) - 1n)
-		return { base: n & mask, mask, v: 6 }
-	}
-	const n = parseIpv4(ipText)
-	if (n === null) return null
-	const prefix = bits ?? 32
-	if (prefix > 32) return null
-	return v4Range(n, prefix)
-}
-
-function v4Range(n: number, prefix: number): IpRange {
-	const mask = prefix === 0 ? 0 : (0xffffffff << (32 - prefix)) >>> 0
-	return { base: (n & mask) >>> 0, mask, v: 4 }
-}
-
-export function ipInRange(addr: IpAddress, range: IpRange): boolean {
-	if (addr.v === 4 && range.v === 4) return (addr.n & range.mask) >>> 0 === range.base
-	if (addr.v === 6 && range.v === 6) return (addr.n & range.mask) === range.base
-	return false
-}

package/src/logger.ts

@@ -1,178 +0,0 @@
-import { namedMiddleware } from "./middleware.ts"
-import type { MiddlewareFn } from "./middleware.ts"
-
-/* ── log levels (pino-compatible numeric values) ── */
-
-type LogLevel = "debug" | "error" | "fatal" | "info" | "trace" | "warn"
-
-const LEVELS: Record<LogLevel, number> = {
-	debug: 20,
-	error: 50,
-	fatal: 60,
-	info: 30,
-	trace: 10,
-	warn: 40,
-}
-
-/* ── logger instance ── */
-
-type LoggerInstance = {
-	child(bindings: Record<string, unknown>): LoggerInstance
-	debug(msg: string): void
-	debug(obj: Record<string, unknown>, msg?: string): void
-	error(msg: string): void
-	error(obj: Record<string, unknown>, msg?: string): void
-	fatal(msg: string): void
-	fatal(obj: Record<string, unknown>, msg?: string): void
-	info(msg: string): void
-	info(obj: Record<string, unknown>, msg?: string): void
-	level: LogLevel
-	trace(msg: string): void
-	trace(obj: Record<string, unknown>, msg?: string): void
-	warn(msg: string): void
-	warn(obj: Record<string, unknown>, msg?: string): void
-}
-
-type CreateLoggerOptions = {
-	base?: Record<string, unknown>
-	level?: LogLevel
-	write?: (line: string) => void
-}
-
-/* Methods live on the prototype: `logger()` makes a child per request, and a
- * closure-per-level instance cost seven allocations each time. */
-class Logger implements LoggerInstance {
-	level: LogLevel
-	#threshold: number
-	#write: (line: string) => void
-	#base: Record<string, unknown>
-
-	constructor(level: LogLevel, write: (line: string) => void, base: Record<string, unknown>) {
-		this.level = level
-		this.#threshold = LEVELS[level]
-		this.#write = write
-		this.#base = base
-	}
-
-	child(bindings: Record<string, unknown>): LoggerInstance {
-		return new Logger(this.level, this.#write, { ...this.#base, ...bindings })
-	}
-
-	trace(first: Record<string, unknown> | string, second?: string): void {
-		this.#emit(LEVELS.trace, first, second)
-	}
-
-	debug(first: Record<string, unknown> | string, second?: string): void {
-		this.#emit(LEVELS.debug, first, second)
-	}
-
-	info(first: Record<string, unknown> | string, second?: string): void {
-		this.#emit(LEVELS.info, first, second)
-	}
-
-	warn(first: Record<string, unknown> | string, second?: string): void {
-		this.#emit(LEVELS.warn, first, second)
-	}
-
-	error(first: Record<string, unknown> | string, second?: string): void {
-		this.#emit(LEVELS.error, first, second)
-	}
-
-	fatal(first: Record<string, unknown> | string, second?: string): void {
-		this.#emit(LEVELS.fatal, first, second)
-	}
-
-	#emit(level: number, first: Record<string, unknown> | string, second?: string): void {
-		if (level < this.#threshold) return
-		const obj =
-			typeof first === "string"
-				? { ...this.#base, level, msg: first, time: Date.now() }
-				: { ...this.#base, ...first, level, msg: second ?? "", time: Date.now() }
-		this.#write(JSON.stringify(obj))
-	}
-}
-
-function createLogger(opts?: CreateLoggerOptions): LoggerInstance {
-	return new Logger(opts?.level ?? "info", opts?.write ?? ((line: string) => console.log(line)), opts?.base ?? {})
-}
-
-/* ── request lifecycle middleware ── */
-
-type LogData = {
-	duration: number
-	method: string
-	path: string
-	requestId: string | null
-	status: number
-}
-
-type LoggerOptions = {
-	instance?: LoggerInstance
-	log?: (data: LogData) => void
-	skip?: (data: LogData) => boolean
-}
-
-function defaultLog(data: LogData): void {
-	const rid = data.requestId ? ` ${data.requestId}` : ""
-	console.log(`${data.method} ${data.path} ${data.status} ${data.duration.toFixed(2)}ms${rid}`)
-}
-
-const noop = () => {}
-const noopLogger: LoggerInstance = createLogger({ level: "fatal", write: noop })
-
-function logger(options?: LoggerOptions): MiddlewareFn<{ path: string; req: Request }, { log: LoggerInstance }> {
-	const log = options?.log ?? defaultLog
-	const skip = options?.skip
-	const instance = options?.instance
-
-	return namedMiddleware("logger", 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 child = instance
-			? instance.child({
-					method,
-					path,
-					...(rid ? { requestId: rid } : {}),
-				})
-			: noopLogger
-
-		/* a failing sink never fails the request, on the way in or out */
-		if (instance) {
-			try {
-				child.info(`--> ${method} ${path}`)
-			} catch (err) {
-				console.error("logger: failed to log request", err)
-			}
-		}
-
-		const response = await next({ log: child })
-
-		const duration = performance.now() - start
-		const data: LogData = {
-			duration,
-			method,
-			path,
-			requestId: rid,
-			status: response.status,
-		}
-
-		try {
-			if (skip?.(data)) return response
-			if (instance) {
-				child.info({ duration, status: response.status }, `<-- ${method} ${path}`)
-			} else {
-				log(data)
-			}
-		} catch (err) {
-			console.error("logger: failed to log request", err)
-		}
-
-		return response
-	})
-}
-
-export { createLogger, logger }
-export type { CreateLoggerOptions, LogData, LoggerInstance, LoggerOptions, LogLevel }

package/src/media-type.ts

@@ -1,104 +0,0 @@
-/**
- * One media-type parser (RFC 9110 §8.3.1) for every place that reads a `Content-Type`:
- * input validation, `bodyLimit`, and the client. Type, subtype and parameter names are
- * case-insensitive, so they are lowercased; parameter values keep their case.
- *
- * Pure and dependency-free: the client entry imports it too.
- */
-
-export type MediaType = {
-	/** `type/subtype`, lowercased, without parameters */
-	essence: string
-	/** parameters by lowercased name; a repeated name keeps the first value */
-	params: Record<string, string>
-	subtype: string
-	/** the structured-syntax suffix (`json` for `application/vnd.api+json`), or `null` */
-	suffix: string | null
-	type: string
-}
-
-/* RFC 9110 token characters */
-const TOKEN = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/
-
-function isToken(s: string): boolean {
-	return s.length > 0 && TOKEN.test(s)
-}
-
-/**
- * Parses a `Content-Type` (or any media type) value. Returns `null` for an absent or
- * malformed value, so a caller never mistakes `application/jsonx` or `json` for JSON.
- */
-export function parseMediaType(value: string | null | undefined): MediaType | null {
-	if (value === null || value === undefined) return null
-	const semi = value.indexOf(";")
-	const head = (semi === -1 ? value : value.slice(0, semi)).trim()
-	const slash = head.indexOf("/")
-	if (slash === -1) return null
-	const type = head.slice(0, slash).toLowerCase()
-	const subtype = head.slice(slash + 1).toLowerCase()
-	if (!isToken(type) || !isToken(subtype)) return null
-	const plus = subtype.lastIndexOf("+")
-	const suffix = plus > 0 && plus < subtype.length - 1 ? subtype.slice(plus + 1) : null
-	const params = Object.create(null) as Record<string, string>
-	if (semi !== -1) parseParams(value, semi + 1, params)
-	return { essence: `${type}/${subtype}`, params, subtype, suffix, type }
-}
-
-/* `; name=value` pairs; value is a token or a quoted-string. Malformed pairs are skipped,
- * as browsers and undici do, rather than rejecting the whole header. */
-function parseParams(value: string, start: number, out: Record<string, string>): void {
-	let i = start
-	const n = value.length
-	while (i < n) {
-		while (i < n && (value[i] === " " || value[i] === "\t" || value[i] === ";")) i++
-		const eq = value.indexOf("=", i)
-		const nextSemi = value.indexOf(";", i)
-		if (eq === -1 || (nextSemi !== -1 && nextSemi < eq)) {
-			i = nextSemi === -1 ? n : nextSemi + 1
-			continue
-		}
-		const name = value.slice(i, eq).trim().toLowerCase()
-		i = eq + 1
-		let v: string
-		if (value[i] === '"') {
-			i++
-			let buf = ""
-			while (i < n && value[i] !== '"') {
-				if (value[i] === "\\" && i + 1 < n) i++
-				buf += value[i]
-				i++
-			}
-			v = buf
-			i++ /* closing quote */
-			const after = value.indexOf(";", i)
-			i = after === -1 ? n : after + 1
-		} else {
-			const end = value.indexOf(";", i)
-			v = (end === -1 ? value.slice(i) : value.slice(i, end)).trim()
-			i = end === -1 ? n : end + 1
-		}
-		if (isToken(name) && !(name in out)) out[name] = v
-	}
-}
-
-/** `application/json`, or any `+json` structured-syntax type (`application/problem+json`). */
-export function isJsonMediaType(mt: MediaType | null): boolean {
-	return mt !== null && (mt.essence === "application/json" || mt.suffix === "json")
-}
-
-/** Text-like bodies: `text/*`, `application/xml`, and any `+xml` type. */
-export function isTextMediaType(mt: MediaType | null): boolean {
-	return mt !== null && (mt.type === "text" || mt.essence === "application/xml" || mt.suffix === "xml")
-}
-
-export type BodyParser = "json" | "multipart" | "urlencoded"
-
-/** Which body parser a request `Content-Type` selects, or `null` when none applies. */
-export function bodyParserFor(contentType: string | null | undefined): BodyParser | null {
-	const mt = parseMediaType(contentType)
-	if (mt === null) return null
-	if (isJsonMediaType(mt)) return "json"
-	if (mt.essence === "multipart/form-data") return "multipart"
-	if (mt.essence === "application/x-www-form-urlencoded") return "urlencoded"
-	return null
-}

package/src/meta-spec-merge.ts

@@ -1,80 +0,0 @@
-/**
- * Composition of metaSpec policies across mounted sub-apps. Kept apart from the policy engine
- * so the app core can merge policies without loading the engine.
- */
-import type { MetaSpecConfig, MetaSpecEntry, MetaSpecMergeConflict, MetaSpecStrictness } from "./types.ts"
-
-/** The strictness a declared policy actually runs with: `"error"` unless it says otherwise. */
-export function resolvedStrictness(config: MetaSpecConfig | null): MetaSpecStrictness {
-	return config?.strict ?? (config ? "error" : "off")
-}
-
-/**
- * Merge a mounted sub-app's policy into a parent's.
- *
- * The parent wins on conflict, so one gateway keeps one answer for its aggregate document —
- * with a single exception. A sub entry of `false` wins over anything the parent says, because
- * hiding is a safety claim and the strictest claim has to survive composition: a worker that
- * declares a field unpublishable must not have the gateway publish it. Wrongly hidden is a
- * visible gap; wrongly published is a leak.
- *
- * Strictness is the parent's *resolved* setting: a parent that never wrote `strict` runs with
- * `"error"`, and a sub-app's `"off"` must not downgrade it. Every other disagreement is
- * recorded in `conflicts` and reported at codegen.
- *
- * Order-independent with respect to when the parent declares its own policy: callers may keep
- * the absorbed sub policies and merge them in at codegen time.
- */
-export function mergeMetaSpec(own: MetaSpecConfig | null, sub: MetaSpecConfig | null): MetaSpecConfig | null {
-	if (!sub) return own
-	if (!own) return sub
-	const conflicts: MetaSpecMergeConflict[] = [...(own.conflicts ?? []), ...(sub.conflicts ?? [])]
-
-	const meta: Record<string, MetaSpecEntry> = { ...sub.meta, ...own.meta }
-	for (const [key, subEntry] of Object.entries(sub.meta ?? {})) {
-		const ownEntry = own.meta?.[key]
-		if (ownEntry === undefined || ownEntry === subEntry) continue
-		if (subEntry === false && ownEntry !== false) {
-			meta[key] = false
-			conflicts.push({ key, resolution: "hidden", section: "meta" })
-			continue
-		}
-		conflicts.push({ key, resolution: "parent", section: "meta" })
-	}
-
-	const recordOverlap = (section: "profiles" | "schema", subSide: object, ownSide: object): void => {
-		for (const [key, subEntry] of Object.entries(subSide)) {
-			const ownEntry = (ownSide as Record<string, unknown>)[key]
-			if (ownEntry === undefined || ownEntry === subEntry) continue
-			conflicts.push({ key, resolution: "parent", section })
-		}
-	}
-	recordOverlap("schema", sub.schema ?? {}, own.schema ?? {})
-	recordOverlap("profiles", sub.profiles ?? {}, own.profiles ?? {})
-
-	return {
-		conflicts,
-		meta,
-		profiles: { ...sub.profiles, ...own.profiles },
-		schema: { ...sub.schema, ...own.schema },
-		strict: resolvedStrictness(own),
-	}
-}
-
-/** A policy as an app holds it: its own declaration and each mounted sub-app's source, unmerged. */
-export type MetaSpecSource = {
-	readonly declared: MetaSpecConfig | null
-	readonly absorbed: readonly MetaSpecSource[]
-}
-
-function resolveSource(source: MetaSpecSource): MetaSpecConfig | null {
-	let merged = source.declared
-	for (const sub of source.absorbed) merged = mergeMetaSpec(merged, resolveSource(sub))
-	return merged
-}
-
-/** The policy codegen applies to `app`: its own, with every mounted sub-app's merged in mount order. */
-export function metaSpecOf(app: unknown): MetaSpecConfig | null {
-	const source = (app as { _metaSpecSource?: MetaSpecSource })._metaSpecSource
-	return source === undefined ? null : resolveSource(source)
-}