TypeScript icon, indicating that this package has built-in type declarations

    1.0.0-alpha.0 • Public • Published

    Aldo-application is an object containing a stack of middleware functions which are composed and executed upon each HTTP request.

    const { Application } = require('aldo')
    const app = new Application()
    // add a request handler
    app.use(() => 'Hello world!')
    // create a HTTP server to serve the application


    Middlewares could be a common or an async function. Each function receives a request context and a next function to call the downstream middlewares, and must return a response as output.

    // Handler function signature
    declare type Middleware = (ctx: Context, next: () => any) => any;

    You can register as many middlewares as needed with the application's method .use(fn)

    // to add a handler directly in the stack

    Whether a middleware runs before or after a downstream middlewares depends on the middleware itself. For example, the following middleware would perform some task before the others

    app.use((ctx, next) => {
      // Perform task
      return next()

    However, this middleware would perform its task after the request is handled by the following middlewares

    app.use(async (ctx, next) => {
      let response = await next()
      // Perform task
      return response


    The context object is a simple plain object with these properties:

    • request refers to the incoming request object
    • response function to get a new Response instance each time called
    • Other fields defined with .set(key, value) or .bind(key, getter)
    declare interface Context {
      request: Request;
      response: ResponseFactory;
      [key: string]: any;

    To extend the request context, and add shared properties, like a DB connection or a global logger, you may use .set(key, value)

    const mongoose = require('mongoose')
    await mongoose.connect('mongodb://localhost/test')
    app.set('db', mongoose)

    To set a per request private properties, you may use .bind(key, getter). This method takes a field name, and a function to be used as a lazy getter of the field value.

    app.bind('session', () => new Session(options))

    This method is very useful, since it allows you to lazily (only when needed) attach a per request property into the context without adding a dedicated handler.

    .has(key) and .get(key) are aldo available to check the existence of a certain field or to get a previously defined field value.


    The middleware output could be:

    • strings or buffers sent directly
    • streams which will be piped to the outgoing response
    • null or undefind as empty responses (By default with 204 status code)
    • Response instances which can be created with the context response property
    • otherwise, any other value will be serialized as JSON, with the proper Content-Type and Content-Length


    npm i aldo-application

    DownloadsWeekly Downloads






    Unpacked Size

    10 kB

    Total Files


    Last publish


    • absolux