@metamask-previews/controller-utils 11.4.5-preview-ee77a6d9 → 11.4.5-preview-4c4eb52a

package/CHANGELOG.md

@@ -9,12 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
-- Add utility function for reducing boilerplate for service classes ([#5154](https://github.com/MetaMask/core/pull/5154), [#5143](https://github.com/MetaMask/core/pull/5143), [#5149](https://github.com/MetaMask/core/pull/5149), [#5188](https://github.com/MetaMask/core/pull/5188), [#5192](https://github.com/MetaMask/core/pull/5192), [#5225](https://github.com/MetaMask/core/pull/5225))
-  - Add function `createServicePolicy`
-  - Add constants `DEFAULT_CIRCUIT_BREAK_DURATION`, `DEFAULT_DEGRADED_THRESHOLD`, `DEFAULT_MAX_CONSECUTIVE_FAILURES`, and `DEFAULT_MAX_RETRIES`
-  - Add types `ServicePolicy` and `CreateServicePolicyOptions`
-  - Re-export `BrokenCircuitError`, `CircuitState`, `handleAll`, and `handleWhen` from `cockatiel`
-  - Export `CockatielEvent` type which is an alias of the `Event` type from `cockatiel`
+- Add `createServicePolicy` function to assist with reducing boilerplate for service classes ([#5154](https://github.com/MetaMask/core/pull/5154), [#5143](https://github.com/MetaMask/core/pull/5143))
 
 ## [11.4.5]
 

package/dist/create-service-policy.cjs

@@ -1,11 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createServicePolicy = exports.DEFAULT_DEGRADED_THRESHOLD = exports.DEFAULT_CIRCUIT_BREAK_DURATION = exports.DEFAULT_MAX_CONSECUTIVE_FAILURES = exports.DEFAULT_MAX_RETRIES = exports.handleWhen = exports.handleAll = exports.BrokenCircuitError = exports.CircuitState = void 0;
+exports.createServicePolicy = exports.DEFAULT_DEGRADED_THRESHOLD = exports.DEFAULT_CIRCUIT_BREAK_DURATION = exports.DEFAULT_MAX_CONSECUTIVE_FAILURES = exports.DEFAULT_MAX_RETRIES = void 0;
 const cockatiel_1 = require("cockatiel");
-Object.defineProperty(exports, "BrokenCircuitError", { enumerable: true, get: function () { return cockatiel_1.BrokenCircuitError; } });
-Object.defineProperty(exports, "CircuitState", { enumerable: true, get: function () { return cockatiel_1.CircuitState; } });
-Object.defineProperty(exports, "handleAll", { enumerable: true, get: function () { return cockatiel_1.handleAll; } });
-Object.defineProperty(exports, "handleWhen", { enumerable: true, get: function () { return cockatiel_1.handleWhen; } });
 /**
  * The maximum number of times that a failing service should be re-run before
  * giving up.
@@ -13,9 +9,7 @@ Object.defineProperty(exports, "handleWhen", { enumerable: true, get: function (
 exports.DEFAULT_MAX_RETRIES = 3;
 /**
  * The maximum number of times that the service is allowed to fail before
- * pausing further retries. This is set to a value such that if given a
- * service that continually fails, the policy needs to be executed 3 times
- * before further retries are paused.
+ * pausing further retries.
  */
 exports.DEFAULT_MAX_CONSECUTIVE_FAILURES = (1 + exports.DEFAULT_MAX_RETRIES) * 3;
 /**
@@ -44,12 +38,6 @@ exports.DEFAULT_DEGRADED_THRESHOLD = 5000;
  * there for more.
  *
  * @param options - The options to this function.
- * @param options.maxRetries - The maximum number of times that a failing
- * service should be re-invoked before giving up. Defaults to 3.
- * @param options.retryFilterPolicy - The policy used to control when the
- * service should be retried based on either the result of the servce or an
- * error that it throws. For instance, you could use this to retry only certain
- * errors. See `handleWhen` and friends from Cockatiel for more.
  * @param options.maxConsecutiveFailures - The maximum number of times that the
  * service is allowed to fail before pausing further retries. Defaults to 12.
  * @param options.circuitBreakDuration - The length of time (in milliseconds) to
@@ -58,6 +46,14 @@ exports.DEFAULT_DEGRADED_THRESHOLD = 5000;
  * @param options.degradedThreshold - The length of time (in milliseconds) that
  * governs when the service is regarded as degraded (affecting when `onDegraded`
  * is called). Defaults to 5 seconds.
+ * @param options.onBreak - A function which is called when the service fails
+ * too many times in a row (specifically, more than `maxConsecutiveFailures`).
+ * @param options.onDegraded - A function which is called when the service
+ * succeeds before `maxConsecutiveFailures` is reached, but takes more time than
+ * the `degradedThreshold` to run.
+ * @param options.onRetry - A function which will be called the moment the
+ * policy kicks off a timer to re-run the function passed to the policy. This is
+ * primarily useful in tests where we are mocking timers.
  * @returns The service policy.
  * @example
  * This function is designed to be used in the context of a service class like
@@ -66,10 +62,6 @@ exports.DEFAULT_DEGRADED_THRESHOLD = 5000;
  * class Service {
  *   constructor() {
  *     this.#policy = createServicePolicy({
- *       maxRetries: 3,
- *       retryFilterPolicy: handleWhen((error) => {
- *         return error.message.includes('oops');
- *       }),
  *       maxConsecutiveFailures: 3,
  *       circuitBreakDuration: 5000,
  *       degradedThreshold: 2000,
@@ -91,16 +83,21 @@ exports.DEFAULT_DEGRADED_THRESHOLD = 5000;
  * }
  * ```
  */
-function createServicePolicy({ maxRetries = exports.DEFAULT_MAX_RETRIES, retryFilterPolicy = cockatiel_1.handleAll, maxConsecutiveFailures = exports.DEFAULT_MAX_CONSECUTIVE_FAILURES, circuitBreakDuration = exports.DEFAULT_CIRCUIT_BREAK_DURATION, degradedThreshold = exports.DEFAULT_DEGRADED_THRESHOLD, } = {}) {
-    const retryPolicy = (0, cockatiel_1.retry)(retryFilterPolicy, {
+function createServicePolicy({ maxConsecutiveFailures = exports.DEFAULT_MAX_CONSECUTIVE_FAILURES, circuitBreakDuration = exports.DEFAULT_CIRCUIT_BREAK_DURATION, degradedThreshold = exports.DEFAULT_DEGRADED_THRESHOLD, onBreak = () => {
+    // do nothing
+}, onDegraded = () => {
+    // do nothing
+}, onRetry = () => {
+    // do nothing
+}, } = {}) {
+    const retryPolicy = (0, cockatiel_1.retry)(cockatiel_1.handleAll, {
         // Note that although the option here is called "max attempts", it's really
         // maximum number of *retries* (attempts past the initial attempt).
-        maxAttempts: maxRetries,
+        maxAttempts: exports.DEFAULT_MAX_RETRIES,
         // Retries of the service will be executed following ever increasing delays,
         // determined by a backoff formula.
         backoff: new cockatiel_1.ExponentialBackoff(),
     });
-    const onRetry = retryPolicy.onRetry.bind(retryPolicy);
     const circuitBreakerPolicy = (0, cockatiel_1.circuitBreaker)(cockatiel_1.handleAll, {
         // While the circuit is open, any additional invocations of the service
         // passed to the policy (either via automatic retries or by manually
@@ -111,31 +108,38 @@ function createServicePolicy({ maxRetries = exports.DEFAULT_MAX_RETRIES, retryFi
         halfOpenAfter: circuitBreakDuration,
         breaker: new cockatiel_1.ConsecutiveBreaker(maxConsecutiveFailures),
     });
-    const onBreak = circuitBreakerPolicy.onBreak.bind(circuitBreakerPolicy);
-    const onDegradedEventEmitter = new cockatiel_1.EventEmitter();
+    // The `onBreak` callback will be called if the service consistently throws
+    // for as many times as exceeds the maximum consecutive number of failures.
+    // Combined with the retry policy, this can happen if:
+    // - `maxConsecutiveFailures` < the default max retries (3) and the policy is
+    // executed once
+    // - `maxConsecutiveFailures` >= the default max retries (3) but the policy is
+    //   executed multiple times, enough for the total number of retries to exceed
+    //   `maxConsecutiveFailures`
+    circuitBreakerPolicy.onBreak(onBreak);
+    // The `onRetryPolicy` callback will be called each time the service is
+    // invoked (including retries).
+    retryPolicy.onRetry(onRetry);
     retryPolicy.onGiveUp(() => {
         if (circuitBreakerPolicy.state === cockatiel_1.CircuitState.Closed) {
-            onDegradedEventEmitter.emit();
+            // The `onDegraded` callback will be called if the number of retries is
+            // exceeded and the maximum number of consecutive failures has not been
+            // reached yet (whether the policy is called once or multiple times).
+            onDegraded();
         }
     });
     retryPolicy.onSuccess(({ duration }) => {
         if (circuitBreakerPolicy.state === cockatiel_1.CircuitState.Closed &&
             duration > degradedThreshold) {
-            onDegradedEventEmitter.emit();
+            // The `onDegraded` callback will also be called if the service does not
+            // throw, but the time it takes for the service to run exceeds the
+            // `degradedThreshold`.
+            onDegraded();
         }
     });
-    const onDegraded = onDegradedEventEmitter.addListener;
-    // Every time the retry policy makes an attempt, it executes the circuit
-    // breaker policy, which executes the service.
-    const policy = (0, cockatiel_1.wrap)(retryPolicy, circuitBreakerPolicy);
-    return {
-        ...policy,
-        circuitBreakerPolicy,
-        retryPolicy,
-        onBreak,
-        onDegraded,
-        onRetry,
-    };
+    // The retry policy really retries the circuit breaker policy, which invokes
+    // the service.
+    return (0, cockatiel_1.wrap)(retryPolicy, circuitBreakerPolicy);
 }
 exports.createServicePolicy = createServicePolicy;
 //# sourceMappingURL=create-service-policy.cjs.map

package/dist/create-service-policy.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"create-service-policy.cjs","sourceRoot":"","sources":["../src/create-service-policy.ts"],"names":[],"mappings":";;;AAAA,yCAWmB;AASI,mGAnBrB,8BAAkB,OAmBqB;AAAhC,6FAlBP,wBAAY,OAkBO;AAAsB,0FAbzC,qBAAS,OAayC;AAAE,2FAZpD,sBAAU,OAYoD;AAuEhE;;;GAGG;AACU,QAAA,mBAAmB,GAAG,CAAC,CAAC;AAErC;;;;;GAKG;AACU,QAAA,gCAAgC,GAAG,CAAC,CAAC,GAAG,2BAAmB,CAAC,GAAG,CAAC,CAAC;AAE9E;;;GAGG;AACU,QAAA,8BAA8B,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;AAE7D;;;GAGG;AACU,QAAA,0BAA0B,GAAG,IAAK,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,SAAgB,mBAAmB,CAAC,EAClC,UAAU,GAAG,2BAAmB,EAChC,iBAAiB,GAAG,qBAAS,EAC7B,sBAAsB,GAAG,wCAAgC,EACzD,oBAAoB,GAAG,sCAA8B,EACrD,iBAAiB,GAAG,kCAA0B,MAChB,EAAE;IAChC,MAAM,WAAW,GAAG,IAAA,iBAAK,EAAC,iBAAiB,EAAE;QAC3C,2EAA2E;QAC3E,mEAAmE;QACnE,WAAW,EAAE,UAAU;QACvB,4EAA4E;QAC5E,mCAAmC;QACnC,OAAO,EAAE,IAAI,8BAAkB,EAAE;KAClC,CAAC,CAAC;IACH,MAAM,OAAO,GAAG,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAEtD,MAAM,oBAAoB,GAAG,IAAA,0BAAc,EAAC,qBAAS,EAAE;QACrD,uEAAuE;QACvE,oEAAoE;QACpE,wEAAwE;QACxE,4EAA4E;QAC5E,qEAAqE;QACrE,qDAAqD;QACrD,aAAa,EAAE,oBAAoB;QACnC,OAAO,EAAE,IAAI,8BAAkB,CAAC,sBAAsB,CAAC;KACxD,CAAC,CAAC;IACH,MAAM,OAAO,GAAG,oBAAoB,CAAC,OAAO,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;IAExE,MAAM,sBAAsB,GAAG,IAAI,wBAAqB,EAAQ,CAAC;IACjE,WAAW,CAAC,QAAQ,CAAC,GAAG,EAAE;QACxB,IAAI,oBAAoB,CAAC,KAAK,KAAK,wBAAY,CAAC,MAAM,EAAE;YACtD,sBAAsB,CAAC,IAAI,EAAE,CAAC;SAC/B;IACH,CAAC,CAAC,CAAC;IACH,WAAW,CAAC,SAAS,CAAC,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE;QACrC,IACE,oBAAoB,CAAC,KAAK,KAAK,wBAAY,CAAC,MAAM;YAClD,QAAQ,GAAG,iBAAiB,EAC5B;YACA,sBAAsB,CAAC,IAAI,EAAE,CAAC;SAC/B;IACH,CAAC,CAAC,CAAC;IACH,MAAM,UAAU,GAAG,sBAAsB,CAAC,WAAW,CAAC;IAEtD,wEAAwE;IACxE,8CAA8C;IAC9C,MAAM,MAAM,GAAG,IAAA,gBAAI,EAAC,WAAW,EAAE,oBAAoB,CAAC,CAAC;IAEvD,OAAO;QACL,GAAG,MAAM;QACT,oBAAoB;QACpB,WAAW;QACX,OAAO;QACP,UAAU;QACV,OAAO;KACR,CAAC;AACJ,CAAC;AAzDD,kDAyDC","sourcesContent":["import {\n  BrokenCircuitError,\n  CircuitState,\n  EventEmitter as CockatielEventEmitter,\n  ConsecutiveBreaker,\n  ExponentialBackoff,\n  circuitBreaker,\n  handleAll,\n  handleWhen,\n  retry,\n  wrap,\n} from 'cockatiel';\nimport type {\n  CircuitBreakerPolicy,\n  Event as CockatielEvent,\n  IPolicy,\n  Policy,\n  RetryPolicy,\n} from 'cockatiel';\n\nexport { CircuitState, BrokenCircuitError, handleAll, handleWhen };\n\nexport type { CockatielEvent };\n\n/**\n * The options for `createServicePolicy`.\n */\nexport type CreateServicePolicyOptions = {\n  /**\n   * The length of time (in milliseconds) to pause retries of the action after\n   * the number of failures reaches `maxConsecutiveFailures`.\n   */\n  circuitBreakDuration?: number;\n  /**\n   * The length of time (in milliseconds) that governs when the service is\n   * regarded as degraded (affecting when `onDegraded` is called).\n   */\n  degradedThreshold?: number;\n  /**\n   * The maximum number of times that the service is allowed to fail before\n   * pausing further retries.\n   */\n  maxConsecutiveFailures?: number;\n  /**\n   * The maximum number of times that a failing service should be re-invoked\n   * before giving up.\n   */\n  maxRetries?: number;\n  /**\n   * The policy used to control when the service should be retried based on\n   * either the result of the service or an error that it throws. For instance,\n   * you could use this to retry only certain errors. See `handleWhen` and\n   * friends from Cockatiel for more.\n   */\n  retryFilterPolicy?: Policy;\n};\n\n/**\n * The service policy object.\n */\nexport type ServicePolicy = IPolicy & {\n  /**\n   * The Cockatiel circuit breaker policy that the service policy uses\n   * internally.\n   */\n  circuitBreakerPolicy: CircuitBreakerPolicy;\n  /**\n   * The Cockatiel retry policy that the service policy uses internally.\n   */\n  retryPolicy: RetryPolicy;\n  /**\n   * A function which is called when the number of times that the service fails\n   * in a row meets the set maximum number of consecutive failures.\n   */\n  onBreak: CircuitBreakerPolicy['onBreak'];\n  /**\n   * A function which is called in two circumstances: 1) when the service\n   * succeeds before the maximum number of consecutive failures is reached, but\n   * takes more time than the `degradedThreshold` to run, or 2) if the service\n   * never succeeds before the retry policy gives up and before the maximum\n   * number of consecutive failures has been reached.\n   */\n  onDegraded: CockatielEvent<void>;\n  /**\n   * A function which will be called by the retry policy each time the service\n   * fails and the policy kicks off a timer to re-run the service. This is\n   * primarily useful in tests where we are mocking timers.\n   */\n  onRetry: RetryPolicy['onRetry'];\n};\n\n/**\n * The maximum number of times that a failing service should be re-run before\n * giving up.\n */\nexport const DEFAULT_MAX_RETRIES = 3;\n\n/**\n * The maximum number of times that the service is allowed to fail before\n * pausing further retries. This is set to a value such that if given a\n * service that continually fails, the policy needs to be executed 3 times\n * before further retries are paused.\n */\nexport const DEFAULT_MAX_CONSECUTIVE_FAILURES = (1 + DEFAULT_MAX_RETRIES) * 3;\n\n/**\n * The default length of time (in milliseconds) to temporarily pause retries of\n * the service after enough consecutive failures.\n */\nexport const DEFAULT_CIRCUIT_BREAK_DURATION = 30 * 60 * 1000;\n\n/**\n * The default length of time (in milliseconds) that governs when the service is\n * regarded as degraded (affecting when `onDegraded` is called).\n */\nexport const DEFAULT_DEGRADED_THRESHOLD = 5_000;\n\n/**\n * Constructs an object exposing an `execute` method which, given a function —\n * hereafter called the \"service\" — will retry that service with ever increasing\n * delays until it succeeds. If the policy detects too many consecutive\n * failures, it will block further retries until a designated time period has\n * passed; this particular behavior is primarily designed for services that wrap\n * API calls so as not to make needless HTTP requests when the API is down and\n * to be able to recover when the API comes back up. In addition, hooks allow\n * for responding to certain events, one of which can be used to detect when an\n * HTTP request is performing slowly.\n *\n * Internally, this function makes use of the retry and circuit breaker policies\n * from the [Cockatiel](https://www.npmjs.com/package/cockatiel) library; see\n * there for more.\n *\n * @param options - The options to this function.\n * @param options.maxRetries - The maximum number of times that a failing\n * service should be re-invoked before giving up. Defaults to 3.\n * @param options.retryFilterPolicy - The policy used to control when the\n * service should be retried based on either the result of the servce or an\n * error that it throws. For instance, you could use this to retry only certain\n * errors. See `handleWhen` and friends from Cockatiel for more.\n * @param options.maxConsecutiveFailures - The maximum number of times that the\n * service is allowed to fail before pausing further retries. Defaults to 12.\n * @param options.circuitBreakDuration - The length of time (in milliseconds) to\n * pause retries of the action after the number of failures reaches\n * `maxConsecutiveFailures`.\n * @param options.degradedThreshold - The length of time (in milliseconds) that\n * governs when the service is regarded as degraded (affecting when `onDegraded`\n * is called). Defaults to 5 seconds.\n * @returns The service policy.\n * @example\n * This function is designed to be used in the context of a service class like\n * this:\n * ``` ts\n * class Service {\n *   constructor() {\n *     this.#policy = createServicePolicy({\n *       maxRetries: 3,\n *       retryFilterPolicy: handleWhen((error) => {\n *         return error.message.includes('oops');\n *       }),\n *       maxConsecutiveFailures: 3,\n *       circuitBreakDuration: 5000,\n *       degradedThreshold: 2000,\n *       onBreak: () => {\n *         console.log('Circuit broke');\n *       },\n *       onDegraded: () => {\n *         console.log('Service is degraded');\n *       },\n *     });\n *   }\n *\n *   async fetch() {\n *     return await this.#policy.execute(async () => {\n *       const response = await fetch('https://some/url');\n *       return await response.json();\n *     });\n *   }\n * }\n * ```\n */\nexport function createServicePolicy({\n  maxRetries = DEFAULT_MAX_RETRIES,\n  retryFilterPolicy = handleAll,\n  maxConsecutiveFailures = DEFAULT_MAX_CONSECUTIVE_FAILURES,\n  circuitBreakDuration = DEFAULT_CIRCUIT_BREAK_DURATION,\n  degradedThreshold = DEFAULT_DEGRADED_THRESHOLD,\n}: CreateServicePolicyOptions = {}): ServicePolicy {\n  const retryPolicy = retry(retryFilterPolicy, {\n    // Note that although the option here is called \"max attempts\", it's really\n    // maximum number of *retries* (attempts past the initial attempt).\n    maxAttempts: maxRetries,\n    // Retries of the service will be executed following ever increasing delays,\n    // determined by a backoff formula.\n    backoff: new ExponentialBackoff(),\n  });\n  const onRetry = retryPolicy.onRetry.bind(retryPolicy);\n\n  const circuitBreakerPolicy = circuitBreaker(handleAll, {\n    // While the circuit is open, any additional invocations of the service\n    // passed to the policy (either via automatic retries or by manually\n    // executing the policy again) will result in a BrokenCircuitError. This\n    // will remain the case until `circuitBreakDuration` passes, after which the\n    // service will be allowed to run again. If the service succeeds, the\n    // circuit will close, otherwise it will remain open.\n    halfOpenAfter: circuitBreakDuration,\n    breaker: new ConsecutiveBreaker(maxConsecutiveFailures),\n  });\n  const onBreak = circuitBreakerPolicy.onBreak.bind(circuitBreakerPolicy);\n\n  const onDegradedEventEmitter = new CockatielEventEmitter<void>();\n  retryPolicy.onGiveUp(() => {\n    if (circuitBreakerPolicy.state === CircuitState.Closed) {\n      onDegradedEventEmitter.emit();\n    }\n  });\n  retryPolicy.onSuccess(({ duration }) => {\n    if (\n      circuitBreakerPolicy.state === CircuitState.Closed &&\n      duration > degradedThreshold\n    ) {\n      onDegradedEventEmitter.emit();\n    }\n  });\n  const onDegraded = onDegradedEventEmitter.addListener;\n\n  // Every time the retry policy makes an attempt, it executes the circuit\n  // breaker policy, which executes the service.\n  const policy = wrap(retryPolicy, circuitBreakerPolicy);\n\n  return {\n    ...policy,\n    circuitBreakerPolicy,\n    retryPolicy,\n    onBreak,\n    onDegraded,\n    onRetry,\n  };\n}\n"]}
+{"version":3,"file":"create-service-policy.cjs","sourceRoot":"","sources":["../src/create-service-policy.ts"],"names":[],"mappings":";;;AAAA,yCAQmB;AAKnB;;;GAGG;AACU,QAAA,mBAAmB,GAAG,CAAC,CAAC;AAErC;;;GAGG;AACU,QAAA,gCAAgC,GAAG,CAAC,CAAC,GAAG,2BAAmB,CAAC,GAAG,CAAC,CAAC;AAE9E;;;GAGG;AACU,QAAA,8BAA8B,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;AAE7D;;;GAGG;AACU,QAAA,0BAA0B,GAAG,IAAK,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,SAAgB,mBAAmB,CAAC,EAClC,sBAAsB,GAAG,wCAAgC,EACzD,oBAAoB,GAAG,sCAA8B,EACrD,iBAAiB,GAAG,kCAA0B,EAC9C,OAAO,GAAG,GAAG,EAAE;IACb,aAAa;AACf,CAAC,EACD,UAAU,GAAG,GAAG,EAAE;IAChB,aAAa;AACf,CAAC,EACD,OAAO,GAAG,GAAG,EAAE;IACb,aAAa;AACf,CAAC,MAQC,EAAE;IACJ,MAAM,WAAW,GAAG,IAAA,iBAAK,EAAC,qBAAS,EAAE;QACnC,2EAA2E;QAC3E,mEAAmE;QACnE,WAAW,EAAE,2BAAmB;QAChC,4EAA4E;QAC5E,mCAAmC;QACnC,OAAO,EAAE,IAAI,8BAAkB,EAAE;KAClC,CAAC,CAAC;IAEH,MAAM,oBAAoB,GAAG,IAAA,0BAAc,EAAC,qBAAS,EAAE;QACrD,uEAAuE;QACvE,oEAAoE;QACpE,wEAAwE;QACxE,4EAA4E;QAC5E,qEAAqE;QACrE,qDAAqD;QACrD,aAAa,EAAE,oBAAoB;QACnC,OAAO,EAAE,IAAI,8BAAkB,CAAC,sBAAsB,CAAC;KACxD,CAAC,CAAC;IAEH,2EAA2E;IAC3E,2EAA2E;IAC3E,sDAAsD;IACtD,6EAA6E;IAC7E,gBAAgB;IAChB,8EAA8E;IAC9E,8EAA8E;IAC9E,6BAA6B;IAC7B,oBAAoB,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IAEtC,uEAAuE;IACvE,+BAA+B;IAC/B,WAAW,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IAE7B,WAAW,CAAC,QAAQ,CAAC,GAAG,EAAE;QACxB,IAAI,oBAAoB,CAAC,KAAK,KAAK,wBAAY,CAAC,MAAM,EAAE;YACtD,uEAAuE;YACvE,uEAAuE;YACvE,qEAAqE;YACrE,UAAU,EAAE,CAAC;SACd;IACH,CAAC,CAAC,CAAC;IACH,WAAW,CAAC,SAAS,CAAC,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE;QACrC,IACE,oBAAoB,CAAC,KAAK,KAAK,wBAAY,CAAC,MAAM;YAClD,QAAQ,GAAG,iBAAiB,EAC5B;YACA,wEAAwE;YACxE,kEAAkE;YAClE,uBAAuB;YACvB,UAAU,EAAE,CAAC;SACd;IACH,CAAC,CAAC,CAAC;IAEH,4EAA4E;IAC5E,eAAe;IACf,OAAO,IAAA,gBAAI,EAAC,WAAW,EAAE,oBAAoB,CAAC,CAAC;AACjD,CAAC;AA9ED,kDA8EC","sourcesContent":["import {\n  circuitBreaker,\n  ConsecutiveBreaker,\n  ExponentialBackoff,\n  handleAll,\n  retry,\n  wrap,\n  CircuitState,\n} from 'cockatiel';\nimport type { IPolicy } from 'cockatiel';\n\nexport type { IPolicy as IServicePolicy };\n\n/**\n * The maximum number of times that a failing service should be re-run before\n * giving up.\n */\nexport const DEFAULT_MAX_RETRIES = 3;\n\n/**\n * The maximum number of times that the service is allowed to fail before\n * pausing further retries.\n */\nexport const DEFAULT_MAX_CONSECUTIVE_FAILURES = (1 + DEFAULT_MAX_RETRIES) * 3;\n\n/**\n * The default length of time (in milliseconds) to temporarily pause retries of\n * the service after enough consecutive failures.\n */\nexport const DEFAULT_CIRCUIT_BREAK_DURATION = 30 * 60 * 1000;\n\n/**\n * The default length of time (in milliseconds) that governs when the service is\n * regarded as degraded (affecting when `onDegraded` is called).\n */\nexport const DEFAULT_DEGRADED_THRESHOLD = 5_000;\n\n/**\n * Constructs an object exposing an `execute` method which, given a function —\n * hereafter called the \"service\" — will retry that service with ever increasing\n * delays until it succeeds. If the policy detects too many consecutive\n * failures, it will block further retries until a designated time period has\n * passed; this particular behavior is primarily designed for services that wrap\n * API calls so as not to make needless HTTP requests when the API is down and\n * to be able to recover when the API comes back up. In addition, hooks allow\n * for responding to certain events, one of which can be used to detect when an\n * HTTP request is performing slowly.\n *\n * Internally, this function makes use of the retry and circuit breaker policies\n * from the [Cockatiel](https://www.npmjs.com/package/cockatiel) library; see\n * there for more.\n *\n * @param options - The options to this function.\n * @param options.maxConsecutiveFailures - The maximum number of times that the\n * service is allowed to fail before pausing further retries. Defaults to 12.\n * @param options.circuitBreakDuration - The length of time (in milliseconds) to\n * pause retries of the action after the number of failures reaches\n * `maxConsecutiveFailures`.\n * @param options.degradedThreshold - The length of time (in milliseconds) that\n * governs when the service is regarded as degraded (affecting when `onDegraded`\n * is called). Defaults to 5 seconds.\n * @param options.onBreak - A function which is called when the service fails\n * too many times in a row (specifically, more than `maxConsecutiveFailures`).\n * @param options.onDegraded - A function which is called when the service\n * succeeds before `maxConsecutiveFailures` is reached, but takes more time than\n * the `degradedThreshold` to run.\n * @param options.onRetry - A function which will be called the moment the\n * policy kicks off a timer to re-run the function passed to the policy. This is\n * primarily useful in tests where we are mocking timers.\n * @returns The service policy.\n * @example\n * This function is designed to be used in the context of a service class like\n * this:\n * ``` ts\n * class Service {\n *   constructor() {\n *     this.#policy = createServicePolicy({\n *       maxConsecutiveFailures: 3,\n *       circuitBreakDuration: 5000,\n *       degradedThreshold: 2000,\n *       onBreak: () => {\n *         console.log('Circuit broke');\n *       },\n *       onDegraded: () => {\n *         console.log('Service is degraded');\n *       },\n *     });\n *   }\n *\n *   async fetch() {\n *     return await this.#policy.execute(async () => {\n *       const response = await fetch('https://some/url');\n *       return await response.json();\n *     });\n *   }\n * }\n * ```\n */\nexport function createServicePolicy({\n  maxConsecutiveFailures = DEFAULT_MAX_CONSECUTIVE_FAILURES,\n  circuitBreakDuration = DEFAULT_CIRCUIT_BREAK_DURATION,\n  degradedThreshold = DEFAULT_DEGRADED_THRESHOLD,\n  onBreak = () => {\n    // do nothing\n  },\n  onDegraded = () => {\n    // do nothing\n  },\n  onRetry = () => {\n    // do nothing\n  },\n}: {\n  maxConsecutiveFailures?: number;\n  circuitBreakDuration?: number;\n  degradedThreshold?: number;\n  onBreak?: () => void;\n  onDegraded?: () => void;\n  onRetry?: () => void;\n} = {}): IPolicy {\n  const retryPolicy = retry(handleAll, {\n    // Note that although the option here is called \"max attempts\", it's really\n    // maximum number of *retries* (attempts past the initial attempt).\n    maxAttempts: DEFAULT_MAX_RETRIES,\n    // Retries of the service will be executed following ever increasing delays,\n    // determined by a backoff formula.\n    backoff: new ExponentialBackoff(),\n  });\n\n  const circuitBreakerPolicy = circuitBreaker(handleAll, {\n    // While the circuit is open, any additional invocations of the service\n    // passed to the policy (either via automatic retries or by manually\n    // executing the policy again) will result in a BrokenCircuitError. This\n    // will remain the case until `circuitBreakDuration` passes, after which the\n    // service will be allowed to run again. If the service succeeds, the\n    // circuit will close, otherwise it will remain open.\n    halfOpenAfter: circuitBreakDuration,\n    breaker: new ConsecutiveBreaker(maxConsecutiveFailures),\n  });\n\n  // The `onBreak` callback will be called if the service consistently throws\n  // for as many times as exceeds the maximum consecutive number of failures.\n  // Combined with the retry policy, this can happen if:\n  // - `maxConsecutiveFailures` < the default max retries (3) and the policy is\n  // executed once\n  // - `maxConsecutiveFailures` >= the default max retries (3) but the policy is\n  //   executed multiple times, enough for the total number of retries to exceed\n  //   `maxConsecutiveFailures`\n  circuitBreakerPolicy.onBreak(onBreak);\n\n  // The `onRetryPolicy` callback will be called each time the service is\n  // invoked (including retries).\n  retryPolicy.onRetry(onRetry);\n\n  retryPolicy.onGiveUp(() => {\n    if (circuitBreakerPolicy.state === CircuitState.Closed) {\n      // The `onDegraded` callback will be called if the number of retries is\n      // exceeded and the maximum number of consecutive failures has not been\n      // reached yet (whether the policy is called once or multiple times).\n      onDegraded();\n    }\n  });\n  retryPolicy.onSuccess(({ duration }) => {\n    if (\n      circuitBreakerPolicy.state === CircuitState.Closed &&\n      duration > degradedThreshold\n    ) {\n      // The `onDegraded` callback will also be called if the service does not\n      // throw, but the time it takes for the service to run exceeds the\n      // `degradedThreshold`.\n      onDegraded();\n    }\n  });\n\n  // The retry policy really retries the circuit breaker policy, which invokes\n  // the service.\n  return wrap(retryPolicy, circuitBreakerPolicy);\n}\n"]}

package/dist/create-service-policy.d.cts

@@ -1,72 +1,5 @@
-import { BrokenCircuitError, CircuitState, handleAll, handleWhen } from "cockatiel";
-import type { CircuitBreakerPolicy, Event as CockatielEvent, IPolicy, Policy, RetryPolicy } from "cockatiel";
-export { CircuitState, BrokenCircuitError, handleAll, handleWhen };
-export type { CockatielEvent };
-/**
- * The options for `createServicePolicy`.
- */
-export type CreateServicePolicyOptions = {
-    /**
-     * The length of time (in milliseconds) to pause retries of the action after
-     * the number of failures reaches `maxConsecutiveFailures`.
-     */
-    circuitBreakDuration?: number;
-    /**
-     * The length of time (in milliseconds) that governs when the service is
-     * regarded as degraded (affecting when `onDegraded` is called).
-     */
-    degradedThreshold?: number;
-    /**
-     * The maximum number of times that the service is allowed to fail before
-     * pausing further retries.
-     */
-    maxConsecutiveFailures?: number;
-    /**
-     * The maximum number of times that a failing service should be re-invoked
-     * before giving up.
-     */
-    maxRetries?: number;
-    /**
-     * The policy used to control when the service should be retried based on
-     * either the result of the service or an error that it throws. For instance,
-     * you could use this to retry only certain errors. See `handleWhen` and
-     * friends from Cockatiel for more.
-     */
-    retryFilterPolicy?: Policy;
-};
-/**
- * The service policy object.
- */
-export type ServicePolicy = IPolicy & {
-    /**
-     * The Cockatiel circuit breaker policy that the service policy uses
-     * internally.
-     */
-    circuitBreakerPolicy: CircuitBreakerPolicy;
-    /**
-     * The Cockatiel retry policy that the service policy uses internally.
-     */
-    retryPolicy: RetryPolicy;
-    /**
-     * A function which is called when the number of times that the service fails
-     * in a row meets the set maximum number of consecutive failures.
-     */
-    onBreak: CircuitBreakerPolicy['onBreak'];
-    /**
-     * A function which is called in two circumstances: 1) when the service
-     * succeeds before the maximum number of consecutive failures is reached, but
-     * takes more time than the `degradedThreshold` to run, or 2) if the service
-     * never succeeds before the retry policy gives up and before the maximum
-     * number of consecutive failures has been reached.
-     */
-    onDegraded: CockatielEvent<void>;
-    /**
-     * A function which will be called by the retry policy each time the service
-     * fails and the policy kicks off a timer to re-run the service. This is
-     * primarily useful in tests where we are mocking timers.
-     */
-    onRetry: RetryPolicy['onRetry'];
-};
+import type { IPolicy } from "cockatiel";
+export type { IPolicy as IServicePolicy };
 /**
  * The maximum number of times that a failing service should be re-run before
  * giving up.
@@ -74,9 +7,7 @@ export type ServicePolicy = IPolicy & {
 export declare const DEFAULT_MAX_RETRIES = 3;
 /**
  * The maximum number of times that the service is allowed to fail before
- * pausing further retries. This is set to a value such that if given a
- * service that continually fails, the policy needs to be executed 3 times
- * before further retries are paused.
+ * pausing further retries.
  */
 export declare const DEFAULT_MAX_CONSECUTIVE_FAILURES: number;
 /**
@@ -105,12 +36,6 @@ export declare const DEFAULT_DEGRADED_THRESHOLD = 5000;
  * there for more.
  *
  * @param options - The options to this function.
- * @param options.maxRetries - The maximum number of times that a failing
- * service should be re-invoked before giving up. Defaults to 3.
- * @param options.retryFilterPolicy - The policy used to control when the
- * service should be retried based on either the result of the servce or an
- * error that it throws. For instance, you could use this to retry only certain
- * errors. See `handleWhen` and friends from Cockatiel for more.
  * @param options.maxConsecutiveFailures - The maximum number of times that the
  * service is allowed to fail before pausing further retries. Defaults to 12.
  * @param options.circuitBreakDuration - The length of time (in milliseconds) to
@@ -119,6 +44,14 @@ export declare const DEFAULT_DEGRADED_THRESHOLD = 5000;
  * @param options.degradedThreshold - The length of time (in milliseconds) that
  * governs when the service is regarded as degraded (affecting when `onDegraded`
  * is called). Defaults to 5 seconds.
+ * @param options.onBreak - A function which is called when the service fails
+ * too many times in a row (specifically, more than `maxConsecutiveFailures`).
+ * @param options.onDegraded - A function which is called when the service
+ * succeeds before `maxConsecutiveFailures` is reached, but takes more time than
+ * the `degradedThreshold` to run.
+ * @param options.onRetry - A function which will be called the moment the
+ * policy kicks off a timer to re-run the function passed to the policy. This is
+ * primarily useful in tests where we are mocking timers.
  * @returns The service policy.
  * @example
  * This function is designed to be used in the context of a service class like
@@ -127,10 +60,6 @@ export declare const DEFAULT_DEGRADED_THRESHOLD = 5000;
  * class Service {
  *   constructor() {
  *     this.#policy = createServicePolicy({
- *       maxRetries: 3,
- *       retryFilterPolicy: handleWhen((error) => {
- *         return error.message.includes('oops');
- *       }),
  *       maxConsecutiveFailures: 3,
  *       circuitBreakDuration: 5000,
  *       degradedThreshold: 2000,
@@ -152,5 +81,12 @@ export declare const DEFAULT_DEGRADED_THRESHOLD = 5000;
  * }
  * ```
  */
-export declare function createServicePolicy({ maxRetries, retryFilterPolicy, maxConsecutiveFailures, circuitBreakDuration, degradedThreshold, }?: CreateServicePolicyOptions): ServicePolicy;
+export declare function createServicePolicy({ maxConsecutiveFailures, circuitBreakDuration, degradedThreshold, onBreak, onDegraded, onRetry, }?: {
+    maxConsecutiveFailures?: number;
+    circuitBreakDuration?: number;
+    degradedThreshold?: number;
+    onBreak?: () => void;
+    onDegraded?: () => void;
+    onRetry?: () => void;
+}): IPolicy;
 //# sourceMappingURL=create-service-policy.d.cts.map

package/dist/create-service-policy.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"create-service-policy.d.cts","sourceRoot":"","sources":["../src/create-service-policy.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,YAAY,EAKZ,SAAS,EACT,UAAU,EAGX,kBAAkB;AACnB,OAAO,KAAK,EACV,oBAAoB,EACpB,KAAK,IAAI,cAAc,EACvB,OAAO,EACP,MAAM,EACN,WAAW,EACZ,kBAAkB;AAEnB,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,SAAS,EAAE,UAAU,EAAE,CAAC;AAEnE,YAAY,EAAE,cAAc,EAAE,CAAC;AAE/B;;GAEG;AACH,MAAM,MAAM,0BAA0B,GAAG;IACvC;;;OAGG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;OAGG;IACH,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG;IACpC;;;OAGG;IACH,oBAAoB,EAAE,oBAAoB,CAAC;IAC3C;;OAEG;IACH,WAAW,EAAE,WAAW,CAAC;IACzB;;;OAGG;IACH,OAAO,EAAE,oBAAoB,CAAC,SAAS,CAAC,CAAC;IACzC;;;;;;OAMG;IACH,UAAU,EAAE,cAAc,CAAC,IAAI,CAAC,CAAC;IACjC;;;;OAIG;IACH,OAAO,EAAE,WAAW,CAAC,SAAS,CAAC,CAAC;CACjC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,mBAAmB,IAAI,CAAC;AAErC;;;;;GAKG;AACH,eAAO,MAAM,gCAAgC,QAAgC,CAAC;AAE9E;;;GAGG;AACH,eAAO,MAAM,8BAA8B,QAAiB,CAAC;AAE7D;;;GAGG;AACH,eAAO,MAAM,0BAA0B,OAAQ,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,wBAAgB,mBAAmB,CAAC,EAClC,UAAgC,EAChC,iBAA6B,EAC7B,sBAAyD,EACzD,oBAAqD,EACrD,iBAA8C,GAC/C,GAAE,0BAA+B,GAAG,aAAa,CAmDjD"}
+{"version":3,"file":"create-service-policy.d.cts","sourceRoot":"","sources":["../src/create-service-policy.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,OAAO,EAAE,kBAAkB;AAEzC,YAAY,EAAE,OAAO,IAAI,cAAc,EAAE,CAAC;AAE1C;;;GAGG;AACH,eAAO,MAAM,mBAAmB,IAAI,CAAC;AAErC;;;GAGG;AACH,eAAO,MAAM,gCAAgC,QAAgC,CAAC;AAE9E;;;GAGG;AACH,eAAO,MAAM,8BAA8B,QAAiB,CAAC;AAE7D;;;GAGG;AACH,eAAO,MAAM,0BAA0B,OAAQ,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,wBAAgB,mBAAmB,CAAC,EAClC,sBAAyD,EACzD,oBAAqD,EACrD,iBAA8C,EAC9C,OAEC,EACD,UAEC,EACD,OAEC,GACF,GAAE;IACD,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;CACjB,GAAG,OAAO,CA0Df"}

package/dist/create-service-policy.d.mts

@@ -1,72 +1,5 @@
-import { BrokenCircuitError, CircuitState, handleAll, handleWhen } from "cockatiel";
-import type { CircuitBreakerPolicy, Event as CockatielEvent, IPolicy, Policy, RetryPolicy } from "cockatiel";
-export { CircuitState, BrokenCircuitError, handleAll, handleWhen };
-export type { CockatielEvent };
-/**
- * The options for `createServicePolicy`.
- */
-export type CreateServicePolicyOptions = {
-    /**
-     * The length of time (in milliseconds) to pause retries of the action after
-     * the number of failures reaches `maxConsecutiveFailures`.
-     */
-    circuitBreakDuration?: number;
-    /**
-     * The length of time (in milliseconds) that governs when the service is
-     * regarded as degraded (affecting when `onDegraded` is called).
-     */
-    degradedThreshold?: number;
-    /**
-     * The maximum number of times that the service is allowed to fail before
-     * pausing further retries.
-     */
-    maxConsecutiveFailures?: number;
-    /**
-     * The maximum number of times that a failing service should be re-invoked
-     * before giving up.
-     */
-    maxRetries?: number;
-    /**
-     * The policy used to control when the service should be retried based on
-     * either the result of the service or an error that it throws. For instance,
-     * you could use this to retry only certain errors. See `handleWhen` and
-     * friends from Cockatiel for more.
-     */
-    retryFilterPolicy?: Policy;
-};
-/**
- * The service policy object.
- */
-export type ServicePolicy = IPolicy & {
-    /**
-     * The Cockatiel circuit breaker policy that the service policy uses
-     * internally.
-     */
-    circuitBreakerPolicy: CircuitBreakerPolicy;
-    /**
-     * The Cockatiel retry policy that the service policy uses internally.
-     */
-    retryPolicy: RetryPolicy;
-    /**
-     * A function which is called when the number of times that the service fails
-     * in a row meets the set maximum number of consecutive failures.
-     */
-    onBreak: CircuitBreakerPolicy['onBreak'];
-    /**
-     * A function which is called in two circumstances: 1) when the service
-     * succeeds before the maximum number of consecutive failures is reached, but
-     * takes more time than the `degradedThreshold` to run, or 2) if the service
-     * never succeeds before the retry policy gives up and before the maximum
-     * number of consecutive failures has been reached.
-     */
-    onDegraded: CockatielEvent<void>;
-    /**
-     * A function which will be called by the retry policy each time the service
-     * fails and the policy kicks off a timer to re-run the service. This is
-     * primarily useful in tests where we are mocking timers.
-     */
-    onRetry: RetryPolicy['onRetry'];
-};
+import type { IPolicy } from "cockatiel";
+export type { IPolicy as IServicePolicy };
 /**
  * The maximum number of times that a failing service should be re-run before
  * giving up.
@@ -74,9 +7,7 @@ export type ServicePolicy = IPolicy & {
 export declare const DEFAULT_MAX_RETRIES = 3;
 /**
  * The maximum number of times that the service is allowed to fail before
- * pausing further retries. This is set to a value such that if given a
- * service that continually fails, the policy needs to be executed 3 times
- * before further retries are paused.
+ * pausing further retries.
  */
 export declare const DEFAULT_MAX_CONSECUTIVE_FAILURES: number;
 /**
@@ -105,12 +36,6 @@ export declare const DEFAULT_DEGRADED_THRESHOLD = 5000;
  * there for more.
  *
  * @param options - The options to this function.
- * @param options.maxRetries - The maximum number of times that a failing
- * service should be re-invoked before giving up. Defaults to 3.
- * @param options.retryFilterPolicy - The policy used to control when the
- * service should be retried based on either the result of the servce or an
- * error that it throws. For instance, you could use this to retry only certain
- * errors. See `handleWhen` and friends from Cockatiel for more.
  * @param options.maxConsecutiveFailures - The maximum number of times that the
  * service is allowed to fail before pausing further retries. Defaults to 12.
  * @param options.circuitBreakDuration - The length of time (in milliseconds) to
@@ -119,6 +44,14 @@ export declare const DEFAULT_DEGRADED_THRESHOLD = 5000;
  * @param options.degradedThreshold - The length of time (in milliseconds) that
  * governs when the service is regarded as degraded (affecting when `onDegraded`
  * is called). Defaults to 5 seconds.
+ * @param options.onBreak - A function which is called when the service fails
+ * too many times in a row (specifically, more than `maxConsecutiveFailures`).
+ * @param options.onDegraded - A function which is called when the service
+ * succeeds before `maxConsecutiveFailures` is reached, but takes more time than
+ * the `degradedThreshold` to run.
+ * @param options.onRetry - A function which will be called the moment the
+ * policy kicks off a timer to re-run the function passed to the policy. This is
+ * primarily useful in tests where we are mocking timers.
  * @returns The service policy.
  * @example
  * This function is designed to be used in the context of a service class like
@@ -127,10 +60,6 @@ export declare const DEFAULT_DEGRADED_THRESHOLD = 5000;
  * class Service {
  *   constructor() {
  *     this.#policy = createServicePolicy({
- *       maxRetries: 3,
- *       retryFilterPolicy: handleWhen((error) => {
- *         return error.message.includes('oops');
- *       }),
  *       maxConsecutiveFailures: 3,
  *       circuitBreakDuration: 5000,
  *       degradedThreshold: 2000,
@@ -152,5 +81,12 @@ export declare const DEFAULT_DEGRADED_THRESHOLD = 5000;
  * }
  * ```
  */
-export declare function createServicePolicy({ maxRetries, retryFilterPolicy, maxConsecutiveFailures, circuitBreakDuration, degradedThreshold, }?: CreateServicePolicyOptions): ServicePolicy;
+export declare function createServicePolicy({ maxConsecutiveFailures, circuitBreakDuration, degradedThreshold, onBreak, onDegraded, onRetry, }?: {
+    maxConsecutiveFailures?: number;
+    circuitBreakDuration?: number;
+    degradedThreshold?: number;
+    onBreak?: () => void;
+    onDegraded?: () => void;
+    onRetry?: () => void;
+}): IPolicy;
 //# sourceMappingURL=create-service-policy.d.mts.map

package/dist/create-service-policy.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"create-service-policy.d.mts","sourceRoot":"","sources":["../src/create-service-policy.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,YAAY,EAKZ,SAAS,EACT,UAAU,EAGX,kBAAkB;AACnB,OAAO,KAAK,EACV,oBAAoB,EACpB,KAAK,IAAI,cAAc,EACvB,OAAO,EACP,MAAM,EACN,WAAW,EACZ,kBAAkB;AAEnB,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,SAAS,EAAE,UAAU,EAAE,CAAC;AAEnE,YAAY,EAAE,cAAc,EAAE,CAAC;AAE/B;;GAEG;AACH,MAAM,MAAM,0BAA0B,GAAG;IACvC;;;OAGG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;OAGG;IACH,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG;IACpC;;;OAGG;IACH,oBAAoB,EAAE,oBAAoB,CAAC;IAC3C;;OAEG;IACH,WAAW,EAAE,WAAW,CAAC;IACzB;;;OAGG;IACH,OAAO,EAAE,oBAAoB,CAAC,SAAS,CAAC,CAAC;IACzC;;;;;;OAMG;IACH,UAAU,EAAE,cAAc,CAAC,IAAI,CAAC,CAAC;IACjC;;;;OAIG;IACH,OAAO,EAAE,WAAW,CAAC,SAAS,CAAC,CAAC;CACjC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,mBAAmB,IAAI,CAAC;AAErC;;;;;GAKG;AACH,eAAO,MAAM,gCAAgC,QAAgC,CAAC;AAE9E;;;GAGG;AACH,eAAO,MAAM,8BAA8B,QAAiB,CAAC;AAE7D;;;GAGG;AACH,eAAO,MAAM,0BAA0B,OAAQ,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,wBAAgB,mBAAmB,CAAC,EAClC,UAAgC,EAChC,iBAA6B,EAC7B,sBAAyD,EACzD,oBAAqD,EACrD,iBAA8C,GAC/C,GAAE,0BAA+B,GAAG,aAAa,CAmDjD"}
+{"version":3,"file":"create-service-policy.d.mts","sourceRoot":"","sources":["../src/create-service-policy.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,OAAO,EAAE,kBAAkB;AAEzC,YAAY,EAAE,OAAO,IAAI,cAAc,EAAE,CAAC;AAE1C;;;GAGG;AACH,eAAO,MAAM,mBAAmB,IAAI,CAAC;AAErC;;;GAGG;AACH,eAAO,MAAM,gCAAgC,QAAgC,CAAC;AAE9E;;;GAGG;AACH,eAAO,MAAM,8BAA8B,QAAiB,CAAC;AAE7D;;;GAGG;AACH,eAAO,MAAM,0BAA0B,OAAQ,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,wBAAgB,mBAAmB,CAAC,EAClC,sBAAyD,EACzD,oBAAqD,EACrD,iBAA8C,EAC9C,OAEC,EACD,UAEC,EACD,OAEC,GACF,GAAE;IACD,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;CACjB,GAAG,OAAO,CA0Df"}

package/dist/create-service-policy.mjs

@@ -1,5 +1,4 @@
-import { BrokenCircuitError, CircuitState, EventEmitter as CockatielEventEmitter, ConsecutiveBreaker, ExponentialBackoff, circuitBreaker, handleAll, handleWhen, retry, wrap } from "cockatiel";
-export { CircuitState, BrokenCircuitError, handleAll, handleWhen };
+import { circuitBreaker, ConsecutiveBreaker, ExponentialBackoff, handleAll, retry, wrap, CircuitState } from "cockatiel";
 /**
  * The maximum number of times that a failing service should be re-run before
  * giving up.
@@ -7,9 +6,7 @@ export { CircuitState, BrokenCircuitError, handleAll, handleWhen };
 export const DEFAULT_MAX_RETRIES = 3;
 /**
  * The maximum number of times that the service is allowed to fail before
- * pausing further retries. This is set to a value such that if given a
- * service that continually fails, the policy needs to be executed 3 times
- * before further retries are paused.
+ * pausing further retries.
  */
 export const DEFAULT_MAX_CONSECUTIVE_FAILURES = (1 + DEFAULT_MAX_RETRIES) * 3;
 /**
@@ -38,12 +35,6 @@ export const DEFAULT_DEGRADED_THRESHOLD = 5000;
  * there for more.
  *
  * @param options - The options to this function.
- * @param options.maxRetries - The maximum number of times that a failing
- * service should be re-invoked before giving up. Defaults to 3.
- * @param options.retryFilterPolicy - The policy used to control when the
- * service should be retried based on either the result of the servce or an
- * error that it throws. For instance, you could use this to retry only certain
- * errors. See `handleWhen` and friends from Cockatiel for more.
  * @param options.maxConsecutiveFailures - The maximum number of times that the
  * service is allowed to fail before pausing further retries. Defaults to 12.
  * @param options.circuitBreakDuration - The length of time (in milliseconds) to
@@ -52,6 +43,14 @@ export const DEFAULT_DEGRADED_THRESHOLD = 5000;
  * @param options.degradedThreshold - The length of time (in milliseconds) that
  * governs when the service is regarded as degraded (affecting when `onDegraded`
  * is called). Defaults to 5 seconds.
+ * @param options.onBreak - A function which is called when the service fails
+ * too many times in a row (specifically, more than `maxConsecutiveFailures`).
+ * @param options.onDegraded - A function which is called when the service
+ * succeeds before `maxConsecutiveFailures` is reached, but takes more time than
+ * the `degradedThreshold` to run.
+ * @param options.onRetry - A function which will be called the moment the
+ * policy kicks off a timer to re-run the function passed to the policy. This is
+ * primarily useful in tests where we are mocking timers.
  * @returns The service policy.
  * @example
  * This function is designed to be used in the context of a service class like
@@ -60,10 +59,6 @@ export const DEFAULT_DEGRADED_THRESHOLD = 5000;
  * class Service {
  *   constructor() {
  *     this.#policy = createServicePolicy({
- *       maxRetries: 3,
- *       retryFilterPolicy: handleWhen((error) => {
- *         return error.message.includes('oops');
- *       }),
  *       maxConsecutiveFailures: 3,
  *       circuitBreakDuration: 5000,
  *       degradedThreshold: 2000,
@@ -85,16 +80,21 @@ export const DEFAULT_DEGRADED_THRESHOLD = 5000;
  * }
  * ```
  */
-export function createServicePolicy({ maxRetries = DEFAULT_MAX_RETRIES, retryFilterPolicy = handleAll, maxConsecutiveFailures = DEFAULT_MAX_CONSECUTIVE_FAILURES, circuitBreakDuration = DEFAULT_CIRCUIT_BREAK_DURATION, degradedThreshold = DEFAULT_DEGRADED_THRESHOLD, } = {}) {
-    const retryPolicy = retry(retryFilterPolicy, {
+export function createServicePolicy({ maxConsecutiveFailures = DEFAULT_MAX_CONSECUTIVE_FAILURES, circuitBreakDuration = DEFAULT_CIRCUIT_BREAK_DURATION, degradedThreshold = DEFAULT_DEGRADED_THRESHOLD, onBreak = () => {
+    // do nothing
+}, onDegraded = () => {
+    // do nothing
+}, onRetry = () => {
+    // do nothing
+}, } = {}) {
+    const retryPolicy = retry(handleAll, {
         // Note that although the option here is called "max attempts", it's really
         // maximum number of *retries* (attempts past the initial attempt).
-        maxAttempts: maxRetries,
+        maxAttempts: DEFAULT_MAX_RETRIES,
         // Retries of the service will be executed following ever increasing delays,
         // determined by a backoff formula.
         backoff: new ExponentialBackoff(),
     });
-    const onRetry = retryPolicy.onRetry.bind(retryPolicy);
     const circuitBreakerPolicy = circuitBreaker(handleAll, {
         // While the circuit is open, any additional invocations of the service
         // passed to the policy (either via automatic retries or by manually
@@ -105,30 +105,37 @@ export function createServicePolicy({ maxRetries = DEFAULT_MAX_RETRIES, retryFil
         halfOpenAfter: circuitBreakDuration,
         breaker: new ConsecutiveBreaker(maxConsecutiveFailures),
     });
-    const onBreak = circuitBreakerPolicy.onBreak.bind(circuitBreakerPolicy);
-    const onDegradedEventEmitter = new CockatielEventEmitter();
+    // The `onBreak` callback will be called if the service consistently throws
+    // for as many times as exceeds the maximum consecutive number of failures.
+    // Combined with the retry policy, this can happen if:
+    // - `maxConsecutiveFailures` < the default max retries (3) and the policy is
+    // executed once
+    // - `maxConsecutiveFailures` >= the default max retries (3) but the policy is
+    //   executed multiple times, enough for the total number of retries to exceed
+    //   `maxConsecutiveFailures`
+    circuitBreakerPolicy.onBreak(onBreak);
+    // The `onRetryPolicy` callback will be called each time the service is
+    // invoked (including retries).
+    retryPolicy.onRetry(onRetry);
     retryPolicy.onGiveUp(() => {
         if (circuitBreakerPolicy.state === CircuitState.Closed) {
-            onDegradedEventEmitter.emit();
+            // The `onDegraded` callback will be called if the number of retries is
+            // exceeded and the maximum number of consecutive failures has not been
+            // reached yet (whether the policy is called once or multiple times).
+            onDegraded();
         }
     });
     retryPolicy.onSuccess(({ duration }) => {
         if (circuitBreakerPolicy.state === CircuitState.Closed &&
             duration > degradedThreshold) {
-            onDegradedEventEmitter.emit();
+            // The `onDegraded` callback will also be called if the service does not
+            // throw, but the time it takes for the service to run exceeds the
+            // `degradedThreshold`.
+            onDegraded();
         }
     });
-    const onDegraded = onDegradedEventEmitter.addListener;
-    // Every time the retry policy makes an attempt, it executes the circuit
-    // breaker policy, which executes the service.
-    const policy = wrap(retryPolicy, circuitBreakerPolicy);
-    return {
-        ...policy,
-        circuitBreakerPolicy,
-        retryPolicy,
-        onBreak,
-        onDegraded,
-        onRetry,
-    };
+    // The retry policy really retries the circuit breaker policy, which invokes
+    // the service.
+    return wrap(retryPolicy, circuitBreakerPolicy);
 }
 //# sourceMappingURL=create-service-policy.mjs.map

package/dist/create-service-policy.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"create-service-policy.mjs","sourceRoot":"","sources":["../src/create-service-policy.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,YAAY,EACZ,YAAY,IAAI,qBAAqB,EACrC,kBAAkB,EAClB,kBAAkB,EAClB,cAAc,EACd,SAAS,EACT,UAAU,EACV,KAAK,EACL,IAAI,EACL,kBAAkB;AASnB,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,SAAS,EAAE,UAAU,EAAE,CAAC;AAuEnE;;;GAGG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC;AAErC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,gCAAgC,GAAG,CAAC,CAAC,GAAG,mBAAmB,CAAC,GAAG,CAAC,CAAC;AAE9E;;;GAGG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;AAE7D;;;GAGG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,IAAK,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,MAAM,UAAU,mBAAmB,CAAC,EAClC,UAAU,GAAG,mBAAmB,EAChC,iBAAiB,GAAG,SAAS,EAC7B,sBAAsB,GAAG,gCAAgC,EACzD,oBAAoB,GAAG,8BAA8B,EACrD,iBAAiB,GAAG,0BAA0B,MAChB,EAAE;IAChC,MAAM,WAAW,GAAG,KAAK,CAAC,iBAAiB,EAAE;QAC3C,2EAA2E;QAC3E,mEAAmE;QACnE,WAAW,EAAE,UAAU;QACvB,4EAA4E;QAC5E,mCAAmC;QACnC,OAAO,EAAE,IAAI,kBAAkB,EAAE;KAClC,CAAC,CAAC;IACH,MAAM,OAAO,GAAG,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAEtD,MAAM,oBAAoB,GAAG,cAAc,CAAC,SAAS,EAAE;QACrD,uEAAuE;QACvE,oEAAoE;QACpE,wEAAwE;QACxE,4EAA4E;QAC5E,qEAAqE;QACrE,qDAAqD;QACrD,aAAa,EAAE,oBAAoB;QACnC,OAAO,EAAE,IAAI,kBAAkB,CAAC,sBAAsB,CAAC;KACxD,CAAC,CAAC;IACH,MAAM,OAAO,GAAG,oBAAoB,CAAC,OAAO,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;IAExE,MAAM,sBAAsB,GAAG,IAAI,qBAAqB,EAAQ,CAAC;IACjE,WAAW,CAAC,QAAQ,CAAC,GAAG,EAAE;QACxB,IAAI,oBAAoB,CAAC,KAAK,KAAK,YAAY,CAAC,MAAM,EAAE;YACtD,sBAAsB,CAAC,IAAI,EAAE,CAAC;SAC/B;IACH,CAAC,CAAC,CAAC;IACH,WAAW,CAAC,SAAS,CAAC,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE;QACrC,IACE,oBAAoB,CAAC,KAAK,KAAK,YAAY,CAAC,MAAM;YAClD,QAAQ,GAAG,iBAAiB,EAC5B;YACA,sBAAsB,CAAC,IAAI,EAAE,CAAC;SAC/B;IACH,CAAC,CAAC,CAAC;IACH,MAAM,UAAU,GAAG,sBAAsB,CAAC,WAAW,CAAC;IAEtD,wEAAwE;IACxE,8CAA8C;IAC9C,MAAM,MAAM,GAAG,IAAI,CAAC,WAAW,EAAE,oBAAoB,CAAC,CAAC;IAEvD,OAAO;QACL,GAAG,MAAM;QACT,oBAAoB;QACpB,WAAW;QACX,OAAO;QACP,UAAU;QACV,OAAO;KACR,CAAC;AACJ,CAAC","sourcesContent":["import {\n  BrokenCircuitError,\n  CircuitState,\n  EventEmitter as CockatielEventEmitter,\n  ConsecutiveBreaker,\n  ExponentialBackoff,\n  circuitBreaker,\n  handleAll,\n  handleWhen,\n  retry,\n  wrap,\n} from 'cockatiel';\nimport type {\n  CircuitBreakerPolicy,\n  Event as CockatielEvent,\n  IPolicy,\n  Policy,\n  RetryPolicy,\n} from 'cockatiel';\n\nexport { CircuitState, BrokenCircuitError, handleAll, handleWhen };\n\nexport type { CockatielEvent };\n\n/**\n * The options for `createServicePolicy`.\n */\nexport type CreateServicePolicyOptions = {\n  /**\n   * The length of time (in milliseconds) to pause retries of the action after\n   * the number of failures reaches `maxConsecutiveFailures`.\n   */\n  circuitBreakDuration?: number;\n  /**\n   * The length of time (in milliseconds) that governs when the service is\n   * regarded as degraded (affecting when `onDegraded` is called).\n   */\n  degradedThreshold?: number;\n  /**\n   * The maximum number of times that the service is allowed to fail before\n   * pausing further retries.\n   */\n  maxConsecutiveFailures?: number;\n  /**\n   * The maximum number of times that a failing service should be re-invoked\n   * before giving up.\n   */\n  maxRetries?: number;\n  /**\n   * The policy used to control when the service should be retried based on\n   * either the result of the service or an error that it throws. For instance,\n   * you could use this to retry only certain errors. See `handleWhen` and\n   * friends from Cockatiel for more.\n   */\n  retryFilterPolicy?: Policy;\n};\n\n/**\n * The service policy object.\n */\nexport type ServicePolicy = IPolicy & {\n  /**\n   * The Cockatiel circuit breaker policy that the service policy uses\n   * internally.\n   */\n  circuitBreakerPolicy: CircuitBreakerPolicy;\n  /**\n   * The Cockatiel retry policy that the service policy uses internally.\n   */\n  retryPolicy: RetryPolicy;\n  /**\n   * A function which is called when the number of times that the service fails\n   * in a row meets the set maximum number of consecutive failures.\n   */\n  onBreak: CircuitBreakerPolicy['onBreak'];\n  /**\n   * A function which is called in two circumstances: 1) when the service\n   * succeeds before the maximum number of consecutive failures is reached, but\n   * takes more time than the `degradedThreshold` to run, or 2) if the service\n   * never succeeds before the retry policy gives up and before the maximum\n   * number of consecutive failures has been reached.\n   */\n  onDegraded: CockatielEvent<void>;\n  /**\n   * A function which will be called by the retry policy each time the service\n   * fails and the policy kicks off a timer to re-run the service. This is\n   * primarily useful in tests where we are mocking timers.\n   */\n  onRetry: RetryPolicy['onRetry'];\n};\n\n/**\n * The maximum number of times that a failing service should be re-run before\n * giving up.\n */\nexport const DEFAULT_MAX_RETRIES = 3;\n\n/**\n * The maximum number of times that the service is allowed to fail before\n * pausing further retries. This is set to a value such that if given a\n * service that continually fails, the policy needs to be executed 3 times\n * before further retries are paused.\n */\nexport const DEFAULT_MAX_CONSECUTIVE_FAILURES = (1 + DEFAULT_MAX_RETRIES) * 3;\n\n/**\n * The default length of time (in milliseconds) to temporarily pause retries of\n * the service after enough consecutive failures.\n */\nexport const DEFAULT_CIRCUIT_BREAK_DURATION = 30 * 60 * 1000;\n\n/**\n * The default length of time (in milliseconds) that governs when the service is\n * regarded as degraded (affecting when `onDegraded` is called).\n */\nexport const DEFAULT_DEGRADED_THRESHOLD = 5_000;\n\n/**\n * Constructs an object exposing an `execute` method which, given a function —\n * hereafter called the \"service\" — will retry that service with ever increasing\n * delays until it succeeds. If the policy detects too many consecutive\n * failures, it will block further retries until a designated time period has\n * passed; this particular behavior is primarily designed for services that wrap\n * API calls so as not to make needless HTTP requests when the API is down and\n * to be able to recover when the API comes back up. In addition, hooks allow\n * for responding to certain events, one of which can be used to detect when an\n * HTTP request is performing slowly.\n *\n * Internally, this function makes use of the retry and circuit breaker policies\n * from the [Cockatiel](https://www.npmjs.com/package/cockatiel) library; see\n * there for more.\n *\n * @param options - The options to this function.\n * @param options.maxRetries - The maximum number of times that a failing\n * service should be re-invoked before giving up. Defaults to 3.\n * @param options.retryFilterPolicy - The policy used to control when the\n * service should be retried based on either the result of the servce or an\n * error that it throws. For instance, you could use this to retry only certain\n * errors. See `handleWhen` and friends from Cockatiel for more.\n * @param options.maxConsecutiveFailures - The maximum number of times that the\n * service is allowed to fail before pausing further retries. Defaults to 12.\n * @param options.circuitBreakDuration - The length of time (in milliseconds) to\n * pause retries of the action after the number of failures reaches\n * `maxConsecutiveFailures`.\n * @param options.degradedThreshold - The length of time (in milliseconds) that\n * governs when the service is regarded as degraded (affecting when `onDegraded`\n * is called). Defaults to 5 seconds.\n * @returns The service policy.\n * @example\n * This function is designed to be used in the context of a service class like\n * this:\n * ``` ts\n * class Service {\n *   constructor() {\n *     this.#policy = createServicePolicy({\n *       maxRetries: 3,\n *       retryFilterPolicy: handleWhen((error) => {\n *         return error.message.includes('oops');\n *       }),\n *       maxConsecutiveFailures: 3,\n *       circuitBreakDuration: 5000,\n *       degradedThreshold: 2000,\n *       onBreak: () => {\n *         console.log('Circuit broke');\n *       },\n *       onDegraded: () => {\n *         console.log('Service is degraded');\n *       },\n *     });\n *   }\n *\n *   async fetch() {\n *     return await this.#policy.execute(async () => {\n *       const response = await fetch('https://some/url');\n *       return await response.json();\n *     });\n *   }\n * }\n * ```\n */\nexport function createServicePolicy({\n  maxRetries = DEFAULT_MAX_RETRIES,\n  retryFilterPolicy = handleAll,\n  maxConsecutiveFailures = DEFAULT_MAX_CONSECUTIVE_FAILURES,\n  circuitBreakDuration = DEFAULT_CIRCUIT_BREAK_DURATION,\n  degradedThreshold = DEFAULT_DEGRADED_THRESHOLD,\n}: CreateServicePolicyOptions = {}): ServicePolicy {\n  const retryPolicy = retry(retryFilterPolicy, {\n    // Note that although the option here is called \"max attempts\", it's really\n    // maximum number of *retries* (attempts past the initial attempt).\n    maxAttempts: maxRetries,\n    // Retries of the service will be executed following ever increasing delays,\n    // determined by a backoff formula.\n    backoff: new ExponentialBackoff(),\n  });\n  const onRetry = retryPolicy.onRetry.bind(retryPolicy);\n\n  const circuitBreakerPolicy = circuitBreaker(handleAll, {\n    // While the circuit is open, any additional invocations of the service\n    // passed to the policy (either via automatic retries or by manually\n    // executing the policy again) will result in a BrokenCircuitError. This\n    // will remain the case until `circuitBreakDuration` passes, after which the\n    // service will be allowed to run again. If the service succeeds, the\n    // circuit will close, otherwise it will remain open.\n    halfOpenAfter: circuitBreakDuration,\n    breaker: new ConsecutiveBreaker(maxConsecutiveFailures),\n  });\n  const onBreak = circuitBreakerPolicy.onBreak.bind(circuitBreakerPolicy);\n\n  const onDegradedEventEmitter = new CockatielEventEmitter<void>();\n  retryPolicy.onGiveUp(() => {\n    if (circuitBreakerPolicy.state === CircuitState.Closed) {\n      onDegradedEventEmitter.emit();\n    }\n  });\n  retryPolicy.onSuccess(({ duration }) => {\n    if (\n      circuitBreakerPolicy.state === CircuitState.Closed &&\n      duration > degradedThreshold\n    ) {\n      onDegradedEventEmitter.emit();\n    }\n  });\n  const onDegraded = onDegradedEventEmitter.addListener;\n\n  // Every time the retry policy makes an attempt, it executes the circuit\n  // breaker policy, which executes the service.\n  const policy = wrap(retryPolicy, circuitBreakerPolicy);\n\n  return {\n    ...policy,\n    circuitBreakerPolicy,\n    retryPolicy,\n    onBreak,\n    onDegraded,\n    onRetry,\n  };\n}\n"]}
+{"version":3,"file":"create-service-policy.mjs","sourceRoot":"","sources":["../src/create-service-policy.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,kBAAkB,EAClB,kBAAkB,EAClB,SAAS,EACT,KAAK,EACL,IAAI,EACJ,YAAY,EACb,kBAAkB;AAKnB;;;GAGG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC;AAErC;;;GAGG;AACH,MAAM,CAAC,MAAM,gCAAgC,GAAG,CAAC,CAAC,GAAG,mBAAmB,CAAC,GAAG,CAAC,CAAC;AAE9E;;;GAGG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;AAE7D;;;GAGG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,IAAK,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,MAAM,UAAU,mBAAmB,CAAC,EAClC,sBAAsB,GAAG,gCAAgC,EACzD,oBAAoB,GAAG,8BAA8B,EACrD,iBAAiB,GAAG,0BAA0B,EAC9C,OAAO,GAAG,GAAG,EAAE;IACb,aAAa;AACf,CAAC,EACD,UAAU,GAAG,GAAG,EAAE;IAChB,aAAa;AACf,CAAC,EACD,OAAO,GAAG,GAAG,EAAE;IACb,aAAa;AACf,CAAC,MAQC,EAAE;IACJ,MAAM,WAAW,GAAG,KAAK,CAAC,SAAS,EAAE;QACnC,2EAA2E;QAC3E,mEAAmE;QACnE,WAAW,EAAE,mBAAmB;QAChC,4EAA4E;QAC5E,mCAAmC;QACnC,OAAO,EAAE,IAAI,kBAAkB,EAAE;KAClC,CAAC,CAAC;IAEH,MAAM,oBAAoB,GAAG,cAAc,CAAC,SAAS,EAAE;QACrD,uEAAuE;QACvE,oEAAoE;QACpE,wEAAwE;QACxE,4EAA4E;QAC5E,qEAAqE;QACrE,qDAAqD;QACrD,aAAa,EAAE,oBAAoB;QACnC,OAAO,EAAE,IAAI,kBAAkB,CAAC,sBAAsB,CAAC;KACxD,CAAC,CAAC;IAEH,2EAA2E;IAC3E,2EAA2E;IAC3E,sDAAsD;IACtD,6EAA6E;IAC7E,gBAAgB;IAChB,8EAA8E;IAC9E,8EAA8E;IAC9E,6BAA6B;IAC7B,oBAAoB,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IAEtC,uEAAuE;IACvE,+BAA+B;IAC/B,WAAW,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IAE7B,WAAW,CAAC,QAAQ,CAAC,GAAG,EAAE;QACxB,IAAI,oBAAoB,CAAC,KAAK,KAAK,YAAY,CAAC,MAAM,EAAE;YACtD,uEAAuE;YACvE,uEAAuE;YACvE,qEAAqE;YACrE,UAAU,EAAE,CAAC;SACd;IACH,CAAC,CAAC,CAAC;IACH,WAAW,CAAC,SAAS,CAAC,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE;QACrC,IACE,oBAAoB,CAAC,KAAK,KAAK,YAAY,CAAC,MAAM;YAClD,QAAQ,GAAG,iBAAiB,EAC5B;YACA,wEAAwE;YACxE,kEAAkE;YAClE,uBAAuB;YACvB,UAAU,EAAE,CAAC;SACd;IACH,CAAC,CAAC,CAAC;IAEH,4EAA4E;IAC5E,eAAe;IACf,OAAO,IAAI,CAAC,WAAW,EAAE,oBAAoB,CAAC,CAAC;AACjD,CAAC","sourcesContent":["import {\n  circuitBreaker,\n  ConsecutiveBreaker,\n  ExponentialBackoff,\n  handleAll,\n  retry,\n  wrap,\n  CircuitState,\n} from 'cockatiel';\nimport type { IPolicy } from 'cockatiel';\n\nexport type { IPolicy as IServicePolicy };\n\n/**\n * The maximum number of times that a failing service should be re-run before\n * giving up.\n */\nexport const DEFAULT_MAX_RETRIES = 3;\n\n/**\n * The maximum number of times that the service is allowed to fail before\n * pausing further retries.\n */\nexport const DEFAULT_MAX_CONSECUTIVE_FAILURES = (1 + DEFAULT_MAX_RETRIES) * 3;\n\n/**\n * The default length of time (in milliseconds) to temporarily pause retries of\n * the service after enough consecutive failures.\n */\nexport const DEFAULT_CIRCUIT_BREAK_DURATION = 30 * 60 * 1000;\n\n/**\n * The default length of time (in milliseconds) that governs when the service is\n * regarded as degraded (affecting when `onDegraded` is called).\n */\nexport const DEFAULT_DEGRADED_THRESHOLD = 5_000;\n\n/**\n * Constructs an object exposing an `execute` method which, given a function —\n * hereafter called the \"service\" — will retry that service with ever increasing\n * delays until it succeeds. If the policy detects too many consecutive\n * failures, it will block further retries until a designated time period has\n * passed; this particular behavior is primarily designed for services that wrap\n * API calls so as not to make needless HTTP requests when the API is down and\n * to be able to recover when the API comes back up. In addition, hooks allow\n * for responding to certain events, one of which can be used to detect when an\n * HTTP request is performing slowly.\n *\n * Internally, this function makes use of the retry and circuit breaker policies\n * from the [Cockatiel](https://www.npmjs.com/package/cockatiel) library; see\n * there for more.\n *\n * @param options - The options to this function.\n * @param options.maxConsecutiveFailures - The maximum number of times that the\n * service is allowed to fail before pausing further retries. Defaults to 12.\n * @param options.circuitBreakDuration - The length of time (in milliseconds) to\n * pause retries of the action after the number of failures reaches\n * `maxConsecutiveFailures`.\n * @param options.degradedThreshold - The length of time (in milliseconds) that\n * governs when the service is regarded as degraded (affecting when `onDegraded`\n * is called). Defaults to 5 seconds.\n * @param options.onBreak - A function which is called when the service fails\n * too many times in a row (specifically, more than `maxConsecutiveFailures`).\n * @param options.onDegraded - A function which is called when the service\n * succeeds before `maxConsecutiveFailures` is reached, but takes more time than\n * the `degradedThreshold` to run.\n * @param options.onRetry - A function which will be called the moment the\n * policy kicks off a timer to re-run the function passed to the policy. This is\n * primarily useful in tests where we are mocking timers.\n * @returns The service policy.\n * @example\n * This function is designed to be used in the context of a service class like\n * this:\n * ``` ts\n * class Service {\n *   constructor() {\n *     this.#policy = createServicePolicy({\n *       maxConsecutiveFailures: 3,\n *       circuitBreakDuration: 5000,\n *       degradedThreshold: 2000,\n *       onBreak: () => {\n *         console.log('Circuit broke');\n *       },\n *       onDegraded: () => {\n *         console.log('Service is degraded');\n *       },\n *     });\n *   }\n *\n *   async fetch() {\n *     return await this.#policy.execute(async () => {\n *       const response = await fetch('https://some/url');\n *       return await response.json();\n *     });\n *   }\n * }\n * ```\n */\nexport function createServicePolicy({\n  maxConsecutiveFailures = DEFAULT_MAX_CONSECUTIVE_FAILURES,\n  circuitBreakDuration = DEFAULT_CIRCUIT_BREAK_DURATION,\n  degradedThreshold = DEFAULT_DEGRADED_THRESHOLD,\n  onBreak = () => {\n    // do nothing\n  },\n  onDegraded = () => {\n    // do nothing\n  },\n  onRetry = () => {\n    // do nothing\n  },\n}: {\n  maxConsecutiveFailures?: number;\n  circuitBreakDuration?: number;\n  degradedThreshold?: number;\n  onBreak?: () => void;\n  onDegraded?: () => void;\n  onRetry?: () => void;\n} = {}): IPolicy {\n  const retryPolicy = retry(handleAll, {\n    // Note that although the option here is called \"max attempts\", it's really\n    // maximum number of *retries* (attempts past the initial attempt).\n    maxAttempts: DEFAULT_MAX_RETRIES,\n    // Retries of the service will be executed following ever increasing delays,\n    // determined by a backoff formula.\n    backoff: new ExponentialBackoff(),\n  });\n\n  const circuitBreakerPolicy = circuitBreaker(handleAll, {\n    // While the circuit is open, any additional invocations of the service\n    // passed to the policy (either via automatic retries or by manually\n    // executing the policy again) will result in a BrokenCircuitError. This\n    // will remain the case until `circuitBreakDuration` passes, after which the\n    // service will be allowed to run again. If the service succeeds, the\n    // circuit will close, otherwise it will remain open.\n    halfOpenAfter: circuitBreakDuration,\n    breaker: new ConsecutiveBreaker(maxConsecutiveFailures),\n  });\n\n  // The `onBreak` callback will be called if the service consistently throws\n  // for as many times as exceeds the maximum consecutive number of failures.\n  // Combined with the retry policy, this can happen if:\n  // - `maxConsecutiveFailures` < the default max retries (3) and the policy is\n  // executed once\n  // - `maxConsecutiveFailures` >= the default max retries (3) but the policy is\n  //   executed multiple times, enough for the total number of retries to exceed\n  //   `maxConsecutiveFailures`\n  circuitBreakerPolicy.onBreak(onBreak);\n\n  // The `onRetryPolicy` callback will be called each time the service is\n  // invoked (including retries).\n  retryPolicy.onRetry(onRetry);\n\n  retryPolicy.onGiveUp(() => {\n    if (circuitBreakerPolicy.state === CircuitState.Closed) {\n      // The `onDegraded` callback will be called if the number of retries is\n      // exceeded and the maximum number of consecutive failures has not been\n      // reached yet (whether the policy is called once or multiple times).\n      onDegraded();\n    }\n  });\n  retryPolicy.onSuccess(({ duration }) => {\n    if (\n      circuitBreakerPolicy.state === CircuitState.Closed &&\n      duration > degradedThreshold\n    ) {\n      // The `onDegraded` callback will also be called if the service does not\n      // throw, but the time it takes for the service to run exceeds the\n      // `degradedThreshold`.\n      onDegraded();\n    }\n  });\n\n  // The retry policy really retries the circuit breaker policy, which invokes\n  // the service.\n  return wrap(retryPolicy, circuitBreakerPolicy);\n}\n"]}

package/dist/index.cjs

@@ -14,17 +14,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isEqualCaseInsensitive = exports.weiHexToGweiDec = exports.toHex = exports.toChecksumHexAddress = exports.timeoutFetch = exports.successfulFetch = exports.safelyExecuteWithTimeout = exports.safelyExecute = exports.query = exports.normalizeEnsName = exports.isValidHexAddress = exports.isValidJson = exports.isSmartContractCode = exports.isSafeDynamicKey = exports.isSafeChainId = exports.isPlainObject = exports.isNonEmptyArray = exports.hexToText = exports.hexToBN = exports.handleFetch = exports.gweiDecToWEIBN = exports.getBuyURL = exports.fromHex = exports.fractionBN = exports.fetchWithErrorHandling = exports.convertHexToDecimal = exports.BNToHex = exports.handleWhen = exports.handleAll = exports.createServicePolicy = exports.DEFAULT_MAX_RETRIES = exports.DEFAULT_MAX_CONSECUTIVE_FAILURES = exports.DEFAULT_DEGRADED_THRESHOLD = exports.DEFAULT_CIRCUIT_BREAK_DURATION = exports.CircuitState = exports.BrokenCircuitError = void 0;
+exports.isEqualCaseInsensitive = exports.weiHexToGweiDec = exports.toHex = exports.toChecksumHexAddress = exports.timeoutFetch = exports.successfulFetch = exports.safelyExecuteWithTimeout = exports.safelyExecute = exports.query = exports.normalizeEnsName = exports.isValidHexAddress = exports.isValidJson = exports.isSmartContractCode = exports.isSafeDynamicKey = exports.isSafeChainId = exports.isPlainObject = exports.isNonEmptyArray = exports.hexToText = exports.hexToBN = exports.handleFetch = exports.gweiDecToWEIBN = exports.getBuyURL = exports.fromHex = exports.fractionBN = exports.fetchWithErrorHandling = exports.convertHexToDecimal = exports.BNToHex = exports.createServicePolicy = void 0;
 var create_service_policy_1 = require("./create-service-policy.cjs");
-Object.defineProperty(exports, "BrokenCircuitError", { enumerable: true, get: function () { return create_service_policy_1.BrokenCircuitError; } });
-Object.defineProperty(exports, "CircuitState", { enumerable: true, get: function () { return create_service_policy_1.CircuitState; } });
-Object.defineProperty(exports, "DEFAULT_CIRCUIT_BREAK_DURATION", { enumerable: true, get: function () { return create_service_policy_1.DEFAULT_CIRCUIT_BREAK_DURATION; } });
-Object.defineProperty(exports, "DEFAULT_DEGRADED_THRESHOLD", { enumerable: true, get: function () { return create_service_policy_1.DEFAULT_DEGRADED_THRESHOLD; } });
-Object.defineProperty(exports, "DEFAULT_MAX_CONSECUTIVE_FAILURES", { enumerable: true, get: function () { return create_service_policy_1.DEFAULT_MAX_CONSECUTIVE_FAILURES; } });
-Object.defineProperty(exports, "DEFAULT_MAX_RETRIES", { enumerable: true, get: function () { return create_service_policy_1.DEFAULT_MAX_RETRIES; } });
 Object.defineProperty(exports, "createServicePolicy", { enumerable: true, get: function () { return create_service_policy_1.createServicePolicy; } });
-Object.defineProperty(exports, "handleAll", { enumerable: true, get: function () { return create_service_policy_1.handleAll; } });
-Object.defineProperty(exports, "handleWhen", { enumerable: true, get: function () { return create_service_policy_1.handleWhen; } });
 __exportStar(require("./constants.cjs"), exports);
 var util_1 = require("./util.cjs");
 Object.defineProperty(exports, "BNToHex", { enumerable: true, get: function () { return util_1.BNToHex; } });

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,qEAUiC;AAT/B,2HAAA,kBAAkB,OAAA;AAClB,qHAAA,YAAY,OAAA;AACZ,uIAAA,8BAA8B,OAAA;AAC9B,mIAAA,0BAA0B,OAAA;AAC1B,yIAAA,gCAAgC,OAAA;AAChC,4HAAA,mBAAmB,OAAA;AACnB,4HAAA,mBAAmB,OAAA;AACnB,kHAAA,SAAS,OAAA;AACT,mHAAA,UAAU,OAAA;AAOZ,kDAA4B;AAE5B,mCA4BgB;AA3Bd,+FAAA,OAAO,OAAA;AACP,2GAAA,mBAAmB,OAAA;AACnB,8GAAA,sBAAsB,OAAA;AACtB,kGAAA,UAAU,OAAA;AACV,+FAAA,OAAO,OAAA;AACP,iGAAA,SAAS,OAAA;AACT,sGAAA,cAAc,OAAA;AACd,mGAAA,WAAW,OAAA;AACX,+FAAA,OAAO,OAAA;AACP,iGAAA,SAAS,OAAA;AACT,uGAAA,eAAe,OAAA;AACf,qGAAA,aAAa,OAAA;AACb,qGAAA,aAAa,OAAA;AACb,wGAAA,gBAAgB,OAAA;AAChB,2GAAA,mBAAmB,OAAA;AACnB,mGAAA,WAAW,OAAA;AACX,yGAAA,iBAAiB,OAAA;AACjB,wGAAA,gBAAgB,OAAA;AAChB,6FAAA,KAAK,OAAA;AACL,qGAAA,aAAa,OAAA;AACb,gHAAA,wBAAwB,OAAA;AACxB,uGAAA,eAAe,OAAA;AACf,oGAAA,YAAY,OAAA;AACZ,4GAAA,oBAAoB,OAAA;AACpB,6FAAA,KAAK,OAAA;AACL,uGAAA,eAAe,OAAA;AACf,8GAAA,sBAAsB,OAAA;AAExB,8CAAwB;AACxB,6CAAuB","sourcesContent":["export {\n  BrokenCircuitError,\n  CircuitState,\n  DEFAULT_CIRCUIT_BREAK_DURATION,\n  DEFAULT_DEGRADED_THRESHOLD,\n  DEFAULT_MAX_CONSECUTIVE_FAILURES,\n  DEFAULT_MAX_RETRIES,\n  createServicePolicy,\n  handleAll,\n  handleWhen,\n} from './create-service-policy';\nexport type {\n  CockatielEvent,\n  CreateServicePolicyOptions,\n  ServicePolicy,\n} from './create-service-policy';\nexport * from './constants';\nexport type { NonEmptyArray } from './util';\nexport {\n  BNToHex,\n  convertHexToDecimal,\n  fetchWithErrorHandling,\n  fractionBN,\n  fromHex,\n  getBuyURL,\n  gweiDecToWEIBN,\n  handleFetch,\n  hexToBN,\n  hexToText,\n  isNonEmptyArray,\n  isPlainObject,\n  isSafeChainId,\n  isSafeDynamicKey,\n  isSmartContractCode,\n  isValidJson,\n  isValidHexAddress,\n  normalizeEnsName,\n  query,\n  safelyExecute,\n  safelyExecuteWithTimeout,\n  successfulFetch,\n  timeoutFetch,\n  toChecksumHexAddress,\n  toHex,\n  weiHexToGweiDec,\n  isEqualCaseInsensitive,\n} from './util';\nexport * from './types';\nexport * from './siwe';\n"]}
+{"version":3,"file":"index.cjs","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,qEAA8D;AAArD,4HAAA,mBAAmB,OAAA;AAC5B,kDAA4B;AAE5B,mCA4BgB;AA3Bd,+FAAA,OAAO,OAAA;AACP,2GAAA,mBAAmB,OAAA;AACnB,8GAAA,sBAAsB,OAAA;AACtB,kGAAA,UAAU,OAAA;AACV,+FAAA,OAAO,OAAA;AACP,iGAAA,SAAS,OAAA;AACT,sGAAA,cAAc,OAAA;AACd,mGAAA,WAAW,OAAA;AACX,+FAAA,OAAO,OAAA;AACP,iGAAA,SAAS,OAAA;AACT,uGAAA,eAAe,OAAA;AACf,qGAAA,aAAa,OAAA;AACb,qGAAA,aAAa,OAAA;AACb,wGAAA,gBAAgB,OAAA;AAChB,2GAAA,mBAAmB,OAAA;AACnB,mGAAA,WAAW,OAAA;AACX,yGAAA,iBAAiB,OAAA;AACjB,wGAAA,gBAAgB,OAAA;AAChB,6FAAA,KAAK,OAAA;AACL,qGAAA,aAAa,OAAA;AACb,gHAAA,wBAAwB,OAAA;AACxB,uGAAA,eAAe,OAAA;AACf,oGAAA,YAAY,OAAA;AACZ,4GAAA,oBAAoB,OAAA;AACpB,6FAAA,KAAK,OAAA;AACL,uGAAA,eAAe,OAAA;AACf,8GAAA,sBAAsB,OAAA;AAExB,8CAAwB;AACxB,6CAAuB","sourcesContent":["export { createServicePolicy } from './create-service-policy';\nexport * from './constants';\nexport type { NonEmptyArray } from './util';\nexport {\n  BNToHex,\n  convertHexToDecimal,\n  fetchWithErrorHandling,\n  fractionBN,\n  fromHex,\n  getBuyURL,\n  gweiDecToWEIBN,\n  handleFetch,\n  hexToBN,\n  hexToText,\n  isNonEmptyArray,\n  isPlainObject,\n  isSafeChainId,\n  isSafeDynamicKey,\n  isSmartContractCode,\n  isValidJson,\n  isValidHexAddress,\n  normalizeEnsName,\n  query,\n  safelyExecute,\n  safelyExecuteWithTimeout,\n  successfulFetch,\n  timeoutFetch,\n  toChecksumHexAddress,\n  toHex,\n  weiHexToGweiDec,\n  isEqualCaseInsensitive,\n} from './util';\nexport * from './types';\nexport * from './siwe';\n"]}

package/dist/index.d.cts

@@ -1,5 +1,4 @@
-export { BrokenCircuitError, CircuitState, DEFAULT_CIRCUIT_BREAK_DURATION, DEFAULT_DEGRADED_THRESHOLD, DEFAULT_MAX_CONSECUTIVE_FAILURES, DEFAULT_MAX_RETRIES, createServicePolicy, handleAll, handleWhen, } from "./create-service-policy.cjs";
-export type { CockatielEvent, CreateServicePolicyOptions, ServicePolicy, } from "./create-service-policy.cjs";
+export { createServicePolicy } from "./create-service-policy.cjs";
 export * from "./constants.cjs";
 export type { NonEmptyArray } from "./util.cjs";
 export { BNToHex, convertHexToDecimal, fetchWithErrorHandling, fractionBN, fromHex, getBuyURL, gweiDecToWEIBN, handleFetch, hexToBN, hexToText, isNonEmptyArray, isPlainObject, isSafeChainId, isSafeDynamicKey, isSmartContractCode, isValidJson, isValidHexAddress, normalizeEnsName, query, safelyExecute, safelyExecuteWithTimeout, successfulFetch, timeoutFetch, toChecksumHexAddress, toHex, weiHexToGweiDec, isEqualCaseInsensitive, } from "./util.cjs";

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,YAAY,EACZ,8BAA8B,EAC9B,0BAA0B,EAC1B,gCAAgC,EAChC,mBAAmB,EACnB,mBAAmB,EACnB,SAAS,EACT,UAAU,GACX,oCAAgC;AACjC,YAAY,EACV,cAAc,EACd,0BAA0B,EAC1B,aAAa,GACd,oCAAgC;AACjC,gCAA4B;AAC5B,YAAY,EAAE,aAAa,EAAE,mBAAe;AAC5C,OAAO,EACL,OAAO,EACP,mBAAmB,EACnB,sBAAsB,EACtB,UAAU,EACV,OAAO,EACP,SAAS,EACT,cAAc,EACd,WAAW,EACX,OAAO,EACP,SAAS,EACT,eAAe,EACf,aAAa,EACb,aAAa,EACb,gBAAgB,EAChB,mBAAmB,EACnB,WAAW,EACX,iBAAiB,EACjB,gBAAgB,EAChB,KAAK,EACL,aAAa,EACb,wBAAwB,EACxB,eAAe,EACf,YAAY,EACZ,oBAAoB,EACpB,KAAK,EACL,eAAe,EACf,sBAAsB,GACvB,mBAAe;AAChB,4BAAwB;AACxB,2BAAuB"}
+{"version":3,"file":"index.d.cts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,oCAAgC;AAC9D,gCAA4B;AAC5B,YAAY,EAAE,aAAa,EAAE,mBAAe;AAC5C,OAAO,EACL,OAAO,EACP,mBAAmB,EACnB,sBAAsB,EACtB,UAAU,EACV,OAAO,EACP,SAAS,EACT,cAAc,EACd,WAAW,EACX,OAAO,EACP,SAAS,EACT,eAAe,EACf,aAAa,EACb,aAAa,EACb,gBAAgB,EAChB,mBAAmB,EACnB,WAAW,EACX,iBAAiB,EACjB,gBAAgB,EAChB,KAAK,EACL,aAAa,EACb,wBAAwB,EACxB,eAAe,EACf,YAAY,EACZ,oBAAoB,EACpB,KAAK,EACL,eAAe,EACf,sBAAsB,GACvB,mBAAe;AAChB,4BAAwB;AACxB,2BAAuB"}

package/dist/index.d.mts

@@ -1,5 +1,4 @@
-export { BrokenCircuitError, CircuitState, DEFAULT_CIRCUIT_BREAK_DURATION, DEFAULT_DEGRADED_THRESHOLD, DEFAULT_MAX_CONSECUTIVE_FAILURES, DEFAULT_MAX_RETRIES, createServicePolicy, handleAll, handleWhen, } from "./create-service-policy.mjs";
-export type { CockatielEvent, CreateServicePolicyOptions, ServicePolicy, } from "./create-service-policy.mjs";
+export { createServicePolicy } from "./create-service-policy.mjs";
 export * from "./constants.mjs";
 export type { NonEmptyArray } from "./util.mjs";
 export { BNToHex, convertHexToDecimal, fetchWithErrorHandling, fractionBN, fromHex, getBuyURL, gweiDecToWEIBN, handleFetch, hexToBN, hexToText, isNonEmptyArray, isPlainObject, isSafeChainId, isSafeDynamicKey, isSmartContractCode, isValidJson, isValidHexAddress, normalizeEnsName, query, safelyExecute, safelyExecuteWithTimeout, successfulFetch, timeoutFetch, toChecksumHexAddress, toHex, weiHexToGweiDec, isEqualCaseInsensitive, } from "./util.mjs";

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,YAAY,EACZ,8BAA8B,EAC9B,0BAA0B,EAC1B,gCAAgC,EAChC,mBAAmB,EACnB,mBAAmB,EACnB,SAAS,EACT,UAAU,GACX,oCAAgC;AACjC,YAAY,EACV,cAAc,EACd,0BAA0B,EAC1B,aAAa,GACd,oCAAgC;AACjC,gCAA4B;AAC5B,YAAY,EAAE,aAAa,EAAE,mBAAe;AAC5C,OAAO,EACL,OAAO,EACP,mBAAmB,EACnB,sBAAsB,EACtB,UAAU,EACV,OAAO,EACP,SAAS,EACT,cAAc,EACd,WAAW,EACX,OAAO,EACP,SAAS,EACT,eAAe,EACf,aAAa,EACb,aAAa,EACb,gBAAgB,EAChB,mBAAmB,EACnB,WAAW,EACX,iBAAiB,EACjB,gBAAgB,EAChB,KAAK,EACL,aAAa,EACb,wBAAwB,EACxB,eAAe,EACf,YAAY,EACZ,oBAAoB,EACpB,KAAK,EACL,eAAe,EACf,sBAAsB,GACvB,mBAAe;AAChB,4BAAwB;AACxB,2BAAuB"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,oCAAgC;AAC9D,gCAA4B;AAC5B,YAAY,EAAE,aAAa,EAAE,mBAAe;AAC5C,OAAO,EACL,OAAO,EACP,mBAAmB,EACnB,sBAAsB,EACtB,UAAU,EACV,OAAO,EACP,SAAS,EACT,cAAc,EACd,WAAW,EACX,OAAO,EACP,SAAS,EACT,eAAe,EACf,aAAa,EACb,aAAa,EACb,gBAAgB,EAChB,mBAAmB,EACnB,WAAW,EACX,iBAAiB,EACjB,gBAAgB,EAChB,KAAK,EACL,aAAa,EACb,wBAAwB,EACxB,eAAe,EACf,YAAY,EACZ,oBAAoB,EACpB,KAAK,EACL,eAAe,EACf,sBAAsB,GACvB,mBAAe;AAChB,4BAAwB;AACxB,2BAAuB"}

package/dist/index.mjs

@@ -1,4 +1,4 @@
-export { BrokenCircuitError, CircuitState, DEFAULT_CIRCUIT_BREAK_DURATION, DEFAULT_DEGRADED_THRESHOLD, DEFAULT_MAX_CONSECUTIVE_FAILURES, DEFAULT_MAX_RETRIES, createServicePolicy, handleAll, handleWhen } from "./create-service-policy.mjs";
+export { createServicePolicy } from "./create-service-policy.mjs";
 export * from "./constants.mjs";
 export { BNToHex, convertHexToDecimal, fetchWithErrorHandling, fractionBN, fromHex, getBuyURL, gweiDecToWEIBN, handleFetch, hexToBN, hexToText, isNonEmptyArray, isPlainObject, isSafeChainId, isSafeDynamicKey, isSmartContractCode, isValidJson, isValidHexAddress, normalizeEnsName, query, safelyExecute, safelyExecuteWithTimeout, successfulFetch, timeoutFetch, toChecksumHexAddress, toHex, weiHexToGweiDec, isEqualCaseInsensitive } from "./util.mjs";
 export * from "./types.mjs";

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,YAAY,EACZ,8BAA8B,EAC9B,0BAA0B,EAC1B,gCAAgC,EAChC,mBAAmB,EACnB,mBAAmB,EACnB,SAAS,EACT,UAAU,EACX,oCAAgC;AAMjC,gCAA4B;AAE5B,OAAO,EACL,OAAO,EACP,mBAAmB,EACnB,sBAAsB,EACtB,UAAU,EACV,OAAO,EACP,SAAS,EACT,cAAc,EACd,WAAW,EACX,OAAO,EACP,SAAS,EACT,eAAe,EACf,aAAa,EACb,aAAa,EACb,gBAAgB,EAChB,mBAAmB,EACnB,WAAW,EACX,iBAAiB,EACjB,gBAAgB,EAChB,KAAK,EACL,aAAa,EACb,wBAAwB,EACxB,eAAe,EACf,YAAY,EACZ,oBAAoB,EACpB,KAAK,EACL,eAAe,EACf,sBAAsB,EACvB,mBAAe;AAChB,4BAAwB;AACxB,2BAAuB","sourcesContent":["export {\n  BrokenCircuitError,\n  CircuitState,\n  DEFAULT_CIRCUIT_BREAK_DURATION,\n  DEFAULT_DEGRADED_THRESHOLD,\n  DEFAULT_MAX_CONSECUTIVE_FAILURES,\n  DEFAULT_MAX_RETRIES,\n  createServicePolicy,\n  handleAll,\n  handleWhen,\n} from './create-service-policy';\nexport type {\n  CockatielEvent,\n  CreateServicePolicyOptions,\n  ServicePolicy,\n} from './create-service-policy';\nexport * from './constants';\nexport type { NonEmptyArray } from './util';\nexport {\n  BNToHex,\n  convertHexToDecimal,\n  fetchWithErrorHandling,\n  fractionBN,\n  fromHex,\n  getBuyURL,\n  gweiDecToWEIBN,\n  handleFetch,\n  hexToBN,\n  hexToText,\n  isNonEmptyArray,\n  isPlainObject,\n  isSafeChainId,\n  isSafeDynamicKey,\n  isSmartContractCode,\n  isValidJson,\n  isValidHexAddress,\n  normalizeEnsName,\n  query,\n  safelyExecute,\n  safelyExecuteWithTimeout,\n  successfulFetch,\n  timeoutFetch,\n  toChecksumHexAddress,\n  toHex,\n  weiHexToGweiDec,\n  isEqualCaseInsensitive,\n} from './util';\nexport * from './types';\nexport * from './siwe';\n"]}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,oCAAgC;AAC9D,gCAA4B;AAE5B,OAAO,EACL,OAAO,EACP,mBAAmB,EACnB,sBAAsB,EACtB,UAAU,EACV,OAAO,EACP,SAAS,EACT,cAAc,EACd,WAAW,EACX,OAAO,EACP,SAAS,EACT,eAAe,EACf,aAAa,EACb,aAAa,EACb,gBAAgB,EAChB,mBAAmB,EACnB,WAAW,EACX,iBAAiB,EACjB,gBAAgB,EAChB,KAAK,EACL,aAAa,EACb,wBAAwB,EACxB,eAAe,EACf,YAAY,EACZ,oBAAoB,EACpB,KAAK,EACL,eAAe,EACf,sBAAsB,EACvB,mBAAe;AAChB,4BAAwB;AACxB,2BAAuB","sourcesContent":["export { createServicePolicy } from './create-service-policy';\nexport * from './constants';\nexport type { NonEmptyArray } from './util';\nexport {\n  BNToHex,\n  convertHexToDecimal,\n  fetchWithErrorHandling,\n  fractionBN,\n  fromHex,\n  getBuyURL,\n  gweiDecToWEIBN,\n  handleFetch,\n  hexToBN,\n  hexToText,\n  isNonEmptyArray,\n  isPlainObject,\n  isSafeChainId,\n  isSafeDynamicKey,\n  isSmartContractCode,\n  isValidJson,\n  isValidHexAddress,\n  normalizeEnsName,\n  query,\n  safelyExecute,\n  safelyExecuteWithTimeout,\n  successfulFetch,\n  timeoutFetch,\n  toChecksumHexAddress,\n  toHex,\n  weiHexToGweiDec,\n  isEqualCaseInsensitive,\n} from './util';\nexport * from './types';\nexport * from './siwe';\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metamask-previews/controller-utils",
-  "version": "11.4.5-preview-ee77a6d9",
+  "version": "11.4.5-preview-4c4eb52a",
   "description": "Data and convenience functions shared by multiple packages",
   "keywords": [
     "MetaMask",
@@ -50,7 +50,7 @@
     "@ethereumjs/util": "^8.1.0",
     "@metamask/eth-query": "^4.0.0",
     "@metamask/ethjs-unit": "^0.3.0",
-    "@metamask/utils": "^11.1.0",
+    "@metamask/utils": "^11.0.1",
     "@spruceid/siwe-parser": "2.1.0",
     "@types/bn.js": "^5.1.5",
     "bignumber.js": "^9.1.2",