@azure/cosmos 4.9.1 → 4.9.3

package/dist/commonjs/retry/index.js

@@ -1,12 +1,30 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-tslib_1.__exportStar(require("./retryOptions.js"), exports);
-tslib_1.__exportStar(require("./endpointDiscoveryRetryPolicy.js"), exports);
-tslib_1.__exportStar(require("./resourceThrottleRetryPolicy.js"), exports);
-tslib_1.__exportStar(require("./sessionRetryPolicy.js"), exports);
-tslib_1.__exportStar(require("./retryUtility.js"), exports);
-tslib_1.__exportStar(require("./timeoutFailoverRetryPolicy.js"), exports);
-//# sourceMappingURL=index.js.map
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var retry_exports = {};
+module.exports = __toCommonJS(retry_exports);
+__reExport(retry_exports, require("./endpointDiscoveryRetryPolicy.js"), module.exports);
+__reExport(retry_exports, require("./resourceThrottleRetryPolicy.js"), module.exports);
+__reExport(retry_exports, require("./sessionRetryPolicy.js"), module.exports);
+__reExport(retry_exports, require("./retryUtility.js"), module.exports);
+__reExport(retry_exports, require("./timeoutFailoverRetryPolicy.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./endpointDiscoveryRetryPolicy.js"),
+  ...require("./resourceThrottleRetryPolicy.js"),
+  ...require("./sessionRetryPolicy.js"),
+  ...require("./retryUtility.js"),
+  ...require("./timeoutFailoverRetryPolicy.js")
+});
+//# sourceMappingURL=index.js.map

package/dist/commonjs/retry/index.js.map

@@ -1 +1,7 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/retry/index.ts"],"names":[],"mappings":";;;AAAA,uCAAuC;AACvC,kCAAkC;AAClC,4DAAkC;AAClC,4EAAkD;AAClD,2EAAiD;AACjD,kEAAwC;AACxC,4DAAkC;AAClC,0EAAgD","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\nexport * from \"./retryOptions.js\";\nexport * from \"./endpointDiscoveryRetryPolicy.js\";\nexport * from \"./resourceThrottleRetryPolicy.js\";\nexport * from \"./sessionRetryPolicy.js\";\nexport * from \"./retryUtility.js\";\nexport * from \"./timeoutFailoverRetryPolicy.js\";\n"]}
+{
+  "version": 3,
+  "sources": ["../../../src/retry/index.ts"],
+  "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\nexport type * from \"./retryOptions.js\";\nexport * from \"./endpointDiscoveryRetryPolicy.js\";\nexport * from \"./resourceThrottleRetryPolicy.js\";\nexport * from \"./sessionRetryPolicy.js\";\nexport * from \"./retryUtility.js\";\nexport * from \"./timeoutFailoverRetryPolicy.js\";\n"],
+  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;AAGA,0BAAc,8CAHd;AAIA,0BAAc,6CAJd;AAKA,0BAAc,oCALd;AAMA,0BAAc,8BANd;AAOA,0BAAc,4CAPd;",
+  "names": []
+}

package/dist/commonjs/retry/resourceThrottleRetryPolicy.js

@@ -1,65 +1,78 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResourceThrottleRetryPolicy = void 0;
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-const constants_js_1 = require("../common/constants.js");
-/**
- * This class implements the resource throttle retry policy for requests.
- * @hidden
- */
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var resourceThrottleRetryPolicy_exports = {};
+__export(resourceThrottleRetryPolicy_exports, {
+  ResourceThrottleRetryPolicy: () => ResourceThrottleRetryPolicy
+});
+module.exports = __toCommonJS(resourceThrottleRetryPolicy_exports);
+var import_constants = require("../common/constants.js");
 class ResourceThrottleRetryPolicy {
-    /** Current retry attempt count. */
-    currentRetryAttemptCount = 0;
-    /** Cummulative wait time in milliseconds for a request while the retries are happening. */
-    cummulativeWaitTimeinMs = 0;
-    /** Retry interval in milliseconds to wait before the next request will be sent. */
-    retryAfterInMs = 0;
-    /** Max wait time in milliseconds to wait for a request while the retries are happening. */
-    timeoutInMs;
-    /**
-     * @param maxTries - Max number of retries to be performed for a request.
-     * @param fixedRetryIntervalInMs - Fixed retry interval in milliseconds to wait between each
-     * retry ignoring the retryAfter returned as part of the response.
-     * @param timeoutInSeconds - Max wait time in seconds to wait for a request while the
-     * retries are happening.
-     */
-    maxTries;
-    fixedRetryIntervalInMs;
-    constructor(options) {
-        this.maxTries = options.maxRetryAttemptCount ?? constants_js_1.Constants.ThrottledRequestMaxRetryAttemptCount;
-        this.fixedRetryIntervalInMs =
-            options.fixedRetryIntervalInMilliseconds ?? constants_js_1.Constants.ThrottledRequestFixedRetryIntervalInMs;
-        const timeoutInSeconds = options.maxWaitTimeInSeconds ?? constants_js_1.Constants.ThrottledRequestMaxWaitTimeInSeconds;
-        this.timeoutInMs = timeoutInSeconds * 1000;
-        this.currentRetryAttemptCount = 0;
-        this.cummulativeWaitTimeinMs = 0;
-    }
-    /**
-     * Determines whether the request should be retried or not.
-     * @param err - Error returned by the request.
-     */
-    async shouldRetry(err, diagnosticNode) {
-        // TODO: any custom error object
-        if (err) {
-            if (this.currentRetryAttemptCount < this.maxTries) {
-                this.currentRetryAttemptCount++;
-                this.retryAfterInMs = 0;
-                if (this.fixedRetryIntervalInMs) {
-                    this.retryAfterInMs = this.fixedRetryIntervalInMs;
-                }
-                else if (err.retryAfterInMs) {
-                    this.retryAfterInMs = err.retryAfterInMs;
-                }
-                if (this.cummulativeWaitTimeinMs < this.timeoutInMs) {
-                    this.cummulativeWaitTimeinMs += this.retryAfterInMs;
-                    diagnosticNode.addData({ successfulRetryPolicy: "resourceThrottle" });
-                    return true;
-                }
-            }
+  /** Current retry attempt count. */
+  currentRetryAttemptCount = 0;
+  /** Cummulative wait time in milliseconds for a request while the retries are happening. */
+  cummulativeWaitTimeinMs = 0;
+  /** Retry interval in milliseconds to wait before the next request will be sent. */
+  retryAfterInMs = 0;
+  /** Max wait time in milliseconds to wait for a request while the retries are happening. */
+  timeoutInMs;
+  /**
+   * @param maxTries - Max number of retries to be performed for a request.
+   * @param fixedRetryIntervalInMs - Fixed retry interval in milliseconds to wait between each
+   * retry ignoring the retryAfter returned as part of the response.
+   * @param timeoutInSeconds - Max wait time in seconds to wait for a request while the
+   * retries are happening.
+   */
+  maxTries;
+  fixedRetryIntervalInMs;
+  constructor(options) {
+    this.maxTries = options.maxRetryAttemptCount ?? import_constants.Constants.ThrottledRequestMaxRetryAttemptCount;
+    this.fixedRetryIntervalInMs = options.fixedRetryIntervalInMilliseconds ?? import_constants.Constants.ThrottledRequestFixedRetryIntervalInMs;
+    const timeoutInSeconds = options.maxWaitTimeInSeconds ?? import_constants.Constants.ThrottledRequestMaxWaitTimeInSeconds;
+    this.timeoutInMs = timeoutInSeconds * 1e3;
+    this.currentRetryAttemptCount = 0;
+    this.cummulativeWaitTimeinMs = 0;
+  }
+  /**
+   * Determines whether the request should be retried or not.
+   * @param err - Error returned by the request.
+   */
+  async shouldRetry(err, diagnosticNode) {
+    if (err) {
+      if (this.currentRetryAttemptCount < this.maxTries) {
+        this.currentRetryAttemptCount++;
+        this.retryAfterInMs = 0;
+        if (this.fixedRetryIntervalInMs) {
+          this.retryAfterInMs = this.fixedRetryIntervalInMs;
+        } else if (err.retryAfterInMs) {
+          this.retryAfterInMs = err.retryAfterInMs;
+        }
+        if (this.cummulativeWaitTimeinMs < this.timeoutInMs) {
+          this.cummulativeWaitTimeinMs += this.retryAfterInMs;
+          diagnosticNode.addData({ successfulRetryPolicy: "resourceThrottle" });
+          return true;
         }
-        return false;
+      }
     }
+    return false;
+  }
 }
-exports.ResourceThrottleRetryPolicy = ResourceThrottleRetryPolicy;
-//# sourceMappingURL=resourceThrottleRetryPolicy.js.map
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ResourceThrottleRetryPolicy
+});
+//# sourceMappingURL=resourceThrottleRetryPolicy.js.map

package/dist/commonjs/retry/resourceThrottleRetryPolicy.js.map

@@ -1 +1,7 @@
-{"version":3,"file":"resourceThrottleRetryPolicy.js","sourceRoot":"","sources":["../../../src/retry/resourceThrottleRetryPolicy.ts"],"names":[],"mappings":";;;AAAA,uCAAuC;AACvC,kCAAkC;AAClC,yDAAmD;AAKnD;;;GAGG;AACH,MAAa,2BAA2B;IACtC,mCAAmC;IAC5B,wBAAwB,GAAW,CAAC,CAAC;IAC5C,2FAA2F;IACpF,uBAAuB,GAAW,CAAC,CAAC;IAC3C,mFAAmF;IAC5E,cAAc,GAAW,CAAC,CAAC;IAElC,2FAA2F;IACnF,WAAW,CAAS;IAC5B;;;;;;OAMG;IAEK,QAAQ,CAAS;IACjB,sBAAsB,CAAS;IACvC,YAAY,OAAqB;QAC/B,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC,oBAAoB,IAAI,wBAAS,CAAC,oCAAoC,CAAC;QAC/F,IAAI,CAAC,sBAAsB;YACzB,OAAO,CAAC,gCAAgC,IAAI,wBAAS,CAAC,sCAAsC,CAAC;QAC/F,MAAM,gBAAgB,GACpB,OAAO,CAAC,oBAAoB,IAAI,wBAAS,CAAC,oCAAoC,CAAC;QACjF,IAAI,CAAC,WAAW,GAAG,gBAAgB,GAAG,IAAI,CAAC;QAC3C,IAAI,CAAC,wBAAwB,GAAG,CAAC,CAAC;QAClC,IAAI,CAAC,uBAAuB,GAAG,CAAC,CAAC;IACnC,CAAC;IACD;;;OAGG;IACI,KAAK,CAAC,WAAW,CACtB,GAAkB,EAClB,cAAsC;QAEtC,gCAAgC;QAChC,IAAI,GAAG,EAAE,CAAC;YACR,IAAI,IAAI,CAAC,wBAAwB,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;gBAClD,IAAI,CAAC,wBAAwB,EAAE,CAAC;gBAChC,IAAI,CAAC,cAAc,GAAG,CAAC,CAAC;gBAExB,IAAI,IAAI,CAAC,sBAAsB,EAAE,CAAC;oBAChC,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,sBAAsB,CAAC;gBACpD,CAAC;qBAAM,IAAI,GAAG,CAAC,cAAc,EAAE,CAAC;oBAC9B,IAAI,CAAC,cAAc,GAAG,GAAG,CAAC,cAAc,CAAC;gBAC3C,CAAC;gBAED,IAAI,IAAI,CAAC,uBAAuB,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;oBACpD,IAAI,CAAC,uBAAuB,IAAI,IAAI,CAAC,cAAc,CAAC;oBACpD,cAAc,CAAC,OAAO,CAAC,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,CAAC,CAAC;oBACtE,OAAO,IAAI,CAAC;gBACd,CAAC;YACH,CAAC;QACH,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;CACF;AA3DD,kEA2DC","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\nimport { Constants } from \"../common/constants.js\";\nimport type { DiagnosticNodeInternal } from \"../diagnostics/DiagnosticNodeInternal.js\";\nimport type { ErrorResponse } from \"../request/index.js\";\nimport type { RetryOptions } from \"./retryOptions.js\";\n\n/**\n * This class implements the resource throttle retry policy for requests.\n * @hidden\n */\nexport class ResourceThrottleRetryPolicy {\n  /** Current retry attempt count. */\n  public currentRetryAttemptCount: number = 0;\n  /** Cummulative wait time in milliseconds for a request while the retries are happening. */\n  public cummulativeWaitTimeinMs: number = 0;\n  /** Retry interval in milliseconds to wait before the next request will be sent. */\n  public retryAfterInMs: number = 0;\n\n  /** Max wait time in milliseconds to wait for a request while the retries are happening. */\n  private timeoutInMs: number;\n  /**\n   * @param maxTries - Max number of retries to be performed for a request.\n   * @param fixedRetryIntervalInMs - Fixed retry interval in milliseconds to wait between each\n   * retry ignoring the retryAfter returned as part of the response.\n   * @param timeoutInSeconds - Max wait time in seconds to wait for a request while the\n   * retries are happening.\n   */\n\n  private maxTries: number;\n  private fixedRetryIntervalInMs: number;\n  constructor(options: RetryOptions) {\n    this.maxTries = options.maxRetryAttemptCount ?? Constants.ThrottledRequestMaxRetryAttemptCount;\n    this.fixedRetryIntervalInMs =\n      options.fixedRetryIntervalInMilliseconds ?? Constants.ThrottledRequestFixedRetryIntervalInMs;\n    const timeoutInSeconds =\n      options.maxWaitTimeInSeconds ?? Constants.ThrottledRequestMaxWaitTimeInSeconds;\n    this.timeoutInMs = timeoutInSeconds * 1000;\n    this.currentRetryAttemptCount = 0;\n    this.cummulativeWaitTimeinMs = 0;\n  }\n  /**\n   * Determines whether the request should be retried or not.\n   * @param err - Error returned by the request.\n   */\n  public async shouldRetry(\n    err: ErrorResponse,\n    diagnosticNode: DiagnosticNodeInternal,\n  ): Promise<boolean> {\n    // TODO: any custom error object\n    if (err) {\n      if (this.currentRetryAttemptCount < this.maxTries) {\n        this.currentRetryAttemptCount++;\n        this.retryAfterInMs = 0;\n\n        if (this.fixedRetryIntervalInMs) {\n          this.retryAfterInMs = this.fixedRetryIntervalInMs;\n        } else if (err.retryAfterInMs) {\n          this.retryAfterInMs = err.retryAfterInMs;\n        }\n\n        if (this.cummulativeWaitTimeinMs < this.timeoutInMs) {\n          this.cummulativeWaitTimeinMs += this.retryAfterInMs;\n          diagnosticNode.addData({ successfulRetryPolicy: \"resourceThrottle\" });\n          return true;\n        }\n      }\n    }\n    return false;\n  }\n}\n"]}
+{
+  "version": 3,
+  "sources": ["../../../src/retry/resourceThrottleRetryPolicy.ts"],
+  "sourcesContent": ["\uFEFF// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\nimport { Constants } from \"../common/constants.js\";\nimport type { DiagnosticNodeInternal } from \"../diagnostics/DiagnosticNodeInternal.js\";\nimport type { ErrorResponse } from \"../request/index.js\";\nimport type { RetryOptions } from \"./retryOptions.js\";\n\n/**\n * This class implements the resource throttle retry policy for requests.\n * @hidden\n */\nexport class ResourceThrottleRetryPolicy {\n  /** Current retry attempt count. */\n  public currentRetryAttemptCount: number = 0;\n  /** Cummulative wait time in milliseconds for a request while the retries are happening. */\n  public cummulativeWaitTimeinMs: number = 0;\n  /** Retry interval in milliseconds to wait before the next request will be sent. */\n  public retryAfterInMs: number = 0;\n\n  /** Max wait time in milliseconds to wait for a request while the retries are happening. */\n  private timeoutInMs: number;\n  /**\n   * @param maxTries - Max number of retries to be performed for a request.\n   * @param fixedRetryIntervalInMs - Fixed retry interval in milliseconds to wait between each\n   * retry ignoring the retryAfter returned as part of the response.\n   * @param timeoutInSeconds - Max wait time in seconds to wait for a request while the\n   * retries are happening.\n   */\n\n  private maxTries: number;\n  private fixedRetryIntervalInMs: number;\n  constructor(options: RetryOptions) {\n    this.maxTries = options.maxRetryAttemptCount ?? Constants.ThrottledRequestMaxRetryAttemptCount;\n    this.fixedRetryIntervalInMs =\n      options.fixedRetryIntervalInMilliseconds ?? Constants.ThrottledRequestFixedRetryIntervalInMs;\n    const timeoutInSeconds =\n      options.maxWaitTimeInSeconds ?? Constants.ThrottledRequestMaxWaitTimeInSeconds;\n    this.timeoutInMs = timeoutInSeconds * 1000;\n    this.currentRetryAttemptCount = 0;\n    this.cummulativeWaitTimeinMs = 0;\n  }\n  /**\n   * Determines whether the request should be retried or not.\n   * @param err - Error returned by the request.\n   */\n  public async shouldRetry(\n    err: ErrorResponse,\n    diagnosticNode: DiagnosticNodeInternal,\n  ): Promise<boolean> {\n    // TODO: any custom error object\n    if (err) {\n      if (this.currentRetryAttemptCount < this.maxTries) {\n        this.currentRetryAttemptCount++;\n        this.retryAfterInMs = 0;\n\n        if (this.fixedRetryIntervalInMs) {\n          this.retryAfterInMs = this.fixedRetryIntervalInMs;\n        } else if (err.retryAfterInMs) {\n          this.retryAfterInMs = err.retryAfterInMs;\n        }\n\n        if (this.cummulativeWaitTimeinMs < this.timeoutInMs) {\n          this.cummulativeWaitTimeinMs += this.retryAfterInMs;\n          diagnosticNode.addData({ successfulRetryPolicy: \"resourceThrottle\" });\n          return true;\n        }\n      }\n    }\n    return false;\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,uBAA0B;AASnB,MAAM,4BAA4B;AAAA;AAAA,EAEhC,2BAAmC;AAAA;AAAA,EAEnC,0BAAkC;AAAA;AAAA,EAElC,iBAAyB;AAAA;AAAA,EAGxB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA;AAAA,EACA;AAAA,EACR,YAAY,SAAuB;AACjC,SAAK,WAAW,QAAQ,wBAAwB,2BAAU;AAC1D,SAAK,yBACH,QAAQ,oCAAoC,2BAAU;AACxD,UAAM,mBACJ,QAAQ,wBAAwB,2BAAU;AAC5C,SAAK,cAAc,mBAAmB;AACtC,SAAK,2BAA2B;AAChC,SAAK,0BAA0B;AAAA,EACjC;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA,MAAa,YACX,KACA,gBACkB;AAElB,QAAI,KAAK;AACP,UAAI,KAAK,2BAA2B,KAAK,UAAU;AACjD,aAAK;AACL,aAAK,iBAAiB;AAEtB,YAAI,KAAK,wBAAwB;AAC/B,eAAK,iBAAiB,KAAK;AAAA,QAC7B,WAAW,IAAI,gBAAgB;AAC7B,eAAK,iBAAiB,IAAI;AAAA,QAC5B;AAEA,YAAI,KAAK,0BAA0B,KAAK,aAAa;AACnD,eAAK,2BAA2B,KAAK;AACrC,yBAAe,QAAQ,EAAE,uBAAuB,mBAAmB,CAAC;AACpE,iBAAO;AAAA,QACT;AAAA,MACF;AAAA,IACF;AACA,WAAO;AAAA,EACT;AACF;",
+  "names": []
+}

package/dist/commonjs/retry/retryOptions.js

@@ -1,3 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=retryOptions.js.map
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var retryOptions_exports = {};
+module.exports = __toCommonJS(retryOptions_exports);
+//# sourceMappingURL=retryOptions.js.map

package/dist/commonjs/retry/retryOptions.js.map

@@ -1 +1,7 @@
-{"version":3,"file":"retryOptions.js","sourceRoot":"","sources":["../../../src/retry/retryOptions.ts"],"names":[],"mappings":"","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n/**\n * Represents the Retry policy assocated with throttled requests in the Azure Cosmos DB database service.\n */\nexport interface RetryOptions {\n  /** Max number of retries to be performed for a request. Default value 9. */\n  maxRetryAttemptCount?: number;\n  /** Fixed retry interval in milliseconds to wait between each retry ignoring the retryAfter returned as part of the response. */\n  fixedRetryIntervalInMilliseconds?: number;\n  /** Max wait time in seconds to wait for a request while the retries are happening. Default value 30 seconds. */\n  maxWaitTimeInSeconds?: number;\n}\n"]}
+{
+  "version": 3,
+  "sources": ["../../../src/retry/retryOptions.ts"],
+  "sourcesContent": ["\uFEFF// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n/**\n * Represents the Retry policy assocated with throttled requests in the Azure Cosmos DB database service.\n */\nexport interface RetryOptions {\n  /** Max number of retries to be performed for a request. Default value 9. */\n  maxRetryAttemptCount?: number;\n  /** Fixed retry interval in milliseconds to wait between each retry ignoring the retryAfter returned as part of the response. */\n  fixedRetryIntervalInMilliseconds?: number;\n  /** Max wait time in seconds to wait for a request while the retries are happening. Default value 30 seconds. */\n  maxWaitTimeInSeconds?: number;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;AAAA;AAAA;",
+  "names": []
+}

package/dist/commonjs/retry/retryUtility.js

@@ -1,140 +1,176 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.execute = execute;
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-const constants_js_1 = require("../common/constants.js");
-const helper_js_1 = require("../common/helper.js");
-const statusCodes_js_1 = require("../common/statusCodes.js");
-const DiagnosticNodeInternal_js_1 = require("../diagnostics/DiagnosticNodeInternal.js");
-const TimeoutError_js_1 = require("../request/TimeoutError.js");
-const diagnostics_js_1 = require("../utils/diagnostics.js");
-const time_js_1 = require("../utils/time.js");
-const defaultRetryPolicy_js_1 = require("./defaultRetryPolicy.js");
-const endpointDiscoveryRetryPolicy_js_1 = require("./endpointDiscoveryRetryPolicy.js");
-const resourceThrottleRetryPolicy_js_1 = require("./resourceThrottleRetryPolicy.js");
-const sessionRetryPolicy_js_1 = require("./sessionRetryPolicy.js");
-const timeoutFailoverRetryPolicy_js_1 = require("./timeoutFailoverRetryPolicy.js");
-/**
- * @hidden
- */
-async function execute({ diagnosticNode, retryContext = { retryCount: 0 }, retryPolicies, requestContext, executeRequest, }) {
-    // TODO: any response
-    return (0, diagnostics_js_1.addDiagnosticChild)(async (localDiagnosticNode) => {
-        localDiagnosticNode.addData({ requestAttempNumber: retryContext.retryCount });
-        if (!retryPolicies) {
-            retryPolicies = {
-                endpointDiscoveryRetryPolicy: new endpointDiscoveryRetryPolicy_js_1.EndpointDiscoveryRetryPolicy(requestContext.globalEndpointManager, requestContext.resourceType, requestContext.operationType, requestContext.globalPartitionEndpointManager),
-                resourceThrottleRetryPolicy: new resourceThrottleRetryPolicy_js_1.ResourceThrottleRetryPolicy(requestContext.connectionPolicy.retryOptions ?? {}),
-                sessionReadRetryPolicy: new sessionRetryPolicy_js_1.SessionRetryPolicy(requestContext.globalEndpointManager, requestContext.resourceType, requestContext.operationType, requestContext.connectionPolicy),
-                defaultRetryPolicy: new defaultRetryPolicy_js_1.DefaultRetryPolicy(requestContext.operationType),
-                timeoutFailoverRetryPolicy: new timeoutFailoverRetryPolicy_js_1.TimeoutFailoverRetryPolicy(requestContext.globalEndpointManager, requestContext.headers, requestContext.method, requestContext.resourceType, requestContext.operationType, requestContext.connectionPolicy.enableEndpointDiscovery, requestContext.globalPartitionEndpointManager),
-            };
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var retryUtility_exports = {};
+__export(retryUtility_exports, {
+  execute: () => execute
+});
+module.exports = __toCommonJS(retryUtility_exports);
+var import_constants = require("../common/constants.js");
+var import_helper = require("../common/helper.js");
+var import_statusCodes = require("../common/statusCodes.js");
+var import_DiagnosticNodeInternal = require("../diagnostics/DiagnosticNodeInternal.js");
+var import_TimeoutError = require("../request/TimeoutError.js");
+var import_diagnostics = require("../utils/diagnostics.js");
+var import_time = require("../utils/time.js");
+var import_defaultRetryPolicy = require("./defaultRetryPolicy.js");
+var import_endpointDiscoveryRetryPolicy = require("./endpointDiscoveryRetryPolicy.js");
+var import_resourceThrottleRetryPolicy = require("./resourceThrottleRetryPolicy.js");
+var import_sessionRetryPolicy = require("./sessionRetryPolicy.js");
+var import_timeoutFailoverRetryPolicy = require("./timeoutFailoverRetryPolicy.js");
+async function execute({
+  diagnosticNode,
+  retryContext = { retryCount: 0 },
+  retryPolicies,
+  requestContext,
+  executeRequest
+}) {
+  return (0, import_diagnostics.addDiagnosticChild)(
+    async (localDiagnosticNode) => {
+      localDiagnosticNode.addData({ requestAttempNumber: retryContext.retryCount });
+      if (!retryPolicies) {
+        retryPolicies = {
+          endpointDiscoveryRetryPolicy: new import_endpointDiscoveryRetryPolicy.EndpointDiscoveryRetryPolicy(
+            requestContext.globalEndpointManager,
+            requestContext.resourceType,
+            requestContext.operationType,
+            requestContext.globalPartitionEndpointManager
+          ),
+          resourceThrottleRetryPolicy: new import_resourceThrottleRetryPolicy.ResourceThrottleRetryPolicy(
+            requestContext.connectionPolicy.retryOptions ?? {}
+          ),
+          sessionReadRetryPolicy: new import_sessionRetryPolicy.SessionRetryPolicy(
+            requestContext.globalEndpointManager,
+            requestContext.resourceType,
+            requestContext.operationType,
+            requestContext.connectionPolicy
+          ),
+          defaultRetryPolicy: new import_defaultRetryPolicy.DefaultRetryPolicy(requestContext.operationType),
+          timeoutFailoverRetryPolicy: new import_timeoutFailoverRetryPolicy.TimeoutFailoverRetryPolicy(
+            requestContext.globalEndpointManager,
+            requestContext.headers,
+            requestContext.method,
+            requestContext.resourceType,
+            requestContext.operationType,
+            requestContext.connectionPolicy.enableEndpointDiscovery,
+            requestContext.globalPartitionEndpointManager
+          )
+        };
+      }
+      if (retryContext && retryContext.clearSessionTokenNotAvailable) {
+        requestContext.client.clearSessionToken(requestContext.path);
+        delete requestContext.headers["x-ms-session-token"];
+      }
+      if (retryContext && retryContext.retryLocationServerIndex) {
+        requestContext.endpoint = await requestContext.globalEndpointManager.resolveServiceEndpointInternal({
+          diagnosticNode: localDiagnosticNode,
+          resourceType: requestContext.resourceType,
+          operationType: requestContext.operationType,
+          startServiceEndpointIndex: retryContext.retryLocationServerIndex,
+          excludedLocations: requestContext.options?.excludedLocations
+        });
+      } else {
+        requestContext.endpoint = await requestContext.globalEndpointManager.resolveServiceEndpointInternal({
+          diagnosticNode: localDiagnosticNode,
+          resourceType: requestContext.resourceType,
+          operationType: requestContext.operationType,
+          startServiceEndpointIndex: 0,
+          excludedLocations: requestContext.options?.excludedLocations
+        });
+      }
+      const startTimeUTCInMs = (0, import_time.getCurrentTimestampInMs)();
+      const correlatedActivityId = requestContext.headers[import_constants.Constants.HttpHeaders.CorrelatedActivityId];
+      if (requestContext.globalPartitionEndpointManager) {
+        requestContext = await requestContext.globalPartitionEndpointManager.tryAddPartitionLevelLocationOverride(
+          requestContext,
+          localDiagnosticNode
+        );
+      }
+      try {
+        const response = await executeRequest(localDiagnosticNode, requestContext);
+        response.headers[import_constants.Constants.ThrottleRetryCount] = retryPolicies.resourceThrottleRetryPolicy.currentRetryAttemptCount;
+        response.headers[import_constants.Constants.ThrottleRetryWaitTimeInMs] = retryPolicies.resourceThrottleRetryPolicy.cummulativeWaitTimeinMs;
+        if (correlatedActivityId) {
+          response.headers[import_constants.Constants.HttpHeaders.CorrelatedActivityId] = correlatedActivityId;
         }
-        if (retryContext && retryContext.clearSessionTokenNotAvailable) {
-            requestContext.client.clearSessionToken(requestContext.path);
-            delete requestContext.headers["x-ms-session-token"];
+        return response;
+      } catch (err) {
+        let retryPolicy = null;
+        const headers = err.headers || {};
+        if (correlatedActivityId) {
+          headers[import_constants.Constants.HttpHeaders.CorrelatedActivityId] = correlatedActivityId;
         }
-        if (retryContext && retryContext.retryLocationServerIndex) {
-            requestContext.endpoint =
-                await requestContext.globalEndpointManager.resolveServiceEndpointInternal({
-                    diagnosticNode: localDiagnosticNode,
-                    resourceType: requestContext.resourceType,
-                    operationType: requestContext.operationType,
-                    startServiceEndpointIndex: retryContext.retryLocationServerIndex,
-                    excludedLocations: requestContext.options?.excludedLocations,
-                });
+        if (err.code === import_statusCodes.StatusCodes.ENOTFOUND || err.code === "REQUEST_SEND_ERROR" || err.code === import_statusCodes.StatusCodes.Forbidden && (err.substatus === import_statusCodes.SubStatusCodes.DatabaseAccountNotFound || err.substatus === import_statusCodes.SubStatusCodes.WriteForbidden)) {
+          retryPolicy = retryPolicies.endpointDiscoveryRetryPolicy;
+        } else if (err.code === import_statusCodes.StatusCodes.TooManyRequests && !isBulkRequest(requestContext)) {
+          retryPolicy = retryPolicies.resourceThrottleRetryPolicy;
+        } else if (err.code === import_statusCodes.StatusCodes.NotFound && err.substatus === import_statusCodes.SubStatusCodes.ReadSessionNotAvailable) {
+          retryPolicy = retryPolicies.sessionReadRetryPolicy;
+        } else if (err.code === import_statusCodes.StatusCodes.ServiceUnavailable || err.code === import_TimeoutError.TimeoutErrorCode) {
+          retryPolicy = retryPolicies.timeoutFailoverRetryPolicy;
+        } else {
+          retryPolicy = retryPolicies.defaultRetryPolicy;
         }
-        else {
-            requestContext.endpoint =
-                await requestContext.globalEndpointManager.resolveServiceEndpointInternal({
-                    diagnosticNode: localDiagnosticNode,
-                    resourceType: requestContext.resourceType,
-                    operationType: requestContext.operationType,
-                    startServiceEndpointIndex: 0,
-                    excludedLocations: requestContext.options?.excludedLocations,
-                });
+        const results = await retryPolicy.shouldRetry(
+          err,
+          localDiagnosticNode,
+          retryContext,
+          requestContext.endpoint,
+          requestContext
+        );
+        if (!results) {
+          headers[import_constants.Constants.ThrottleRetryCount] = retryPolicies.resourceThrottleRetryPolicy.currentRetryAttemptCount;
+          headers[import_constants.Constants.ThrottleRetryWaitTimeInMs] = retryPolicies.resourceThrottleRetryPolicy.cummulativeWaitTimeinMs;
+          err.headers = { ...err.headers, ...headers };
+          throw err;
+        } else {
+          requestContext.retryCount++;
+          const newUrl = results[1];
+          if (newUrl !== void 0) {
+            requestContext.endpoint = newUrl;
+          }
+          localDiagnosticNode.recordFailedNetworkCall(
+            startTimeUTCInMs,
+            requestContext,
+            retryContext.retryCount,
+            err.code,
+            err.subsstatusCode,
+            headers
+          );
+          await (0, import_helper.sleep)(retryPolicy.retryAfterInMs);
+          return execute({
+            diagnosticNode,
+            executeRequest,
+            requestContext,
+            retryContext,
+            retryPolicies
+          });
         }
-        const startTimeUTCInMs = (0, time_js_1.getCurrentTimestampInMs)();
-        const correlatedActivityId = requestContext.headers[constants_js_1.Constants.HttpHeaders.CorrelatedActivityId];
-        if (requestContext.globalPartitionEndpointManager) {
-            // Try partition level location override
-            // This is used to override the partition level location for the request
-            // if there has been a partition level failover
-            requestContext =
-                await requestContext.globalPartitionEndpointManager.tryAddPartitionLevelLocationOverride(requestContext, localDiagnosticNode);
-        }
-        try {
-            const response = await executeRequest(localDiagnosticNode, requestContext);
-            response.headers[constants_js_1.Constants.ThrottleRetryCount] =
-                retryPolicies.resourceThrottleRetryPolicy.currentRetryAttemptCount;
-            response.headers[constants_js_1.Constants.ThrottleRetryWaitTimeInMs] =
-                retryPolicies.resourceThrottleRetryPolicy.cummulativeWaitTimeinMs;
-            if (correlatedActivityId) {
-                response.headers[constants_js_1.Constants.HttpHeaders.CorrelatedActivityId] = correlatedActivityId;
-            }
-            return response;
-        }
-        catch (err) {
-            // TODO: any error
-            let retryPolicy = null;
-            const headers = err.headers || {};
-            if (correlatedActivityId) {
-                headers[constants_js_1.Constants.HttpHeaders.CorrelatedActivityId] = correlatedActivityId;
-            }
-            if (err.code === statusCodes_js_1.StatusCodes.ENOTFOUND ||
-                err.code === "REQUEST_SEND_ERROR" ||
-                (err.code === statusCodes_js_1.StatusCodes.Forbidden &&
-                    (err.substatus === statusCodes_js_1.SubStatusCodes.DatabaseAccountNotFound ||
-                        err.substatus === statusCodes_js_1.SubStatusCodes.WriteForbidden))) {
-                retryPolicy = retryPolicies.endpointDiscoveryRetryPolicy;
-            }
-            else if (err.code === statusCodes_js_1.StatusCodes.TooManyRequests && !isBulkRequest(requestContext)) {
-                retryPolicy = retryPolicies.resourceThrottleRetryPolicy;
-            }
-            else if (err.code === statusCodes_js_1.StatusCodes.NotFound &&
-                err.substatus === statusCodes_js_1.SubStatusCodes.ReadSessionNotAvailable) {
-                retryPolicy = retryPolicies.sessionReadRetryPolicy;
-            }
-            else if (err.code === statusCodes_js_1.StatusCodes.ServiceUnavailable || err.code === TimeoutError_js_1.TimeoutErrorCode) {
-                retryPolicy = retryPolicies.timeoutFailoverRetryPolicy;
-            }
-            else {
-                retryPolicy = retryPolicies.defaultRetryPolicy;
-            }
-            const results = await retryPolicy.shouldRetry(err, localDiagnosticNode, retryContext, requestContext.endpoint, requestContext);
-            if (!results) {
-                headers[constants_js_1.Constants.ThrottleRetryCount] =
-                    retryPolicies.resourceThrottleRetryPolicy.currentRetryAttemptCount;
-                headers[constants_js_1.Constants.ThrottleRetryWaitTimeInMs] =
-                    retryPolicies.resourceThrottleRetryPolicy.cummulativeWaitTimeinMs;
-                err.headers = { ...err.headers, ...headers };
-                throw err;
-            }
-            else {
-                requestContext.retryCount++;
-                const newUrl = results[1]; // TODO: any hack
-                if (newUrl !== undefined) {
-                    requestContext.endpoint = newUrl;
-                }
-                localDiagnosticNode.recordFailedNetworkCall(startTimeUTCInMs, requestContext, retryContext.retryCount, err.code, err.subsstatusCode, headers);
-                await (0, helper_js_1.sleep)(retryPolicy.retryAfterInMs);
-                return execute({
-                    diagnosticNode,
-                    executeRequest,
-                    requestContext,
-                    retryContext,
-                    retryPolicies,
-                });
-            }
-        }
-    }, diagnosticNode, DiagnosticNodeInternal_js_1.DiagnosticNodeType.HTTP_REQUEST);
+      }
+    },
+    diagnosticNode,
+    import_DiagnosticNodeInternal.DiagnosticNodeType.HTTP_REQUEST
+  );
 }
-/**
- * @hidden
- */
 function isBulkRequest(requestContext) {
-    return (requestContext.operationType === "batch" &&
-        !requestContext.headers[constants_js_1.Constants.HttpHeaders.IsBatchAtomic]);
+  return requestContext.operationType === "batch" && !requestContext.headers[import_constants.Constants.HttpHeaders.IsBatchAtomic];
 }
-//# sourceMappingURL=retryUtility.js.map
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  execute
+});
+//# sourceMappingURL=retryUtility.js.map