@znight/http 0.1.1 → 0.1.3

package/src/plugin.ts

@@ -1,6 +1,5 @@
 import type { Container, Plugin, PluginContext, PluginOptions, ProviderKey, Token, ZnightMetadata } from '@znight/core'
 import type {
-  AdapterReply,
   HttpAdapter,
   HttpServerAddress,
   InjectRequest,
@@ -49,7 +48,14 @@ import { openInjectSse } from './inject-sse.ts'
 import { isMediaTypePattern } from './mime.ts'
 import { invalidOption } from './option-error.ts'
 import { compareRoutePaths, compareStrings, joinPaths, parseRoutePath, type RoutePath, RoutePathError } from './path.ts'
-import { DEFAULT_SSE_SETTINGS, Pipeline, type Resolvable, type RoutePlan, type SseSettings } from './pipeline.ts'
+import {
+  DEFAULT_SSE_SETTINGS,
+  Pipeline,
+  type Resolvable,
+  type RoutePlan,
+  randomRequestId,
+  type SseSettings,
+} from './pipeline.ts'
 import { collectPluginRoutes } from './plugin-routes.ts'
 import { resolveTrustProxy } from './proxy.ts'
 import { RouteTable } from './router.ts'
@@ -512,7 +518,7 @@ export class HttpPlugin implements Plugin {
       adapter.registerRoute({
         method: registration.method,
         path: registration.path,
-        handler: (request): Promise<AdapterReply> => pipeline.handle(plan, request),
+        handler: pipeline.handler(plan),
       })
       routes.push(
         Object.freeze({
@@ -649,7 +655,7 @@ function resolve(options: HttpPluginOptions): Resolved {
   if (requestIdHeader !== false && (typeof requestIdHeader !== 'string' || !isHeaderName(requestIdHeader))) {
     throw invalidOption('requestIdHeader', 'a header name or false', requestIdHeader)
   }
-  const generateRequestId = options.generateRequestId ?? ((): string => crypto.randomUUID())
+  const generateRequestId = options.generateRequestId ?? randomRequestId
   if (typeof generateRequestId !== 'function') throw invalidOption('generateRequestId', 'a function', generateRequestId)
   const adapter = options.adapter ?? nodeAdapter()
   if (

package/src/query.ts

@@ -23,8 +23,14 @@ export function parseQuery(query: string): QueryRecord {
   return result
 }
 
+/** A request target split into its raw path and raw query string (without `?`). */
+export interface RequestTarget {
+  readonly path: string
+  readonly query: string
+}
+
 /** Splits a request target (`/users?page=2`) into its raw path and raw query (without `?`). */
-export function splitUrl(url: string): { readonly path: string; readonly query: string } {
+export function splitUrl(url: string): RequestTarget {
   const index = url.indexOf('?')
   return index === -1 ? { path: url, query: '' } : { path: url.slice(0, index), query: url.slice(index + 1) }
 }

package/src/response.ts

@@ -229,12 +229,10 @@ function withCookie(cookies: readonly ResponseCookie[], cookie: ResponseCookie):
 
 /** Whether `value` is an {@link HttpResponse} (also across duplicated package copies). */
 export function isHttpResponse(value: unknown): value is HttpResponse {
-  return (
-    value instanceof HttpResponse ||
-    (value !== null &&
-      typeof value === 'object' &&
-      (value as { constructor?: { name?: unknown } }).constructor?.name === 'HttpResponse' &&
-      'body' in value &&
-      'headers' in value)
-  )
+  if (value instanceof HttpResponse) return true
+  if (value === null || typeof value !== 'object') return false
+  const type = (value as { constructor?: { name?: unknown } }).constructor
+  // object literals and arrays (most handler results): reading a function's name is slow
+  if (type === Object || type === Array) return false
+  return type?.name === 'HttpResponse' && 'body' in value && 'headers' in value
 }

package/src/serialize.ts

@@ -5,6 +5,7 @@ import type { ResolvedFile } from './files.ts'
 import type { HttpResponse } from './response.ts'
 import type { SseSession } from './sse.ts'
 
+import { Buffer } from 'node:buffer'
 import { Readable } from 'node:stream'
 
 import { isFileBody } from './files.ts'
@@ -12,10 +13,16 @@ import { isHttpResponse } from './response.ts'
 import { isSseBody } from './sse.ts'
 import { isBodylessStatus } from './status.ts'
 import { discardStream, isByteStream, toByteStream } from './stream.ts'
-import { emptyRecord } from './utils.ts'
+import { fastRecord, isBun } from './utils.ts'
 
 const ENCODER = new TextEncoder()
 
+/**
+ * UTF-8 encoding of a text body: a pooled `Buffer` (a `Uint8Array`) is several times cheaper than
+ * `TextEncoder` on Node.js, `TextEncoder` is the fastest on Bun.
+ */
+const utf8: (text: string) => Uint8Array = isBun() ? text => ENCODER.encode(text) : text => Buffer.from(text, 'utf8')
+
 /** Content types set by the serialiser. */
 export const ContentType: {
   readonly json: string
@@ -48,6 +55,10 @@ export interface SerializedReply {
   readonly status: number
   readonly headers: Record<string, HeaderValue>
   readonly body: ReplyBody
+  /** The text `body` encodes, for a body serialised from a string (JSON, text). */
+  readonly text?: string
+  /** Only the serialiser set the headers (content type and length): they are valid by construction. */
+  readonly ownHeaders?: boolean
   /** Cookies of the `HttpResponse` (`withCookie`), applied by the pipeline over those of the context. */
   readonly cookies?: readonly ResponseCookie[]
   /** The event stream of the body (`@Sse`, `HttpResponse.sse()`). */
@@ -85,12 +96,30 @@ export function serializeResult(result: unknown, options: SerializeOptions): Ser
     cookies = cookiesOf(result)
   }
   const finalStatus = options.status ?? status ?? defaultStatus(options.routeMethod, payload)
-  const headers = emptyRecord<HeaderValue>()
-  const body = encode(payload, headers)
-  if (options.headers !== undefined) assignHeaders(headers, options.headers)
-  if (options.context !== undefined) assignHeaders(headers, options.context)
-  if (extra !== undefined) assignHeaders(headers, extra)
-  return withCookies(finish(finalStatus, headers, body, options.method), cookies)
+  const headers = fastRecord<HeaderValue>()
+  const encoded = encode(payload, headers)
+  let body: ReplyBody
+  let text: string | undefined
+  if (typeof encoded === 'string') {
+    text = encoded
+    body = encodeText(encoded, headers, sendsBody(finalStatus, options.method))
+  } else {
+    body = encoded
+  }
+  let own = true
+  if (options.headers !== undefined) {
+    assignHeaders(headers, options.headers)
+    own = false
+  }
+  if (options.context !== undefined) {
+    assignHeaders(headers, options.context)
+    own = false
+  }
+  if (extra !== undefined) {
+    assignHeaders(headers, extra)
+    own = false
+  }
+  return withCookies(finish(finalStatus, headers, body, options.method, text, own), cookies)
 }
 
 /**
@@ -106,7 +135,7 @@ export function serializeSseReply(
   options: SerializeOptions,
 ): SerializedReply {
   const status = options.status ?? response?.status ?? 200
-  const headers = emptyRecord<HeaderValue>()
+  const headers = fastRecord<HeaderValue>()
   headers['cache-control'] = 'no-cache, no-transform'
   headers['x-accel-buffering'] = 'no'
   if (options.headers !== undefined) assignHeaders(headers, options.headers)
@@ -140,7 +169,7 @@ export function serializeFileReply(
   options: SerializeOptions,
 ): SerializedReply {
   const status = file.status === 200 ? (options.status ?? response.status ?? 200) : file.status
-  const headers = emptyRecord<HeaderValue>()
+  const headers = fastRecord<HeaderValue>()
   assignHeaders(headers, file.headers)
   if (options.headers !== undefined) assignHeaders(headers, options.headers)
   if (options.context !== undefined) assignHeaders(headers, options.context)
@@ -156,9 +185,10 @@ function defaultStatus(routeMethod: string, payload: unknown): number {
 
 /** Serialises an error body as JSON. */
 export function serializeError(status: number, body: HttpErrorBody | unknown, method: string): SerializedReply {
-  const headers = emptyRecord<HeaderValue>()
+  const headers = fastRecord<HeaderValue>()
   const encoded = encode(body, headers)
-  return finish(status, headers, encoded, method)
+  if (typeof encoded !== 'string') return finish(status, headers, encoded, method)
+  return finish(status, headers, encodeText(encoded, headers, sendsBody(status, method)), method, encoded)
 }
 
 /** Copies headers with lower-case names (later values win). */
@@ -184,11 +214,17 @@ export function addMissingHeaders(
   }
 }
 
+/**
+ * The reply of a body: `text` is the string `body` encodes (see {@link encodeText}). `own`: only
+ * {@link encode} set `headers`, which are then valid for a text body.
+ */
 function finish(
   status: number,
   headers: Record<string, HeaderValue>,
   body: ReplyBody,
   method: string,
+  text?: string,
+  own = false,
 ): SerializedReply {
   if (isBodylessStatus(status)) {
     discard(body)
@@ -200,16 +236,42 @@ function finish(
     discard(body)
     return { status, headers, body: null }
   }
-  return { status, headers, body }
+  if (text === undefined) return { status, headers, body }
+  return own ? { status, headers, body, text, ownHeaders: true } : { status, headers, body, text }
 }
 
 function discard(body: ReplyBody): void {
   if (body instanceof ReadableStream) discardStream(body)
 }
 
-function encode(payload: unknown, headers: Record<string, HeaderValue>): ReplyBody {
+/** Whether a reply with this status, to this method, carries its body (see {@link finish}). */
+function sendsBody(status: number, method: string): boolean {
+  return method !== 'HEAD' && !isBodylessStatus(status)
+}
+
+/**
+ * Sets the `content-length` of a text body (right after its `content-type`, before the route
+ * headers) and returns its UTF-8 bytes: their length is the header, a lone surrogate counting as
+ * U+FFFD. `null` when the reply sends no body (`HEAD`, bodyless status): nothing is encoded then,
+ * `Buffer.byteLength` counts the same bytes.
+ */
+function encodeText(text: string, headers: Record<string, HeaderValue>, sent: boolean): Uint8Array | null {
+  if (!sent) {
+    headers['content-length'] = String(Buffer.byteLength(text, 'utf8'))
+    return null
+  }
+  const bytes = utf8(text)
+  headers['content-length'] = String(bytes.byteLength)
+  return bytes
+}
+
+/**
+ * The body of a payload, its `content-type` and, for bytes, its `content-length` set in `headers`.
+ * Text (a string, JSON) is returned as a string: {@link encodeText} sets its length and encodes it.
+ */
+function encode(payload: unknown, headers: Record<string, HeaderValue>): ReplyBody | string {
   if (payload === undefined) return null
-  if (typeof payload === 'string') return bytes(ENCODER.encode(payload), headers, ContentType.text)
+  if (typeof payload === 'string') return text(payload, headers, ContentType.text)
   if (payload instanceof Uint8Array) return bytes(payload, headers, ContentType.bytes)
   if (payload instanceof ArrayBuffer) return bytes(new Uint8Array(payload), headers, ContentType.bytes)
   if (ArrayBuffer.isView(payload)) {
@@ -233,7 +295,7 @@ function encode(payload: unknown, headers: Record<string, HeaderValue>): ReplyBo
   if (isSseBody(payload)) throw new TypeError('An event stream (HttpResponse.sse()) cannot be serialised here')
   const json = JSON.stringify(payload)
   if (json === undefined) throw new TypeError(`Cannot serialise a ${typeof payload} as a response body`)
-  return bytes(ENCODER.encode(json), headers, ContentType.json)
+  return text(json, headers, ContentType.json)
 }
 
 function bytes(data: Uint8Array, headers: Record<string, HeaderValue>, type: string): Uint8Array {
@@ -242,6 +304,11 @@ function bytes(data: Uint8Array, headers: Record<string, HeaderValue>, type: str
   return data
 }
 
+function text(data: string, headers: Record<string, HeaderValue>, type: string): string {
+  headers['content-type'] = type
+  return data
+}
+
 function isNodeReadable(value: unknown): value is Readable {
   return (
     value instanceof Readable ||
@@ -254,7 +321,7 @@ function isNodeReadable(value: unknown): value is Readable {
 }
 
 function fromWebResponse(response: Response, method: string): SerializedReply {
-  const headers = emptyRecord<HeaderValue>()
+  const headers = fastRecord<HeaderValue>()
   for (const [name, value] of response.headers) {
     if (name !== 'set-cookie') headers[name] = value
   }

package/src/utils.ts

@@ -1,7 +1,13 @@
 /** Internal helpers (not part of the public API). */
 
-/** Whether `value` is a promise-like object (has a callable `then`). */
-export function isThenable(value: unknown): value is PromiseLike<unknown> {
+/**
+ * Whether `value` is a promise-like object (has a callable `then`). The guard keeps the thenable
+ * part of the value's type (`Promise<R>` of `R | Promise<R>`, even when `R` is `object` or `any`), so
+ * that generated code awaiting it gets `R`.
+ */
+export function isThenable<T>(
+  value: T,
+): value is unknown extends T ? T & PromiseLike<unknown> : Extract<T, PromiseLike<unknown>> {
   return (
     value !== null &&
     (typeof value === 'object' || typeof value === 'function') &&
@@ -25,6 +31,23 @@ export function emptyRecord<V>(): Record<string, V> {
   return Object.create(null) as Record<string, V>
 }
 
+/**
+ * Constructor of {@link fastRecord}: its prototype is an empty, frozen object without prototype, so
+ * nothing is inherited (`__proto__`, `constructor`, `toString`... are plain own keys).
+ */
+const FastRecord = function FastRecord() {} as unknown as new () => object
+FastRecord.prototype = Object.freeze(Object.create(null))
+
+/**
+ * A `Record` that inherits nothing, like {@link emptyRecord}, but that V8 keeps in fast mode: an
+ * `Object.create(null)` object is a dictionary, about twice as slow to fill and enumerate (response
+ * headers: built, completed and enumerated on every request). Its prototype is not `null` (an empty
+ * frozen object): use {@link emptyRecord} for records handed to user code (query, fields...).
+ */
+export function fastRecord<V>(): Record<string, V> {
+  return new FastRecord() as Record<string, V>
+}
+
 /** Whether the code runs on Bun. */
 export function isBun(): boolean {
   return typeof (globalThis as { Bun?: unknown }).Bun !== 'undefined'

package/src/validate.ts

@@ -1,20 +1,28 @@
-import { ValidationException } from './exceptions.ts'
-import {
-  type InferSchemaOutput,
-  isStandardSchema,
-  type StandardSchemaV1,
-  type StandardSchemaV1Issue,
-  type StandardSchemaV1Result,
+import type {
+  InferSchemaOutput,
+  StandardSchemaV1,
+  StandardSchemaV1Issue,
+  StandardSchemaV1Props,
+  StandardSchemaV1Result,
 } from './standard-schema.ts'
+
+import { ValidationException } from './exceptions.ts'
 import { isThenable } from './utils.ts'
 
+/**
+ * Whether `value` is a promise-like object (has a callable `then`). Called by the generated
+ * `invoke` functions on the result of {@link validate} (README, "Compiler contract").
+ */
+export { isThenable } from './utils.ts'
+
 /**
  * Validates `value` with a [Standard Schema](https://standardschema.dev) (Zod, Valibot, ArkType...)
  * and returns the schema **output** (defaults applied, transforms run, unknown keys stripped when
  * the schema strips them).
  *
  * Returns synchronously when the schema validates synchronously, a promise otherwise (async
- * refinements): generated code always `await`s it.
+ * refinements): generated code calls the handler directly with the value, and `await`s the value
+ * when it is a thenable (`isThenable`).
  *
  * @param location what is validated, used in the error message: `body`, `query`, `query "page"`,
  *   `param "id"`, `headers`, `cookie "sid"`, `cookies`...
@@ -28,12 +36,20 @@ export function validate<S extends StandardSchemaV1>(
   value: unknown,
   location: string,
 ): InferSchemaOutput<S> | Promise<InferSchemaOutput<S>> {
-  if (!isStandardSchema(schema)) {
+  // `~standard` is read once (the same checks as `isStandardSchema`)
+  const props =
+    schema !== null && (typeof schema === 'object' || typeof schema === 'function')
+      ? (schema as { readonly '~standard'?: unknown })['~standard']
+      : undefined
+  if (
+    props === null ||
+    typeof props !== 'object' ||
+    (props as { readonly version?: unknown }).version !== 1 ||
+    typeof (props as { readonly validate?: unknown }).validate !== 'function'
+  ) {
     throw new TypeError(`The schema of ${location} is not a Standard Schema v1 (missing "~standard.validate")`)
   }
-  const result = schema['~standard'].validate(value) as
-    | StandardSchemaV1Result<InferSchemaOutput<S>>
-    | Promise<StandardSchemaV1Result<InferSchemaOutput<S>>>
+  const result = (props as StandardSchemaV1Props<unknown, InferSchemaOutput<S>>).validate(value)
   if (isThenable(result)) return Promise.resolve(result).then(settled => unwrap(settled, location))
   return unwrap(result, location)
 }

package/dist/utils-DCbu3a4w.mjs

@@ -1,27 +0,0 @@
-// src/utils.ts
-/** Internal helpers (not part of the public API). */
-/** Whether `value` is a promise-like object (has a callable `then`). */
-function isThenable(value) {
-	return value !== null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
-}
-/** Message of any thrown value. */
-function errorMessage(error) {
-	if (error instanceof Error) return error.message;
-	if (typeof error === "string") return error;
-	try {
-		return String(error);
-	} catch {
-		return Object.prototype.toString.call(error);
-	}
-}
-/** A `Record` without prototype (safe for user-controlled keys such as `__proto__`). */
-function emptyRecord() {
-	return Object.create(null);
-}
-/** Whether the code runs on Bun. */
-function isBun() {
-	return typeof globalThis.Bun !== "undefined";
-}
-export { isThenable as i, errorMessage as n, isBun as r, emptyRecord as t };
-
-//# sourceMappingURL=utils-DCbu3a4w.mjs.map

package/dist/utils-DCbu3a4w.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils-DCbu3a4w.mjs","names":[],"sources":["../src/utils.ts"],"sourcesContent":["/** Internal helpers (not part of the public API). */\n\n/** Whether `value` is a promise-like object (has a callable `then`). */\nexport function isThenable(value: unknown): value is PromiseLike<unknown> {\n  return (\n    value !== null &&\n    (typeof value === 'object' || typeof value === 'function') &&\n    typeof (value as { then?: unknown }).then === 'function'\n  )\n}\n\n/** Message of any thrown value. */\nexport function errorMessage(error: unknown): string {\n  if (error instanceof Error) return error.message\n  if (typeof error === 'string') return error\n  try {\n    return String(error)\n  } catch {\n    return Object.prototype.toString.call(error)\n  }\n}\n\n/** A `Record` without prototype (safe for user-controlled keys such as `__proto__`). */\nexport function emptyRecord<V>(): Record<string, V> {\n  return Object.create(null) as Record<string, V>\n}\n\n/** Whether the code runs on Bun. */\nexport function isBun(): boolean {\n  return typeof (globalThis as { Bun?: unknown }).Bun !== 'undefined'\n}\n"],"mappings":";;;AAGA,SAAgB,WAAW,OAA+C;CACxE,OACE,UAAU,SACT,OAAO,UAAU,YAAY,OAAO,UAAU,eAC/C,OAAQ,MAA6B,SAAS;AAElD;;AAGA,SAAgB,aAAa,OAAwB;CACnD,IAAI,iBAAiB,OAAO,OAAO,MAAM;CACzC,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI;EACF,OAAO,OAAO,KAAK;CACrB,QAAQ;EACN,OAAO,OAAO,UAAU,SAAS,KAAK,KAAK;CAC7C;AACF;;AAGA,SAAgB,cAAoC;CAClD,OAAO,OAAO,OAAO,IAAI;AAC3B;;AAGA,SAAgB,QAAiB;CAC/B,OAAO,OAAQ,WAAiC,QAAQ;AAC1D"}