Need private packages and team management tools?Check out npm Teams »

middleware-decorator

1.1.0 • Public • Published

middleware-decorator

Decorates functions with middleware super-powers.

Travis build status Code Climate Test Coverage Dependency Status devDependency Status

Table of contents

Features

  • Synchronous, asynchronous and promised middleware support
  • Zero dependencies
  • UMD Module
  • Tiny(5KB)

Installation

npm

    npm install middleware-decorator

bower

    bower install middleware-decorator

Sample usage

Prerequisites

The module has been imported with your favorite loader as middlewareDecorator and the following function is available

function getPrice(){
    return 10;
}

Decorate with a synchronous middleware runner

getPrice = middlewareDecorator(getPrice);
 
function halfPriceMiddleware(price){
    return price / 2;
}
 
getPrice.use(halfPriceMiddleware);
 
console.log(getPrice()); // 5
 

Decorate with an asynchronous middleware runner

getPrice = middlewareDecorator.async(getPrice);
 
function halfPriceMiddleware(price, done){
    setTimeout(()=>{
        done(price / 2);
    }, 2000);
}
 
getPrice.use(halfPriceMiddleware);
 
getPrice().cb((price)=>{
    console.log(price()); // 5
});
 

Decorate with a promised middleware runner

getPrice = middlewareDecorator.promised(getPrice);
 
// Can return any value, if it's a promise, next middleware won't get executed till resolved
function halfPriceMiddleware(price){
    return hasHalfPriceDiscount().then((hasHalfPriceDiscount)=>{
        return hasHalfPriceDiscount ? price / 2 : price;
    });
}
 
getPrice.use(halfPriceMiddleware);
 
getPrice().then((price)=>{
    console.log(price()); // 5
});
 

API

Module

(anyFunction) : SynchronousMiddlewareRunner

Takes a function as argument and returns a synchronous middleware runner

synchronousMiddlewareRunner = middlewareDecorator(anyFunction);

promised(anyFunction) : PromisedMiddlewareRunner

Takes a function as argument and returns a promised middleware runner

promisedMiddlewareRunner = middlewareDecorator(anyFunction);

async(anyFunction) : AsynchronousMiddlewareRunner

Takes a function as argument and returns an asynchronous middleware runner

asynchronousMiddlewareRunner = middlewareDecorator(anyFunction);

SynchronousMiddlewareRunner

synchronousMiddlewareRunner.use(synchronousMiddleware: Function)

Adds a synchronous middleware

synchronousMiddlewareRunner.use((middlewareOutput) => {
    return middlewareOutput;
});

synchronousMiddlewareRunner.has(synchronousMiddleware: Function):boolean

Checks if has the given middleware

synchronousMiddlewareRunner.has(aMiddleware); // true || false

synchronousMiddlewareRunner(...args);

Calls the original function with the given arguments and runs it's output through the registered synchronous middleware

synchronousMiddlewareRunner(arg1, arg2);

AsynchronousMiddlewareRunner

asynchronousMiddlewareRunner.use(asynchronousMiddleware: Function)

Adds an asynchronous middleware

asynchronousMiddlewareRunner.use((middlewareOutput, done) => {
    done(middlewareOutput);
});

asynchronousMiddlewareRunner.has(asynchronousMiddleware: Function):boolean

Checks if has the given middleware

asynchronousMiddlewareRunner.has(aMiddleware); // true || false

asynchronousMiddlewareRunner(...args).cb(callback: Function);

Calls the original function with the given arguments and runs it's output through the registered middleware, when done, calls the provided callback

asynchronousMiddlewareRunner(arg1, arg2).cb((middlewareOutput)=>{
    console.log(`Done with ${middlewareOutput}`);
});

PromisedMiddlewareRunner

promisedMiddlewareRunner.use(promisedMiddleware: Function)

Adds a promised middleware

promisedMiddlewareRunner.use((middlewareOutput) => {
    return new Promise((resolve, reject) => {
        resolve(middlewareOutput);
    });
});

promisedMiddlewareRunner.has(promisedMiddleware: Function):boolean

Checks if has the given middleware

promisedMiddlewareRunner.has(aMiddleware); // true || false

promisedMiddlewareRunner(...args).then(promiseHandler: Function);

Calls the original function with the given arguments and runs it's output through the registered middleware, when done, calls the provided callback

promisedMiddlewareRunner(arg1, arg2).then((middlewareOutput)=>{
    console.log(`Done with ${middlewareOutput}`);
});

Contributing

Clone the repository

git clone git@github.com:thefabulousdev/middleware-decorator.git

Install dependencies

npm install

Use npm scripts

  • npm test - Lint the library and tests, then run the unit tests
  • npm run lint - Lint the source and unit tests
  • npm run watch - Continuously run the unit tests as you make changes to the source and test files themselves
  • npm run test-browser - Build the library for use with the browser spec runner. Changes to the source will cause the runner to automatically refresh.
  • npm run build - Lint then build the library
  • npm run coverage - Generate a coverage report

Author: Joel Hernández

Install

npm i middleware-decorator

DownloadsWeekly Downloads

1

Version

1.1.0

License

MIT

Last publish

Collaborators

  • avatar