servest

🌾A progressive http server / router for deno🌾

Usage

Serve API

Serve API is similar to deno_std@v0.17.0 but has different implementation. Some progressive features for HTTP/1.1 server are implemented.

Support Keep-Alive connection
Support trailer headers
Support keep-alive timeout and read timeout
serve and listenAndServe is cancellable by cancel promise
Fully interface based type definition

import { listenAndServe } from "https://denopkg.com/keroxp/servest/server.ts";
listenAndServe(":8899", async req => {
  await req.respond({
    status: 200,
    headers: new Headers({
      "Content-Type": "text/plain"
    }),
    body: new TextEncoder().encode("hello")
  });
});

NOTE: use listenAndServe instead of serve

Generally listenAndServe has higher concurrency than serve because serve is built top of async iteration. yield in async iteration degrades concurrency of promises.

Processing of requests from identical keep-alive connection should be handled in serial, but requests from different connections should be handled in concurrent.

listenAndServe does it as it is built top of async callback. It is faster than serve about x2 in our benchmark test.

Router API

Router API is minimal routing system on top of listenAndServe()

import { createRouter } from "https://denopkg.com/keroxp/servest/router.ts";

const router = createRouter();
router.handle("/", async req => {
  await req.respond({
    status: 200,
    headers: new Headers({
      "content-type": "text/plain"
    }),
    body: new TextEncoder().encode("ok")
  });
});
router.handle(new RegExp("/foo/(?<id>.+)"), async req => {
  const { id } = req.match.groups;
  await req.respond({
    status: 200,
    headers: new Headers({
      "content-type": "application/json"
    }),
    body: new TextEncoder().encode(JSON.stringify({ id }))
  });
});
router.listen("127.0.0.1:8898");

Middleware API for Router

Router can use common http handler

import { serveStatic } from "https://denopkg.com/keroxp/servest/serve_static.ts";
// Files in ./public are served automatically (GET, HEAD)
router.use(serveStatic("./public"));

Global Error Handler for Router

// Called when unhandled error occurred while processing requests
router.handleError((e, req) => {
  console.error(e);
  req.respond({
    status: 500,
    body: new TextEncoder().encode("Internal Server Error")
  });
});

Agent API

Agent API is basic HTTP agent. It manages persistent connection to host. Each request will be sent in serial.

fetch is enough for most cases. It is useful if you want to manage keep-alive connection to host.

NOTE: Currently TLS (HTTPS) agent is not supported as Deno doesn't.

Use fetch for https request.

GET

import { createAgent } from "https://denopkg.com/keroxp/servest/agent.ts";
const agent = createAgent("http://127.0.0.1:8700");
const { status, body } = await agent.send({
  path: "/get?deno=land",
  method: "GET"
});

POST

import { createAgent } from "https://denopkg.com/keroxp/servest/agent.ts";
const { status, headers, body } = await agent.send({
  path: "/post",
  method: "POST",
  headers: new Headers({
    "Content-Type": "text/plain"
  }),
  body: new TextEncoder().encode("deno=land")
});

Loadmaps

HTTP/2
HTTP testing api

License

MIT

Contributor

@keroxp