Sign Up for Free

RunKit +

Try any Node.js package right in your browser

This is a playground to test code. It runs a full Node.js environment and already has all of npm’s 400,000 packages pre-installed, including middleware-decorator with all npm packages installed. Try it out:

var middlewareDecorator = require("middleware-decorator")

This service is provided by RunKit and is not affiliated with npm, Inc or the package authors.

middleware-decorator v1.1.0

Decorates functions with middleware super-powers

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

RunKit is a free, in-browser JavaScript dev environment for prototyping Node.js code, with every npm package installed. Sign up to share your code.
Sign Up for Free