Passing dispatch to saga

I have a situation where I’d like to use dispatch within a nested callback of an async ajax response, outside of the typical generator flow. I was wondering if you saw any problems with changing this line in middleware.js from:

sagas.forEach(runSaga)

to:

sagas.forEach(runSaga.bind(null, dispatch))

so dispatch would be received by the root saga(s) and it’d be possible to then pass this along to additional functions which operate outside of the generator runtime.

[yelouafi]

Arguments are passed here.

Using the dynamic running API. Can’t the following solve your issue ?

configureStore.js

import createSagaMiddleware from 'redux-saga'

// export middleware
export const sagaMiddleware = createSagaMiddleware()

export default function createStore() {
   return createStore(reducer, applyMiddleware(sagaMiddleware ))
}

main.js

import createStore, {  sagaMiddleware } from `./configureStore`
import rootSaga from '...'

const store = createStore()
sagaMiddleware.run(rootSaga, store.dispatch))

[danturu]

I’ve just found the way. With the wrapObservable helper from the https://github.com/eggers/async-generator package we can do:

type ResolvePromise<T> = (value: T) => void;
type RejectPromise<T> = (value: any) => void;
type PromiseArguments<T> = [ResolvePromise<T>, RejectPromise<T>];

export function* wrapObservable<T>(observable: Observable<T>): IterableIterator<Promise<T>> {
  let subscription: any;

  try {

    let done: boolean = false;

    const sentPromises: PromiseArguments<T>[] = [];
    const completedPromises: Promise<T>[] = [];

    subscription = observable.subscribe(
      (item: T) => {
        if (sentPromises.length > 0) {
          let [resolve, ] = sentPromises.shift();

          resolve(item);
        } else {
          completedPromises.push(Promise.resolve<T>(item));
        }

      },
      (error: any) => {
        if (sentPromises.length > 0) {
          let [, reject] = sentPromises.shift();

          reject(error);
        } else {
          completedPromises.push(Promise.reject<T>(error));
        }
      },
      () => {
        done = true;
      });

    while (!done || completedPromises.length > 0) {
      if (completedPromises.length > 0) {
        yield completedPromises.shift();
      } else {
        yield new Promise((r: ResolvePromise<T>, e: RejectPromise<T>) => sentPromises.push([r, e]));
      }
    }
  } finally {
    subscription.unsubscribe();
  }
}

function *saga() {
  while (true) {
    yield take(SUBSCRIBE);

    const { observable } = yield select();

    for (let next of wrapObservable(observable)) {
      const { action } = yield race({ action: next, overwise: take(UNSUBSCRIBE) });

      if (action) {
        yield put(...);
      } else {
        break;
      }
    }
  }
}