Peko

  Server     Routing     Request handling     Response caching  

API DOCS

Philosophy

• Client-edge synergy - Share modules for server-side-rendering and data consistency.
• Production-ready backend - Cascading middleware server + caching and other helpful web dev utilities, all with tests.
• Software minimalism - No build-step, built using only the Deno std library.
• Ease of adoption - Intuitive API, lots of examples and no fixed project structure.

Any feature suggestions or code reviews are very welcome!

Get started

Try the examples:

1. Deno is sick. Install it.

2. $ git clone https://github.com/sebringrose/peko.git
3. $ cd peko/examples
4. $ deno task start:dev

Note: Lit-html VS Code plugin recommended if using HTM & Preact.

Import to your project:

import * as Peko from "https://deno.land/x/peko/mod.ts"

and if you don’t want unnecessary utitlies:

import { Server } from "https://deno.land/x/peko/server.ts"

Deployment

Instantly deploy from GitHub with Deno Deploy (deploy the auth or preact examples if you fancy it 💖).

Overview

Server

The Server is the main class of Peko. It wraps Deno’s std/serve and holds all route and middleware data for request handling. Server.use can be used to add global middleware like the popular Express and Koa frameworks. The server.logging function can also be overwritten for remote logging.

Routing

Requests are matched to a mutable array of Routes. Routes can be added or removed at runtime via addRoute or addRoutes, and removeRoute or removeRoutes server methods.

Request handling

Each route must have a handler function that generates a response as well as optional method and middleware properties. If no matching route is found for a request an empty 404 response is sent. If an error occurs in handling a request an empty 500 response is sent. Both of these behaviours can be overwritten with middleware.

The included staticHandler, ssrHandler and sseHandler handlers can be plugged straight into a route and reduce boilerplate code for serving static assets, rendering client-side apps to html or streaming server-sent events respectively (see /examples for implementations). There are also authentication, logging and caching middleware. Of course, you can also create your own middleware or handlers and plug them into your routes (see examples/custom-handler).

Response caching

In stateless computing, memory should only be used for source code and disposable cache data. Response caching ensures that we only store data that can be regenerated or refetched. Peko provides a ResponseCache utility for this. The cache middleware wraps it and provides drop in response caching for your routes. The ResponseCache is indexed by serializing the incoming RequestContext and has a configurable cache item lifetime.

The modern edge is cool because…

Our apps can share source code across frontend and backend. We can have all of the SEO and UX benefits of SSR without any JavaScript transpilation or bundling. We can write classes that let users store data in the browser until they decide to back it up to the cloud. If we want TS on the server we can just emit JS versions of code to the browser. This completely eliminates part of the traditional JavaScript toolchain, increasing project maintainability and simplicity, all while making our software even faster.

Better yet, Peko is not build for any specific frontend framework or library. You can use barebones HTML, React, Preact, Vue… you name it (if you do set up a React or Vue project please consider adding it to the examples). Simply plug your app-rendering logic into the SSRHandler with a Render function.

This is all made possible by powerful new JavaScript tools. Deno is built to the ECMAScript specification. This makes it compatible with browser JavaScript which elimates the need to generate separate client and server JavaScript bundles (the support for URL imports is the secret sauce). UI libraries like Preact combined with htm offer lightning fast client-side hydration with a browser-friendly markup syntax. On top of this Deno has native TypeScript support, a rich runtime API and loads of community tools for your back-end needs.

This project started out of excitement for the elegancy of Deno and the freedom it would bring to the JavaScript community. At time of writing all library code has been written and maintained by me. If you are interested in contributing please submit a PR or get in contact :D