Request Lifecycle & Routing

Path variables come from the matched route template, so they exist whenever the handler runs. Query parameters and headers come from the client, so either may be missing or repeated, which is why frameworks expose both single- and multi-value accessors.

An HTTP response carries its status line and header block ahead of the body, so the framework sends them first. Once body bytes are flushed the response is committed, and later status, header or cookie changes are lost.

A static path matches one exact sequence of literal segments. A template such as /orders/{id} matches any single segment in that position and captures its text as a named path variable the handler can read.

Registering a route binds an HTTP method and path template to a handler in the routing table before requests arrive. A group registers many routes under a shared prefix and shared hooks, writing the common part once.

Everything downstream is skipped: the remaining hooks, binding, the handler and normal rendering. The hooks that already ran still get control back on the way out, and the response the short-circuiting hook produced is still written before the request's resources are released.

The body is a forward-only stream over the connection rather than a stored value: the first reader consumes the bytes and nothing rewinds them, so a later read reaches end-of-stream and produces nothing, usually without any error.

A response is committed once its first bytes reach the client. Commit freezes the status line and every header, cookies included; only body bytes may still be appended. Buffer overflow, an explicit flush or the handler ending triggers it.

Two rules are in use. Most-specific-wins ranks templates structurally, so a literal segment beats a placeholder and a placeholder beats a catch-all whatever the order. First-match-wins simply takes the earliest registration that matches.

Three styles dominate: declarative metadata attached to the handler, an explicit route table built by registration calls, and a convention that derives paths from file or name layout. They trade locality against a single readable inventory, and discovery against explicitness.

The server hands over one parsed request - method, target, headers, body stream and connection facts - plus a way to answer. The framework returns a status, headers and body, or writes them into the response handle.

Servers cap the request line, the header block and the body before hand-off. An over-long target usually returns 414, an over-large header block 431, an over-large body 413 - produced below the seam, so the application never sees the request.

The response committed before the failure, so the success status and headers were already on the wire and the error stage had nothing left to set. Do fallible work before the first byte, and give streamed responses a completeness signal.

By wrapping rather than mutating: the hook builds a delegating object that forwards every accessor to the original except the ones it overrides, then invokes the next stage with the wrapper instead of the original request.

A framework can declare a length only if it knows the total body size when the header block goes out. That holds when the whole body is still buffered; an early flush commits first, so the response is delimited instead.

A path miss and a method miss are different failures. If no template matches the path, the answer is 404; if templates match but none takes the request method, it is 405 and the matched set names the accepted methods.

Three policies are common: strict matching treats the spellings as different paths and misses, lenient matching sends both to one handler, and canonicalising redirects to the preferred form. Path segments are case-sensitive by specification, so ignoring case is an opt-in.

Reverse generation asks the router to build a path from a route's name plus parameter values, so the template exists in one place. Change the template and every generated link follows; the generator also encodes parameters and applies group prefixes.

The start line and the whole header block are parsed and validated before hand-off; the body is usually handed over unread. Query strings and structured header values are often left raw, parsed on demand above the seam.

An unmatched route exits at resolution; a binding failure exits before the handler; a handler exception unwinds into the error stage; a rendering failure reaches it too, but may arrive after the first bytes are already on the wire.

A request's lifetime runs from the hand-off into the pipeline until dispatch completes and its resources are released. Work handed to a separate executor is not bound to that window, so it can outlive the request object and its per-request context.

The same accessors stop describing the immediate connection and start reporting what forwarded header fields claim about the original client. Those fields are ordinary request text, so the framework believes them only where it is configured to trust the peer.

Replay the exact path, then read the router's effective route table and which template it selects — the handler you are debugging never ran. Fix it by narrowing the catch-all, then pin the winner with a test.

Mounting attaches a whole routing tree under a base path. Two contracts must agree: the path the inner tree matches, and the base it builds links from. Wrong links mean the base was never configured.

Application code barely changes, because the adapter boundary is the same either way. What moves is ownership: process lifecycle, listener and transport configuration, timeouts, size caps, shutdown behaviour and the deployment unit.

Anchor the guarantee at the pipeline's completion boundary, not at a position in the chain that an earlier exit can skip. Cover what the pipeline never sees at the layer in front, and never let the accounting path fail the request.

Make late commit the default: size the buffer above the common payload so ordinary responses stay replaceable by an error response, and make early flushing an opt-in that owes a completeness signal and a post-commit failure metric.

Cap deliberately at every layer: the edge strictest as the platform default, the server looser as a process-protection backstop, the framework tightest per route. The failure to avoid is caps that differ by accident.

Keep streaming as the default and make capture an opt-in per route, with a measured cap and a loud failure past it. Worst-case memory is peak concurrency times that cap, so upload and relay routes stay streaming permanently.

Optimise for ownership and review, not typing. Compose per-module route trees at reserved prefixes, attach cross-cutting hooks at the group so new routes are safe by default, and keep the effective inventory printable and diffable.