@poomcha/retrier NPM

Retrier

Retrier is a lightweight and flexible library for managing retries of synchronous and asynchronous operations in JavaScript/TypeScript. It allows you to specify a maximum number of retries and a delay between attempts, along with optional success and failure handlers.

Installation

To install retrier, use npm or yarn:

npm install @poomcha/retrier

yarn add @poomcha/retrier

Usage

Importing

Import the Retrier class and its methods into your project:

import { Retrier, retrySync, retryAsync } from '@poomcha/retrier';

Configuration

Create an instance of Retrier with custom configuration options:

const retrier = new Retrier({
  maxRetries: 5, // Maximum number of retries
  delay: 1000, // Delay between retries in milliseconds
  onSuccess: {
    // Callback on success
    callback: (result) => console.log('Operation succeeded:', result),
    override: true, // Override default behavior
  },
  onFailure: {
    // Callback on failure
    callback: (error) => console.error('Operation failed:', error),
    override: true, // Override default behavior
  },
});

Methods

retrySync

Retries a synchronous operation:

const result = retrier.retrySync(() => {
  // Your synchronous operation here
  if (Math.random() > 0.5) throw new Error('Random failure');
  return 'Success';
});

console.log(result);

retryAsync

Retries an asynchronous operation:

const result = await retrier.retryAsync(async () => {
  // Your asynchronous operation here
  if (Math.random() > 0.5) throw new Error('Random failure');
  return 'Success';
});

console.log(result);

Static Methods

You can also use the static methods without instantiating the class:

retrySync

const result = retrySync(5, () => {
  // Your synchronous operation here
  if (Math.random() > 0.5) throw new Error('Random failure');
  return 'Success';
});

console.log(result);

retryAsync

const result = await retryAsync(5, async () => {
  // Your asynchronous operation here
  if (Math.random() > 0.5) throw new Error('Random failure');
  return 'Success';
});

console.log(result);

Options

maxRetries: Maximum number of retries (default: 2).
delay: Delay between retries in milliseconds (default: 0).
onSuccess: Callback executed on success.
onSuccess.callback: Function to run on success.
onSuccess.args: Additional arguments for the callback.
onSuccess.override: If true, overrides the default behavior.
onFailure: Callback executed on failure.
onFailure.callback: Function to run on failure.
onFailure.args: Additional arguments for the callback.
onFailure.override: If true, overrides the default behavior.

Examples

Success Example

const retrier = new Retrier({
  maxRetries: 3,
  onSuccess: {
    callback: (result) => console.log('Operation succeeded:', result),
    override: true,
  },
});

const result = retrier.retrySync(() => {
  return 'Operation completed';
});

// Output: Operation succeeded: Operation completed

Failure Example

const retrier = new Retrier({
  maxRetries: 3,
  onFailure: {
    callback: (error) => console.error('Operation failed:', error.message),
    override: true,
  },
});

const result = retrier.retrySync(() => {
  throw new Error('Operation failed');
});

// Output: Operation failed: Operation failed

Complex context

import { Retrier } from '@poomcha/retrier';

export class Example {
  private client;

  private retrier;
  private readonly retrierOptions = {
    maxRetries: 2,
    delay: 1000,
    onSuccess: {
      callback: function (_res) {
        return;
      },
      args: [],
      override: false,
    },
    onFailure: {
      callback: function (error) {
        console.error(error);

        return `Error: Example Unavailable.`;
      },
      args: [],
      override: true,
    },
  };

  constructor() {
    this.client = new ExampleClient();
    this.retrier = new Retrier(this.retrierOptions);
  }

  public async queryExample(apiCallOptions) {
    const callApi = async function (options) {
      return await this.client.exampleGet(apiCallOptions);
    };

    const apiCallOptions = {
      // ...
    };

    // In context such as classes, make sure to bind this to your callback to keep track of the context
    const response = await this.retrier.retryAsync(queryExample.bind(this), [
      apiCallOptions,
    ]);

    return response;
  }
}