kimu v1.4.3

Kimu—Immutable HTTP Server Abstraction

Kimu is heavily inspired by ring.

Basic example

import { createServer } from 'http'
import { kimu, response } from 'kimu'

const app = request => response('Hello, world!')

createServer(kimu(app, console.error)).listen(3000)

Routing

Kimu comes with a built-in router that is easy to use. Use router.del for DELETE requests. URL parameters are stored in request.urlParams.

import { match, router, respose } from 'kimu'

const home = request => response('Hello, kimu!')

// /add/5?to=7
// => 12
const addNumbers = request => {
  const firstNumber = request.urlParams.num
  const secondNumber = request.params.to
  return response(firstNumber + secondNumber)
}

// /mul/10/by/10
// => 100
const multiplyNumbers = request => {
  const firstNumber = request.urlParams.first
  const secondNumber = request.urlParams.second
  return respones(firstNumber * secondNumber)
}

const app = match([
  router.get('/', home),
  router.post('/add/:num', wrapParams(addNumbers)),
  router.post('/mul/:first/by/:second', multiplyNumbers),
  router.notFound(request => response('Not found! Uh oh :(', 404))
])

Middleware

Middleware are just higher-order functions. By convention, the function's name starts with wrap.

import { contentType } from 'kimu'

// This is an empty middleware
const wrapNothing = handler => request => handler(request)

// This middleware adds a parameter `extra` to the request
const wrapExtra = handler => request =>
  handler(Object.assign(request, { extra: 42 }))

API

Request

{
  raw: req,
  headers: req.headers,
  method: req.method,
  url: req.url,
  socket: req.socket
}

Response

{
  headers,
  status,
  body
}

kimu

(handler, logger = console.error) -> (req, res) -> ()

response

(body, status = 200, contentType = 'text/plain') -> response

status

(response, statusCode) -> response

contentType

(response, contentType) -> response

wrapJsonResponse

(handler, force = false) -> async request -> response

wrapParams

handler -> request -> response

wrapAuth

({ fn, secret, success, failure }) -> request -> response

wrapBody

(handler, options) -> request -> response

match

paths -> request -> response

router.any|get|head|post|put|del|connect|options|trace|patch

(path, handler) -> request -> response

router.notFound

handler -> request -> response