redux-middleware

common redux middleware



Disclaimer: This library is in early development alongside redux-addons. It will be changing rapidly and is not ready for production use.

npm i -S redux-middleware

Will install middlewares to:

ES5 => 'redux-middleware/lib'

ES6+ => 'redux-middleware/src/lib'

Usage

##### configureStore.js

``js
import { createStore } from 'redux'
import { applyLogicalMiddleware } from 'redux-middleware'
import rootReducer from '../reducers'

const createStore = applyLogicalMiddleware()(createStore)

export default function configureStore() {
return createStore(rootReducer, initialState)
}
`


##### middleware.js

`js
import { applyMiddleware } from 'redux'

import metaRouter from 'redux-middleware/lib/metaRouter'
import thunk from 'redux-middleware/lib/thunk'
import readyStatePromise from 'redux-middleware/lib/readyStatePromise'
import logger from 'redux-middleware/lib/logger'
import crashReporter from 'redux-middleware/lib/crashReporter'


/* Default array of useful redux middleware /
export default function middleware() {
return [ metaRouter
, thunk
, readyStatePromise
, logger
, crashReporter
]
}

export const applyLogicalMiddleware = () => applyMiddleware(...middleware())
`



##### metaRouter.js (Needs work)

`js
import timeoutScheduler from './timeoutScheduler'
import identityHandler from './identityHandler'
import apiDispatcher from './apiDispatcher'
import routeHandler from './routeHandler'
import idleMiddleware from './idleMiddleware'
import errorHandler from './errorHandler'

/**
* Lets you dispatch special actions with a { meta } field.
*
* This middleware will chain through all middleware specified in metaMap in
* order and return the result.
*/
export const createMetaRouter = (metaMap = new Map( [ [ 'delay', timeoutScheduler ]
, [ 'identity', identityHandler ]
, [ 'api', apiDispatcher ]
, [ 'route', routeHandler ]
, [ 'idle', idleMiddleware ]
, [ 'err', errorHandler ]
] )) => store => next => action => {
if(!action.meta)
return next(action)
const supportedTypes = metaMap.keys()
const metaTypes = Object.keys(action.meta)
let result = metaTypes.filter(x => supportedTypes.includes(x))
.map(x => metaMap.get(x))
.reduce((last, middleware) => middleware(last), action)
return next(result)
}

export default createMetaRouter()

``