redux-fluent

redux-fluent

Tiny and eloquent way of bringing redux to the next level (~3K, dependencies free, typings included).

Try it out on RunKit

Motivation

Redux is great, every recent web application has most likely been built on top of it, and we can really make it better!

• λ Go Functional, Everything is a function and reducers are built by function composition rather than piling up if and switch-case statements: Let's introduce Redux Fluent Reducers.
• Reducers at scale, due to being handling multiple actions, reducers tend to grow and become difficult to maintain: Let's introduce Redux Fluent Action Handlers.
• Less boilerplate, Flux architecture is usually verbose and some of their concepts, such as Action, Action Type and Action Creator could all be implemented in a single entity: Let's introduce Redux Fluent Actions.
• FSA compliance, FSA Actions may have a error: boolean field, which indicates whether the action represents a failure or not. Respecting this pattern leads to a series of if statements inside reducers, compromising both readability and maintainability, so the community normally tends to split error and failures into two separate actions (eg: ADD_TODO_SUCCESS and ADD_TODO_ERROR) which reduces cognitive complexity on one hand but produces even more boilerplate on the other. Let's embrace FSA and abstract error handling with filterable action handlers.

Installation

yarn add redux-fluent redux

Getting Started

/** todos.actions.js **/
import { createAction } from 'redux-fluent';

export const addTodo = createAction('todos | add');
console.log(addTodo.type); // 'todos | add'

/** todos.reducer.js **/
import { createReducer, ofType } from 'redux-fluent';
import * as actions from './todos.actions.js';

const addTodo = (state, { payload }) => state.concat(payload);

export const todos = createReducer('todos')
  .actions(
    ofType(actions.addTodo).map(addTodo),
    /* and so on */
  )
  .default(() => []);

/** application.js **/
import { createStore } from 'redux';
import { combineReducers } from 'redux-fluent';
import * as actions from './todos.actions.js';
import { todos } from './todos.reducer.js';

const rootReducer = combineReducers(todos, ...);
const store = createStore(rootReducer);
console.log(store.getState()); // { todos: [] }

store.dispatch(actions.addTodo({ title: 'Walk Gipsy' }));
console.log(store.getState()); // { todos: [{ title: 'Walk Gipsy' }] }

Documentation

• createReducer()
• createAction()
• ofType()
• withConfig()
• combineReducers()
• createReducersMapObject()

createReducer()

createReducer is a function combinator whose purpose is to output a redux reducer by combining action handlers and getDefaultState together.

import { createReducer } from 'redux-fluent';

const reducer = createReducer(name)
  .actions(
    ...handlers: (state, action, config?) => state,
  )
  .default(
    getDefaultState: (state: void, action, config?) => state,
  );

createAction()

createAction is a factory function whose purpose is to output an action creator responsible of shaping your actions. The resulting function holds a field type giving you access to the action type.

import { createAction } from 'redux-fluent';

const action = createAction(
  type: string,
  payloadCreator?: (rawPayload, rawMeta, type) => payload,
  metaCreator?: (rawPayload, rawMeta, type) => meta,
);

console.log(action.type);

ofType()

As we just said, a reducer is nothing more than a function combinator, it does not contain any business logic. The job of actually mutating the state is left to the Action Handlers. Embracing the Single Responsibility Principle, we can build simple, easy to test, dedicated functions that do only one thing.

import { ofType } from 'redux-fluent';

ofType(action: ReduxFluentActionCreator).map((state: any, action: AnyAction) => state);
ofType(type: string).map((state: any, action: AnyAction) => state);
ofType(action: { type: string }).map((state: any, action: AnyAction) => state);

// write your action handlers by only focusing on the actual task,
// let `ofType` take care of the orchestration (i.e. intercepting actions).
ofType('todos | add').map(
  (state, action) => state.concat(action.payload),
);

withConfig()

Redux Fluent also comes with some additional features to help you write your code that scales. Functions that only rely on their arguments are easy to test and share, so you can provide an additional argument config: any (multiple config are shallowly merged).

import * as R from 'ramda';
import { withConfig, createReducer, ofType } from 'redux-fluent';

withConfig(config: any);

const todos = createReducer('todos')
  .actions(
    ofType('todos | doSomething').map(
      (state, action, { doSomething }) => doSomething(state, action),
    ),
    ofType('todos | doSomethingElse').map(
      (state, action, { doSomethingElse }) => doSomethingElse(state, action),
    ),
  )
  .default(() => []);

export default R.pipe(
  withConfig({ doSomething: R.tap(console.log) }),
  withConfig({ doSomethingElse: R.tap(console.log) }),
)(todos);

combineReducers()

This api is not strictly needed, you can still use redux#combineReducers. With Redux Fluent, by the way, both namespace and reducer are defined in the same place so that you don't need to take care of the shape when combining them.

import { createStore } from 'redux';
import { combineReducers } from 'redux-fluent';
import { todosReducer, notesReducer, otherReducer } from './reducers';

combineReducers(...reducers: ReduxFluentReducer[]);

const rootReducer = combineReducers(todosReducer, notesReducer, otherReducer, ...);
const store = createStore(rootReducer);

createReducersMapObject()

This api lets you combine your reducers with redux#combineReducers, and can be useful when mixing redux fluent reducers with any other reducer.

import { createStore, combineReducers } from 'redux';
import { createReducersMapObject } from 'redux-fluent';
import { todosReducer, notesReducer, otherReducer } from './reducers';

createReducersMapObject(...reducers: ReduxFluentReducer[]);

const reducersMapObject = createReducersMapObject(todosReducer, notesReducer, otherReducer, ...);
const rootReducer = combineReducers({
  ...reducersMapObject,
  anyOtherReducer: (state, action) => 'any other state',
});
const store = createStore(rootReducer);