Skip to content
middleware center for JavaScript, just like http://koajs.com middleware.
JavaScript
Branch: master
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
.vscode
src
test
.babelrc
.gitignore
.travis.yml
README.md
package-lock.json
package.json
webpack.config.js

README.md

middleware-center

NPM version travis ci Coverage Status

middleware center for JavaScript, just like koa middleware.

Installation

npm i middleware-center

Usage

Sync method

import MiddlewareCenter from "middleware-center"

const middlewareCenter = new MiddlewareCenter()

middlewareCenter.use(function validate(ctx, next) {
    console.log('before validate', ctx);
    if (ctx.name === 'zhh' && ctx.passwd === '123') {
        next()
        console.log('after validate');
    }
})

middlewareCenter.use(function request(ctx, next) {
    console.log('before request', ctx);
    next()
    console.log('after request');
})

middlewareCenter.use(function success(ctx, next) {
    console.log('on success', ctx);
})

middlewareCenter.handleRequest({name: 'zhh', passwd: '123'})

/* result
before validate { name: 'zhh', passwd: '123' }
before request { name: 'zhh', passwd: '123' }
on success { name: 'zhh', passwd: '123' }
after request
after validate
*/

Async method

import MiddlewareCenter from "middleware-center"

const middlewareCenter = new MiddlewareCenter()

var async1 = function () {
    return new Promise((resolve, reject) => {
        setTimeout(function () {
            resolve(1)
        }, 10)
    })
}

var async2 = function (ctx, next) {
    return new Promise((resolve, reject) => {
        setTimeout(function () {
            resolve(2)
        }, 20)
    })
}

var m1 = async function (ctx, next) {
    console.log('before m1')
    let result =  await async1()
    await next()
    console.log('after m1')
}

var m2 = async function (ctx, next) {
    console.log('before m2')
    let result = await async2()
    console.log('after m2')
}

middlewareCenter.use(m1)
middlewareCenter.use(m2)

middlewareCenter.handleRequest()

/* result
before m1
before m2
after m2
after m1
*/

Custom MiddlewareCenter

import MiddlewareCenter from "middleware-center"

const middlewareCenter = new CustomMiddlewareCenter()
middlewareCenter.handle('uploader')

class CustomMiddlewareCenter extends MiddlewareCenter {

    constructor() {
        super()
        this._middlewareMap = { 'uploader': [this.beforeUpload, this.startUplaod, this.finishUpload] }
        this.content = ""
    }

    handle(name) {
        let middlewares = this._middlewareMap[name]
        for (let middleware of middlewares) {
            this.use(middleware)
        }
        this.handleRequest(this)
    }

    // Middlewares

    async beforeUpload (ctx, next) {
        console.log('beforeUpload')
        ctx.content = await ctx.genContent()
        await next()
        console.log('after beforeUpload')
    }

    async startUplaod (ctx, next) {
        console.log('startUplaod')
        let result = await ctx.upload(ctx.content)
        await next()
        console.log('after startUplaod')
    }

    finishUpload (ctx, next) {
        console.log('finishUpload')
        //do something like notify listeners
        console.log('after finishUpload')
    }

    // Helpers
    genContent() {
        return new Promise((resolve, reject) => {
            setTimeout(function () {
                resolve('upload content')
            }, 3)
        })
    }

    upload(content) {
        return new Promise((resolve, reject) => {
            setTimeout(function () {
                resolve(true)
            }, 5)
        })
    }
}

/* result
beforeUpload
startUplaod
finishUpload
after finishUpload
after startUplaod
after beforeUpload
*/

Handle Error

middlewareCenter.handleRequest(ctx).catch(function(err){
  console.log(err.message)
})

API

use(middleware)

push a middleware. middleware must be function.

handleRequest(context)

handle request with context. It will trigger next chain.

You can’t perform that action at this time.