Merge pull request cerebral#132 from cerebral/improvements2

fix(overmind): force input and output on pipe to fix typing

Author: christianalfoni

packages/node_modules/overmind-devtools/src/app/actions.ts

@@ -44,7 +44,7 @@ export const onInitialize: OnInitialize = async ({
   connector.connect(state.port)
 }
 
-const handleClientMessage: Pipe<Message> = pipe(
+const handleClientMessage: Pipe<Message, any> = pipe(
   ensureCurrentApp,
   ensureApp,
   addClientMessages,
@@ -68,7 +68,7 @@ const handleClientMessage: Pipe<Message> = pipe(
   })
 )
 
-export const onMessage: Pipe<Message> = pipe(
+export const onMessage: Pipe<Message, any> = pipe(
   isPortExistsMessage({
     true: setPortExists,
     false: handleClientMessage,

packages/node_modules/overmind-devtools/src/app/operators.ts

@@ -39,10 +39,10 @@ export const setPortExists = mutate<any>(({ state }) => {
 })
 
 export const isPortExistsMessage = (paths: {
-  true: Operator<Message>
-  false: Operator<Message>
+  true: Operator<Message, any>
+  false: Operator<Message, any>
 }) =>
-  when<Message>(
+  when(
     ({ value: message }) => message.messages[0].type === 'PORT_EXISTS',
     paths
   )
@@ -296,5 +296,5 @@ export const getMessages = map<Message, AppMessage<any>[]>(({ value }) =>
 )
 
 export const forkEachMessage = (paths: {
-  [key: string]: Operator<AppMessage<any>>
+  [key: string]: Operator<AppMessage<any>, AppMessage<any>>
 }) => forEach<AppMessage<any>[]>(fork(({ value }) => value.type, paths))

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

@@ -5,7 +5,60 @@ function toJSON(obj) {
   return JSON.parse(JSON.stringify(obj))
 }
 
-describe.only('Overmind', () => {
+function createDefaultApp() {
+  const state = {
+    foo: 'bar',
+  }
+  const changeFoo: Action = (context) => {
+    context.state.foo = 'bar2'
+  }
+  const changeFooWithEffect: Action = (context) => {
+    context.state.foo = context.hello()
+  }
+  const waitAndChangeFoo: Action = (context) => {
+    return context.wait().then(() => {
+      context.state.foo = 'bar2'
+    })
+  }
+  const asyncChangeFoo: Action = async (context) => {
+    await Promise.resolve()
+    context.state.foo = 'bar2'
+  }
+  const actions = {
+    changeFoo,
+    changeFooWithEffect,
+    waitAndChangeFoo,
+    asyncChangeFoo,
+  }
+  const effects = {
+    hello() {
+      return 'hello'
+    },
+    wait() {
+      return Promise.resolve()
+    },
+  }
+  const config = {
+    state,
+    actions,
+    effects,
+  }
+
+  type App = TApp<{
+    state: typeof state
+    actions: typeof actions
+    effects: typeof effects
+  }>
+  type Action<Value = void, ReturnValue = Value> = TAction<
+    App,
+    Value,
+    ReturnValue
+  >
+
+  return new Overmind(config)
+}
+
+describe('Overmind', () => {
   test('should instantiate app with state', () => {
     const app = new Overmind({
       state: {
@@ -35,96 +88,34 @@ describe.only('Overmind', () => {
   })
   test('should be able to type actions', () => {
     expect.assertions(2)
-    const state = {
-      foo: 'bar',
-    }
-    const doThis: Action = (context) => {
-      context.state.foo = 'bar2'
-    }
-    const actions = {
-      doThis,
-    }
-    const config = {
-      state,
-      actions,
-    }
-
-    type App = TApp<{
-      state: typeof state
-      actions: typeof actions
-    }>
-    type Action<Value = void, ReturnValue = Value> = TAction<
-      App,
-      Value,
-      ReturnValue
-    >
 
-    const app = new Overmind(config)
+    const app = createDefaultApp()
 
     expect(app.state.foo).toBe('bar')
-    app.actions.doThis()
+    app.actions.changeFoo()
     expect(app.state.foo).toBe('bar2')
   })
   test('should allow changing state in actions', () => {
     expect.assertions(2)
-    const app = new Overmind({
-      state: {
-        foo: 'bar',
-      },
-      actions: {
-        doThis(context?) {
-          context.state.foo = 'bar2'
-        },
-      },
-    })
+    const app = createDefaultApp()
 
     expect(app.state.foo).toBe('bar')
-    app.actions.doThis()
+    app.actions.changeFoo()
     expect(app.state.foo).toBe('bar2')
   })
   test('should expose effects to actions', () => {
     expect.assertions(2)
-    const app = new Overmind({
-      state: {
-        foo: 'bar',
-      },
-      actions: {
-        doThis(context?) {
-          context.state.foo = context.hello()
-        },
-      },
-      effects: {
-        hello() {
-          return 'hello'
-        },
-      },
-    })
+    const app = createDefaultApp()
 
     expect(app.state.foo).toBe('bar')
-    app.actions.doThis()
+    app.actions.changeFooWithEffect()
     expect(app.state.foo).toBe('hello')
   })
   test('should be able to do mutations async via effects', () => {
     expect.assertions(2)
-    const app = new Overmind({
-      state: {
-        foo: 'bar',
-      },
-      actions: {
-        doThis(context?) {
-          return context.wait().then(() => {
-            context.state.foo = 'bar2'
-          })
-        },
-      },
-      effects: {
-        wait() {
-          return Promise.resolve()
-        },
-      },
-    })
+    const app = createDefaultApp()
     expect(app.state.foo).toBe('bar')
-    return app.actions.doThis().then(() => {
+    return app.actions.waitAndChangeFoo().then(() => {
       expect(app.state.foo).toBe('bar2')
     })
   })
@@ -187,20 +178,11 @@ describe.only('Overmind', () => {
   })
   test('should track mutations', () => {
     expect.assertions(1)
-    const app = new Overmind({
-      state: {
-        foo: 'bar',
-      },
-      actions: {
-        doThis(context?) {
-          context.state.foo = 'bar2'
-        },
-      },
-    })
+    const app = createDefaultApp()
     app.eventHub.once(EventType.MUTATIONS, (data) => {
       expect(toJSON(data)).toEqual({
         actionId: 0,
-        actionName: 'doThis',
+        actionName: 'changeFoo',
         mutations: [
           {
             args: ['bar2'],
@@ -213,26 +195,15 @@ describe.only('Overmind', () => {
         path: [],
       })
     })
-    app.actions.doThis()
+    app.actions.changeFoo()
   })
   test('should track async mutations', () => {
     expect.assertions(1)
-    const app = new Overmind({
-      state: {
-        foo: 'bar',
-      },
-      actions: {
-        doThis(context?) {
-          Promise.resolve().then(() => {
-            context.state.foo = 'bar2'
-          })
-        },
-      },
-    })
+    const app = createDefaultApp()
     app.eventHub.on(EventType.MUTATIONS, (data) => {
       expect(toJSON(data)).toEqual({
-        actionId: 0,
-        actionName: 'doThis',
+        actionId: 2,
+        actionName: 'waitAndChangeFoo',
         mutations: [
           {
             args: ['bar2'],
@@ -245,25 +216,15 @@ describe.only('Overmind', () => {
         path: [],
       })
     })
-    app.actions.doThis()
+    app.actions.waitAndChangeFoo()
   })
   test('should track async mutations with async await', () => {
     expect.assertions(1)
-    const app = new Overmind({
-      state: {
-        foo: 'bar',
-      },
-      actions: {
-        doThis: async (context?) => {
-          await Promise.resolve()
-          context.state.foo = 'bar2'
-        },
-      },
-    })
+    const app = createDefaultApp()
     app.eventHub.on(EventType.MUTATIONS, (data) => {
       expect(toJSON(data)).toEqual({
-        actionId: 0,
-        actionName: 'doThis',
+        actionId: 3,
+        actionName: 'asyncChangeFoo',
         mutations: [
           {
             args: ['bar2'],
@@ -276,7 +237,7 @@ describe.only('Overmind', () => {
         path: [],
       })
     })
-    app.actions.doThis()
+    app.actions.asyncChangeFoo()
   })
   test('should instantiate app with modules', () => {
     const foo = {