@furystack/utils 1.2.45 → 2.0.3

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()
-  })
-})