Skip to content
Go to file

Latest commit


Git stats


Failed to load latest commit information.
Latest commit message
Commit time


Reno logo

Build Status

deno doc

Reno is a thin routing library designed to sit on top of Deno's standard HTTP module.


import { listenAndServe } from "";

import {
} from "";

function createErrorResponse(status: number, { message }: Error) {
  return textResponse(message, {}, status);

export const routes = createRouteMap([
  ["/home", () => textResponse("Hello world!")],

  // Supports RegExp routes for further granularity
  [/^\/api\/swanson\/?([0-9]?)$/, async (req: AugmentedRequest) => {
    const [quotesCount = "1"] = req.routeParams;

    const res = await fetch(

    return jsonResponse(await res.json());

  // Supports Reader for streaming responses in chunks
  ["/streamed-response", () => streamResponse(
    new ReactReader(<App />),

const notFound = (e: NotFoundError) => createErrorResponse(404, e);
const serverError = (e: Error) => createErrorResponse(500, e);

const mapToErrorResponse = (e: Error) =>
  e instanceof NotFoundError ? notFound(e) : serverError(e);

const router = createRouter(routes);

console.log("Listening for requests...");

await listenAndServe(
  async (req: ServerRequest) => {
    try {
      const res = await router(req);
      return req.respond(res);
    } catch (e) {
      return req.respond(mapToErrorResponse(e));

Key Features

Responses are just Data Structures

This, along with request handlers being pure functions, makes unit testing Reno services a breeze:

import { jsonResponse, assertResponsesAreEqual } from "";
import { createRonSwansonQuoteHandler } from "./routes.ts";

const createFetchStub = (response: string[]) =>
    json: sinon.stub().resolves(response),

  name: "ronSwansonQuoteHandler should fetch a quote from an API and return it",
  async fn() {
    const quotes = ["Some Ron Swanson Quote"];
    const fetchStub = createFetchStub(quotes);
    const ronSwansonQuoteHandler = createRonSwansonQuoteHandler(fetchStub);

    const req = {
      routeParams: []

    const response = await ronSwansonQuoteHandler(req);

    await assertResponsesAreEqual(
      jsonResponse(quotes, {
        "X-Foo": "bar",

Wildcard Path Segments

Despite the power of regular expressions for matching and capturing paths when their route parameters conform to an expected format or type, they can often prove verbose and unwieldy for simpler applications. Reno thus provides an alternative wildcard syntax ("*") for string paths to achieve route param extraction:

async function wildcardRouteParams(req: Pick<AugmentedRequest, "routeParams">) {
  const [authorId, postId] = req.routeParams;

  return textResponse(`You requested ${postId} by ${authorId}`);

const routes = createRouteMap([
  ["/wildcard-route-params/authors/*/posts/*", wildcardRouteParams],

const router = createRouter(routes);

Nested Routers

Like most other HTTP routing libraries that you know and love, Reno supports nested routers; you can use wildcards as suffixes to group routers by a common path segment:

const routes = createRouteMap([
          createRouter(createRouteMap([["/baz", () =>
            textResponse("Hello from a nested route!")]])),

const router = createRouter(routes);

pipe() - An Alternative to Middleware

Reno emulates the middleware pattern, found in Express, by favouring function piping to create reusable, higher-order route handlers:

import { createRouteMap, jsonResponse, pipe } from "";

const withCaching = pipe(
  (req, res) => {
    /* Mutate the response returned by
     * the inner route handler... */
    res.headers.append("Cache-Control", "max-age=86400");

  /* ...or go FP and return a new
   * response reference entirely. */
  (req, res) => ({
    cookies: new Map<string, string>([["requested_proto", req.proto]])

const home = withCaching(() =>
    foo: "bar",
    isLol: true

export const routes = createRouteMap([["/", home]]);

Reno Apps are Unobtrusive, Pure Functions

Given that a Reno router is a function that takes a request and returns a response (or more specifically, Promise<Response>), you are free to integrate it as you wish, managing the lifecycle of your HTTP server independently. This also makes it trivial to write end-to-end tests with SuperDeno, as evidenced by Reno's own E2E suite:

import { superdeno } from "";
import app from "../example/app.ts";

Deno.test("/ should return the expected response", async () => {
  await superdeno(app).get("/")
    .expect("Cache-Control", "max-age=86400")
    .expect("Set-Cookie", "requested_proto=HTTP/1.1")
      foo: "bar",
      isLol: true,

Example Apps

As well as the example app found in this repo, which is targetted by the end-to-end test suite, there is a standalone repository for a blog microservice built with Deno, Reno, PostgreSQL, and Docker.

API Documentation

Consult Reno's entry on the Deno Doc website for comprehensive documentation on Reno's API.

Local Development

Once you've cloned the repository, you'll need to ensure you're running the version of Deno against which this project is developed; this is stored in .deno_version. To install the correct version, run:

# If Deno isn't currently installed...
$ curl -fsSL | sh -s v$(cat .deno_version)

# ...or it it's already present on your system
deno upgrade --version $(cat .deno_version)

You should also run ./tools/ to install the TypeScript definitions for Deno and any other third-party dependencies.

Then you can run:

  • ./scripts/ - starts the example server
  • ./scripts/ - formats the source code
  • ./scripts/ - checks the formatting of the source code
  • ./scripts/ - lints the source code
  • ./scripts/ - runs the unit tests
  • ./scripts/ - runs the end-to-end tests

Functionality Checklist

  • Path routing
  • Async-compatible route handlers
  • Error handling
  • Route params
  • Query params
  • Response helpers
  • JSON
  • Custom headers
  • Request bodies
  • Cookies
  • Streaming responses with Reader
  • Streaming request bodies
You can’t perform that action at this time.