@adobe/cloud-service-client - npm Package Compare versions

Comparing version 1.0.3 to 1.1.0

dist/http-backends/axios-backend.js

@@ -90,3 +90,2 @@ "use strict";
       if (!config) {
-        console.log(error);
         throw new Error("Axios error does not have a config");
@@ -93,0 +92,0 @@ }

dist/http-client-utils.js

@@ -45,3 +45,3 @@ "use strict";
   _retryWithStrategies = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(httpOptions, backend, response, attempts) {
-    var retryStrategies, options, rawResponse, i, strategy, retryOptions, shouldRetry, delayMultiple, maxRetries, retryDelay;
+    var retryStrategies, options, rawResponse, i, strategy, retryOptions, shouldRetry, delayMultiple, maxRetries, delay, requestOptions, retryDelay;
     return _regeneratorRuntime().wrap(function _callee$(_context) {
@@ -60,3 +60,3 @@ while (1) {
             if (!(i < retryStrategies.length)) {
-              _context.next = 27;
+              _context.next = 33;
               break;
@@ -71,3 +71,4 @@ }
               maxAttempts: httpOptions.getMaxRetries(),
-              delayMultiple: httpOptions.getRetryDelayMultiple()
+              delayMultiple: httpOptions.getRetryDelayMultiple(),
+              delay: httpOptions.getRetryDelay()
             };
@@ -82,3 +83,3 @@ _context.next = 11;
             if (!shouldRetry) {
-              _context.next = 24;
+              _context.next = 30;
               break;
@@ -94,17 +95,28 @@ }
             maxRetries = _context.sent;
+            _context.next = 22;
+            return strategy.getRetryDelay(retryOptions);
+          case 22:
+            delay = _context.sent;
+            _context.next = 25;
+            return strategy.getRetryRequestOptions(retryOptions);
+          case 25:
+            requestOptions = _context.sent;
             if (!(attempts >= maxRetries && maxRetries >= 0)) {
-              _context.next = 22;
+              _context.next = 28;
               break;
             }
             return _context.abrupt("return", false);
-          case 22:
-            retryDelay = httpOptions.getRetryDelay() * Math.pow(delayMultiple, attempts - 1);
-            return _context.abrupt("return", retryDelay);
-          case 24:
+          case 28:
+            retryDelay = delay * Math.pow(delayMultiple, attempts - 1);
+            return _context.abrupt("return", {
+              delay: retryDelay,
+              options: requestOptions
+            });
+          case 30:
             i++;
             _context.next = 6;
             break;
-          case 27:
+          case 33:
             return _context.abrupt("return", false);
-          case 28:
+          case 34:
           case "end":
@@ -111,0 +123,0 @@ return _context.stop();

dist/http-client.js

@@ -221,3 +221,3 @@ "use strict";
       var _getRetryOptionsFromResponse = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(backend, rawOptions, rawResponse, error) {
-        var httpOptions, httpResponse, shouldRetry;
+        var httpOptions, httpResponse, retryInfo, delay, requestOptions;
         return _regeneratorRuntime().wrap(function _callee4$(_context4) {
@@ -232,17 +232,19 @@ while (1) {
               case 4:
-                shouldRetry = _context4.sent;
-                if (!shouldRetry) {
-                  _context4.next = 12;
+                retryInfo = _context4.sent;
+                if (!retryInfo) {
+                  _context4.next = 14;
                   break;
                 }
-                httpOptions.addRetry(httpResponse, shouldRetry);
+                delay = retryInfo.delay, requestOptions = retryInfo.options;
+                httpOptions.addRetry(httpResponse, delay);
                 httpResponse.setRequestTime(httpOptions.getRequestTime());
-                httpOptions.logInfo("request is being retried by a retry strategy. waiting ".concat(shouldRetry, " for attempt ").concat(httpOptions.getRetries(), "."));
-                _context4.next = 11;
-                return sleep(shouldRetry);
-              case 11:
+                httpOptions.logInfo("request is being retried by a retry strategy. waiting ".concat(delay, " for attempt ").concat(httpOptions.getRetries(), "."));
+                httpOptions.setRequestOptions(requestOptions);
+                _context4.next = 13;
+                return sleep(delay);
+              case 13:
                 return _context4.abrupt("return", backend.getRequestConfig(httpOptions));
-              case 12:
+              case 14:
                 return _context4.abrupt("return", false);
-              case 13:
+              case 15:
               case "end":
@@ -249,0 +251,0 @@ return _context4.stop();

dist/http-options.js

@@ -10,8 +10,8 @@ "use strict";
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+function _regeneratorRuntime() { "use strict"; /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */ _regeneratorRuntime = function _regeneratorRuntime() { return exports; }; var exports = {}, Op = Object.prototype, hasOwn = Op.hasOwnProperty, defineProperty = Object.defineProperty || function (obj, key, desc) { obj[key] = desc.value; }, $Symbol = "function" == typeof Symbol ? Symbol : {}, iteratorSymbol = $Symbol.iterator || "@@iterator", asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator", toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag"; function define(obj, key, value) { return Object.defineProperty(obj, key, { value: value, enumerable: !0, configurable: !0, writable: !0 }), obj[key]; } try { define({}, ""); } catch (err) { define = function define(obj, key, value) { return obj[key] = value; }; } function wrap(innerFn, outerFn, self, tryLocsList) { var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator, generator = Object.create(protoGenerator.prototype), context = new Context(tryLocsList || []); return defineProperty(generator, "_invoke", { value: makeInvokeMethod(innerFn, self, context) }), generator; } function tryCatch(fn, obj, arg) { try { return { type: "normal", arg: fn.call(obj, arg) }; } catch (err) { return { type: "throw", arg: err }; } } exports.wrap = wrap; var ContinueSentinel = {}; function Generator() {} function GeneratorFunction() {} function GeneratorFunctionPrototype() {} var IteratorPrototype = {}; define(IteratorPrototype, iteratorSymbol, function () { return this; }); var getProto = Object.getPrototypeOf, NativeIteratorPrototype = getProto && getProto(getProto(values([]))); NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype); var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype); function defineIteratorMethods(prototype) { ["next", "throw", "return"].forEach(function (method) { define(prototype, method, function (arg) { return this._invoke(method, arg); }); }); } function AsyncIterator(generator, PromiseImpl) { function invoke(method, arg, resolve, reject) { var record = tryCatch(generator[method], generator, arg); if ("throw" !== record.type) { var result = record.arg, value = result.value; return value && "object" == _typeof(value) && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) { invoke("next", value, resolve, reject); }, function (err) { invoke("throw", err, resolve, reject); }) : PromiseImpl.resolve(value).then(function (unwrapped) { result.value = unwrapped, resolve(result); }, function (error) { return invoke("throw", error, resolve, reject); }); } reject(record.arg); } var previousPromise; defineProperty(this, "_invoke", { value: function value(method, arg) { function callInvokeWithMethodAndArg() { return new PromiseImpl(function (resolve, reject) { invoke(method, arg, resolve, reject); }); } return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg(); } }); } function makeInvokeMethod(innerFn, self, context) { var state = "suspendedStart"; return function (method, arg) { if ("executing" === state) throw new Error("Generator is already running"); if ("completed" === state) { if ("throw" === method) throw arg; return doneResult(); } for (context.method = method, context.arg = arg;;) { var delegate = context.delegate; if (delegate) { var delegateResult = maybeInvokeDelegate(delegate, context); if (delegateResult) { if (delegateResult === ContinueSentinel) continue; return delegateResult; } } if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) { if ("suspendedStart" === state) throw state = "completed", context.arg; context.dispatchException(context.arg); } else "return" === context.method && context.abrupt("return", context.arg); state = "executing"; var record = tryCatch(innerFn, self, context); if ("normal" === record.type) { if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue; return { value: record.arg, done: context.done }; } "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg); } }; } function maybeInvokeDelegate(delegate, context) { var method = delegate.iterator[context.method]; if (undefined === method) { if (context.delegate = null, "throw" === context.method) { if (delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method)) return ContinueSentinel; context.method = "throw", context.arg = new TypeError("The iterator does not provide a 'throw' method"); } return ContinueSentinel; } var record = tryCatch(method, delegate.iterator, context.arg); if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel; var info = record.arg; return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel); } function pushTryEntry(locs) { var entry = { tryLoc: locs[0] }; 1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry); } function resetTryEntry(entry) { var record = entry.completion || {}; record.type = "normal", delete record.arg, entry.completion = record; } function Context(tryLocsList) { this.tryEntries = [{ tryLoc: "root" }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0); } function values(iterable) { if (iterable) { var iteratorMethod = iterable[iteratorSymbol]; if (iteratorMethod) return iteratorMethod.call(iterable); if ("function" == typeof iterable.next) return iterable; if (!isNaN(iterable.length)) { var i = -1, next = function next() { for (; ++i < iterable.length;) { if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next; } return next.value = undefined, next.done = !0, next; }; return next.next = next; } } return { next: doneResult }; } function doneResult() { return { value: undefined, done: !0 }; } return GeneratorFunction.prototype = GeneratorFunctionPrototype, defineProperty(Gp, "constructor", { value: GeneratorFunctionPrototype, configurable: !0 }), defineProperty(GeneratorFunctionPrototype, "constructor", { value: GeneratorFunction, configurable: !0 }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) { var ctor = "function" == typeof genFun && genFun.constructor; return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name)); }, exports.mark = function (genFun) { return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun; }, exports.awrap = function (arg) { return { __await: arg }; }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () { return this; }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) { void 0 === PromiseImpl && (PromiseImpl = Promise); var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl); return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) { return result.done ? result.value : iter.next(); }); }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () { return this; }), define(Gp, "toString", function () { return "[object Generator]"; }), exports.keys = function (val) { var object = Object(val), keys = []; for (var key in object) { keys.push(key); } return keys.reverse(), function next() { for (; keys.length;) { var key = keys.pop(); if (key in object) return next.value = key, next.done = !1, next; } return next.done = !0, next; }; }, exports.values = values, Context.prototype = { constructor: Context, reset: function reset(skipTempReset) { if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) { "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined); } }, stop: function stop() { this.done = !0; var rootRecord = this.tryEntries[0].completion; if ("throw" === rootRecord.type) throw rootRecord.arg; return this.rval; }, dispatchException: function dispatchException(exception) { if (this.done) throw exception; var context = this; function handle(loc, caught) { return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught; } for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i], record = entry.completion; if ("root" === entry.tryLoc) return handle("end"); if (entry.tryLoc <= this.prev) { var hasCatch = hasOwn.call(entry, "catchLoc"), hasFinally = hasOwn.call(entry, "finallyLoc"); if (hasCatch && hasFinally) { if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0); if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc); } else if (hasCatch) { if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0); } else { if (!hasFinally) throw new Error("try statement without catch or finally"); if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc); } } } }, abrupt: function abrupt(type, arg) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) { var finallyEntry = entry; break; } } finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null); var record = finallyEntry ? finallyEntry.completion : {}; return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record); }, complete: function complete(record, afterLoc) { if ("throw" === record.type) throw record.arg; return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel; }, finish: function finish(finallyLoc) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel; } }, catch: function _catch(tryLoc) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.tryLoc === tryLoc) { var record = entry.completion; if ("throw" === record.type) { var thrown = record.arg; resetTryEntry(entry); } return thrown; } } throw new Error("illegal catch attempt"); }, delegateYield: function delegateYield(iterable, resultName, nextLoc) { return this.delegate = { iterator: values(iterable), resultName: resultName, nextLoc: nextLoc }, "next" === this.method && (this.arg = undefined), ContinueSentinel; } }, exports; }
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _regeneratorRuntime() { "use strict"; /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */ _regeneratorRuntime = function _regeneratorRuntime() { return exports; }; var exports = {}, Op = Object.prototype, hasOwn = Op.hasOwnProperty, defineProperty = Object.defineProperty || function (obj, key, desc) { obj[key] = desc.value; }, $Symbol = "function" == typeof Symbol ? Symbol : {}, iteratorSymbol = $Symbol.iterator || "@@iterator", asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator", toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag"; function define(obj, key, value) { return Object.defineProperty(obj, key, { value: value, enumerable: !0, configurable: !0, writable: !0 }), obj[key]; } try { define({}, ""); } catch (err) { define = function define(obj, key, value) { return obj[key] = value; }; } function wrap(innerFn, outerFn, self, tryLocsList) { var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator, generator = Object.create(protoGenerator.prototype), context = new Context(tryLocsList || []); return defineProperty(generator, "_invoke", { value: makeInvokeMethod(innerFn, self, context) }), generator; } function tryCatch(fn, obj, arg) { try { return { type: "normal", arg: fn.call(obj, arg) }; } catch (err) { return { type: "throw", arg: err }; } } exports.wrap = wrap; var ContinueSentinel = {}; function Generator() {} function GeneratorFunction() {} function GeneratorFunctionPrototype() {} var IteratorPrototype = {}; define(IteratorPrototype, iteratorSymbol, function () { return this; }); var getProto = Object.getPrototypeOf, NativeIteratorPrototype = getProto && getProto(getProto(values([]))); NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype); var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype); function defineIteratorMethods(prototype) { ["next", "throw", "return"].forEach(function (method) { define(prototype, method, function (arg) { return this._invoke(method, arg); }); }); } function AsyncIterator(generator, PromiseImpl) { function invoke(method, arg, resolve, reject) { var record = tryCatch(generator[method], generator, arg); if ("throw" !== record.type) { var result = record.arg, value = result.value; return value && "object" == _typeof(value) && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) { invoke("next", value, resolve, reject); }, function (err) { invoke("throw", err, resolve, reject); }) : PromiseImpl.resolve(value).then(function (unwrapped) { result.value = unwrapped, resolve(result); }, function (error) { return invoke("throw", error, resolve, reject); }); } reject(record.arg); } var previousPromise; defineProperty(this, "_invoke", { value: function value(method, arg) { function callInvokeWithMethodAndArg() { return new PromiseImpl(function (resolve, reject) { invoke(method, arg, resolve, reject); }); } return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg(); } }); } function makeInvokeMethod(innerFn, self, context) { var state = "suspendedStart"; return function (method, arg) { if ("executing" === state) throw new Error("Generator is already running"); if ("completed" === state) { if ("throw" === method) throw arg; return doneResult(); } for (context.method = method, context.arg = arg;;) { var delegate = context.delegate; if (delegate) { var delegateResult = maybeInvokeDelegate(delegate, context); if (delegateResult) { if (delegateResult === ContinueSentinel) continue; return delegateResult; } } if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) { if ("suspendedStart" === state) throw state = "completed", context.arg; context.dispatchException(context.arg); } else "return" === context.method && context.abrupt("return", context.arg); state = "executing"; var record = tryCatch(innerFn, self, context); if ("normal" === record.type) { if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue; return { value: record.arg, done: context.done }; } "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg); } }; } function maybeInvokeDelegate(delegate, context) { var method = delegate.iterator[context.method]; if (undefined === method) { if (context.delegate = null, "throw" === context.method) { if (delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method)) return ContinueSentinel; context.method = "throw", context.arg = new TypeError("The iterator does not provide a 'throw' method"); } return ContinueSentinel; } var record = tryCatch(method, delegate.iterator, context.arg); if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel; var info = record.arg; return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel); } function pushTryEntry(locs) { var entry = { tryLoc: locs[0] }; 1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry); } function resetTryEntry(entry) { var record = entry.completion || {}; record.type = "normal", delete record.arg, entry.completion = record; } function Context(tryLocsList) { this.tryEntries = [{ tryLoc: "root" }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0); } function values(iterable) { if (iterable) { var iteratorMethod = iterable[iteratorSymbol]; if (iteratorMethod) return iteratorMethod.call(iterable); if ("function" == typeof iterable.next) return iterable; if (!isNaN(iterable.length)) { var i = -1, next = function next() { for (; ++i < iterable.length;) { if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next; } return next.value = undefined, next.done = !0, next; }; return next.next = next; } } return { next: doneResult }; } function doneResult() { return { value: undefined, done: !0 }; } return GeneratorFunction.prototype = GeneratorFunctionPrototype, defineProperty(Gp, "constructor", { value: GeneratorFunctionPrototype, configurable: !0 }), defineProperty(GeneratorFunctionPrototype, "constructor", { value: GeneratorFunction, configurable: !0 }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) { var ctor = "function" == typeof genFun && genFun.constructor; return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name)); }, exports.mark = function (genFun) { return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun; }, exports.awrap = function (arg) { return { __await: arg }; }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () { return this; }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) { void 0 === PromiseImpl && (PromiseImpl = Promise); var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl); return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) { return result.done ? result.value : iter.next(); }); }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () { return this; }), define(Gp, "toString", function () { return "[object Generator]"; }), exports.keys = function (val) { var object = Object(val), keys = []; for (var key in object) { keys.push(key); } return keys.reverse(), function next() { for (; keys.length;) { var key = keys.pop(); if (key in object) return next.value = key, next.done = !1, next; } return next.done = !0, next; }; }, exports.values = values, Context.prototype = { constructor: Context, reset: function reset(skipTempReset) { if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) { "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined); } }, stop: function stop() { this.done = !0; var rootRecord = this.tryEntries[0].completion; if ("throw" === rootRecord.type) throw rootRecord.arg; return this.rval; }, dispatchException: function dispatchException(exception) { if (this.done) throw exception; var context = this; function handle(loc, caught) { return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught; } for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i], record = entry.completion; if ("root" === entry.tryLoc) return handle("end"); if (entry.tryLoc <= this.prev) { var hasCatch = hasOwn.call(entry, "catchLoc"), hasFinally = hasOwn.call(entry, "finallyLoc"); if (hasCatch && hasFinally) { if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0); if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc); } else if (hasCatch) { if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0); } else { if (!hasFinally) throw new Error("try statement without catch or finally"); if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc); } } } }, abrupt: function abrupt(type, arg) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) { var finallyEntry = entry; break; } } finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null); var record = finallyEntry ? finallyEntry.completion : {}; return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record); }, complete: function complete(record, afterLoc) { if ("throw" === record.type) throw record.arg; return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel; }, finish: function finish(finallyLoc) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel; } }, catch: function _catch(tryLoc) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.tryLoc === tryLoc) { var record = entry.completion; if ("throw" === record.type) { var thrown = record.arg; resetTryEntry(entry); } return thrown; } } throw new Error("illegal catch attempt"); }, delegateYield: function delegateYield(iterable, resultName, nextLoc) { return this.delegate = { iterator: values(iterable), resultName: resultName, nextLoc: nextLoc }, "next" === this.method && (this.arg = undefined), ContinueSentinel; } }, exports; }
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
@@ -168,2 +168,14 @@ function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
     /**
+     * Sets the raw HTTP request options upon which the client's options are based. This will merge
+     * the current options with the given options.
+     *
+     * @param {typedefs.RequestOptions} options Raw HTTP request options.
+     */
+  }, {
+    key: "setRequestOptions",
+    value: function setRequestOptions(options) {
+      this[PRIVATE].options = _objectSpread(_objectSpread({}, this[PRIVATE].options), options);
+    }
+
+    /**
      * Records the start time of the most recent request.
@@ -170,0 +182,0 @@ *

dist/retry-strategies/retry-strategy.js

@@ -176,14 +176,15 @@ "use strict";
     /**
-     * Retrieves the maximum number of times that a request should be retried according to
-     * the strategy.
+     * Retrieves the amount of time, in milliseconds, that the retry should be delayed. Note
+     * that the retry delay multiple will be used to expentially increase this delay with
+     * each retry.
      *
      * @param {RetryOptions} retryOptions Information about the current request, which
-     *  can be used to determine the count.
-     * @returns {Promise<number>} Retry count.
+     *  can be used to determine the delay.
+     * @returns {Promise<number>} Retry delay.
      */
   }, {
-    key: "getMaxRetryCount",
+    key: "getRetryDelay",
     value: function () {
-      var _getMaxRetryCount = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(retryOptions) {
-        var _this$PRIVATE$options3, getMaxRetries;
+      var _getRetryDelay = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(retryOptions) {
+        var _this$PRIVATE$options3, getDelay;
         return _regeneratorRuntime().wrap(function _callee6$(_context6) {
@@ -193,3 +194,3 @@ while (1) {
               case 0:
-                _this$PRIVATE$options3 = this[PRIVATE].options.getMaxRetries, getMaxRetries = _this$PRIVATE$options3 === void 0 ? /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5() {
+                _this$PRIVATE$options3 = this[PRIVATE].options.getDelay, getDelay = _this$PRIVATE$options3 === void 0 ? /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5() {
                   return _regeneratorRuntime().wrap(function _callee5$(_context5) {
@@ -199,3 +200,3 @@ while (1) {
                         case 0:
-                          return _context5.abrupt("return", retryOptions.maxAttempts);
+                          return _context5.abrupt("return", retryOptions.delay);
                         case 1:
@@ -208,3 +209,3 @@ case "end":
                 })) : _this$PRIVATE$options3;
-                return _context6.abrupt("return", getMaxRetries(retryOptions));
+                return _context6.abrupt("return", getDelay(retryOptions));
               case 2:
@@ -217,3 +218,46 @@ case "end":
       }));
-      function getMaxRetryCount(_x3) {
+      function getRetryDelay(_x3) {
+        return _getRetryDelay.apply(this, arguments);
+      }
+      return getRetryDelay;
+    }()
+    /**
+     * Retrieves the maximum number of times that a request should be retried according to
+     * the strategy.
+     *
+     * @param {RetryOptions} retryOptions Information about the current request, which
+     *  can be used to determine the count.
+     * @returns {Promise<number>} Retry count.
+     */
+  }, {
+    key: "getMaxRetryCount",
+    value: function () {
+      var _getMaxRetryCount = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee8(retryOptions) {
+        var _this$PRIVATE$options4, getMaxRetries;
+        return _regeneratorRuntime().wrap(function _callee8$(_context8) {
+          while (1) {
+            switch (_context8.prev = _context8.next) {
+              case 0:
+                _this$PRIVATE$options4 = this[PRIVATE].options.getMaxRetries, getMaxRetries = _this$PRIVATE$options4 === void 0 ? /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7() {
+                  return _regeneratorRuntime().wrap(function _callee7$(_context7) {
+                    while (1) {
+                      switch (_context7.prev = _context7.next) {
+                        case 0:
+                          return _context7.abrupt("return", retryOptions.maxAttempts);
+                        case 1:
+                        case "end":
+                          return _context7.stop();
+                      }
+                    }
+                  }, _callee7);
+                })) : _this$PRIVATE$options4;
+                return _context8.abrupt("return", getMaxRetries(retryOptions));
+              case 2:
+              case "end":
+                return _context8.stop();
+            }
+          }
+        }, _callee8, this);
+      }));
+      function getMaxRetryCount(_x4) {
         return _getMaxRetryCount.apply(this, arguments);
@@ -223,2 +267,45 @@ }
     }()
+    /**
+     * Retrieves the raw options that will be given to the underlying HTTP library on the
+     * next retry.
+     *
+     * @param {RetryOptions} retryOptions Information about the current request, which
+     *  can be used to determine the options.
+     * @returns {Promise<object>} Raw request options.
+     */
+  }, {
+    key: "getRetryRequestOptions",
+    value: function () {
+      var _getRetryRequestOptions = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee10(retryOptions) {
+        var _this$PRIVATE$options5, getRequestOptions;
+        return _regeneratorRuntime().wrap(function _callee10$(_context10) {
+          while (1) {
+            switch (_context10.prev = _context10.next) {
+              case 0:
+                _this$PRIVATE$options5 = this[PRIVATE].options.getRequestOptions, getRequestOptions = _this$PRIVATE$options5 === void 0 ? /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9() {
+                  return _regeneratorRuntime().wrap(function _callee9$(_context9) {
+                    while (1) {
+                      switch (_context9.prev = _context9.next) {
+                        case 0:
+                          return _context9.abrupt("return", {});
+                        case 1:
+                        case "end":
+                          return _context9.stop();
+                      }
+                    }
+                  }, _callee9);
+                })) : _this$PRIVATE$options5;
+                return _context10.abrupt("return", getRequestOptions(retryOptions));
+              case 2:
+              case "end":
+                return _context10.stop();
+            }
+          }
+        }, _callee10, this);
+      }));
+      function getRetryRequestOptions(_x5) {
+        return _getRetryRequestOptions.apply(this, arguments);
+      }
+      return getRetryRequestOptions;
+    }()
   }]);
@@ -225,0 +312,0 @@ return RetryStrategy;

package.json

 {
   "name": "@adobe/cloud-service-client",
-  "version": "1.0.3",
+  "version": "1.1.0",
   "description": "Client for working with an HTTP-based cloud service",
@@ -5,0 +5,0 @@ "main": "index.js",

README.md

 # Node.JS Cloud Service Client
 
 [![build status](https://github.com/adobe/cloud-service-client/actions/workflows/node.js.yml/badge.svg)](https://github.com/adobe/cloud-service-client/actions/workflows/node.js.yml)
+[![Node version](https://img.shields.io/npm/v/@adobe/cloud-service-client)](https://www.npmjs.com/package/@adobe/cloud-service-client/)
 
@@ -143,2 +144,3 @@
       * {number} maxAttempts: The _default_ maximum number of attempts as provided in the client's options.
+      * {number} delay: The _default_ time, in milliseconds, that the client should delay between retries.
       * {number} delayMultiple: The _default_ multiple as provided in the client's options.
@@ -148,4 +150,6 @@ * {*} response: Response that was the result of the request. This will be the raw response from the underlying HTTP library.
       * {object} options: Simple object containing the raw options that were given to the underlying HTTP library.
+    * {function} `getDelay`: Should return a `Promise` that resolves with the amount of time, in milliseconds, that the client should wait before retrying the request. This value will be used in conjunction with the delay multiple to exponentially delay subsequent retries. The function will be called with a single argument: an object matching the one described in the `shouldRetry` function. If not specified, the value will default to the delay provided in the client's retry options.
     * {function} `getDelayMultiple`: Should return a `Promise` that resolves to the multiple to use when calculating the amount of time to delay before retrying the request. The function will be called with a single argument: an object matching the object described in the `shouldRetry` function. If not specified the value will default to the multiple provided in the client's retry options.
     * {function} `getMaxRetries`: Should return a `Promise` that resolves to the maximum number of times that a given request should be made. The function will be called with a single argument: an object matching the object described in the `shouldRetry` function. If not specified, the value will default to the number provided in the client's retry options. Note that `-1` indicates the client should continue to retry indefinitely; _use this option with extreme care_.
+    * {function} `getRequestOptions`: Should return a `Promise` that resolves with the raw options to provide to the underlying HTTP client on the next retry request. These options will be merged with the options that originally generated the response. The function will be called with a single argument: an object matching the one described in the `shouldRetry` function. If not specified, the client will use the originally provided request options.
   * {number} `count`: The maximum number of times the client will retry a given request. Note that this is a _default_ value and will not necessarily be respected by all retry strategies. Default: 3.
@@ -152,0 +156,0 @@ * {number} `delay`: The amount of time, in milliseconds, the client will wait before retrying a request when needed. Default: 1000.

src/http-backends/axios-backend.js

@@ -71,3 +71,2 @@ /*
     if (!config) {
-      console.log(error);
       throw new Error("Axios error does not have a config");
@@ -74,0 +73,0 @@ }

src/http-client-utils.js

@@ -47,2 +47,3 @@ /*************************************************************************
       delayMultiple: httpOptions.getRetryDelayMultiple(),
+      delay: httpOptions.getRetryDelay(),
     };
@@ -58,2 +59,6 @@ const shouldRetry = await strategy.shouldRetry(retryOptions);
       const maxRetries = await strategy.getMaxRetryCount(retryOptions);
+      const delay = await strategy.getRetryDelay(retryOptions);
+      const requestOptions = await strategy.getRetryRequestOptions(
+        retryOptions
+      );
 
@@ -64,5 +69,4 @@ if (attempts >= maxRetries && maxRetries >= 0) {
 
-      let retryDelay =
-        httpOptions.getRetryDelay() * Math.pow(delayMultiple, attempts - 1);
-      return retryDelay;
+      let retryDelay = delay * Math.pow(delayMultiple, attempts - 1);
+      return { delay: retryDelay, options: requestOptions };
     }
@@ -69,0 +73,0 @@ }

src/http-client.js

@@ -148,3 +148,3 @@ /*
 
-    const shouldRetry = await retryWithStrategies(
+    const retryInfo = await retryWithStrategies(
       httpOptions,
@@ -156,10 +156,12 @@ backend,
 
-    if (shouldRetry) {
-      httpOptions.addRetry(httpResponse, shouldRetry);
+    if (retryInfo) {
+      const { delay, options: requestOptions } = retryInfo;
+      httpOptions.addRetry(httpResponse, delay);
       httpResponse.setRequestTime(httpOptions.getRequestTime());
       httpOptions.logInfo(
-        `request is being retried by a retry strategy. waiting ${shouldRetry} for attempt ${httpOptions.getRetries()}.`
+        `request is being retried by a retry strategy. waiting ${delay} for attempt ${httpOptions.getRetries()}.`
       );
 
-      await sleep(shouldRetry);
+      httpOptions.setRequestOptions(requestOptions);
+      await sleep(delay);
       return backend.getRequestConfig(httpOptions);
@@ -166,0 +168,0 @@ }

src/http-options.js

@@ -125,2 +125,15 @@ /*
   /**
+   * Sets the raw HTTP request options upon which the client's options are based. This will merge
+   * the current options with the given options.
+   *
+   * @param {typedefs.RequestOptions} options Raw HTTP request options.
+   */
+  setRequestOptions(options) {
+    this[PRIVATE].options = {
+      ...this[PRIVATE].options,
+      ...options,
+    };
+  }
+
+  /**
    * Records the start time of the most recent request.
@@ -127,0 +140,0 @@ *

src/retry-strategies/retry-strategy.js

@@ -108,2 +108,16 @@ /*
   /**
+   * Retrieves the amount of time, in milliseconds, that the retry should be delayed. Note
+   * that the retry delay multiple will be used to expentially increase this delay with
+   * each retry.
+   *
+   * @param {RetryOptions} retryOptions Information about the current request, which
+   *  can be used to determine the delay.
+   * @returns {Promise<number>} Retry delay.
+   */
+  async getRetryDelay(retryOptions) {
+    const { getDelay = async () => retryOptions.delay } = this[PRIVATE].options;
+    return getDelay(retryOptions);
+  }
+
+  /**
    * Retrieves the maximum number of times that a request should be retried according to
@@ -121,4 +135,21 @@ * the strategy.
   }
+
+  /**
+   * Retrieves the raw options that will be given to the underlying HTTP library on the
+   * next retry.
+   *
+   * @param {RetryOptions} retryOptions Information about the current request, which
+   *  can be used to determine the options.
+   * @returns {Promise<object>} Raw request options.
+   */
+  async getRetryRequestOptions(retryOptions) {
+    const {
+      getRequestOptions = async () => {
+        return {};
+      },
+    } = this[PRIVATE].options;
+    return getRequestOptions(retryOptions);
+  }
 }
 
 module.exports = RetryStrategy;

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

478822

increased by1.63%

Lines of code

6478

increased by2.48%

Number of lines in readme file

333

increased by1.22%

No dependency changes