@ama-sdk/client-fetch 12.3.0-prerelease.9 → 12.4.0-prerelease.0

package/cjs/plugins/retry/retry.fetch.js

@@ -78,7 +78,7 @@ function _instanceof(left, right) {
     }
 }
 function _ts_generator(thisArg, body) {
-    var f, y, t, g, _ = {
+    var f, y, t, _ = {
         label: 0,
         sent: function() {
             if (t[0] & 1) throw t[1];
@@ -86,12 +86,8 @@ function _ts_generator(thisArg, body) {
         },
         trys: [],
         ops: []
-    };
-    return g = {
-        next: verb(0),
-        "throw": verb(1),
-        "return": verb(2)
-    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
         return this;
     }), g;
     function verb(n) {
@@ -104,7 +100,7 @@ function _ts_generator(thisArg, body) {
     }
     function step(op) {
         if (f) throw new TypeError("Generator is already executing.");
-        while(_)try {
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
             if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
             if (y = 0, t) op = [
                 op[0] & 2,
@@ -222,7 +218,6 @@ var RetryFetch = /*#__PURE__*/ function() {
         {
             key: "delay",
             value: function delay(countDown) {
-                var _this = this;
                 return _async_to_generator(function() {
                     var time;
                     return _ts_generator(this, function(_state) {
@@ -230,7 +225,7 @@ var RetryFetch = /*#__PURE__*/ function() {
                             case 0:
                                 return [
                                     4,
-                                    _this.sleepBetweenRetry(countDown)
+                                    this.sleepBetweenRetry(countDown)
                                 ];
                             case 1:
                                 time = _state.sent();
@@ -242,40 +237,39 @@ var RetryFetch = /*#__PURE__*/ function() {
                                 ];
                         }
                     });
-                })();
+                }).call(this);
             }
         },
         {
             key: "waitAndRetry",
             value: function waitAndRetry(context, countDown) {
-                var _this = this;
                 return _async_to_generator(function() {
                     return _ts_generator(this, function(_state) {
                         switch(_state.label){
                             case 0:
                                 return [
                                     4,
-                                    _this.delay(countDown)
+                                    this.delay(countDown)
                                 ];
                             case 1:
                                 _state.sent();
                                 return [
                                     2,
-                                    _this.retry(context)
+                                    this.retry(context)
                                 ];
                         }
                     });
-                })();
+                }).call(this);
             }
         },
         {
             key: "load",
             value: /** @inheritDoc */ function load(context) {
-                var countDown = this.numberOfRetry;
                 var _this = this;
+                var countDown = this.numberOfRetry;
                 return {
-                    transform: /*#__PURE__*/ function() {
-                        var _ref = _async_to_generator(function(fetchCall) {
+                    transform: function(fetchCall) {
+                        return _async_to_generator(function() {
                             var result, conditionResult, e, conditionResult1;
                             return _ts_generator(this, function(_state) {
                                 switch(_state.label){
@@ -298,7 +292,7 @@ var RetryFetch = /*#__PURE__*/ function() {
                                         ];
                                         return [
                                             4,
-                                            _this.condition(context, result.clone())
+                                            this.condition(context, result.clone())
                                         ];
                                     case 2:
                                         conditionResult = _state.sent();
@@ -306,7 +300,7 @@ var RetryFetch = /*#__PURE__*/ function() {
                                             countDown--;
                                             return [
                                                 2,
-                                                _this.waitAndRetry(context, countDown)
+                                                this.waitAndRetry(context, countDown)
                                             ];
                                         }
                                         _state.label = 3;
@@ -323,7 +317,7 @@ var RetryFetch = /*#__PURE__*/ function() {
                                         ];
                                         return [
                                             4,
-                                            _this.condition(context, undefined, e)
+                                            this.condition(context, undefined, e)
                                         ];
                                     case 5:
                                         conditionResult1 = _state.sent();
@@ -331,7 +325,7 @@ var RetryFetch = /*#__PURE__*/ function() {
                                             countDown--;
                                             return [
                                                 2,
-                                                _this.waitAndRetry(context, countDown)
+                                                this.waitAndRetry(context, countDown)
                                             ];
                                         }
                                         _state.label = 6;
@@ -343,11 +337,8 @@ var RetryFetch = /*#__PURE__*/ function() {
                                         ];
                                 }
                             });
-                        });
-                        return function(fetchCall) {
-                            return _ref.apply(this, arguments);
-                        };
-                    }()
+                        }).call(_this);
+                    }
                 };
             }
         }

package/cjs/plugins/retry/retry.spec.js

@@ -33,7 +33,7 @@ function _async_to_generator(fn) {
     };
 }
 function _ts_generator(thisArg, body) {
-    var f, y, t, g, _ = {
+    var f, y, t, _ = {
         label: 0,
         sent: function() {
             if (t[0] & 1) throw t[1];
@@ -41,12 +41,8 @@ function _ts_generator(thisArg, body) {
         },
         trys: [],
         ops: []
-    };
-    return g = {
-        next: verb(0),
-        "throw": verb(1),
-        "return": verb(2)
-    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
         return this;
     }), g;
     function verb(n) {
@@ -59,7 +55,7 @@ function _ts_generator(thisArg, body) {
     }
     function step(op) {
         if (f) throw new TypeError("Generator is already executing.");
-        while(_)try {
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
             if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
             if (y = 0, t) op = [
                 op[0] & 2,
@@ -128,221 +124,233 @@ function _ts_generator(thisArg, body) {
     }
 }
 describe('Retry Fetch Plugin', function() {
-    it('should not retry on success', /*#__PURE__*/ _async_to_generator(function() {
-        var condition, plugin, runner, call, res, ret;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    condition = jest.fn().mockReturnValue(true);
-                    plugin = new _retryfetch.RetryFetch(1, condition);
-                    runner = plugin.load({
-                        url: 'http://www.test.com',
-                        fetchPlugins: []
-                    });
-                    call = Promise.resolve({
-                        text: 'test',
-                        ok: true
-                    });
-                    res = runner.transform(call);
-                    expect(condition).not.toHaveBeenCalled();
-                    return [
-                        4,
-                        res
-                    ];
-                case 1:
-                    ret = _state.sent();
-                    expect(ret).toEqual({
-                        text: 'test',
-                        ok: true
-                    });
-                    return [
-                        2
-                    ];
-            }
-        });
-    }));
-    it('should not retry if refused by the condition', /*#__PURE__*/ _async_to_generator(function() {
-        var conditionFalsy, plugin, runner, call, res;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    conditionFalsy = jest.fn().mockReturnValue(false);
-                    plugin = new _retryfetch.RetryFetch(3, conditionFalsy);
-                    runner = plugin.load({
-                        url: 'http://www.test.com',
-                        fetchPlugins: []
-                    });
-                    call = Promise.resolve({
-                        text: 'test',
-                        ok: false,
-                        clone: function() {
-                            return {};
-                        }
-                    });
-                    res = runner.transform(call);
-                    return [
-                        4,
-                        res
-                    ];
-                case 1:
-                    _state.sent();
-                    expect(conditionFalsy).toHaveBeenCalledTimes(1);
-                    return [
-                        2
-                    ];
-            }
-        });
-    }));
-    it('should retry on fetch rejection', /*#__PURE__*/ _async_to_generator(function() {
-        var condition, plugin, runners, runner, call, callback;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    condition = jest.fn().mockReturnValue(true);
-                    plugin = new _retryfetch.RetryFetch(2, condition);
-                    runners = [];
-                    runner = plugin.load({
-                        url: 'not an url',
-                        fetchPlugins: runners
-                    });
-                    runners.push(runner);
-                    call = Promise.reject(new Error(JSON.stringify({
-                        text: 'test',
-                        ok: true
-                    })));
-                    callback = jest.fn();
-                    runner.transform(call).catch(callback);
-                    return [
-                        4,
-                        jest.runAllTimersAsync()
-                    ];
-                case 1:
-                    _state.sent();
-                    expect(callback).toHaveBeenCalledWith(expect.objectContaining({}));
-                    expect(condition).toHaveBeenCalledTimes(2);
-                    return [
-                        2
-                    ];
-            }
-        });
-    }));
-    it('should retry on fetch rejection with wait', /*#__PURE__*/ _async_to_generator(function() {
-        var condition, delay, plugin, runners, runner, call, callback;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    condition = jest.fn().mockReturnValue(true);
-                    delay = 500;
-                    plugin = new _retryfetch.RetryFetch(2, condition, function() {
-                        return delay;
-                    });
-                    runners = [];
-                    runner = plugin.load({
-                        url: 'not an url',
-                        fetchPlugins: runners
-                    });
-                    runners.push(runner);
-                    call = Promise.reject(new Error(JSON.stringify({
-                        text: 'test',
-                        ok: true
-                    })));
-                    callback = jest.fn();
-                    runner.transform(call).catch(callback);
-                    return [
-                        4,
-                        jest.advanceTimersByTimeAsync(delay)
-                    ];
-                case 1:
-                    _state.sent();
-                    expect(callback).not.toHaveBeenCalled();
-                    return [
-                        4,
-                        jest.advanceTimersByTimeAsync(delay)
-                    ];
-                case 2:
-                    _state.sent();
-                    expect(callback).toHaveBeenCalledWith(expect.objectContaining({}));
-                    expect(condition).toHaveBeenCalledTimes(2);
-                    return [
-                        2
-                    ];
-            }
-        });
-    }));
-    it('should retry on not ok call', /*#__PURE__*/ _async_to_generator(function() {
-        var condition, plugin, runners, runner, call, callback;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    condition = jest.fn().mockReturnValue(true);
-                    plugin = new _retryfetch.RetryFetch(3, condition);
-                    runners = [];
-                    runner = plugin.load({
-                        url: 'not an url',
-                        fetchPlugins: runners
-                    });
-                    runners.push(runner);
-                    call = Promise.resolve({
-                        text: 'test',
-                        ok: false
-                    });
-                    callback = jest.fn();
-                    runner.transform(call).catch(callback);
-                    return [
-                        4,
-                        jest.runAllTimersAsync()
-                    ];
-                case 1:
-                    _state.sent();
-                    expect(callback).toHaveBeenCalledWith(expect.objectContaining({}));
-                    expect(condition).toHaveBeenCalledTimes(3);
-                    return [
-                        2
-                    ];
-            }
-        });
-    }));
-    it('should retry on not ok call with wait', /*#__PURE__*/ _async_to_generator(function() {
-        var condition, delay, plugin, runners, runner, call, callback;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    condition = jest.fn().mockReturnValue(true);
-                    delay = 500;
-                    plugin = new _retryfetch.RetryFetch(3, condition, function() {
-                        return delay;
-                    });
-                    runners = [];
-                    runner = plugin.load({
-                        url: 'not an url',
-                        fetchPlugins: runners
-                    });
-                    runners.push(runner);
-                    call = Promise.resolve({
-                        text: 'test',
-                        ok: false
-                    });
-                    callback = jest.fn();
-                    runner.transform(call).catch(callback);
-                    return [
-                        4,
-                        jest.advanceTimersByTimeAsync(2 * delay)
-                    ];
-                case 1:
-                    _state.sent();
-                    expect(callback).not.toHaveBeenCalled();
-                    return [
-                        4,
-                        jest.advanceTimersByTimeAsync(delay)
-                    ];
-                case 2:
-                    _state.sent();
-                    expect(callback).toHaveBeenCalledWith(expect.objectContaining({}));
-                    expect(condition).toHaveBeenCalledTimes(3);
-                    return [
-                        2
-                    ];
-            }
-        });
-    }));
+    it('should not retry on success', function() {
+        return _async_to_generator(function() {
+            var condition, plugin, runner, call, res, ret;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        condition = jest.fn().mockReturnValue(true);
+                        plugin = new _retryfetch.RetryFetch(1, condition);
+                        runner = plugin.load({
+                            url: 'http://www.test.com',
+                            fetchPlugins: []
+                        });
+                        call = Promise.resolve({
+                            text: 'test',
+                            ok: true
+                        });
+                        res = runner.transform(call);
+                        expect(condition).not.toHaveBeenCalled();
+                        return [
+                            4,
+                            res
+                        ];
+                    case 1:
+                        ret = _state.sent();
+                        expect(ret).toEqual({
+                            text: 'test',
+                            ok: true
+                        });
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('should not retry if refused by the condition', function() {
+        return _async_to_generator(function() {
+            var conditionFalsy, plugin, runner, call, res;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        conditionFalsy = jest.fn().mockReturnValue(false);
+                        plugin = new _retryfetch.RetryFetch(3, conditionFalsy);
+                        runner = plugin.load({
+                            url: 'http://www.test.com',
+                            fetchPlugins: []
+                        });
+                        call = Promise.resolve({
+                            text: 'test',
+                            ok: false,
+                            clone: function() {
+                                return {};
+                            }
+                        });
+                        res = runner.transform(call);
+                        return [
+                            4,
+                            res
+                        ];
+                    case 1:
+                        _state.sent();
+                        expect(conditionFalsy).toHaveBeenCalledTimes(1);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('should retry on fetch rejection', function() {
+        return _async_to_generator(function() {
+            var condition, plugin, runners, runner, call, callback;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        condition = jest.fn().mockReturnValue(true);
+                        plugin = new _retryfetch.RetryFetch(2, condition);
+                        runners = [];
+                        runner = plugin.load({
+                            url: 'not an url',
+                            fetchPlugins: runners
+                        });
+                        runners.push(runner);
+                        call = Promise.reject(new Error(JSON.stringify({
+                            text: 'test',
+                            ok: true
+                        })));
+                        callback = jest.fn();
+                        runner.transform(call).catch(callback);
+                        return [
+                            4,
+                            jest.runAllTimersAsync()
+                        ];
+                    case 1:
+                        _state.sent();
+                        expect(callback).toHaveBeenCalledWith(expect.objectContaining({}));
+                        expect(condition).toHaveBeenCalledTimes(2);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('should retry on fetch rejection with wait', function() {
+        return _async_to_generator(function() {
+            var condition, delay, plugin, runners, runner, call, callback;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        condition = jest.fn().mockReturnValue(true);
+                        delay = 500;
+                        plugin = new _retryfetch.RetryFetch(2, condition, function() {
+                            return delay;
+                        });
+                        runners = [];
+                        runner = plugin.load({
+                            url: 'not an url',
+                            fetchPlugins: runners
+                        });
+                        runners.push(runner);
+                        call = Promise.reject(new Error(JSON.stringify({
+                            text: 'test',
+                            ok: true
+                        })));
+                        callback = jest.fn();
+                        runner.transform(call).catch(callback);
+                        return [
+                            4,
+                            jest.advanceTimersByTimeAsync(delay)
+                        ];
+                    case 1:
+                        _state.sent();
+                        expect(callback).not.toHaveBeenCalled();
+                        return [
+                            4,
+                            jest.advanceTimersByTimeAsync(delay)
+                        ];
+                    case 2:
+                        _state.sent();
+                        expect(callback).toHaveBeenCalledWith(expect.objectContaining({}));
+                        expect(condition).toHaveBeenCalledTimes(2);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('should retry on not ok call', function() {
+        return _async_to_generator(function() {
+            var condition, plugin, runners, runner, call, callback;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        condition = jest.fn().mockReturnValue(true);
+                        plugin = new _retryfetch.RetryFetch(3, condition);
+                        runners = [];
+                        runner = plugin.load({
+                            url: 'not an url',
+                            fetchPlugins: runners
+                        });
+                        runners.push(runner);
+                        call = Promise.resolve({
+                            text: 'test',
+                            ok: false
+                        });
+                        callback = jest.fn();
+                        runner.transform(call).catch(callback);
+                        return [
+                            4,
+                            jest.runAllTimersAsync()
+                        ];
+                    case 1:
+                        _state.sent();
+                        expect(callback).toHaveBeenCalledWith(expect.objectContaining({}));
+                        expect(condition).toHaveBeenCalledTimes(3);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('should retry on not ok call with wait', function() {
+        return _async_to_generator(function() {
+            var condition, delay, plugin, runners, runner, call, callback;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        condition = jest.fn().mockReturnValue(true);
+                        delay = 500;
+                        plugin = new _retryfetch.RetryFetch(3, condition, function() {
+                            return delay;
+                        });
+                        runners = [];
+                        runner = plugin.load({
+                            url: 'not an url',
+                            fetchPlugins: runners
+                        });
+                        runners.push(runner);
+                        call = Promise.resolve({
+                            text: 'test',
+                            ok: false
+                        });
+                        callback = jest.fn();
+                        runner.transform(call).catch(callback);
+                        return [
+                            4,
+                            jest.advanceTimersByTimeAsync(2 * delay)
+                        ];
+                    case 1:
+                        _state.sent();
+                        expect(callback).not.toHaveBeenCalled();
+                        return [
+                            4,
+                            jest.advanceTimersByTimeAsync(delay)
+                        ];
+                    case 2:
+                        _state.sent();
+                        expect(callback).toHaveBeenCalledWith(expect.objectContaining({}));
+                        expect(condition).toHaveBeenCalledTimes(3);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
 });