express-async-api

A minimalistic wrapper around express, limiting the available feature set to write explicit, JSON-only APIs.

Explicity is the key, that is why routers and middlewares are not available through this wrapper lib.

• You will have to explicitly define your routes so you will know exactly what route params are available
• Instead of middlewares, you will have to explicitly call functions in the handler function, so you will exactly know what happens

Besides that, a fundamental assumption is that your route handlers will be asynchronous. If you use async and await, it enables you to simply return the result you want to send back to the client, and you can throw an exception if something went wrong, and that will be handled on a separate error handler.

I built this wrapper, because recently I only use these features of express. Later on, I am going to write a lib with the same interface, that does not depend on express, but on the native http lib of Node.js. Since the interface will be the same, it will be easy to swap this lib with the new one that has no dependencies.

Installation

npm i --save-dev express-async-api

Usage

1import createApiServer from 'express-async-api'
2
3import routes from './routes/index.js'
4
5...
6
7function errorHandler(e) {
8  // the thrown error will be passed to this function
9  // based on the error, you should construct and return the output
10  return {
11    status: 500,
12    error: {
13      name: e.name,
14      message: e.message
15    }
16  }
17}
18
19function loggerCb(req, res) {
20  // it gets express' req and res as params, so you can log everything whereever you want.
21  // you can even aggregate your logs in a separate service
22}
23
24const apiServer = createApiServer(errorHandler, loggerCb)
25
26routes(apiServer) // this function should append the route handlers to your server
27
28apiServer.listen(port)
29

The underlying express server is exposed on the apiServer._expressServer property, for testing purposes. See some examples for testing in this very repository.

apiServer.listen(port)

Starts listening on the given port.

apiServer.get(route, handler)

1apiServer.get('/v1/group/:groupId/user/:id', async req => {
2  // these functions have access to the original express req object
3  const response = await fetchGroupUser(req.params.groupId, req.params.id) // if the promise is rejected (and you don't handle it locally), then the global errorHandler will be invoked
4
5  return {
6    status: 200, // you can control the status code of the response by this field
7    result: {
8      ...response
9    }
10  }
11})

apiServer.post(route, handler)

1apiServer.post('/your/:route/is/here', async req => {
2  return {
3    status: 201,
4    result: { ... }
5  }
6})

apiServer.postBinary(route, settings, handler)

The settings object must conftain the following properties:

• fieldName (string): the name of the input field from which the server ready the binary data. (The name of the form field on the frontend that holds the binary.)
• mimeTypes (array of strings): containing the allowed mime types. If the uploaded file's mime type is not in the array, then a ValidationError will be thrown from the standard-api-errors lib, which translates to a HTTP 400 respones.
• maxFileSize (optional, number): the maximum file size limit in bytes.

The maxFileSize property is optional and specifies the maximum file size allowed for upload. If not provided, there is no size limit imposed on the uploaded file

1const settings = {
2  fieldName: 'avatar',
3  mimeTypes: ['image/png', 'image/jpeg', 'image/gif']
4}
5
6apiServer.post('/your/:route/is/here', settings, async req => {
7  return {
8    status: 201,
9    result: { ... }
10  }
11})

apiServer.put(route, handler)

1apiServer.put('/your/:route/is/here', async req => {
2  return {
3    status: 200,
4    result: { ... }
5  }
6})

apiServer.patch(route, handler)

1apiServer.patch('/your/:route/is/here', async req => {
2  return {
3    status: 200,
4    result: { ... }
5  }
6})

apiServer.delete(route, handler)

1apiServer.delete('/your/:route/is/here', async req => {
2  return {
3    status: 201,
4    result: { ... }
5  }
6})

Redirects

You can also redirect in your handlers.

1async function handler(req) {
2  ...
3  return {
4    status: 302,
5    redirect: 'https://example.com'
6  }
7}

Binary response

If you want to respond with binary data.

1async function handler(req) {
2  ...
3  return {
4    binary: <Node JS Buffer ...>
5  }
6}

Errors & Logging

If you take a look at the first example, you can see, that the createApiServer function has two parameters. The first is an error handler callback, the second is a callback for logging.

The error handler callback gets the thrown error as an argument, based on which, you can put together the final output that your server produces. You must implement the error handler function.

The log callback is optional. It recieves the original express req and res objects, which contains everything about the request and the response. You can aggreagate these in a log service, or just simply console.log something.

Upcoming features

• custom error handlers for routes
• execution time -> log function