Skip to content

Latest commit

 

History

History
121 lines (79 loc) · 3.75 KB

routines.md

File metadata and controls

121 lines (79 loc) · 3.75 KB
Raw

Actions

All action creators produce Flux compatible actions with just two props: type and payload. At the moment, we do not implement meta because there was no use for it yet.

Sync routines

Sync routines are just a simple action creators. You can use them to change UI state when you don't need to communicate with server. First argument to the routine is always translated as a payload. The payload can be anything.

import { createSyncRoutine } from 'redux-entity-store'

const showDialog = createSyncRoutine('DIALOG/OPEN')
const hideDialog = createSyncRoutine('DIALOG/HIDE')

showDialog()
// { type: 'DIALOG/OPEN' }

showDialog('foo')
// { type: 'DIALOG/OPEN', payload: 'foo' }

Tip: Use createEntityRoutines when you need a group of routines related to an entity.

import { createEntityRoutines } from 'redux-entity-store'

export const dialogRoutines = createEntityRoutines('dialog', ['open', 'close'], true)

dialogRoutines.open('foo')
// { type: 'DIALOG/OPEN', payload: 'foo' }

Matching sync routines

Sync routines are very simple, but to make them compatible with async routines, there are some constants for your convenience.

  • routine.TRIGGER, routine.SUCCESS - to match the action type, they are equal for sync routines
  • routine.sync = true for all the sync routines
import { createEntityRoutines } from 'redux-entity-store'

export const dialogRoutines = createEntityRoutines('dialog', ['open', 'close'], true)

export function dialogVisibilityReducer (state, action) {
  if (action.type === dialogRoutines.open.SUCCESS) {
    return true
  }
  if (action.type === dialogRoutines.close.SUCCESS) {
    return false
  }
}

Async routines

Async routine is a series of action types that represent checkpoints in asynchronous processes or asynchronous communication. They are used everywhere you communicate with remote sources.

Trigger stage

The routine transaction has been triggered from the UI or some side effect. Next stage is request, but practically it is possible that the routine will not proceed to the next step if you choose to filter it in side effects.

routine.trigger()
routine.trigger(1)
routine.trigger({ id: 1 })

Trigger is the most used routine action, so it has a shortcut for your convenience

routine()
routine(1)
routine({ id: 1 })

To match this stage action type, use routine.TRIGGER constant

Request stage

In this stage, the routine transaction has been requested on the remote source. If you track the transaction status, it can be marked as "loading". Next stage is either success of failure.

routine.request()

To match this stage action type, use routine.REQUEST constant

Success stage

In this stage, we've got the response from the remote source and entity reducers process it. Also it says our request to remote source was successful. Next stage is always fulfill.

routine.success()
routine.success({ id: 1, name: 'Luke Skywalker' })

To match this stage action type, use routine.SUCCESS constant

Failure stage

In this stage, we either have the response from the remote source telling us that it failed to fulfill our request or no response in case the remote source could not be reached. The received payload is the error we met on the way.

routine.failure()
routine.failure(new Error('You must construct additional pylons'))

To match this stage action type, use routine.FAILURE constant

Fulfill stage

In this stage, the routine transaction has been finished. If you track the transaction status, it can be marked as "not loading anymore". This is the final stage.

routine.fulfill()
routine.fulfill(1)

To match this stage action type, use routine.FULFILL constant