Retry with backoff

[minkimcello]

Motivation

Sometimes when an API call fails, we want to be able to retry those requests until it succeeds (within a reasonable amount of time).

useRetryWithBackoff will re-attempt an operation with incremental backoff until the configured timeout exceeds.

Approach

Just copied/pasted what I wrote for the README 👇

There's a default timeout set to 30 seconds. If you'd like to set a different
timeout, you'll need to either pass in options as a second argument to
useRetryWithBackoff:

import { main } from "effection";
import { useRetryWithBackoff } from "@effection-contrib/retry-backoff";

await main(function* () {
  yield* useRetryWithBackoff(function* () {
    yield* call(() => fetch("https://foo.bar/"));
  }, { timeout: 45_000 });
});

Or set the timeout via the context so that the same timeout can be applied to all
of your retry operations:

import { main } from "effection";
import {
  RetryBackoffContext,
  useRetryWithBackoff,
} from "@effection-contrib/retry-backoff";

await main(function* () {
  yield* RetryBackoffContext.set({ timeout: 45_000 });
  yield* retryWithBackoff(function* () {
    yield* call(() => fetch("https://foo.bar/"));
  });
});

Learning

Screenshots

[taras]

Instead of doing the import, can we just inline the operation and use fetch so people see what that looks like?

[minkimcello]

Done

[taras]

Since we're using default now, we can drop this. We don't need this code anymore

[minkimcello]

Don't we still need it if someone wants to override the default for all retries?

[taras]

Let's remove this function.

[minkimcello]

Are you talking about the example myOperation function? or main?

[taras]

the example myOperation function, so the example reads like

await main(function*() {
  yield* retryBackoff(function*() {
     const result = call(() => fetch(....));
     ...
  });
})

[minkimcello]

oh okay. I took care of that from this comment

[taras]

Let's rename this to RetryBackoffContext.

[minkimcello]

Done

[taras]

We need docs for this function.

[minkimcello]

Done

[minkimcello]

What would be the right way to write docs for this context?

/**
  * Description
  *
  * @property {function} set
  * @param {{ timeout: number }}
*/
export const RetryBackoffContext = createContext<RetryWithContextDefaults>(

[taras]

That's right. You don't need to describe the parameters and properties because those will be generated from typescript

[taras]

This won't be compatible with v4, so let's use function syntax: yield* call(() => fetch(...))

[minkimcello]

Done

[taras]

Same here, let's use the function syntax that's compatible with v4

[minkimcello]

And done

[cowboyd]

This is a very common use-case. What about just making this @effection-contrib/retry and have many strategies (retriableWithBackoff) being just one.

interface RetriableOptions {
  backoff(failedAttempts: number): number;
  maxAttempts: number;
}
//. constant backoff
const retriable = createRetriable({ backoff: () => 3, maxAttempts: Math.Infinity}); 
yield* retriable(operation);

//exponential backoff
const retriable = createRetriable({ backoff: (attempts} => 2^attempts, maxAttempts: 100});
yield* retriable(operation);

You can even model the default as a the default that is on the context:

const defaultRetriable = createRetriable({ backoff: () => 10, maxAttempts: 10 });
const DefaulthRetriableContext = createContext<<T>(op: Operation<T>) => Operation<T>>('@effection-contrib/default-retriable', defaultRetriable);

export function* retriable<T>(operation: Operation<T>): Operation<T> {
  let defaultImpl = yield* DefaultRetriableContext.expect();
  return yield* defaultImpl(operation);
}

My suspicion is that most folks will want to roll their own.