feat(overmind): add class replacer to rehydrate

Author: christianalfoni

packages/node_modules/overmind/src/index.test.ts

@@ -5,12 +5,27 @@ function toJSON(obj) {
   return JSON.parse(JSON.stringify(obj))
 }
 
+class StateValue {
+  value = 'foo'
+  toJSON() {
+    return {
+      value: this.value
+    }
+  }
+  static fromJSON(json: { value: string }) {
+    const instance = new StateValue()
+    instance.value = json.value
+    return instance
+  }
+}
+
 function createDefaultOvermind() {
   const state = {
     foo: 'bar',
     item: {
       isAwesome: true,
     },
+    value: [] as StateValue[]
   }
   const changeFoo: Action<void, string> = (context) => {
     context.state.foo = 'bar2'
@@ -41,7 +56,9 @@ function createDefaultOvermind() {
     form[key] = value
   }
   const rehydrateAction: Action<any> = ({ state }, newState) => {
-    rehydrate(state, newState)
+    rehydrate(state, newState, {
+      value: (json) => StateValue.fromJSON(json)
+    })
   }
   const actions = {
     asyncChangeFoo,
@@ -361,8 +378,8 @@ describe('Overmind', () => {
     ).not.toThrow()
     expect(app.state.item.isAwesome).toBe(false)
   })
-  test('should allow rehydration', () => {
-    expect.assertions(2)
+  test.only('should allow rehydration', () => {
+    expect.assertions(4)
     const app = createDefaultOvermind()
     const mutation = {
       method: 'set',
@@ -374,13 +391,17 @@ describe('Overmind', () => {
     app.actions.rehydrateAction({
       item: {
         isAwesome: false
-      }
+      },
+      value: [{
+        value: 'bar'
+      }]
     })
-    expect(app.state).toEqual({
-      foo: 'bar2',
-      item: {
-        isAwesome: false
-      }
+    expect(app.state.foo).toEqual('bar2')
+    expect(app.state.item).toEqual({
+      isAwesome: false
+    })
+    expect(app.state.value[0].toJSON()).toEqual({
+      value: 'bar'
     })
   })
 })

packages/node_modules/overmind/src/index.ts

@@ -21,10 +21,11 @@ import {
   Execution,
   NestedPartial,
   Options,
+  RehydrateClasses,
   ResolveActions,
   ResolveState,
   SSRMode,
-  TestMode,
+  TestMode
 } from './internalTypes'
 import {
   createContext,
@@ -93,24 +94,33 @@ export interface Reaction extends IReaction<Config> {}
 export const json = (obj: any) =>
   deepCopy(obj && obj[IS_PROXY] ? obj[VALUE] : obj)
 
-export const rehydrate = (state: IState, source: IMutation[] | IState) => {
+export const rehydrate = <T extends IState>(state: T, source: IMutation[] | IState, classes: RehydrateClasses<T> = {} as RehydrateClasses<T>) => {
   if (Array.isArray(source)) {
     const mutations = source as IMutation[]
     mutations.forEach((mutation) => {
       const pathArray = mutation.path.split('.')
       const key = pathArray.pop() as string
       const target = pathArray.reduce((aggr, key) => aggr[key], state as any)
+      const classInstance = pathArray.reduce((aggr, key) => aggr[key], classes as any)
 
       if (mutation.method === 'set') {
-        target[key] = mutation.args[0]
+        if (typeof classInstance === 'function' && Array.isArray(mutation.args[0])) {
+          target[key] = mutation.args[0].map((arg) => classInstance(arg))
+        } else if (typeof classInstance === 'function') {
+          target[key] = classInstance(mutation.args[0])
+        } else {
+          target[key] = mutation.args[0]
+        }
       } else if (mutation.method === 'unset') {
         delete target[key]
       } else {
-        target[key][mutation.method](...mutation.args)
+        target[key][mutation.method].apply(target[key], typeof classInstance === 'function' ? mutation.args.map((arg) => {
+          return typeof arg === 'object' && arg !== null ? classInstance(arg) : arg
+        }) : mutation.args)
       }
     })
   } else {
-    rehydrateState(state, source)
+    rehydrateState(state, source, classes)
   } 
 }
 

packages/node_modules/overmind/src/internalTypes.ts

@@ -1,9 +1,10 @@
 import {
+  IFlushCallback,
   IMutation,
   IMutationTree,
   ITrackStateTree,
-  IFlushCallback,
 } from 'proxy-state-tree'
+
 import { IAction, IOperator, IState } from './types'
 
 export type SubType<Base, Condition> = Pick<
@@ -15,6 +16,14 @@ export type NestedPartial<T> = T extends Function
   ? T
   : Partial<{ [P in keyof T]: NestedPartial<T[P]> }>
 
+export type RehydrateClasses<T extends IState> = Pick<{
+  [P in keyof T]: T[P] extends { toJSON: () => infer U } ? (data: U) => T[P] :
+      T[P] extends Array<{ toJSON: () => infer U }> ? (data: U) => T[P][0] :
+      T[P] extends { [key: string]: { toJSON: () => infer U } } ? (data: U) => T[P][0] :
+      T[P] extends IState ? RehydrateClasses<T[P]> :
+      never
+},{ [Key in keyof T]: T[Key] extends { toJSON: () => any } ? Key : never }[keyof T]>
+
 export type Options = {
   name?: string
   devtools?: string | boolean

packages/node_modules/overmind/src/utils.ts

@@ -1,6 +1,7 @@
 import isPlainObject from 'is-plain-obj'
 
 import { Derived } from './derived'
+import { RehydrateClasses } from './internalTypes'
 import { IState } from './types'
 
 export const IS_TEST = process.env.NODE_ENV === 'test'
@@ -155,16 +156,21 @@ export function createActionsProxy(actions, cb) {
   })
 }
 
-export function rehydrateState(target: IState, source: IState) {
+export function rehydrateState<T extends IState>(target: T, source: IState, classes: RehydrateClasses<T> = {} as RehydrateClasses<T>) {
   if (!target || !source) {
     throw new Error(`You have to pass a "target" and "source" object to rehydrate`)
   }
 
   Object.keys(source).forEach((key) => {
     const value = source[key]
+    const classInstance = classes[key]
     if (typeof value === 'object' && !Array.isArray(value) && value !== null) {
       if (!target[key]) target[key] = {}
-      rehydrateState(target[key] as IState, source[key] as IState)
+      rehydrateState(target[key] as IState, source[key] as IState, classes[key])
+    } else if (classInstance && Array.isArray(source[key])) {
+      target[key] = (source[key] as any[]).map(value => classInstance(value))
+    } else if (classInstance) {
+      target[key] = classInstance(source[key])
     } else {
       target[key] = source[key]
     }