feat(overmind): expose operator factories instead of action factory

BREAKING CHANGE:
action is no longer a function

Author: christianalfoni

packages/demos/react-todomvc/src/app/actions.js

@@ -2,15 +2,12 @@ import * as operations from './operations'
 import * as mutations from './mutations'
 
 export const changeNewTodoTitle = (action) =>
-  action()
-    .map(operations.getEventValue)
-    .mutate(mutations.setNewTodoTitle)
+  action.map(operations.getEventValue).mutate(mutations.setNewTodoTitle)
 
 export const addTodo = (action) =>
-  action()
-    .do(operations.preventEventDefault)
+  action
+    .run(operations.preventEventDefault)
     .mutate(mutations.addTodo)
     .mutate(mutations.clearNewTodoTitle)
 
-export const toggleCompleted = (action) =>
-  action().mutate(mutations.toggleCompleted)
+export const toggleCompleted = ({ mutate }) => mutate(mutations.toggleCompleted)

packages/demos/react-typescript-todomvc/src/app/actions.ts

@@ -7,15 +7,13 @@ import * as mutations from './mutations'
 type ChangeEvent = React.ChangeEvent<HTMLInputElement>
 
 export const changeNewTodoTitle: Action<ChangeEvent> = (action) =>
-  action()
-    .map(operations.getEventValue)
-    .mutate(mutations.setNewTodoTitle)
+  action.map(operations.getEventValue).mutate(mutations.setNewTodoTitle)
 
 export const addTodo: Action<React.FormEvent> = (action) =>
-  action()
-    .do(operations.preventEventDefault)
+  action
+    .run(operations.preventEventDefault)
     .mutate(mutations.addTodo)
     .mutate(mutations.clearNewTodoTitle)
 
-export const toggleCompleted: Action<Todo> = (action) =>
-  action().mutate(mutations.toggleCompleted)
+export const toggleCompleted: Action<Todo> = ({ mutate }) =>
+  mutate(mutations.toggleCompleted)

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

@@ -4,76 +4,72 @@ import * as operations from './operations'
 import { Message, Tab } from './types'
 
 const onMessage: Action<Message> = (action) =>
-  action()
+  action
     .mutate(mutations.performMutationsByMessageType)
     .mutate(mutations.addMessagesFromClient)
 
 export const loadDevtools: Action = (action) =>
-  action()
-    // .do(({ storage }) => storage.clear())
-    // Do a check if the current app matches the keys of the ???
+  // .do(({ storage }) => storage.clear())
+  // Do a check if the current app matches the keys of the ???
+  action
     .map(operations.getAppsFromStorage)
     .mutate(mutations.setApps)
     .map(operations.getCurrentPortFromStorage)
     .mutate(mutations.setCurrentPort)
     .mutate(mutations.setAppLoaded)
-    .do(operations.connectCurrentPort(onMessage(action as any)))
+    .run(operations.connectCurrentPort(onMessage(action as any)))
 
-export const setError: Action<string> = (action) =>
-  action().mutate(mutations.setError)
+export const setError: Action<string> = ({ mutate }) =>
+  mutate(mutations.setError)
 
 export const changeNewPortValue: Action<string> = (action) =>
-  action()
-    .map(operations.toNumber)
-    .mutate(mutations.setNewPortValue)
+  action.map(operations.toNumber).mutate(mutations.setNewPortValue)
 
 export const addPort: Action = (action) =>
-  action()
+  action
     .map(operations.getNewPortFromState)
     .mutate(mutations.setCurrentPort)
     .mutate(mutations.addNewApp)
     .mutate(mutations.resetNewPortValue)
-    .do(operations.storeApps)
-    .do(operations.connectCurrentPort(onMessage))
+    .run(operations.storeApps)
+    .run(operations.connectCurrentPort(onMessage))
 
-export const changeTab: Action<Tab> = (action) =>
-  action().mutate(mutations.changeTab)
+export const changeTab: Action<Tab> = ({ mutate }) =>
+  mutate(mutations.changeTab)
 
-export const toggleExpandState: Action<string[]> = (action) =>
-  action().mutate(mutations.toggleExpandStatePath)
+export const toggleExpandState: Action<string[]> = ({ mutate }) =>
+  mutate(mutations.toggleExpandStatePath)
 
-export const selectAction: Action<string> = (action) =>
-  action()
-    .mutate(mutations.toggleActionItemCollapse)
-    .mutate(mutations.selectAction)
+export const selectAction: Action<string> = ({ mutate }) =>
+  mutate(mutations.toggleActionItemCollapse).mutate(mutations.selectAction)
 
 type Collapsed = {
   isCollapsed: boolean
 }
 
 export const toggleCollapsed: Action<Collapsed> = (action) =>
-  action()
+  action
     .filter(operations.isNotExpandingAllActions)
     .mutate(mutations.toggleCollapsed)
 
-export const configurePort: Action = (action) =>
-  action().mutate(mutations.configurePort)
+export const configurePort: Action = ({ mutate }) =>
+  mutate(mutations.configurePort)
 
-export const cancelConfigurePort: Action = (action) =>
-  action().mutate(mutations.cancelConfigurePort)
+export const cancelConfigurePort: Action = ({ mutate }) =>
+  mutate(mutations.cancelConfigurePort)
 
 export const removeApp: Action = (action) =>
-  action()
+  action
     .filter(operations.confirm('Are you sure you want to remove the app?'))
-    .do(operations.removeCurrentPort)
+    .run(operations.removeCurrentPort)
     .mutate(mutations.removeApp)
-    .do(operations.storeApps)
-    .do(operations.connectCurrentPort(onMessage(action as any)))
+    .run(operations.storeApps)
+    .run(operations.connectCurrentPort(onMessage(action as any)))
 
 export const selectPort: Action<string> = (action) =>
-  action()
+  action
     .mutate(mutations.selectPort)
-    .do(operations.connectCurrentPort(onMessage(action as any)))
+    .run(operations.connectCurrentPort(onMessage(action as any)))
 
-export const toggleExpandAllActions: Action = (action) =>
-  action().mutate(mutations.toggleExpandAllActions)
+export const toggleExpandAllActions: Action = ({ mutate }) =>
+  mutate(mutations.toggleExpandAllActions)

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

@@ -16,23 +16,23 @@ export const getCurrentPortFromStorage: Operation.Map<any, Promise<string>> = ({
 export const getNewPortFromState: Operation.Map<any, string> = ({ state }) =>
   state.newPortValue
 
-export const storeApps: Operation.Do = ({ storage, state }) =>
+export const storeApps: Operation.Run = ({ storage, state }) =>
   storage.set('apps', state.apps)
 
 export const toNumber: Operation.Map<string, string> = (_, value) =>
   String(Number(value))
 
 export const connectCurrentPort: (
   action: (message: any) => void
-) => Operation.Do = (action) => ({ state, connector }) => {
+) => Operation.Run = (action) => ({ state, connector }) => {
   if (!state.currentPort) {
     return
   }
 
   connector.addPort(state.currentPort, action)
 }
 
-export const removeCurrentPort: Operation.Do = ({ state, connector }) =>
+export const removeCurrentPort: Operation.Run = ({ state, connector }) =>
   connector.removePort(state.currentPort)
 
 export const isNotExpandingAllActions: Operation.Filter = ({ state }) =>

packages/node_modules/overmind/src/Action.ts

@@ -29,12 +29,12 @@ export interface INoValueAction<
   (): Value
 }
 
+export type ReturnAction<Value, State, Effects> = [Value] extends [void]
+  ? INoValueAction<State, Effects & { state: State }, Value>
+  : IValueAction<State, Effects & { state: State }, Value>
+
 export interface Compose<State, Effects, Value, ReturnValue = Value> {
-  (
-    action: () => [Value] extends [void]
-      ? INoValueAction<State, Effects & { state: State }, Value>
-      : IValueAction<State, Effects & { state: State }, Value>
-  ): [Value] extends [void]
+  (action: ActionClass<State, Effects, Value, Value>): [Value] extends [void]
     ? INoValueAction<State, Effects & { state: State }, Value, ReturnValue>
     : IValueAction<State, Effects & { state: State }, Value, ReturnValue>
 }
@@ -45,19 +45,39 @@ interface MutationsEvents {
   }
 }
 
+export const createOperators = (proxyStateTree, actionChain) => ({
+  fork: (cb, paths) =>
+    new ActionClass(proxyStateTree, actionChain).fork(cb, paths),
+  mutate: (cb) => new ActionClass(proxyStateTree, actionChain).mutate(cb),
+  run: (cb) => new ActionClass(proxyStateTree, actionChain).run(cb),
+  map: (cb) => new ActionClass(proxyStateTree, actionChain).map(cb),
+  attempt: (cb, paths) =>
+    new ActionClass(proxyStateTree, actionChain).attempt(cb, paths),
+  when: (cb, paths) =>
+    new ActionClass(proxyStateTree, actionChain).when(cb, paths),
+  compose: (action) =>
+    new ActionClass(proxyStateTree, actionChain).compose(action),
+  parallel: (actions) =>
+    new ActionClass(proxyStateTree, actionChain).parallel(actions),
+  filter: (cb) => new ActionClass(proxyStateTree, actionChain).filter(cb),
+  debounce: (ms) => new ActionClass(proxyStateTree, actionChain).debounce(ms),
+})
+
 export default class ActionClass<
   State,
   Effects,
   InitialValue,
   Value = InitialValue
 > extends ActionBase<Effects> {
+  operators: any
   constructor(
     private proxyStateTree: ProxyStateTree,
     actionChain: ActionChain<Effects>,
     initialActionId?: number,
     runOperators?
   ) {
     super(actionChain, initialActionId, runOperators)
+    this.operators = createOperators(this.proxyStateTree, this.getActionChain())
   }
   fork: <Paths>(
     cb: (effects: Effects, value: Value) => keyof Paths,
@@ -66,9 +86,7 @@ export default class ActionClass<
     ? INoValueAction<State, Effects, InitialValue, Value>
     : IValueAction<State, Effects, InitialValue, Value> = (cb, paths) => {
     const actions = Object.keys(paths).reduce((aggr, key) => {
-      aggr[key] = paths[key](
-        () => new ActionClass(this.proxyStateTree, this.getActionChain())
-      )
+      aggr[key] = paths[key](this.operators)
 
       return aggr
     }, {})
@@ -124,7 +142,7 @@ export default class ActionClass<
       runOperators
     ) as any
   }
-  do: (
+  run: (
     cb: (effects: Effects, value: Value) => void | Promise<any>
   ) => [InitialValue] extends [void]
     ? INoValueAction<State, Effects, InitialValue, Value>
@@ -140,7 +158,7 @@ export default class ActionClass<
     }
 
     const [chain, initialActionId, runOperators] = this.createOperatorResult(
-      'do',
+      'run',
       (cb as any).displayName || cb.name,
       operator
     )
@@ -170,7 +188,7 @@ export default class ActionClass<
       runOperators
     ) as any
   }
-  try: <ResolveValue, RejectValue, NewValue>(
+  attempt: <ResolveValue, RejectValue, NewValue>(
     cb: OperatorCallback<Effects, Value, NewValue>,
     paths: {
       success: Compose<
@@ -195,12 +213,8 @@ export default class ActionClass<
     cb,
     paths
   ) => {
-    const successPath = paths.success(
-      () => new ActionClass(this.proxyStateTree, this.getActionChain())
-    )
-    const errorPath = paths.error(
-      () => new ActionClass(this.proxyStateTree, this.getActionChain())
-    )
+    const successPath = (paths.success as any)(this.operators)
+    const errorPath = (paths.error as any)(this.operators)
     const operator = (effects, value) => {
       return (cb(effects, value) as any)
         .then((promiseValue) => {
@@ -211,7 +225,7 @@ export default class ActionClass<
         })
     }
     const [chain, initialActionId, runOperators] = this.createOperatorResult(
-      'try',
+      'attempt',
       (cb as any).displayName || cb.name,
       operator
     )
@@ -235,12 +249,8 @@ export default class ActionClass<
     cb,
     paths
   ) => {
-    const trueAction = (paths.true as any)(
-      () => new ActionClass(this.proxyStateTree, this.getActionChain())
-    )
-    const falseAction = (paths.false as any)(
-      () => new ActionClass(this.proxyStateTree, this.getActionChain())
-    )
+    const trueAction = (paths.true as any)(this.operators)
+    const falseAction = (paths.false as any)(this.operators)
     const operator = (effects, value) => {
       const isTrue = cb(effects, value)
       const path = isTrue ? trueAction : falseAction

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

@@ -68,8 +68,8 @@ describe('Computed', () => {
         return state.foo + foo
       }),
     }
-    const changeFoo: Action = (action) =>
-      action().mutate((state) => (state.foo = 'bar2'))
+    const changeFoo: Action = ({ mutate }) =>
+      mutate((state) => (state.foo = 'bar2'))
     const config = {
       state,
       actions: {

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

@@ -17,8 +17,8 @@ describe('Derived', () => {
   })
   test('should track derived state', () => {
     let renderCount = 0
-    const changeFoo: Action = (action) =>
-      action().mutate((state) => (state.foo = 'bar2'))
+    const changeFoo: Action = ({ mutate }) =>
+      mutate((state) => (state.foo = 'bar2'))
     const config = {
       state: {
         foo: 'bar',