feat(overmind): use fromOperator function to make operators an action

BREAKING CHANGE:
have to use fromOperator function to create operator actions

Author: christianalfoni

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

@@ -1,4 +1,4 @@
-import { Action, pipe, OnInitialize, Operator } from 'overmind'
+import { Action, pipe, OnInitialize, Operator, fromOperator } from 'overmind'
 import {
   Message,
   Tab,
@@ -69,11 +69,13 @@ const handleClientMessage: Operator<Message, any> = pipe(
   })
 )
 
-export const onMessage: Operator<Message, any> = pipe(
-  isPortExistsMessage({
-    true: setPortExists,
-    false: handleClientMessage,
-  })
+export const onMessage: Action<Message> = fromOperator(
+  pipe(
+    isPortExistsMessage({
+      true: setPortExists,
+      false: handleClientMessage,
+    })
+  )
 )
 
 export const setError: Action<string> = ({ value: error, state }) =>

packages/node_modules/overmind/src/index.ts

@@ -46,6 +46,8 @@ export interface Derive<Parent extends TStateObject, Value>
 
 export interface OnInitialize extends IOnInitialize<Config> {}
 
+const IS_NODE =
+  typeof module !== 'undefined' && (!this || this.module !== module)
 const IS_PRODUCTION = process.env.NODE_ENV === 'production'
 const IS_DEVELOPMENT = process.env.NODE_ENV === 'development'
 const IS_OPERATOR = Symbol('operator')
@@ -199,7 +201,9 @@ export class Overmind<Config extends Configuration> implements Configuration {
           '\n\n - You are not running on localhost. You will have to manually define the devtools option to connect'
       }
 
-      console.warn(warning)
+      if (!IS_NODE) {
+        console.warn(warning)
+      }
     }
 
     if (IS_PRODUCTION) {
@@ -336,24 +340,10 @@ export class Overmind<Config extends Configuration> implements Configuration {
           this.eventHub.emit(EventType.ACTION_START, execution)
 
           action[IS_OPERATOR]
-            ? action(
-                null,
-                {
-                  value,
-                  state: this.proxyStateTree.state,
-                  actions: this.actions,
-                  execution,
-                  effects: this.trackEffects(this.effects, execution),
-                },
-                (err, finalContext) => {
-                  finalContext &&
-                    this.eventHub.emit(EventType.ACTION_END, {
-                      ...finalContext.execution,
-                      operatorId: finalContext.execution.operatorId - 1,
-                    })
-                  if (err) reject(err)
-                  else resolve(this.options.testMode && finalContext.execution)
-                }
+            ? resolve(
+                action(
+                  this.createContext(value, execution, this.proxyStateTree)
+                )
               )
             : resolve(
                 action(
@@ -617,6 +607,28 @@ export type Operator<Input = void, Output = Input> = IOperator<
   Output
 >
 
+export function fromOperator<Config, Input>(
+  operator: IOperator<Config, Input, any>
+): IAction<Config, Input> {
+  const func = (context) => {
+    return new Promise((resolve, reject) => {
+      operator(null, context, (err, finalContext) => {
+        finalContext &&
+          context.execution.emit(EventType.ACTION_END, {
+            ...finalContext.execution,
+            operatorId: finalContext.execution.operatorId - 1,
+          })
+        if (err) reject(err)
+        else resolve()
+      })
+    })
+  }
+
+  func[IS_OPERATOR] = true
+
+  return func
+}
+
 export function pipe<Config extends Configuration, A, B>(
   aOperator: IOperator<Config, A, B>
 ): IOperator<Config, A, B>
@@ -676,12 +688,12 @@ export function pipe(...operators) {
         operators[operatorIndex++](
           runErr,
           runContext,
-          runNexIOperator,
+          runNextOperator,
           finalClearingAsync
         )
       }
 
-      const runNexIOperator = (operatorError, operatorContext) => {
+      const runNextOperator = (operatorError, operatorContext) => {
         clearTimeout(asyncTimeout)
         if (operatorError) return next(operatorError)
         if (operatorIndex >= operators.length)
@@ -706,7 +718,7 @@ export function pipe(...operators) {
         }
       }
 
-      runNexIOperator(null, context)
+      runNextOperator(null, context)
     }
   }
   instance[IS_OPERATOR] = true

packages/node_modules/overmind/src/internalTypes.ts

@@ -174,10 +174,6 @@ export type ResolveActions<
         ? [TActionValue<Actions[T]>] extends [void]
           ? () => Promise<void>
           : (value: TActionValue<Actions[T]>) => Promise<void>
-        : Actions[T] extends IOperator<any, any, any>
-        ? [TOperationValue<Actions[T]>] extends [void]
-          ? () => Promise<void>
-          : (value: TOperationValue<Actions[T]>) => Promise<void>
         : Actions[T] extends NestedActions
         ? ResolveActions<Actions[T]>
         : never
@@ -203,10 +199,6 @@ export type ResolveMockActions<
         ? [TActionValue<Actions[T]>] extends [void]
           ? () => Promise<MockResult>
           : (value: TActionValue<Actions[T]>) => Promise<MockResult>
-        : Actions[T] extends IOperator<any, any, any>
-        ? [TOperationValue<Actions[T]>] extends [void]
-          ? () => Promise<MockResult>
-          : (value: TOperationValue<Actions[T]>) => Promise<MockResult>
         : Actions[T] extends NestedMockActions
         ? ResolveMockActions<Actions[T]>
         : never