feat(overmind): add branch operator

Author: christianalfoni

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

@@ -1,6 +1,7 @@
 import {
   Overmind,
   pipe,
+  branch,
   filter,
   fork,
   when,
@@ -16,6 +17,39 @@ import {
 import { merge } from './config'
 
 describe('OPERATORS', () => {
+  test('branch - passes input as output', async () => {
+    expect.assertions(1)
+
+    const state = {
+      foo: 'bar',
+    }
+
+    const actions = {
+      test: pipe(
+        branch((_, value: string) => value.toUpperCase()),
+        ({ state }: Context, value) => {
+          state.foo = value
+        }
+      ),
+    }
+
+    const config = {
+      state,
+      actions,
+    }
+
+    type Context = IContext<{
+      state: typeof state
+      actions: typeof actions
+    }>
+
+    const overmind = new Overmind(config)
+
+    await overmind.actions.test('foo')
+
+    expect(overmind.state.foo).toBe('foo')
+  })
+
   test('action - return value', async () => {
     expect.assertions(1)
 

packages/node_modules/overmind/src/operators.ts

@@ -113,6 +113,118 @@ export function pipe(...operators) {
   return instance
 }
 
+export function branch<AI, AO = AI>(
+  a: OperatorContextFunction<AI, AO>
+): IOperator<AI, AI>
+export function branch<A, B, C>(
+  a: OperatorContextFunction<A, B>,
+  b: OperatorContextFunction<B, C>
+): IOperator<A, A>
+export function branch<A, B, C, D>(
+  a: OperatorContextFunction<A, B>,
+  b: OperatorContextFunction<B, C>,
+  c: OperatorContextFunction<C, D>
+): IOperator<A, A>
+export function branch<A, B, C, D, E>(
+  a: OperatorContextFunction<A, B>,
+  b: OperatorContextFunction<B, C>,
+  c: OperatorContextFunction<C, D>,
+  d: OperatorContextFunction<D, E>
+): IOperator<A, A>
+export function branch<A, B, C, D, E, F>(
+  a: OperatorContextFunction<A, B>,
+  b: OperatorContextFunction<B, C>,
+  c: OperatorContextFunction<C, D>,
+  d: OperatorContextFunction<D, E>,
+  e: OperatorContextFunction<E, F>
+): IOperator<A, A>
+export function branch<A, B, C, D, E, F, G>(
+  a: OperatorContextFunction<A, B>,
+  b: OperatorContextFunction<B, C>,
+  c: OperatorContextFunction<C, D>,
+  d: OperatorContextFunction<D, E>,
+  e: OperatorContextFunction<E, F>,
+  f: OperatorContextFunction<F, G>
+): IOperator<A, A>
+export function branch<A, B, C, D, E, F, G, H>(
+  a: OperatorContextFunction<A, B>,
+  b: OperatorContextFunction<B, C>,
+  c: OperatorContextFunction<C, D>,
+  d: OperatorContextFunction<D, E>,
+  e: OperatorContextFunction<E, F>,
+  f: OperatorContextFunction<F, G>,
+  g: OperatorContextFunction<G, H>
+): IOperator<A, A>
+export function branch<A, B, C, D, E, F, G, H, I>(
+  a: OperatorContextFunction<A, B>,
+  b: OperatorContextFunction<B, C>,
+  c: OperatorContextFunction<C, D>,
+  d: OperatorContextFunction<D, E>,
+  e: OperatorContextFunction<E, F>,
+  f: OperatorContextFunction<F, G>,
+  g: OperatorContextFunction<G, H>,
+  h: OperatorContextFunction<H, I>
+): IOperator<A, A>
+export function branch<A, B, C, D, E, F, G, H, I, J>(
+  a: OperatorContextFunction<A, B>,
+  b: OperatorContextFunction<B, C>,
+  c: OperatorContextFunction<C, D>,
+  d: OperatorContextFunction<D, E>,
+  e: OperatorContextFunction<E, F>,
+  f: OperatorContextFunction<F, G>,
+  g: OperatorContextFunction<G, H>,
+  h: OperatorContextFunction<H, I>,
+  i: OperatorContextFunction<I, J>
+): IOperator<A, A>
+export function branch<A, B, C, D, E, F, G, H, I, J, K>(
+  a: OperatorContextFunction<A, B>,
+  b: OperatorContextFunction<B, C>,
+  c: OperatorContextFunction<C, D>,
+  d: OperatorContextFunction<D, E>,
+  e: OperatorContextFunction<E, F>,
+  f: OperatorContextFunction<F, G>,
+  g: OperatorContextFunction<G, H>,
+  h: OperatorContextFunction<H, I>,
+  i: OperatorContextFunction<I, J>,
+  j: OperatorContextFunction<J, K>
+): IOperator<A, A>
+export function branch(...operators) {
+  const instance = (err, context, next, final = next) => {
+    if (err) next(err, context)
+    else {
+      let operatorIndex = 0
+
+      const run = (operatorErr, operatorContext) => {
+        const operator = operators[operatorIndex++]
+        const operatorToRun = operator
+          ? operator[utils.IS_OPERATOR]
+            ? operator
+            : action(operator)
+          : (err, finalContext, finalNext, finalFinal) => {
+              next(
+                err,
+                {
+                  ...finalContext,
+                  value: context.value,
+                },
+                finalNext,
+                finalFinal
+              )
+            }
+        try {
+          operatorToRun(operatorErr, operatorContext, run, final)
+        } catch (operatorError) {
+          operatorToRun(operatorErr, operatorContext, run, final)
+        }
+      }
+
+      run(null, context)
+    }
+  }
+  instance[utils.IS_OPERATOR] = true
+  return instance
+}
+
 /*
     OPERATORS
   */