aldo-application
    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
    app.start(process.env.PORT)

    Middlewares

    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
    app.use(middleware)

    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
    })

    Context

    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.

    Response

    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

    Install

    npm i aldo-application

    DownloadsWeekly Downloads

    1

    Version

    1.0.0-alpha.0

    License

    MIT

    Unpacked Size

    10 kB

    Total Files

    5

    Last publish

    Collaborators

    • absolux