@priestine/routing
v5.0.1
Published
Simple, declarative and dependency-free routing for Node.js
Downloads
3
Maintainers
Readme
@priestine/routing
@priestine/routing
brings simple and eloquent routing to Node.js. It currently only works with Node.js http
and https
yet new releases aim to support other APIs.
NOTE: It doesn't provide integration with Node.js HTTP(S) server itself - you need to install @priestine/grace
to
do that.
TL;DR
const { HttpRouter } = require('@priestine/routing');
const { withRouter } = require('@priestine/grace');
const { createServer } = require('http');
/**
* Create an empty router
*/
const router = HttpRouter.empty();
/**
* Define a set of functions
*/
// Curried for creating header builders
// `ctx` has { request: IncomingMessage, response: ServerResponse, intermediate: {/* Your data plus { route (matched route), error? } */} }
const setHeader = (name) => (value) => ({ response }) => {
response.setHeader(name, value);
};
// Specifically, a Content-Type header builder (we could make it in one go tho)
const setContentTypeHeader = setHeader('Content-Type');
// Anything to be passed to the next middleware should be put to ctx.intermediate
// to keep request and response Node.js-ly pure
//
// Middleware context is passed along the middleware by reference so you can globally change it.
//
// It is recommended to return intermediate though, as this will enable deterministic function behaviour.
// If a middleware returns intermediate, ctx.intermediate is overriden by given value.
// This allows clearing intermediate contents that are no longer needed.
// It also enables support for short syntax, e.g.:
const buildHello = ({ intermediate }) => ({
helloWorld: {
id: 'hello-world',
message: 'Hello World!',
},
});
const sayHello = (ctx) => ctx.response.end(JSON.stringify(ctx.intermediate.helloWorld));
/**
* Register them in the router
*/
router
.get('/', [setContentTypeHeader('application/json'), buildHello, sayHello])
.get(/^\/(\d+)\/?$/, [setContentTypeHeader('text/html'), buildHello, sayHello]);
/**
* Assign the router to serve Node.js HTTP server.
*/
createServer(withRouter(router)).listen(3000);
// Go get http://localhost:3000 or http://localhost:3000/123123123
More
Installation
npm i --save @priestine/routing
or
yarn add @priestine/routing
Routing consists of a few components one should grasp to build routing efficiently. This is the list, from biggest to smallest:
- Routers
- Pipelines
- Middleware
The Router Thing
HttpRouter
is a kind of fluent interface for registering new routes and assigning logic to be executed for them:
router.register
accepts three required arguments:- url - a string or a RegExp describing the URL pathname IncomingMessage url must match
- methods - an array of HTTP methods that IncomingMessage method must be in
- middleware - an array of
HttpMiddlewareLike
or aPipelineInterface
that will be processed if current IncomingMessage matches given url and methods (NOTE if you want to usePipelineInterface
s you need to alsoyarn add @priestine/data
ornpm i --save @priestine/data
)
const router = HttpRouter.empty(); router .register( '/', ['POST', 'PUT'], [ (ctx) => ctx.response.setHeader('Content-Type', 'application/json'), (ctx) => ctx.response.end('{ "success": true }'), ] ) .register('/1', ['GET'], MyCustomPipeline);
router.get
(or one of get, post, put, patch, delete, options, head, all) is a helper method that registers a route with the same method and accepts only url and aPipelineInterface
or array of middlewareconst router = HttpRouter.empty(); router.get('/', [ ({ response }) => response.setHeader('Content-Type', 'application/json'), ({ response }) => response.end('{ "success": true }'), ]);
router.concat
allows concatenating multiple routers into one main router to be used app-wide. This is done to allow building modular routing with separated logic and then merging them to have single route map.// NOTE: middleware provided in this example are not part of @priestine/routing const MainRouter = HttpRouter.empty(); const ApiRouter = HttpRouter.empty(); MainRouter.get('/', [SetContentTypeHeader('text/html'), GetTemplate('./templates/index.html'), EndResponse]); ApiRouter.post('/api/v1/user-actions/subscribe', [ SetContentTypeHeader('application/json'), ParseRequestBody, JSONParseLens(['intermediate', 'requestBody']), UpsertUserSubscriptionStatus, EndJSONResponse, ]); MainRouter.concat(ApiRouter);
The Pipeline Thing
Pipelines are a set of middleware that is executed on matching the route. Pipelines themselves are class-based middleware with helper logic enabled. Internally, they iterate over processing assigned middleware until they get to the end.
Special treatment
- If middleware returns a Promise, pipeline will resolve it before moving on to the next one
- If middleware returns something, or returned Promise successfully resolves into something, this something is
assigned to
ctx.intermediate
- Pipeline passes
ctx
to each middleware by reference so any changes toctx.intermediate
from previous middleware is available in further middleware unlessctx.intermediate
wasn't changed by returning a value from one of previous pieces of middleware - If an exception is thrown during pipeline execution or a Promise is rejected, the Pipeline immediately stops and delegated the error to the wrapper function
Manual Pipeline building
Pipelines are classes implementing PipelineInterface
. To use them manually, you have to npm i --save @priestine/data
or yarn add @priestine/data
.
When you declare routes, you can pass arrays of middleware and Router will create pipelines from those arrays automatically. You can also provide pipelines yourself:
import { Pipeline } from '@priestine/data';
import { HttpRouter } from '@priestine/routing';
import { MyMiddleware, MySecondMiddleware, MyThirdMiddleware } from './middleware';
const router = HttpRouter.empty();
const MyPipeline = Pipeline.from([MyMiddleware, MySecondMiddleware, MyThirdMiddleware]);
router.get('/', MyPipeline);
Pipeline.concat
You can build multiple reusable pipelines and concat them together before assigning to the router:
const AccessControlPipeline = Pipeline.from([
/* Some middleware */
]);
const ContentNegotiationPipeline = Pipeline.from([
/* Some middleware */
]);
router = HttpRouter.empty();
router.get(
'/',
Pipeline.empty()
.concat(AccessControlPipeline)
.concat(ContentNegotiationPipeline)
.concat(Pipeline.of(({ response }) => response.end('OK')))
);
This allows you to compose middleware into reusable sets that can be appended/prepended anywhere in your app.
Middleware
Middleware is a reusable piece of business logic that encapsulates one specific step.
Middleware in @priestine/routing
can be function- or class-based. Each middleware is provided with ctx
argument:
ctx<TIntermediate> = {
request: IncomingMessage,
response: ServerResponse,
intermediate: { route: { url: string | RegExp, method: string } } & TIntermediate,
error?: Error,
};
If middleware is deterministic (meaning that it returns the intermediate or Promise resolving into the intermediate),
the ctx.intermediate
object will be overriden by given value if ctx
successfully validates through isMiddlewareContext
guard. This is done for two reasons:
- Custom transformations for the intermediate that entirely change it
- Easier testing
- Cleaning up intermediate from values that are not going to be used anymore
- Short syntax for returning objects
=> ({})
Having said that, it is entirely optional and you can omit returning the intermediate, thus the argument context will be passed to the next piece of middleware automatically.
For passing any computed data to next middleware, you should assign it to ctx.intermediate
that serves a purpose of
transferring data along the pipeline.
Function Middleware
Function middleware is a fancy name for a function that accepts ctx
.
// Asynchronous function middleware
// Due to the fact that it returns a promise, the Pipeline will resolve it before moving on to the next one
// In the example, the middleware sets intermediate to be { id: 1, aThingToUseSpreadOperatorFor: true } after the
// the timeout.
const MyAsyncMiddleware = () =>
new Promise((resolve) =>
setTimeout(() => {
resolve({ id: 1, aThingToUseSpreadOperatorFor: true });
}, 200)
);
// You can return a Promise with .then assigned as the Pipeline is fully Promise-compliant and the .then callback will
// be automatically applied. As .then returns a Promise, the behaviour in the pipeline is going to be just the same as
// if we returned a Promise itself as in the previous function.
const MyAsyncWithThen = ({ intermediate }) =>
asynchrony
.then((v) => ({
...intermediate,
...v,
}))
.catch((e) =>
HttpError.from(e)
.withStatusCode(500)
.withMessage('No-no-no')
);
// Synchronous function middleware
// Previous middleware assigned intermediate to be { id: 1, aThingToUseSpreadOperatorFor: true } and we can access it
// as the Pipeline resolved the promise. We can use spread operator for the intermediate and use short syntax to return
// a new intermediate with incremented id and additional 'hello' key.
const MyMiddleware = ({ intermediate }) => ({
...intermediate,
id: intermediate.id + 1,
hello: 'world',
});
router.get('/', [MyAsyncMiddleware, MyAsyncWithThen, MyMiddleware]);
Class-based Middleware
Class-based middleware must implement HttpMiddlewareInterface
interface (it must have a process
method that accepts ctx
).
NOTE: When registering middleware in the Pipeline, you must provide an instance of a class-based middleware.
class SetContentTypeHeader {
static applicationJson() {
return new SetContentTypeHeader('application/json');
}
constructor(value) {
this.value = value;
}
process(ctx) {
ctx.response.setHeader('Content-Type', this.value);
}
}
router.get('/', [SetContentTypeHeader.applicationJson()]);
Parallel vs waterfall (Lazy vs Eager)
Asynchronous middleware in the pipeline can be executed either in parallel or sequentially. Each middleware can dictate which type of execution must be applied to it:
- parallel execution does not block the pipeline and allows next middleware start processing even if the promise of
current middleware has not been resolved. In this case, the Promise containing the result of current middleware
computation can be directly assigned to the
ctx.intermediate
key and awaited later where necessary. This approach allows doing extra checks simultaneously and exit the pipeline if something is not right. This can be referred to as Lazy execution. Example (the functions used in the example are not part of@priestine/routing
):
/**
* `GetCurrentPost` doesn't block the next piece of middleware that can trigger exiting the pipeline
* if user is not authenticated thus not allowed to see posts in this imaginary scenario. This allows writing middleware
* in arbitrary order in some cases.
*/
const GetCurrentPost = (ctx) => {
ctx.intermediate.post = db.collection('posts').findOne({ id: ctx.intermediate.params.id });
};
const GetPostComments = async (ctx) => {
ctx.intermediate.body = (await ctx.intermediate.post).comments;
};
HttpRouter.empty().get(/^\/posts\/(?<id>(\w+))\/comments/, [GetCurrentPost, IsAuthenticated, GetPostComments]);
- waterfall execution blocks the pipeline until current middleware is done. This is convenient in cases where further
execution of the pipeline heavily relies on the result of computation. To inform the pipeline that it needs to wait for
current middleware to resolve, you need to return a Promise inside the middleware. This can be referred to as Eager
execution. NOTE this doesn't block JavaScript event loop. Example (the functions used in the example are not part
of
@priestine/routing
):
/**
* `IsAuthorized` blocks the middleware until the `ctx` is resolved. Thus, the Promise is rejected,
* the pipeline will be exited and no further computation will be executed, being replaced with emitting a
* `pipelineError` event.
*/
const IsAuthorized = (ctx) =>
new Promise((resolve, reject) => {
db.collection('users')
.findOne({ _id: ctx.intermediate.userId })
.then((u) => {
if (u.roles.includes('admin')) {
ctx.intermediate.userAuhorized = true;
resolve(); // To make this middleware deterministic, use resolve(ctx)
return;
}
reject(new UnauthorizedError());
});
});
HttpRouter.empty().get(/^\/posts\/(?<id>(\w+))\/comments/, [IsAuthorized, GetCurrentPost, GetPostComments]);
Generic Context
@priestine/routing
is written in TypeScript and provides generic context interfaces for describing types of
ctx.intermediate
:
import { HttpContextInterface } from '@priestine/routing';
interface UserAware {
user: {
_id: string;
name: string;
};
}
export const GetUser = ({ intermediate }: HttpContextInterface<UserAware>) => {
intermediate.user = {
_id: '123123123123',
name: 'Test User',
};
};
Assigning router to listen for connections
The router itself cannot listen for IncomingMessage's and to make it work you need to wrap it into a wrapper
withRouter
from @priestine/grace
and pass it to http.createServer
as an argument:
HTTP
import { createServer } from 'http';
import { HttpRouter } from '@priestine/routing';
import { withRouter } from '@priestine/grace';
const router = HttpRouter.empty().get('/', [(ctx) => ctx.response.end('hi')]);
createServer(withRouter(router)).listen(3000);
HTTPS
import { createServer } from 'https';
import { readFileSync } from 'fs';
import { resolve } from 'path';
import { HttpRouter } from '@priestine/routing';
import { withRouter } from '@priestine/grace';
const router = HttpRouter.empty().get('/', [({ response }) => response.end('hi')]);
const options = {
key: readFileSync(resolve('/path/to/certificate/key.pem')),
cert: readFileSync(resolve('/path/to/certificate/cert.pem')),
};
createServer(options, withRouter(router)).listen(3000);
Error handling
To force quitting current pipeline, you can either throw (synchronous middleware) or reject(e) (asynchronous
middleware). The error
object will be bound to ctx
alongside request
, response
and intermediate
.