@creejs/commons-retrier 1.0.8 → 2.0.2

package/lib/event.js

@@ -1,21 +0,0 @@
-export const Start = 'start' // retry started
-export const Stop = 'stop' // retry stopped
-export const Retry = 'retry' // one retry began
-export const Success = 'success' // one task running succeeded
-export const Failure = 'failure' // one task ran failed
-export const Timeout = 'timeout' // total timeout
-export const TaskTimeout = 'task-timeout' // one task timed out
-export const Completed = 'complete' // all retries completed
-export const MaxRetries = 'max-retries' // Reach the max retries
-
-export default {
-  Start,
-  Retry,
-  Success,
-  Failure,
-  Timeout,
-  TaskTimeout,
-  Stop,
-  Completed,
-  MaxRetries
-}

package/lib/index.js

@@ -1,44 +0,0 @@
-// 3rd
-import { LangUtils } from '@creejs/commons-lang'
-
-// owned
-import Policy from './policy.js'
-import Retrier from './retrier.js'
-import Event from './event.js'
-import RetrierFactory from './retrier-factory.js'
-
-/**
- * Add all factory methods to Retrier as static methods.
- * Now we can create do something like this:
- * ```
- * Retrier.name('myRetrier')
- * Retrier.infinite()
- * ...
- * ```
- */
-LangUtils.defaults(Retrier, RetrierFactory)
-
-/**
- * default export to support
- * 1. import CommonsRetrier from '@creejs/commons-retrier'
- */
-export default {
-  Policy,
-  Retrier,
-  Event,
-  RetrierFactory,
-  ...RetrierFactory
-}
-
-/**
- * named export to support
- * 1. import { Retrier } from '@creejs/commons-retrier'
- * 2. import * as CommonsRetrier from '@creejs/commons-retrier'
- */
-export {
-  Policy,
-  Retrier,
-  Event,
-  RetrierFactory
-}
-export * from './retrier-factory.js'

package/lib/policy/factor-increase-policy.js

@@ -1,46 +0,0 @@
-// 3rd
-// internal
-import { TypeAssert } from '@creejs/commons-lang'
-// owned
-import Policy from '../policy.js'
-// module vars
-const { assertPositive } = TypeAssert
-
-export default class FactoreIncreasePolicy extends Policy {
-  /**
-   * each call to _next() increases the interval by lastInterval * factor
-   * @param {number} factor - the increasement factor, >= 1
-   */
-  constructor (factor) {
-    super()
-    assertPositive(factor, 'factor')
-    if (factor < 1) {
-      throw new Error('factor must be >= 1')
-    }
-    this._factor = factor
-  }
-
-  set factor (factor) {
-    assertPositive(factor, 'factor')
-    if (factor < 1) {
-      throw new Error('factor must be >= 1')
-    }
-    this._factor = factor
-  }
-
-  get factor () {
-    return this._factor
-  }
-
-  /**
-   * Interval ms of next execution
-   * @returns {number}
-   */
-  _next () {
-    if (this._nextInterval >= this._max) {
-      return this._max
-    }
-    return this._nextInterval * this.factor
-  }
-}
-export { FactoreIncreasePolicy as FactoreIncreasePolicyType }

package/lib/policy/fixed-increase-policy.js

@@ -1,39 +0,0 @@
-// 3rd
-// internal
-import { TypeAssert } from '@creejs/commons-lang'
-// owned
-import Policy from '../policy.js'
-// module vars
-const { assertPositive } = TypeAssert
-export default class FixedIncreasePolicy extends Policy {
-  /**
-   * each call to _next() increases the interval by "increasement".
-   * @param {number} increasement - The fixed interval (in milliseconds) between retry attempts.
-   */
-  constructor (increasement) {
-    super()
-    assertPositive(increasement, 'increasement')
-    this._increasement = increasement
-  }
-
-  set increasement (increasement) {
-    assertPositive(increasement, 'increasement')
-    this._increasement = increasement
-  }
-
-  get increasement () {
-    return this._increasement
-  }
-
-  /**
-   * Interval ms of next execution
-   * @returns {number}
-   */
-  _next () {
-    if (this._nextInterval >= this._max) {
-      return this._max
-    }
-    return this._nextInterval + this.increasement
-  }
-}
-export { FixedIncreasePolicy as FixedIncreasePolicyType }

package/lib/policy/fixed-interval-policy.js

@@ -1,38 +0,0 @@
-// 3rd
-// internal
-import { TypeAssert } from '@creejs/commons-lang'
-// owned
-import Policy from '../policy.js'
-// module vars
-const { assertPositive } = TypeAssert
-export default class FixedIntervalPolicy extends Policy {
-  /**
-   * Creates a fixed interval retry policy with the specified interval.
-   * @param {number} interval - The fixed interval (in milliseconds) between retry attempts.
-   */
-  constructor (interval) {
-    super()
-    assertPositive(interval, 'interval')
-    this._interval = interval
-  }
-
-  set interval (interval) {
-    assertPositive(interval, 'interval')
-    this._interval = interval
-  }
-
-  get interval () {
-    return this._interval
-  }
-
-  /**
-   * Interval ms of next execution
-   * @returns {number}
-   * @throws {Error} Always throws "Not Implemented Yet" error.
-   */
-  _next () {
-    return this.interval
-  }
-}
-
-export { FixedIntervalPolicy as FixedIntervalPolicyType }

package/lib/policy/shuttle-policy.js

@@ -1,50 +0,0 @@
-// 3rd
-// internal
-import { TypeAssert } from '@creejs/commons-lang'
-
-// owned
-import Policy from '../policy.js'
-// module vars
-const { assertPositive } = TypeAssert
-
-export default class ShuttlePolicy extends Policy {
-  /**
-   * the inteval value shuttles between min and max
-   * @param {number} stepLength - the step length to change
-   */
-  constructor (stepLength) {
-    super()
-    assertPositive(stepLength, 'stepLength')
-    this._stepLength = stepLength
-    this.increasement = stepLength
-  }
-
-  set stepLength (stepLength) {
-    assertPositive(stepLength, 'stepLength')
-    this._stepLength = stepLength
-    this.increasement = stepLength
-  }
-
-  get stepLength () {
-    return this._stepLength
-  }
-
-  /**
-   * Interval ms of next execution
-   * @returns {number}
-   * @throws {Error} Always throws "Not Implemented Yet" error.
-   */
-  _next () {
-    const nextInterval = this._nextInterval + this.increasement
-    if (nextInterval >= this._max) {
-      this.increasement = -this.stepLength
-      return this._max
-    } else if (nextInterval <= this._min) {
-      this.increasement = this.stepLength
-      return this._min
-    }
-    return nextInterval
-  }
-}
-
-export { ShuttlePolicy as ShuttlePolicyType }

package/lib/policy.js

@@ -1,130 +0,0 @@
-// internal
-import { TypeAssert, TypeUtils } from '@creejs/commons-lang'
-// owned
-import { DefaultMaxInterval, DefaultMinInterval } from './constants.js'
-
-// module vars
-const { assertPositive } = TypeAssert
-const { isNumber } = TypeUtils
-
-export default class Policy {
-  /**
-   * Creates a new Policy instance with specified retry bounds.
-   */
-  constructor () {
-    this._min = DefaultMinInterval
-    this._max = DefaultMaxInterval
-    this._nextInterval = this._min
-  }
-
-  /**
-   * Copies settings to target policy.
-   * @param {Policy} targetPolicy - The policy to modify.
-   */
-  copyPolicySetting (targetPolicy) {
-    targetPolicy.range(this._min, this._max)
-    targetPolicy._nextInterval = this._nextInterval
-  }
-
-  /**
-   * Sets a fixed interval retry policy.
-  }
-
-  /**
-   * Sets the minimum and maximum intervals for retries.
-   * @param {number} min - Minimum delay in milliseconds (must be positive and less than max)
-   * @param {number} max - Maximum delay in milliseconds (must be positive and greater than min)
-   * @returns {this} Returns the Retrier instance for chaining
-   * @throws {Error} If min is not less than max or if values are not positive
-   */
-  range (min, max) {
-    assertPositive(min, 'min')
-    assertPositive(max, 'max')
-    if (min >= max) {
-      throw new Error('min must < max')
-    }
-    this._min = min
-    if (this._nextInterval < this._min) {
-      this._nextInterval = this._min
-    }
-    this._max = max
-    if (this._nextInterval > this._max) {
-      this._nextInterval = this._max
-    }
-    return this
-  }
-
-  /**
-   * Sets the minimum retry delay in milliseconds.
-   * 1. will change currentInterval to min
-   * @param {number} min - The minimum delay (must be positive and less than max).
-   * @returns {this} The retrier instance for chaining.
-   * @throws {Error} If min is not positive or is greater than/equal to max.
-   */
-  min (min) {
-    assertPositive(min, 'min')
-    if (min >= this._max) {
-      throw new Error('min must < max')
-    }
-    this._min = min
-    this._nextInterval = this._min
-    return this
-  }
-
-  /**
-   * Sets the maximum retry retry delay in milliseconds.
-   * @param {number} max - The maximum delay (must be positive and greater than min).
-   * @throws {Error} If max is not greater than min.
-   * @returns {this} The retrier instance for chaining.
-   */
-  max (max) {
-    assertPositive(max, 'max')
-    if (max <= this._min) {
-      throw new Error('max must > min')
-    }
-    this._max = max
-    if (this._nextInterval > this._max) {
-      this._nextInterval = this._max
-    }
-    return this
-  }
-
-  reset () {
-    this._nextInterval = this._min
-    return this
-  }
-
-  /**
-   * Interval ms of next execution
-   * @returns {number}
-   * @throws {Error} Always throws "Not Implemented Yet" error.
-   */
-  generate () {
-    const rtnVal = this._nextInterval
-    this._increase()
-    return rtnVal
-  }
-
-  _increase () {
-    const nextInterval = this._next()
-    if (!isNumber(nextInterval)) {
-      throw new Error('Generated Next Interval Not Number')
-    }
-    if (nextInterval < this._min) {
-      return (this._nextInterval = this._min)
-    } else if (nextInterval > this._max) {
-      return (this._nextInterval = this._max)
-    }
-    return (this._nextInterval = nextInterval)
-  }
-
-  /**
-   * subclass should implement this method
-   * @returns {number} The interval in milliseconds to wait before the next retry attempt.
-   * @protected
-   */
-  _next () {
-    throw new Error('Not Impled Yet')
-  }
-}
-export { Policy as PolicyType }

package/lib/retrier-factory.js

@@ -1,191 +0,0 @@
-// owned
-import Retrier from './retrier.js'
-/**
- * Creates a new Retrier instance with the specified name.
- * @param {string} name - The name to assign to the retrier.
- * @returns {Retrier} A new Retrier instance with the given name.
- */
-function name (name) {
-  const retrier = new Retrier()
-  retrier.name(name)
-  return retrier
-}
-
-/**
- * Creates and returns a Retrier instance configured for infinite retries.
- * @returns {Retrier} A Retrier instance with infinite retry behavior.
- */
-function infinite () {
-  const retrier = new Retrier()
-  retrier.infinite()
-  return retrier
-}
-
-/**
- * Creates a retrier configured to attempt an operation a specified number of times.
- * @param {number} times - The maximum number of retry attempts.
- * @returns {Retrier} A configured Retrier instance with the specified max retries.
- */
-function times (times) {
-  const retrier = new Retrier()
-  retrier.times(times)
-  return retrier
-}
-
-/**
- * Alias for times.
- * @param {number} maxRetries - The maximum number of retry attempts.
- * @returns {Retrier} A configured Retrier instance with the specified max retries.
- */
-function maxRetries (maxRetries) {
-  const retrier = new Retrier()
-  retrier.maxRetries(maxRetries)
-  return retrier
-}
-
-/**
- * Sets the minimum Interval for the retrier and returns the instance.
- * @param {number} min - The minimum Interval in milliseconds.
- * @returns {Retrier} The retrier instance with updated minimum Interval.
- */
-function min (min) {
-  const retrier = new Retrier()
-  retrier.min(min)
-  return retrier
-}
-
-/**
- * Sets the maximum Interval for the retrier and returns the instance.
- * @param {number} max - The maximum Interval in milliseconds.
- * @returns {Retrier} The retrier instance with updated maximum Interval.
- */
-function max (max) {
-  const retrier = new Retrier()
-  retrier.max(max)
-  return retrier
-}
-
-/**
- * Creates a retrier with the specified Interval range.
- * @param {number} min - Minimum Interval.
- * @param {number} max - Maximum Interval.
- * @returns {Retrier} A new Retrier instance configured with specified Interval range.
- */
-function range (min, max) {
-  const retrier = new Retrier()
-  retrier.range(min, max)
-  return retrier
-}
-
-/**
- * Creates a retrier with a fixed interval between attempts.
- * @param {number} fixedInterval - The fixed interval in milliseconds between retry attempts.
- * @returns {Retrier} A new Retrier instance configured with the specified fixed interval.
- */
-function fixedInterval (fixedInterval) {
-  const retrier = new Retrier()
-  retrier.fixedInterval(fixedInterval)
-  return retrier
-}
-
-/**
- * Creates a retrier with a fixed increase strategy.
- * @param {number} increasement - The fixed amount to increase on each retry.
- * @returns {Retrier} A retrier instance configured with fixed increase.
- */
-function fixedIncrease (increasement) {
-  const retrier = new Retrier()
-  retrier.fixedIncrease(increasement)
-  return retrier
-}
-
-/**
- * Creates a new Retrier instance with factor-increase strategy.
- * @param {number} factor - The factor by which to increase the interval on each retry.
- * @returns {Retrier} A new Retrier instance with factor-increase strategy.
- */
-function factorIncrease (factor) {
-  const retrier = new Retrier()
-  retrier.factorIncrease(factor)
-  return retrier
-}
-
-/**
- * Creates a Retrier instance with a shuttle-interval strategt.
- * @param {number} stepLength - The interval step length of each change
- * @returns {Retrier} A configured Retrier instance with shuttle-interval strategt.
- */
-function shuttleInterval (stepLength) {
-  const retrier = new Retrier()
-  retrier.shuttleInterval(stepLength)
-  return retrier
-}
-
-/**
- * Creates a Retrier instance with a total-opertion timeout.
- * @param {number} timeout - The timeout value in milliseconds.
- * @returns {Retrier} A Retrier instance configured with the given timeout.
- */
-function timeout (timeout) {
-  const retrier = new Retrier()
-  retrier.timeout(timeout)
-  return retrier
-}
-
-/**
- * Creates a retrier instance with a single-task timeout.
- * @param {number} timeout - The timeout duration in milliseconds for the retrier task.
- * @returns {Retrier} A Retrier instance configured with the given task timeout.
- */
-function taskTimeout (timeout) {
-  const retrier = new Retrier()
-  retrier.taskTimeout(timeout)
-  return retrier
-}
-
-/**
- * Creates a new Retrier instance, sets the task to be retried, and starts the retry process.
- * @param {Function} task - The asynchronous task function to be retried.
- * @returns {Promise<*>} A promise that resolves when the retry process completes.
- */
-function start (task) {
-  const retrier = new Retrier()
-  retrier.task(task)
-  return retrier.start()
-}
-
-// default export
-export default {
-  name,
-  infinite,
-  times,
-  maxRetries,
-  min,
-  max,
-  range,
-  fixedInterval,
-  fixedIncrease,
-  factorIncrease,
-  shuttleInterval,
-  timeout,
-  taskTimeout,
-  start
-}
-
-// named export
-export {
-  name,
-  infinite,
-  times,
-  maxRetries,
-  min,
-  max,
-  range,
-  fixedInterval,
-  fixedIncrease,
-  factorIncrease,
-  shuttleInterval,
-  timeout,
-  taskTimeout,
-  start
-}