axios-annotations 2.3.0 → 3.1.0

package/wechat-mp/plugins/auth/index.js

@@ -0,0 +1,376 @@
+"use strict";
+var __awaiter = (void 0) && (void 0).__awaiter || function(thisArg, _arguments, P, generator) {
+    function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve) {
+            resolve(value);
+        });
+    }
+    return new (P || (P = Promise))(function(resolve, reject) {
+        function fulfilled(value) {
+            try {
+                step(generator.next(value));
+            } catch (e) {
+                reject(e);
+            }
+        }
+        function rejected(value) {
+            try {
+                step(generator["throw"](value));
+            } catch (e) {
+                reject(e);
+            }
+        }
+        function step(result) {
+            result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (void 0) && (void 0).__generator || function(thisArg, body) {
+    var _ = {
+        label: 0,
+        sent: function sent() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, f, y, t, 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) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        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,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+};
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.SessionStorage = exports.Authorizer = void 0;
+exports["default"] = AuthorizationPlugin;
+var queue_1 = require("./queue");
+var authorizer_1 = require("./authorizer");
+Object.defineProperty(exports, "Authorizer", {
+    enumerable: true,
+    get: function get() {
+        return authorizer_1["default"];
+    }
+});
+var storage_1 = require("./storage");
+Object.defineProperty(exports, "SessionStorage", {
+    enumerable: true,
+    get: function get() {
+        return storage_1["default"];
+    }
+});
+function AuthorizationPlugin(authorizer, options) {
+    return function(axios, config) {
+        var unauthorized = false;
+        var expiredSession = null;
+        var queue = new queue_1["default"](authorizer, config, (options === null || options === void 0 ? void 0 : options.minTryRetryInterval) || 3000, (options === null || options === void 0 ? void 0 : options.maxTryRetryInterval) || 5000, (options === null || options === void 0 ? void 0 : options.retryTimes) || 3);
+        axios.interceptors.response.use(function(i) {
+            if (expiredSession) {
+                // Previously requests sent have been rejected, record and release it (will be resending)
+                // 会话过期加入过期队列，但未确认 refreshToken 是否失效
+                authorizer.sessionHistory.add(expiredSession);
+                expiredSession = null;
+            }
+            return i;
+        }, function(e) {
+            return __awaiter(this, void 0, void 0, function() {
+                var response, session, e5_1, _a, _b, e2_1, e3_1, e4_1;
+                return __generator(this, function(_c) {
+                    switch(_c.label){
+                        case 0:
+                            response = e.response;
+                            if (!!authorizer.checkResponse(response)) return [
+                                3 /*break*/ ,
+                                24
+                            ];
+                            if (!!unauthorized) return [
+                                3 /*break*/ ,
+                                21
+                            ];
+                            unauthorized = true;
+                            return [
+                                4 /*yield*/ ,
+                                authorizer.getSession()
+                            ];
+                        case 1:
+                            session = _c.sent();
+                            if (!authorizer.sessionHistory.isDeprecated(session)) return [
+                                3 /*break*/ ,
+                                6
+                            ];
+                            _c.label = 2;
+                        case 2:
+                            _c.trys.push([
+                                2,
+                                4,
+                                5,
+                                6
+                            ]);
+                            // You may override this method for home page redirecting.
+                            return [
+                                4 /*yield*/ ,
+                                authorizer.onAuthorizedDenied(e)
+                            ];
+                        case 3:
+                            // You may override this method for home page redirecting.
+                            _c.sent();
+                            authorizer.sessionHistory.clean();
+                            return [
+                                3 /*break*/ ,
+                                6
+                            ];
+                        case 4:
+                            e5_1 = _c.sent();
+                            throw e;
+                        case 5:
+                            unauthorized = false;
+                            // 全部 reject 掉, 即抛出原始异常
+                            queue.clear();
+                            return [
+                                7 /*endfinally*/ 
+                            ];
+                        case 6:
+                            expiredSession = session;
+                            if (!!authorizer.checkSession(e.config, session)) return [
+                                3 /*break*/ ,
+                                16
+                            ];
+                            _c.label = 7;
+                        case 7:
+                            _c.trys.push([
+                                7,
+                                10,
+                                ,
+                                16
+                            ]);
+                            _b = (_a = authorizer).storageSession;
+                            return [
+                                4 /*yield*/ ,
+                                authorizer.refreshSession(session)
+                            ];
+                        case 8:
+                            // waiting for next accessToken refresh, on the server side, updates are synchronized.
+                            // Note:
+                            // even if the refreshing request send few times, the server side will only return the same token.
+                            // 翻译：有效期内多次的刷新请求服务端应该保持 accessToken 不变，客户端不需要线程同步
+                            return [
+                                4 /*yield*/ ,
+                                _b.apply(_a, [
+                                    _c.sent()
+                                ])
+                            ];
+                        case 9:
+                            // waiting for next accessToken refresh, on the server side, updates are synchronized.
+                            // Note:
+                            // even if the refreshing request send few times, the server side will only return the same token.
+                            // 翻译：有效期内多次的刷新请求服务端应该保持 accessToken 不变，客户端不需要线程同步
+                            _c.sent();
+                            return [
+                                3 /*break*/ ,
+                                16
+                            ];
+                        case 10:
+                            e2_1 = _c.sent();
+                            // invalid refresh_token
+                            // 此处触发一般就是 refreshSession 刷新返回 401 / 500 等，非标准返回值需要自行抛出异常
+                            // 作废会话，一般就是 refreshToken 失效
+                            authorizer.sessionHistory.deprecate(session);
+                            _c.label = 11;
+                        case 11:
+                            _c.trys.push([
+                                11,
+                                13,
+                                14,
+                                15
+                            ]);
+                            return [
+                                4 /*yield*/ ,
+                                authorizer.onAuthorizedDenied(e2_1)
+                            ];
+                        case 12:
+                            _c.sent();
+                            authorizer.sessionHistory.clean();
+                            return [
+                                3 /*break*/ ,
+                                15
+                            ];
+                        case 13:
+                            e3_1 = _c.sent();
+                            throw e;
+                        case 14:
+                            unauthorized = false;
+                            // cancel all requests resending.
+                            // clear 就是 全部 reject 掉
+                            queue.clear();
+                            return [
+                                7 /*endfinally*/ 
+                            ];
+                        case 15:
+                            return [
+                                3 /*break*/ ,
+                                16
+                            ];
+                        case 16:
+                            unauthorized = false;
+                            // the accessToken refreshed, send the request itself and startup resending queue cleaning.
+                            // 清空 else 分支积压的请求（重发）
+                            (function() {
+                                while(queue.size){
+                                    queue.pop();
+                                }
+                            })();
+                            _c.label = 17;
+                        case 17:
+                            _c.trys.push([
+                                17,
+                                19,
+                                ,
+                                20
+                            ]);
+                            return [
+                                4 /*yield*/ ,
+                                queue.resend(e)
+                            ];
+                        case 18:
+                            // 重发当前请求，当前请求没有压入队列需要单独处理
+                            return [
+                                2 /*return*/ ,
+                                _c.sent()
+                            ];
+                        case 19:
+                            e4_1 = _c.sent();
+                            // 500 502 503 ...
+                            throw e4_1;
+                        case 20:
+                            return [
+                                3 /*break*/ ,
+                                23
+                            ];
+                        case 21:
+                            return [
+                                4 /*yield*/ ,
+                                queue.push(e)
+                            ];
+                        case 22:
+                            // No, 401 request occurred, put in to resending queue itself and waiting.
+                            return [
+                                2 /*return*/ ,
+                                _c.sent()
+                            ];
+                        case 23:
+                            return [
+                                3 /*break*/ ,
+                                25
+                            ];
+                        case 24:
+                            // HTTP Code = 500 503 502 ... just throw it
+                            throw e;
+                        case 25:
+                            return [
+                                2 /*return*/ 
+                            ];
+                    }
+                });
+            });
+        });
+        axios.interceptors.request.use(function(request) {
+            return __awaiter(this, void 0, void 0, function() {
+                var session;
+                return __generator(this, function(_a) {
+                    switch(_a.label){
+                        case 0:
+                            return [
+                                4 /*yield*/ ,
+                                authorizer.getSession()
+                            ];
+                        case 1:
+                            session = _a.sent();
+                            authorizer.withAuthentication(request, session);
+                            return [
+                                2 /*return*/ ,
+                                request
+                            ];
+                    }
+                });
+            });
+        });
+    };
+}

package/wechat-mp/plugins/auth/queue.d.ts

@@ -0,0 +1,29 @@
+import type { AxiosInstance, AxiosError } from 'axios';
+import Authorizer from "./authorizer";
+import Config from "../../core/config";
+export default class PendingQueue {
+    _queue: {
+        error: AxiosError;
+        resolve: (arg: any) => void;
+        reject: (arg: any) => void;
+    }[];
+    _authorizer: Authorizer;
+    _config: Config;
+    _minTryRetryInterval: number;
+    _maxTryRetryInterval: number;
+    _retryTimes: number;
+    _resendAxiosInstance: AxiosInstance | null;
+    /**
+     * @param {Authorizer} authorizer
+     * @param {Config} config
+     * @param {number} minTryRetryInterval
+     * @param {number} maxTryRetryInterval
+     * @param retryTimes
+     */
+    constructor(authorizer: Authorizer, config: Config, minTryRetryInterval?: number, maxTryRetryInterval?: number, retryTimes?: number);
+    resend(error: AxiosError, retries?: number): Promise<any>;
+    push(error: AxiosError): Promise<any>;
+    pop(): void;
+    clear(): void;
+    get size(): number;
+}

package/wechat-mp/plugins/auth/queue.js

@@ -0,0 +1,285 @@
+"use strict";
+var __awaiter = (void 0) && (void 0).__awaiter || function(thisArg, _arguments, P, generator) {
+    function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve) {
+            resolve(value);
+        });
+    }
+    return new (P || (P = Promise))(function(resolve, reject) {
+        function fulfilled(value) {
+            try {
+                step(generator.next(value));
+            } catch (e) {
+                reject(e);
+            }
+        }
+        function rejected(value) {
+            try {
+                step(generator["throw"](value));
+            } catch (e) {
+                reject(e);
+            }
+        }
+        function step(result) {
+            result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (void 0) && (void 0).__generator || function(thisArg, body) {
+    var _ = {
+        label: 0,
+        sent: function sent() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, f, y, t, 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) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        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,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+};
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function random(min, max) {
+    return (Math.random() * (max - min + 1) | 0) + min;
+}
+function sleep(time) {
+    return new Promise(function(resolve) {
+        var t = setTimeout(function() {
+            clearTimeout(t);
+            t = undefined;
+            resolve();
+        }, time);
+    });
+}
+var PendingQueue = /** @class */ function() {
+    /**
+     * @param {Authorizer} authorizer
+     * @param {Config} config
+     * @param {number} minTryRetryInterval
+     * @param {number} maxTryRetryInterval
+     * @param retryTimes
+     */ function PendingQueue(authorizer, config, minTryRetryInterval, maxTryRetryInterval, retryTimes) {
+        if (minTryRetryInterval === void 0) {
+            minTryRetryInterval = 3000;
+        }
+        if (maxTryRetryInterval === void 0) {
+            maxTryRetryInterval = 5000;
+        }
+        if (retryTimes === void 0) {
+            retryTimes = 3;
+        }
+        this._queue = [];
+        this._resendAxiosInstance = null;
+        this._authorizer = authorizer;
+        this._config = config;
+        this._minTryRetryInterval = minTryRetryInterval;
+        this._maxTryRetryInterval = maxTryRetryInterval;
+        this._retryTimes = retryTimes;
+    }
+    PendingQueue.prototype.resend = function(error_1) {
+        return __awaiter(this, arguments, void 0, function(error, retries) {
+            var maxTimes, i, session, _a, e_1;
+            if (retries === void 0) {
+                retries = 3;
+            }
+            return __generator(this, function(_b) {
+                switch(_b.label){
+                    case 0:
+                        maxTimes = Math.max(this._retryTimes, retries, 1);
+                        i = 0;
+                        _b.label = 1;
+                    case 1:
+                        if (!(i < maxTimes)) return [
+                            3 /*break*/ ,
+                            11
+                        ];
+                        if (!(i > 0)) return [
+                            3 /*break*/ ,
+                            3
+                        ];
+                        return [
+                            4 /*yield*/ ,
+                            sleep(random(this._minTryRetryInterval, this._maxTryRetryInterval))
+                        ];
+                    case 2:
+                        _b.sent();
+                        _b.label = 3;
+                    case 3:
+                        return [
+                            4 /*yield*/ ,
+                            this._authorizer.getSession()
+                        ];
+                    case 4:
+                        session = _b.sent();
+                        if (this._authorizer.sessionHistory.isDeprecated(session)) {
+                            // without re-login again, residual invalid session
+                            throw error;
+                        }
+                        _b.label = 5;
+                    case 5:
+                        _b.trys.push([
+                            5,
+                            9,
+                            ,
+                            10
+                        ]);
+                        if (!!this._resendAxiosInstance) return [
+                            3 /*break*/ ,
+                            7
+                        ];
+                        _a = this;
+                        return [
+                            4 /*yield*/ ,
+                            this._config.axiosProvider.get()
+                        ];
+                    case 6:
+                        _a._resendAxiosInstance = _b.sent().create();
+                        _b.label = 7;
+                    case 7:
+                        this._authorizer.withAuthentication(error.config, session);
+                        return [
+                            4 /*yield*/ ,
+                            this._resendAxiosInstance.request(error.config)
+                        ];
+                    case 8:
+                        // fix: 401 循环 忘了加 await
+                        return [
+                            2 /*return*/ ,
+                            _b.sent()
+                        ];
+                    case 9:
+                        e_1 = _b.sent();
+                        if (i >= maxTimes) {
+                            throw e_1;
+                        }
+                        return [
+                            3 /*break*/ ,
+                            10
+                        ];
+                    case 10:
+                        i++;
+                        return [
+                            3 /*break*/ ,
+                            1
+                        ];
+                    case 11:
+                        throw error;
+                }
+            });
+        });
+    };
+    PendingQueue.prototype.push = function(error) {
+        var _this = this;
+        return new Promise(function(resolve, reject) {
+            _this._queue.push({
+                error: error,
+                resolve: resolve,
+                reject: reject
+            });
+        });
+    };
+    PendingQueue.prototype.pop = function() {
+        var requestSaved = this._queue.shift();
+        if (!requestSaved) {
+            return;
+        }
+        var error = requestSaved.error, resolve = requestSaved.resolve, reject = requestSaved.reject;
+        this.resend(error).then(resolve)["catch"](reject);
+    };
+    PendingQueue.prototype.clear = function() {
+        this._queue.splice(0).forEach(function(_a) {
+            var error = _a.error, reject = _a.reject;
+            reject(error);
+        });
+    };
+    Object.defineProperty(PendingQueue.prototype, "size", {
+        get: function get() {
+            return this._queue.length;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return PendingQueue;
+}();
+exports["default"] = PendingQueue;

package/wechat-mp/plugins/auth/storage.d.ts

@@ -0,0 +1,6 @@
+export default class SessionStorage {
+    _inMemoryStorage: Record<string, any>;
+    set(key: string, value: any): Promise<void>;
+    get(key: string): Promise<any>;
+    remove(key: string): Promise<void>;
+}