Allow for any type of root level state

[rufman]

This addresses issue (#64), when you have an immutable object as the root state.

The redux-persist-immutable-state package provides the functions for actually iterating over an immutable root state as well as getting and setting keys.

Usage of redux-persist-immutable-state:

import { stateIterator, stateGetter, stateSetter, 
         stateReconciler, lastStateInit } from 'redux-persist-immutable-state';

persistStore(state, {
  transforms: [reduxPersistImmutable], 
  stateIterator: stateIterator,  
  stateGetter: stateGetter, stateSetter: stateSetter,
  lastStateInit: lastStateInit
})

I've spent some time benchmarking the persisting of new data on state changes, as well as rehydrating the state from localStorage. Here are the results:

The skeleton around those benchmarks is here: https://github.com/rufman/benchmark-redux-persist
If you want to run the tests yourself just clone https://github.com/rufman/redux-persist into the lib directory of benchmark-redux-persist and run webpack. Then open index.html and run the tests.

[rt2zz]

awesome 👍

I like this general approach, but want to wait for some resolution to reduxjs/redux#1792 before committing to a specific api.

[rufman]

OK, cool. In the mean time I have published this PR as redux-persist-2 for anyone that already wants to use it.

[dpereira411]

where is reduxPersistImmutable coming from? from redux-persist-transform-immutable? can I have an example?

[rufman]

reduxPersistImmutable is from redux-persist-immutable, which serializes ImmutableJS substates. If your root level state is an ImmutableJS object you'll need to use redux-persist-immutable-state, but if it's a plain object and just your sub states are Immutable objects redux-persist-immutable will be all you need.

[dpereira411]

thanks, so whats the difference between redux-persist-imutable and redux-persist-transform-immutable? github redirects redux-persist-immutable to redux-persist-transform-immutable

[rt2zz]

@dpereira411 redux-persist-immutable is deprecated, as redux-persist-transform-immutable works with redux-persist v3+

[mattkrick]

Could i get a little help on this API?
Still not getting it to persist from localStorage:

import {persistStore, autoRehydrate} from 'redux-persist-2';
import immutableTransform from 'redux-persist-transform-immutable';
import { stateIterator, stateGetter, stateSetter,
  stateReconciler, lastStateInit } from 'redux-persist-immutable-state';

persistStore(store, {
    transform: [immutableTransform],
    stateIterator: stateIterator,
    stateGetter: stateGetter,
    stateSetter: stateSetter,
    lastStateInit: lastStateInit
  });

[rufman]

transform: [immutableTransform] should be transforms: [immutableTransform]

[mattkrick]

that'll do it, thanks!

[dpereira411]

shouldn't that be transforms: [immutableTransform()] ?

[ntucker]

autoRehydrate doesn't seem to be working

import { persistStore, autoRehydrate } from 'redux-persist-2'
import immutableTransform from 'redux-persist-transform-immutable'
import { stateIterator, stateGetter, stateSetter,
         stateReconciler, lastStateInit } from 'redux-persist-immutable-state'

  let enhancer = compose(
    autoRehydrate(),
    applyMiddleware(
      ...middleware,
    ),
  )

  const store = createStore(rootReducer, Map(), enhancer)
  persistStore(store, {
    whitelist: ['counter'],
    debounce: 500,
    storage: localforage,
    transforms: [immutableTransform({})],
    stateIterator,
    stateGetter, stateSetter,
    lastStateInit, stateReconciler,
  })

It saves state fine (I checked the store), but it won't initialize. It creates an action properly with all the data, but that doesn't update the state for some reason. I put some console.log in the autorehydrate enhancer and I noticed its reducer is only called once on the @@init action, then never again. It's not called on the persist/REHYDRATE or anything else. Anyone know why that might be?

[marcellosachs]

@ntucker I ran into a similar issue - basically you have to pass stateReconciler as a config option to autoRehydrate instead of to persistStore :

import { persistStore, autoRehydrate } from 'redux-persist-2'
import immutableTransform from 'redux-persist-transform-immutable'
import { stateIterator, stateGetter, stateSetter,
         stateReconciler, lastStateInit } from 'redux-persist-immutable-state'

  let enhancer = compose(
    autoRehydrate({stateReconciler}),
    applyMiddleware(
      ...middleware,
    ),
  )

  const store = createStore(rootReducer, Map(), enhancer)
  persistStore(store, {
    whitelist: ['counter'],
    debounce: 500,
    storage: localforage,
    transforms: [immutableTransform({})],
    stateIterator,
    stateGetter, stateSetter,
    lastStateInit, 
  })

@rufman may be helpful to add this note to your original comment. Thanks for making this btw!

[ntucker]

Thanks @marcellosachs !

[rufman]

Yeah, I guess I need to go over the docs and add that. My bad.

[ntucker]

FYI @rt2zz : #158 still has the redux-persist-2 stuff in the README

+# What about redux-persist?
+This is a fork of redux-persist published as redux-persist-2 until the PR #113 gets merged.

[rt2zz]

@ntucker yikes good catch 🙌

[Jbarget]

@rufman @marcellosachs
if anyone could cast an eye at the issue below i'd be very grateful! I'm having some issues with my set up

rt2zz/redux-persist-transform-immutable#15

[ntucker]

The reconciler problem wasn't my issue. The problem is the reducer from createRehydrationReducer is only run once from the @@init action.

stateReconciler only matters INSIDE that reducer, but it doesn't even get the chance to run.

Maybe this is because I'm not using Action Buffers?

PS) I'm using "redux-persist": "3.6.0-alpha1",