Question: Canceling sagas from "upstream" about redux-saga HOT 13 CLOSED

function* createAudienceSaga (getState) {
  let action, cancelLastAudienceBuild = () => {};

  // When a new audience create action comes along, cancel the previous one
  // by resolving the currently-active promise. We're using a promise here
  // so that `race(...)` calls can be our mechanism for determining cancelation
  /*eslint no-cond-assign:0 */
  while (action = yield take(CREATE_AUDIENCE)) {
    cancelLastAudienceBuild(new TransactionCancelledError());

    let transaction = new Promise((_, reject) => cancelLastAudienceBuild = reject);

    yield fork(buildAudience, transaction, action.payload);
  }
}

// Create a new audience
function* buildAudienceFromPlaceId(tx, params) {
  try {
    let [place] = yield [call(api.places.get, id), tx];
    yield put(showPlace(place));

    const [ audienceId ] = [
      call(createAudienceWithDefinition, {
        definition: params.definition,
        geography: [makePlaceGeography(place)],
        product_id: params.product
      }), tx ];

    const [ audience ] = yield [call(api.audience.get, audienceId), tx ];

    yield put(showAudience(audience));    
  } catch (e) {
    if (e instanceof TransactionCancelledError) {
      console.info("Transaction cancelled", id, product);
      return;
    } else {
      throw e;
    }
  }
}

let [place] = yield [call(api.places.get, id), tx];

// a higher order function
function buildTx(cancelEffect) {
  // returns a reusable guarded call subroutine
  // will throw if cancelEffect completes before call(fn, ...args)
  return function* guardedCall(fn, ...args) {
    const {result} = yield race({
      result: call(fn, ...args),
      cancelEffect
    })

    if(result)
       return result
    throw new TransactionCancelledError()
  }
}


function* createAudienceSaga (getState) {
  let action
  const nextCreateAudience = take(CREATE_AUDIENCE)

  /*eslint no-cond-assign:0 */
  while (action = yield nextCreateAudience ) {
    yield fork(
        buildAudience, 
        nextCreateAudience,
        action.payload);
  }
}

// Create a new audience
function* buildAudienceFromPlaceId(cancelEffect, params) {
  const tx = buildTx(cancelEffect)
  try {
    let place = yield call(tx, api.places.get, id);
    yield put(showPlace(place));

    const audienceId = yield
      call(tx, createAudienceWithDefinition, {
        definition: params.definition,
        geography: [makePlaceGeography(place)],
        product_id: params.product
      });

    const audience = yield call(tx, api.audience.get, audienceId);

    yield put(showAudience(audience));    
  } catch (e) {
    if (e instanceof TransactionCancelledError) {
      console.info("Transaction cancelled", id, product);
      return;
    } else {
      throw e;
    }
  }
}

export function* guard(tx, ...args) {
  const { result } = yield race({
    result: call(...args),
    tx
  });

  if(result) {
    return result;
  } else {
    throw new TransactionCancelledError();
  }
}

// Create a new audience from a place and product id
export function* buildAudienceFromPlaceId(tx, id, product) {
  try {
    // Step 1: retrieve the place that the user wants to build the audience in
    let place = yield call(guard, tx, api.places.get, id);
    // ...

import { guard } from 'wherever';

let tx = new Promise(() => {}),
    iterator = buildAudienceFromPlaceId(tx);

assert.deepEqual(
    iterator.next().value,
    call(guard, tx, api.places.get, placeId));

export function* guard(tx, ...args) {...}

const guardedCall = (guard, tx) => call(guard, tx, api.places.get, id);

// Create a new audience from a place and product id
export function* buildAudienceFromPlaceId(tx, id, product) {
  const callWithTx= guardedCall(guard, tx)
  try {
    // Step 1: retrieve the place that the user wants to build the audience in
    let place = yield callWithTx(api.places.get, id);
    // ...

// A saga that waits for CREATE_AUDIENCE actions and uses the data to construct and load a new audience:
export default function* createAudience (getState) {
  let action, lastAction;

  while (action = yield take(CREATE_AUDIENCE)) {
    if(lastAction && lastAction.isRunning()) {
      lastAction._generator.throw(new TransactionCancelledError());
    }
    lastAction = yield fork(buildAudience, action.payload);
  }
}

export function* guard(tx, ...args) {...}

export const guardedCall = (guard, tx) => call(guard, tx, api.places.get, id);

// Create a new audience from a place and product id
export function* buildAudienceFromPlaceId(tx, id, product) {
  const callWithTx= guardedCall(guard, tx)
  try {
    // Step 1: retrieve the place that the user wants to build the audience in
    let place = yield callWithTx(api.places.get, id);
    // ...

import { guard, guardedCall } from 'wherever';

let tx = new Promise(() => {}),
     callWithTx = guardedCall(guard, tx),
     iterator = buildAudienceFromPlaceId(tx);

assert.deepEqual(
    iterator.next().value,
    callWithTx(api.places.get, placeId));

function add(a) { return function(b) { return a + b; } }
assert(add(5)(3) === add(5)(3)); 

assert.deepEqual(
  guardedCall(guard, tx)(api.places.get, placeId),
  guardedCall(guard, tx)(api.places.get, placeId)
)