feat(overmind): review and improve typing

BREAKING CHANGE:
fixed issue with pipe typing and creating defaults on TOperator

Author: christianalfoni

packages/node_modules/overmind/src/index.ts

@@ -454,46 +454,50 @@ export class Overmind<Config extends Configuration> implements Configuration {
   OPERATORS
   needs to be in this file for typing override to work
 */
-export type Operator<Input, Output> = TOperator<TheConfig, Input, Output>
+export type Operator<Input = void, Output = Input> = TOperator<
+  TheConfig,
+  Input,
+  Output
+>
 
-export function pipe<Config extends Configuration, A, B, C>(
+export function pipe<Config extends Configuration, A, B>(
   aOperator: TOperator<Config, A, B>
-): TOperator<Config, A, C>
+): TOperator<Config, A, B>
 
-export function pipe<Config extends Configuration, A, B, C, D>(
+export function pipe<Config extends Configuration, A, B, C>(
   aOperator: TOperator<Config, A, B>,
   bOperator: TOperator<Config, B, C>
-): TOperator<Config, A, D>
+): TOperator<Config, A, C>
 
-export function pipe<Config extends Configuration, A, B, C, D, E>(
+export function pipe<Config extends Configuration, A, B, C, D>(
   aOperator: TOperator<Config, A, B>,
   bOperator: TOperator<Config, B, C>,
   cOperator: TOperator<Config, C, D>
-): TOperator<Config, A, E>
+): TOperator<Config, A, D>
 
-export function pipe<Config extends Configuration, A, B, C, D, E, F>(
+export function pipe<Config extends Configuration, A, B, C, D, E>(
   aOperator: TOperator<Config, A, B>,
   bOperator: TOperator<Config, B, C>,
   cOperator: TOperator<Config, C, D>,
   dOperator: TOperator<Config, D, E>
-): TOperator<Config, A, F>
+): TOperator<Config, A, E>
 
-export function pipe<Config extends Configuration, A, B, C, D, E, F, G>(
+export function pipe<Config extends Configuration, A, B, C, D, E, F>(
   aOperator: TOperator<Config, A, B>,
   bOperator: TOperator<Config, B, C>,
   cOperator: TOperator<Config, C, D>,
   dOperator: TOperator<Config, D, E>,
   eOperator: TOperator<Config, E, F>
-): TOperator<Config, A, G>
+): TOperator<Config, A, F>
 
-export function pipe<Config extends Configuration, A, B, C, D, E, F, G, H>(
+export function pipe<Config extends Configuration, A, B, C, D, E, F, G>(
   aOperator: TOperator<Config, A, B>,
   bOperator: TOperator<Config, B, C>,
   cOperator: TOperator<Config, C, D>,
   dOperator: TOperator<Config, D, E>,
   eOperator: TOperator<Config, E, F>,
   fOperator: TOperator<Config, F, G>
-): TOperator<Config, A, H>
+): TOperator<Config, A, G>
 
 export function pipe(...operators) {
   const instance = (err, context, next, final = next) => {
@@ -701,7 +705,7 @@ export function forEach<
 }
 
 export function parallel<Input, Config extends Configuration = TheConfig>(
-  operators: TOperator<Config, Input, any>[]
+  ...operators: TOperator<Config, Input>[]
 ): TOperator<Config, Input, Input> {
   const instance = (err, context, next) => {
     if (err) next(err)

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

@@ -60,7 +60,7 @@ describe('PIPE', () => {
   describe('OPERATORS', () => {
     test('map', () => {
       expect.assertions(1)
-      const test: Operator<string, string> = pipe(
+      const test: Operator<string> = pipe(
         map(({ value }) => value.toUpperCase())
       )
 
@@ -70,7 +70,7 @@ describe('PIPE', () => {
     })
     test('map (async)', () => {
       expect.assertions(1)
-      const test: Operator<string, string> = pipe(
+      const test: Operator<string> = pipe(
         map(({ value }) => Promise.resolve(value.toUpperCase()))
       )
 
@@ -81,7 +81,7 @@ describe('PIPE', () => {
     test('forEach', () => {
       expect.assertions(1)
       let runCount = 0
-      const test: Operator<string[], string[]> = pipe(
+      const test: Operator<string[]> = pipe(
         forEach((_, val, next) => {
           runCount++
           next(null, val)
@@ -95,17 +95,17 @@ describe('PIPE', () => {
     test('parallel', () => {
       expect.assertions(1)
       let runCount = 0
-      const test: Operator<string, string> = pipe(
-        parallel([
+      const test: Operator<string> = pipe(
+        parallel(
           (_, value, next) => {
             runCount++
             next(null, value)
           },
           (_, value, next) => {
             runCount++
             next(null, value)
-          },
-        ])
+          }
+        )
       )
 
       return createMockAction(test)('foo').then(() => {
@@ -114,7 +114,7 @@ describe('PIPE', () => {
     })
     test('filter - truthy', () => {
       expect.assertions(1)
-      const test: Operator<string, string> = pipe(
+      const test: Operator<string> = pipe(
         filter(({ value }) => value === 'foo'),
         map(({ value }) => value.toUpperCase())
       )
@@ -124,7 +124,7 @@ describe('PIPE', () => {
       })
     })
     test('filter - falsy', () => {
-      const test: Operator<string, string> = pipe(
+      const test: Operator<string> = pipe(
         filter(({ value }) => value === 'bar'),
         map(({ value }) => value.toUpperCase())
       )
@@ -135,7 +135,7 @@ describe('PIPE', () => {
     })
     test('fork', () => {
       expect.assertions(1)
-      const test: Operator<string, string> = pipe(
+      const test: Operator<string> = pipe(
         fork(() => 'foo', {
           foo: map(({ value }) => value.toUpperCase()),
         })
@@ -161,14 +161,14 @@ describe('PIPE', () => {
     test('wait', () => {
       expect.assertions(1)
       const runTime = Date.now()
-      const test: Operator<string, string> = pipe(wait(500))
+      const test: Operator<string> = pipe(wait(500))
       return createMockAction(test)('foo').then(() => {
         expect(Date.now() - runTime).toBeGreaterThanOrEqual(500)
       })
     })
     test('debounce', () => {
       expect.assertions(1)
-      const test: Operator<string, string> = pipe(
+      const test: Operator<string> = pipe(
         debounce(100),
         map(({ value }) => value.toUpperCase())
       )
@@ -190,7 +190,7 @@ describe('PIPE', () => {
     test('action (async)', () => {
       expect.assertions(2)
       let hasRun = false
-      const test: Operator<string, string> = pipe(
+      const test: Operator = pipe(
         action(({ value }) => Promise.resolve(value + '!!!')),
         action(() => (hasRun = true))
       )

packages/node_modules/overmind/src/types.ts

@@ -59,7 +59,7 @@ export type TAction<Config extends Configuration, Value> = (
   context: TValueContext<Config, Value>
 ) => any
 
-export type TOperator<Config extends Configuration, Input, Output> = (
+export type TOperator<Config extends Configuration, Input, Output = Input> = (
   err: Error | null,
   val: TValueContext<Config, Input>,
   next: (err: Error | null, val?: TValueContext<Config, Output>) => void,