@furystack/utils 2.0.2 → 2.0.5

package/src/retrier-options.ts

@@ -1,65 +0,0 @@
-/**
- * Options class for Retrier
- */
-export class RetrierOptions {
-  /**
-   * The default value for retries
-   */
-  public static readonly RETRIES_DEFAULT = 10
-  private retries: number = RetrierOptions.RETRIES_DEFAULT
-  /**
-   * How many times should retry the operation
-   *
-   * @returns the count of retries
-   */
-  public get Retries(): number {
-    return this.retries
-  }
-  public set Retries(v: number) {
-    this.retries = v
-  }
-
-  /**
-   * The default interval between retries
-   */
-  public static readonly RETRY_INTERVAL_MS_DEFAULT = 10
-  private retryIntervalMs?: number
-  /**
-   * @returns the interval in millisecs
-   */
-  public get RetryIntervalMs(): number {
-    return this.retryIntervalMs !== undefined ? this.retryIntervalMs : RetrierOptions.RETRY_INTERVAL_MS_DEFAULT
-  }
-  public set RetryIntervalMs(v: number) {
-    this.retryIntervalMs = v
-  }
-
-  /**
-   * The default timeout in millisecs
-   */
-  public static readonly TIMEOUT_MS_DEFAULT = 1000
-  private timeoutMsValue?: number
-
-  /**
-   * @returns the Timeout interval in milliseconds
-   */
-  public get timeoutMs(): number {
-    return this.timeoutMsValue !== undefined ? this.timeoutMsValue : RetrierOptions.TIMEOUT_MS_DEFAULT
-  }
-  public set timeoutMs(v: number) {
-    this.timeoutMsValue = v
-  }
-
-  /**
-   * Optional callback, triggered right before each try
-   */
-  public onTry?: () => void
-  /**
-   * Optional callback, triggered on success
-   */
-  public onSuccess?: () => void
-  /**
-   * Optional callback, triggered on fail (timeout or too many retries)
-   */
-  public onFail?: () => void
-}

package/src/retrier.ts

@@ -1,105 +0,0 @@
-import { RetrierOptions } from './retrier-options'
-
-/**
- * Utility class for retrying operations.
- *
- * Usage example:
- * ```
- * const methodToRetry: () => Promise<boolean> = async () => {
- *     let hasSucceeded = false;
- *     // ...
- *     // custom logic
- *     // ...
- *     return hasSucceeded;
- * }
- * const retrierSuccess = await Retrier.create(methodToRetry)
- *     .setup({
- *         retries: 3,
- *         retryIntervalMs: 1,
- *         timeoutMs: 1000
- *     })
- *     .run();
- * ```
- */
-export class Retrier {
-  private isRunning = false
-
-  /**
-   * Factory method for creating a Retrier
-   *
-   * @param {()=>Promise<boolean>} callback The method that will be invoked on each try
-   * @returns the created Retrier instance
-   */
-  public static create(callback: () => Promise<boolean>) {
-    return new Retrier(callback, new RetrierOptions())
-  }
-
-  private constructor(private callback: () => Promise<boolean>, public readonly options: RetrierOptions) {}
-
-  private async wait(ms: number) {
-    return new Promise((resolve) => {
-      setTimeout(resolve, ms)
-    })
-  }
-
-  /**
-   * Method to override the default Retrier settings.
-   *
-   * @param options The options to be overridden
-   * @throws Error if the Retrier is running.
-   * @returns the Retrier instance
-   */
-  public setup(options: Partial<RetrierOptions>) {
-    if (this.isRunning) {
-      throw Error('Retrier already started!')
-    }
-    Object.assign(this.options, options)
-    return this
-  }
-
-  /**
-   * Public method that starts the Retrier
-   *
-   * @throws Error if the Retrier is already started.
-   * @returns {Promise<boolean>} A boolean value that indicates if the process has been succeeded.
-   */
-  public async run(): Promise<boolean> {
-    if (this.isRunning) {
-      throw Error('Retrier already started!')
-    }
-
-    let succeeded = false
-    let retries = 0
-    let timedOut = false
-
-    this.isRunning = true
-
-    setTimeout(() => {
-      if (!succeeded) {
-        timedOut = true
-      }
-    }, this.options.timeoutMs)
-
-    while (!succeeded && !timedOut && this.options.Retries > retries) {
-      retries++
-      if (this.options.onTry) {
-        this.options.onTry()
-      }
-      succeeded = await this.callback()
-      if (!succeeded) {
-        await this.wait(this.options.RetryIntervalMs)
-      }
-    }
-
-    if (succeeded) {
-      if (!timedOut && this.options.onSuccess) {
-        this.options.onSuccess()
-      }
-    } else {
-      if (this.options.onFail) {
-        this.options.onFail()
-      }
-    }
-    return succeeded
-  }
-}

package/src/retries.spec.ts

@@ -1,98 +0,0 @@
-import { Retrier } from './retrier'
-
-/**
- * Retrier tests
- */
-export const retrierTests = describe('Retrier', () => {
-  describe('Counter', () => {
-    it('Should be able to count to 3', async () => {
-      let count = 0
-      await Retrier.create(async () => {
-        count = count + 1
-        return count === 3
-      }).run()
-      expect(count).toBe(3)
-    })
-  })
-
-  describe('events', () => {
-    it('should trigger onSuccess on success', async () => {
-      let triggered = false
-      await Retrier.create(async () => true)
-        .setup({
-          onSuccess: () => {
-            triggered = true
-          },
-        })
-        .run()
-
-      expect(triggered).toBe(true)
-    })
-
-    it('should trigger onTimeout on timeout', async () => {
-      let triggered = false
-      await Retrier.create(async () => false)
-        .setup({
-          onFail: () => {
-            triggered = true
-          },
-          timeoutMs: 1,
-        })
-        .run()
-
-      expect(triggered).toBe(true)
-    })
-
-    it('should trigger onTry on each try', async () => {
-      let triggered = false
-      await Retrier.create(async () => true)
-        .setup({
-          onTry: () => {
-            triggered = true
-          },
-        })
-        .run()
-      expect(triggered).toBe(true)
-    })
-  })
-
-  it('should work with an example test', async () => {
-    const funcToRetry: () => Promise<boolean> = async () => {
-      const hasSucceeded = false
-      // ...
-      // custom logic
-      // ...
-      return hasSucceeded
-    }
-    const retrierSuccess = await Retrier.create(funcToRetry)
-      .setup({
-        Retries: 3,
-        RetryIntervalMs: 1,
-        timeoutMs: 1000,
-      })
-      .run()
-
-    expect(retrierSuccess).toBe(false)
-  })
-
-  it('should throw error when started twice', async () => {
-    const retrier = Retrier.create(async () => false)
-    retrier.run()
-    try {
-      await retrier.run()
-      throw Error('Should have been failed')
-    } catch (error) {
-      // ignore
-    }
-  })
-
-  it('should throw an error when trying to set up after started', () => {
-    const retrier = Retrier.create(async () => false)
-    retrier.run()
-    expect(() => {
-      retrier.setup({
-        Retries: 2,
-      })
-    }).toThrow()
-  })
-})