middleware-decorator

Decorates functions with middleware super-powers.

Table of contents

• Features
• Installation
  • npm
  • bower
• Sample usage
  • Prerequisites
  • Decorate with a synchronous middleware runner
  • Decorate with an asynchronous middleware runner
  • Decorate with a promised middleware runner
• API
  • Module
    • (anyFunction) : SynchronousMiddlewareRunner
    • promised(anyFunction) : PromisedMiddlewareRunner
    • async(anyFunction) : AsynchronousMiddlewareRunner
  • SynchronousMiddlewareRunner
    • synchronousMiddlewareRunner.use(synchronousMiddleware: Function)
    • synchronousMiddlewareRunner.has(synchronousMiddleware: Function):boolean
    • synchronousMiddlewareRunner(...args);
  • AsynchronousMiddlewareRunner
    • asynchronousMiddlewareRunner.use(asynchronousMiddleware: Function)
    • asynchronousMiddlewareRunner.has(asynchronousMiddleware: Function):boolean
    • asynchronousMiddlewareRunner(...args).cb(callback: Function);
  • PromisedMiddlewareRunner
    • promisedMiddlewareRunner.use(promisedMiddleware: Function)
    • promisedMiddlewareRunner.has(promisedMiddleware: Function):boolean
    • promisedMiddlewareRunner(...args).then(promiseHandler: Function);
• Contributing
  • Clone the repository
  • Install dependencies
  • Use npm scripts

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 [email protected]: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