# v1: Базовый вариант
```ts
type RetryTask<T> = () => Promise<T>;

interface RetryOptions {
  maxRetries: number;
  delay: number; // задержка в мс
}

class Retrier {
  constructor(private options: RetryOptions) {}

  /**
   * Выполняет задачу с повторами. 
   * Генерирует (yield) ошибку при каждой неудачной попытке.
   * Возвращает результат при успехе.
   */
  async *execute<T>(task: RetryTask<T>, signal?: AbortSignal): AsyncGenerator<unknown, T, void> {
    for (let attempt = 1; attempt <= this.options.maxRetries; attempt++) {
      // Проверка на отмену перед началом попытки
      if (signal?.aborted) throw new Error('Operation aborted');

      try {
        return await task();
      } catch (error) {
        // Если попытки исчерпаны или пришла отмена — пробрасываем ошибку дальше
        if (attempt === this.options.maxRetries || signal?.aborted) {
          throw error;
        }

        // Сообщаем вызывающему коду об ошибке в текущей итерации
        yield error;

        // Ожидание перед следующей попыткой с поддержкой прерывания
        await new Promise((resolve, reject) => {
          const timeout = setTimeout(resolve, this.options.delay);
          signal?.addEventListener('abort', () => {
            clearTimeout(timeout);
            reject(new Error('Operation aborted during delay'));
          }, { once: true });
        });
      }
    }
    throw new Error('Max retries reached');
  }
}

// Паттерн Фабрика для создания экземпляров ретраера
const RetrierFactory = {
  create(options: RetryOptions): Retrier {
    return new Retrier(options);
  }
};
```

## Как это использовать
Использование генератора позволяет гибко логировать ошибки каждой попытки прямо в цикле for await...of.

```ts
async function runWithCancel() {
  const controller = new AbortController();
  const retrier = RetrierFactory.create({ maxRetries: 3, delay: 1000 });

  // Пример задачи: запрос к API
  const fetchData = () => fetch('https://api.example.com').then(r => r.json());

  try {
    const generator = retrier.execute(fetchData, controller.signal);

    for await (const error of generator) {
      console.warn('Попытка не удалась, пробуем снова...', error);
      // Здесь можно вызвать controller.abort(), если решили прекратить попытки
    }

    // Если цикл завершился без ошибки, результат возвращается из генератора
    // Но так как `return` в async генераторах требует особого обращения, 
    // результат часто получают через финальный вызов.
  } catch (err) {
    console.error('Финальная ошибка или отмена:', err.message);
  }
}
```

# v2: Вариант с экспоненциальной задержкой
```ts
type RetryTask<T> = (signal: AbortSignal) => Promise<T>;

interface RetryOptions {
  maxRetries: number;
  initialDelay: number; // Начальная задержка (мс)
  factor: number;       // Множитель (обычно 2)
}

class Retrier {
  constructor(private options: RetryOptions) {}

  async *execute<T>(task: RetryTask<T>, signal?: AbortSignal): AsyncGenerator<unknown, T, void> {
    let currentDelay = this.options.initialDelay;

    for (let attempt = 1; attempt <= this.options.maxRetries; attempt++) {
      if (signal?.aborted) throw new Error('Aborted');

      try {
        // Передаем signal внутрь задачи, чтобы fetch/axios тоже могли прерваться
        return await task(signal!); 
      } catch (error) {
        if (attempt === this.options.maxRetries || signal?.aborted) throw error;

        yield { attempt, error, nextDelay: currentDelay };

        // Ожидание с поддержкой прерывания
        await new Promise((resolve, reject) => {
          const timeout = setTimeout(resolve, currentDelay);
          signal?.addEventListener('abort', () => {
            clearTimeout(timeout);
            reject(new Error('Aborted during backoff'));
            // NOTE: Это состояние означает, что вы отменили операцию (вызвали controller.abort()) в тот момент, когда запрос уже упал с ошибкой, и ретраер просто ждал паузу перед следующей попыткой
          }, { once: true });
        });

        // Увеличиваем задержку для следующего шага
        currentDelay *= this.options.factor;
      }
    }
    throw new Error('Max retries exceeded');
  }
}

const RetrierFactory = {
  createDefault: () => new Retrier({ maxRetries: 5, initialDelay: 500, factor: 2 }),
  createCustom: (options: RetryOptions) => new Retrier(options)
};
```

## Пример работы задержек
Если initialDelay: 1000 и factor: 2, паузы между попытками будут:
```
Попытка 1 (ошибка) -> Пауза 1с
Попытка 2 (ошибка) -> Пауза 2с
Попытка 3 (ошибка) -> Пауза 4с
```
## Использование с контролем отмены
```ts
async function demo() {
  const controller = new AbortController();
  const retrier = RetrierFactory.createDefault();

  // Имитируем отмену через 3 секунды
  setTimeout(() => controller.abort(), 3000);

  try {
    const task = (sig: AbortSignal) => fetch('https://api.example.com', { signal: sig }).then(res => res.json());
    
    const runner = retrier.execute(task, controller.signal);

    for await (const status of runner) {
      console.log(`Попытка ${status.attempt} не удалась. Ждем ${status.nextDelay}мс...`);
    }
  } catch (e) {
    console.log('Результат:', e.message); // Выведет "Aborted..."
  }
}
```

### Что мы добавили:
1. Параметр factor: Позволяет гибко настраивать скорость роста задержки.
2. Проброс сигнала в задачу: Теперь task получает signal, что позволяет отменять сам сетевой запрос, а не только ожидание между ними.
3. Информативный yield: Теперь возвращаем объект с номером попытки и временем следующего ожидания для удобного логирования.

Реализация Retrier на TypeScript с использованием асинхронных генераторов, паттерна «Фабрика» и поддержкой AbortSignal для отмены операции #jsVanilla #generators

🎓 generators redux-saga

Here is the retrier implemented using an Async Generator:
```js
async function* retrier({ attempts = Infinity, delay = 100 }) {
  for (let i = 0; i < attempts; i++) {
    yield i
    await pause(delay)
  }
}
```

Fake HTTP request sample:
```js
const tryHttp = ({ arg }) => {
  if (arg < 3) return Promise.reject({ ok: false, message: 'Fck u' })
  return Promise.resolve({ ok: true })
}
```

Retryable HTTP client sample (high level API for usage in code):
```js
const yourHttpClient = async ({ onEarchIterator, validator }) => {

  // NOTE: Now, if you want to use this,
  // all you have to do is to use a for await loop:
  for await (const i of retrier({ attempts: 10, delay: 500 })) {
    const result = await tryHttp({ arg: i })
      .then((res) => res)
      .catch((err) => err)
    onEarchIterator(result)
    if (validator.result(result)) break
  }
}
```

Usage sample:
```js
yourHttpClient({
  onEarchIterator: (res) => {
    // NOTE: We have event on each iterate
    console.log('- this is your event after request', res)
  },
  validator: {
    // NOTE: We have access to each response
    result: (res) => res.ok === true,
  },
})
```

See also [retry-on-error-js](https://github.com/emartech/retry-on-error-js)

Retryable HTTP client generators based #jsVanilla

https://www.youtube.com/watch?v=ah5voE_SGjo

#jsVanilla #generators #redux-saga 2021

```js
function* Counter() {
  let count = 0
  while (true) yield count++
}
const counter = Counter()

// Usage: counter.next().value
```

generators

Реализация Retrier на TypeScript с использованием асинхронных генераторов, паттерна «Фабрика» и поддержкой AbortSignal для отмены операции #jsVanilla #generators

🎓 generators redux-saga

Retryable HTTP client generators based #jsVanilla

#jsVanilla #generators #redux-saga 2021

#jsVanilla | Counter; Простой счетчик #jsGenerators