axios-annotations 2.3.0 → 3.1.0

package/es/plugins/auth/authorizer.js

@@ -0,0 +1,268 @@
+var __awaiter = this && this.__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 = this && this.__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
+        };
+    }
+};
+import SessionStorage from "./storage.js";
+import SessionHistory from "./history.js";
+var Authorizer = /** @class */ function() {
+    function Authorizer() {
+        this._sessionKey = "$_SESSION";
+        this._sessionStorage = new SessionStorage();
+        this._sessionHistory = new SessionHistory();
+    }
+    Object.defineProperty(Authorizer.prototype, "sessionKey", {
+        get: function get() {
+            return this._sessionKey;
+        },
+        set: function set(value) {
+            this._sessionKey = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Authorizer.prototype, "sessionStorage", {
+        get: function get() {
+            return this._sessionStorage;
+        },
+        set: function set(value) {
+            this._sessionStorage = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Authorizer.prototype, "sessionHistory", {
+        get: function get() {
+            return this._sessionHistory;
+        },
+        set: function set(value) {
+            this._sessionHistory = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Authorizer.prototype.getSession = function() {
+        return __awaiter(this, void 0, void 0, function() {
+            return __generator(this, function(_a) {
+                switch(_a.label){
+                    case 0:
+                        return [
+                            4 /*yield*/ ,
+                            this.sessionStorage.get(this.sessionKey)
+                        ];
+                    case 1:
+                        return [
+                            2 /*return*/ ,
+                            _a.sent()
+                        ];
+                }
+            });
+        });
+    };
+    Authorizer.prototype.storageSession = function(session) {
+        return __awaiter(this, void 0, void 0, function() {
+            return __generator(this, function(_a) {
+                switch(_a.label){
+                    case 0:
+                        return [
+                            4 /*yield*/ ,
+                            this.sessionStorage.set(this.sessionKey, session)
+                        ];
+                    case 1:
+                        _a.sent();
+                        return [
+                            2 /*return*/ 
+                        ];
+                }
+            });
+        });
+    };
+    Authorizer.prototype.refreshSession = function(_session) {
+        return __awaiter(this, void 0, void 0, function() {
+            return __generator(this, function(_a) {
+                return [
+                    2 /*return*/ ,
+                    null
+                ];
+            });
+        });
+    };
+    // append auth headers
+    Authorizer.prototype.withAuthentication = function(request, session) {
+        if (session) {
+            var access_token = session.access_token, accessToken = session.accessToken, token = session.token;
+            if (access_token || accessToken || token) {
+                if (request.headers) {
+                    request.headers['Authorization'] = "Bearer " + (access_token || accessToken || token);
+                }
+            }
+        }
+    };
+    // 匹配队列中的请求头token跟会话token是否一致
+    Authorizer.prototype.checkSession = function(request, session) {
+        var header = (request.headers || {})["Authorization"] || (request.headers || {})["authorization"];
+        var jwt = typeof header === "string" ? header.split(" ")[1] || "" : "";
+        var token = session.access_token || session.accessToken || session.token;
+        if (token === jwt) {
+            // request header token equal to invalid session token
+            return false;
+        }
+        // request time is too long , token may be refreshed few times
+        if (this.sessionHistory.size) {
+            if (this.sessionHistory.check(jwt)) {
+                return false;
+            }
+        }
+        return true;
+    };
+    Authorizer.prototype.checkResponse = function(response) {
+        var status = (response || {
+            status: 0
+        }).status;
+        return status !== 401;
+    };
+    Authorizer.prototype.onAuthorizedDenied = function(error) {
+        return __awaiter(this, void 0, void 0, function() {
+            return __generator(this, function(_a) {
+                throw error;
+            });
+        });
+    };
+    Authorizer.prototype.onSessionInvalidated = function() {
+        return;
+    };
+    Authorizer.prototype.invalidateSession = function() {
+        return __awaiter(this, void 0, void 0, function() {
+            return __generator(this, function(_a) {
+                switch(_a.label){
+                    case 0:
+                        return [
+                            4 /*yield*/ ,
+                            this.sessionStorage.remove(this.sessionKey)
+                        ];
+                    case 1:
+                        _a.sent();
+                        this.onSessionInvalidated();
+                        return [
+                            2 /*return*/ 
+                        ];
+                }
+            });
+        });
+    };
+    return Authorizer;
+}();
+export default Authorizer;

package/es/plugins/auth/history.d.ts

@@ -0,0 +1,15 @@
+import { BasicSession } from "./index";
+/**
+ * 缓存过期会话，判断请求是否过期
+ */
+export default class SessionHistory {
+    _history: (BasicSession | null)[];
+    _position: number;
+    _size: number;
+    get size(): number;
+    add(session: BasicSession): void;
+    check(jwt: string): boolean;
+    deprecate(session: BasicSession): void;
+    clean(): void;
+    isDeprecated(session: BasicSession): boolean;
+}

package/es/plugins/auth/history.js

@@ -0,0 +1,94 @@
+import { isNullOrEmpty } from "../../core/common.js";
+/**
+ * 缓存过期会话，判断请求是否过期
+ */ var SessionHistory = /** @class */ function() {
+    function SessionHistory() {
+        // store up to 10 sessions, include expired or not
+        this._history = new Array(10);
+        // next session storage location
+        this._position = 0;
+        this._size = 0;
+    }
+    Object.defineProperty(SessionHistory.prototype, "size", {
+        get: function get() {
+            return this._size;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    // store primary keys for session
+    // 缓存 session 历史，这里只是添加并未作废，防止同时存在多个有效 session，这里允许存放有效 session
+    // 使用 invalid 作为标记
+    SessionHistory.prototype.add = function(session) {
+        if (Object.keys(session).every(function(i) {
+            return isNullOrEmpty(session[i]);
+        })) {
+            return;
+        }
+        var access_token = session.access_token, accessToken = session.accessToken, token = session.token, refresh_token = session.refresh_token, refreshToken = session.refreshToken;
+        this._history[this._position] = Object.assign({}, session, {
+            access_token: access_token || accessToken || token,
+            refresh_token: refresh_token || refreshToken,
+            invalid: false
+        });
+        this._position++;
+        this._position %= this._history.length;
+        this._size = this._history.reduce(function(s, i) {
+            return i ? s + 1 : s;
+        }, 0);
+    };
+    // session exist or not
+    SessionHistory.prototype.check = function(jwt) {
+        return this._history.some(function(session) {
+            if (session) {
+                var access_token = session.access_token, accessToken = session.accessToken, token = session.token;
+                return (access_token || accessToken || token) === jwt;
+            }
+            return false;
+        });
+    };
+    // mark the session expired
+    SessionHistory.prototype.deprecate = function(session) {
+        var position = 0;
+        var refresh_token = session.refresh_token, refreshToken = session.refreshToken;
+        var matching = this._history.find(function(s, i) {
+            position = i;
+            if (s) {
+                return (s.refresh_token || s.refreshToken) === (refresh_token || refreshToken);
+            }
+            return false;
+        });
+        if (matching) {
+            matching.invalid = true;
+            var first = this._history[0];
+            this._history[0] = this._history[position];
+            this._history[position] = first;
+        }
+    };
+    // remove expired sessions
+    SessionHistory.prototype.clean = function() {
+        for(var i = 0; i < this._history.length; ++i){
+            var s = this._history[i];
+            if (s && s.invalid) {
+                this._history[i] = null;
+            }
+        }
+        this._size = this._history.reduce(function(s, i) {
+            return i ? s + 1 : s;
+        }, 0);
+    };
+    // is the session expired
+    SessionHistory.prototype.isDeprecated = function(session) {
+        return this._history.some(function(s) {
+            if (s) {
+                var refresh_token = session.refresh_token, refreshToken = session.refreshToken;
+                if (refresh_token || refreshToken) {
+                    return (s.refresh_token || s.refreshToken) === (refresh_token || refreshToken) && s.invalid;
+                }
+            }
+            return false;
+        });
+    };
+    return SessionHistory;
+}();
+export default SessionHistory;

package/es/plugins/auth/index.d.ts

@@ -0,0 +1,16 @@
+import Authorizer from "./authorizer";
+import type { ConfigPlugin } from "../../core/config";
+export { default as Authorizer } from "./authorizer";
+export { default as SessionStorage } from "./storage";
+export type BasicSession = {
+    access_token?: string;
+    accessToken?: string;
+    token?: string;
+    refreshToken?: string;
+    refresh_token?: string;
+} & Record<string, any>;
+export default function AuthorizationPlugin(authorizer: Authorizer, options?: {
+    minTryRetryInterval: number;
+    maxTryRetryInterval: number;
+    retryTimes: number;
+}): ConfigPlugin;