Saga nesting - Or is there a down-side to call a saga?

[Domiii]

I am trying to come up with a clever scheme to nest sagas.

I found that you can just yield call(someSaga) inside a saga and it works as expected, but I'm wondering if that's a good idea?

E.g.: in the following example:

• I tell the outer saga (saga1) to serially execute all sagas of an array of configured sagas.
• The set of sagas and their parameters can be configured dynamically via action.payload.
• E.g., in the sample below, it nests the sagas: sagaCfgs.test1.
• The secret sauce: yield call(...nestedSagas[i]);, where nestedSagas[i] will (for example) be: [saga2, "HI"].

I wonder if this is a valid way of nesting sagas.

Codepen playground.

Code excerpt:

async function sleep1() {
  await sleep(100);
}

function* saga2(x) {
  console.log("saga2", x, 1);
  yield call(sleep1);
  console.log("saga2", x, 2);
  yield call(sleep1);
  console.log("saga2", x, 3);
}

const sagaCfgs = {
  test1: {
    nested: [
      [saga2, "HI"],
      [saga2, "HELLO"]
    ]
  }
};

function* saga1(action) {
  console.log(`start`);
  const sagaCfgName = action.payload?.nested;
  const sagaCfg = sagaCfgs[sagaCfgName]; // || "test1"
  console.log(sagaCfgs, sagaCfg);
  const nestedSagas = sagaCfg.nested;
  try {
    for (let i = 0; i < nestedSagas.length; ++i) {
      yield call(...nestedSagas[i]);
    }
  } catch (error) {
    yield put({ type: "FAILED", error });
  }
  console.log(`end`);
}

export default function* rootSaga() {
  yield takeLatest("A", saga1);
}

What does the Saga Documentation Say?

From what I could find: the documentation is lacking.

Most relevant are:

• https://redux-saga.js.org/docs/advanced/ComposingSagas/
• https://redux-saga.js.org/docs/advanced/SequencingSagas/

But they don't really explain whether calling a saga is a valid approach.

I understand that I can just do yield* nestedSagas[i](...nestedSagas[i].slice(1)) etc, but the way I am organizing my sagas, they always have the central call element. I could add an explicit yield * to it, but I'd prefer not to.

[Andarist]

But they don't really explain whether calling a saga is a valid approach.

It all depends on what kind of concurrency pattern are you trying to express. If you want to wait before executing a new saga in the sequence before starting a new one then yes - calling them one after another is the appropriate thing to do. If you keep them in some kind of a dynamic object~ then looping through them (with a call inside a loop) is probably the best what you can do.