alex-okrushko

export interface IntervalBackoffConfig {
  initialInterval: number;
  maxInterval?: number;
  backoffDelay?: (iteration: number, initialInterval: number) => number;
}

alex-okrushko

import { Injectable } from '@angular/core';
import { of, throwError, defer } from 'rxjs';

export interface HttpError {
  error: string,
  status: string,
}

const ERROR_404: HttpError = { error: 'No need to try anymore', status: '404' };
const ERROR_503: HttpError = { error: 'Try again?', status: '503' };

alex-okrushko

// Determine if the error matches our expected type
// http://www.typescriptlang.org/docs/handbook/advanced-types.html#user-defined-type-guards
function isHttpError(error: {}): error is HttpError {
  // This is a type guard for interface
  // if HttpError was a class we would use instanceof check instead 
  return (error as HttpError).status !== undefined;
}

message$ = of('Call me!').pipe(
    tap(console.log),

alex-okrushko

function calculateDelay(iteration, initialInterval) {
 return Math.pow(2, iteration) * initialInterval;
}

alex-okrushko

message$ = of('Call me!').pipe(
    switchMap(() => this.service.callBackend()),
    retryBackoff(1000),
);

alex-okrushko

import {fromEvent} from 'rxjs';
import {sampleTime, startWith, switchMap} from 'rxjs/operators';
import {intervalBackoff} from 'backoff-rxjs';
import {service} from './service';

const newData$ = fromEvent(document, 'mousemove').pipe(
  
    // There could be many mousemoves, we'd want to sample only
    // with certain frequency
    sampleTime(1000),

alex-okrushko

it("should handle a basic source that emits next then errors, count=3", () => {
    testScheduler.run(({ expectObservable, cold, expectSubscriptions }) => {
      const source = cold("--1-2-3-#");
      const subs = [      "^       !                ",
                          "        ^        !        ",
                          "                 ^         !"
      ];
      const expected =   "--1-2-3----1-2-3-----1-2-3-#";

      expectObservable(

alex-okrushko

export interface RetryBackoffConfig {
  initialInterval: number;
  maxRetries?: number;
  maxInterval?: number;
  shouldRetry?: (error: any) => boolean;
  backoffDelay?: (iteration: number, initialInterval: number) => number;
}

alex-okrushko

message$ = of('Call me!').pipe(
    switchMap(() => this.service.callBackend()),
    retryBackoff({
        initialInterval: 100, 
        maxRetries: 12,
    }),
);

alex-okrushko

@Effect()
fetchProducts: Observable<Action> = this.actions$.pipe(
  ofType<actions.FetchProducts>(actions.FETCH_PRODUCTS),
  switchMap(() =>
    this.productService.getProducts().pipe(
      map(products => new actions.FetchProductsSuccess(products)),
      catchError(() => of(new actions.FetchProductsError()))
    )
  )
);