@cloudbase/oauth 0.1.1-alpha → 1.0.0-alpha.3

package/dist/oauth2client/oauth2client.js

@@ -0,0 +1,634 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "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 (_) 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.OAuth2Client = exports.LocalCredentials = exports.defaultStorage = exports.generateRequestId = exports.toResponseError = exports.defaultRequest = void 0;
+var consts_1 = require("./consts");
+var uuid_1 = require("../utils/uuid");
+var single_promise_1 = require("../utils/function/single-promise");
+var RequestIdHeaderName = 'x-request-id';
+var DeviceIdHeaderName = 'x-device-id';
+var DeviceIdSectionName = 'device_id';
+exports.defaultRequest = function (url, options) { return __awaiter(void 0, void 0, void 0, function () {
+    var result, responseError, copyOptions, responseResult, jsonResponse, error_1;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                result = null;
+                responseError = null;
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, 4, , 5]);
+                copyOptions = Object.assign({}, options);
+                if (!copyOptions.method) {
+                    copyOptions.method = 'GET';
+                }
+                if (copyOptions.body && typeof copyOptions.body !== 'string') {
+                    copyOptions.body = JSON.stringify(copyOptions.body);
+                }
+                return [4, fetch(url, copyOptions)];
+            case 2:
+                responseResult = _a.sent();
+                return [4, responseResult.json()];
+            case 3:
+                jsonResponse = _a.sent();
+                if (jsonResponse === null || jsonResponse === void 0 ? void 0 : jsonResponse.error) {
+                    responseError = jsonResponse;
+                    responseError.error_uri = new URL(url).pathname;
+                }
+                else {
+                    result = jsonResponse;
+                }
+                return [3, 5];
+            case 4:
+                error_1 = _a.sent();
+                responseError = {
+                    error: consts_1.ErrorType.UNREACHABLE,
+                    error_description: error_1.message,
+                    error_uri: new URL(url).pathname,
+                };
+                return [3, 5];
+            case 5:
+                if (responseError) {
+                    throw responseError;
+                }
+                else {
+                    return [2, result];
+                }
+                return [2];
+        }
+    });
+}); };
+exports.toResponseError = function (error, options) {
+    var responseError;
+    var formatOptions = options || {};
+    if (error instanceof Error) {
+        responseError = {
+            error: formatOptions.error || consts_1.ErrorType.LOCAL,
+            error_description: formatOptions.error_description || error.message,
+            error_uri: formatOptions.error_uri,
+            details: formatOptions.details || error.stack,
+        };
+    }
+    else {
+        var formatError = error || {};
+        responseError = {
+            error: formatOptions.error || formatError.error || consts_1.ErrorType.LOCAL,
+            error_description: formatOptions.error_description || formatError.error_description,
+            error_uri: formatOptions.error_uri || formatError.error_uri,
+            details: formatOptions.details || formatError.details,
+        };
+    }
+    return responseError;
+};
+function generateRequestId() {
+    return uuid_1.uuidv4();
+}
+exports.generateRequestId = generateRequestId;
+var DefaultStorage = (function () {
+    function DefaultStorage() {
+    }
+    DefaultStorage.prototype.getItem = function (key) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, window.localStorage.getItem(key)];
+            });
+        });
+    };
+    DefaultStorage.prototype.removeItem = function (key) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                window.localStorage.removeItem(key);
+                return [2];
+            });
+        });
+    };
+    DefaultStorage.prototype.setItem = function (key, value) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                window.localStorage.setItem(key, value);
+                return [2];
+            });
+        });
+    };
+    DefaultStorage.prototype.getItemSync = function (key) {
+        return window.localStorage.getItem(key);
+    };
+    DefaultStorage.prototype.removeItemSync = function (key) {
+        window.localStorage.removeItem(key);
+    };
+    DefaultStorage.prototype.setItemSync = function (key, value) {
+        window.localStorage.setItem(key, value);
+    };
+    return DefaultStorage;
+}());
+exports.defaultStorage = new DefaultStorage();
+function isCredentialsExpired(credentials) {
+    var isExpired = true;
+    if ((credentials === null || credentials === void 0 ? void 0 : credentials.expires_at) && (credentials === null || credentials === void 0 ? void 0 : credentials.access_token)) {
+        isExpired = credentials.expires_at < new Date();
+    }
+    return isExpired;
+}
+var LocalCredentials = (function () {
+    function LocalCredentials(options) {
+        this._credentials = null;
+        this._singlePromise = new single_promise_1.SinglePromise();
+        this._tokenSectionName = options.tokenSectionName;
+        this._storage = options.storage;
+    }
+    LocalCredentials.prototype.setCredentials = function (credentials) {
+        return __awaiter(this, void 0, void 0, function () {
+            var tokenStr;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(credentials === null || credentials === void 0 ? void 0 : credentials.expires_in)) return [3, 3];
+                        credentials.expires_at = new Date(Date.now() + (credentials.expires_in - 30) * 1000);
+                        if (!this._storage) return [3, 2];
+                        tokenStr = JSON.stringify(credentials);
+                        return [4, this._storage.setItem(this._tokenSectionName, tokenStr)];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        this._credentials = credentials;
+                        return [3, 6];
+                    case 3:
+                        if (!this._storage) return [3, 5];
+                        return [4, this._storage.removeItem(this._tokenSectionName)];
+                    case 4:
+                        _a.sent();
+                        _a.label = 5;
+                    case 5:
+                        this._credentials = null;
+                        _a.label = 6;
+                    case 6: return [2];
+                }
+            });
+        });
+    };
+    LocalCredentials.prototype.getCredentials = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2, this._singlePromise.run('getCredentials', function () { return __awaiter(_this, void 0, void 0, function () {
+                        var _a;
+                        return __generator(this, function (_b) {
+                            switch (_b.label) {
+                                case 0:
+                                    if (!isCredentialsExpired(this._credentials)) return [3, 2];
+                                    _a = this;
+                                    return [4, this._getStorageCredentials()];
+                                case 1:
+                                    _a._credentials = _b.sent();
+                                    _b.label = 2;
+                                case 2: return [2, this._credentials];
+                            }
+                        });
+                    }); })];
+            });
+        });
+    };
+    LocalCredentials.prototype._getStorageCredentials = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2, this._singlePromise.run('_getStorageCredentials', function () { return __awaiter(_this, void 0, void 0, function () {
+                        var credentials, tokenStr, error_2;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    credentials = null;
+                                    return [4, this._storage.getItem(this._tokenSectionName)];
+                                case 1:
+                                    tokenStr = _a.sent();
+                                    if (!(tokenStr !== undefined && tokenStr !== null)) return [3, 5];
+                                    _a.label = 2;
+                                case 2:
+                                    _a.trys.push([2, 3, , 5]);
+                                    credentials = JSON.parse(tokenStr);
+                                    if (credentials === null || credentials === void 0 ? void 0 : credentials.expires_at) {
+                                        credentials.expires_at = new Date(credentials.expires_at);
+                                    }
+                                    return [3, 5];
+                                case 3:
+                                    error_2 = _a.sent();
+                                    return [4, this._storage.removeItem(this._tokenSectionName)];
+                                case 4:
+                                    _a.sent();
+                                    credentials = null;
+                                    return [3, 5];
+                                case 5: return [2, credentials];
+                            }
+                        });
+                    }); })];
+            });
+        });
+    };
+    LocalCredentials.prototype._getStorageCredentialsSync = function () {
+        var credentials = null;
+        var tokenStr = this._storage.getItemSync(this._tokenSectionName);
+        if (tokenStr !== undefined && tokenStr !== null) {
+            try {
+                credentials = JSON.parse(tokenStr);
+                if (credentials === null || credentials === void 0 ? void 0 : credentials.expires_at) {
+                    credentials.expires_at = new Date(credentials.expires_at);
+                }
+            }
+            catch (error) {
+                this._storage.removeItem(this._tokenSectionName);
+                credentials = null;
+            }
+        }
+        return credentials;
+    };
+    return LocalCredentials;
+}());
+exports.LocalCredentials = LocalCredentials;
+var OAuth2Client = (function () {
+    function OAuth2Client(options) {
+        this._singlePromise = new single_promise_1.SinglePromise();
+        this._apiOrigin = options.apiOrigin;
+        this._clientId = options.clientId;
+        this._retry = this._formatRetry(options.retry, OAuth2Client._defaultRetry);
+        if (options.baseRequest != undefined) {
+            this._baseRequest = options.baseRequest;
+        }
+        else {
+            this._baseRequest = exports.defaultRequest;
+        }
+        this._tokenInURL = options.tokenInURL;
+        this._headers = options.headers;
+        this._storage = options.storage || exports.defaultStorage;
+        this._localCredentials = new LocalCredentials({
+            tokenSectionName: 'credentials_' + options.clientId,
+            storage: this._storage,
+        });
+        this._clientSecret = options.clientSecret;
+        this._refreshTokenFunc =
+            options.refreshTokenFunc || this._defaultRefreshTokenFunc;
+    }
+    OAuth2Client.prototype.setCredentials = function (credentials) {
+        return this._localCredentials.setCredentials(credentials);
+    };
+    OAuth2Client.prototype.getAccessToken = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var credentials;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, this._getCredentials()];
+                    case 1:
+                        credentials = _a.sent();
+                        if (credentials === null || credentials === void 0 ? void 0 : credentials.access_token) {
+                            return [2, Promise.resolve(credentials.access_token)];
+                        }
+                        return [2, Promise.reject({ error: consts_1.ErrorType.UNAUTHENTICATED })];
+                }
+            });
+        });
+    };
+    OAuth2Client.prototype.request = function (url, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var retry, deviceId, credentials, response, maxRequestTimes, requestTime, responseError_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!options) {
+                            options = {};
+                        }
+                        retry = this._formatRetry(options.retry, this._retry);
+                        options.headers = options.headers || {};
+                        if (this._headers) {
+                            options.headers = __assign(__assign({}, this._headers), options.headers);
+                        }
+                        if (!options.headers[RequestIdHeaderName]) {
+                            options.headers[RequestIdHeaderName] = generateRequestId();
+                        }
+                        if (!!options.headers[DeviceIdHeaderName]) return [3, 2];
+                        return [4, this._getDeviceId()];
+                    case 1:
+                        deviceId = _a.sent();
+                        options.headers[DeviceIdHeaderName] = deviceId;
+                        _a.label = 2;
+                    case 2:
+                        if (!(options === null || options === void 0 ? void 0 : options.withCredentials)) return [3, 4];
+                        return [4, this._getCredentials()];
+                    case 3:
+                        credentials = _a.sent();
+                        if (credentials) {
+                            if (this._tokenInURL) {
+                                if (url.indexOf('?') < 0) {
+                                    url += '?';
+                                }
+                                url += 'access_token=' + credentials.access_token;
+                            }
+                            else {
+                                options.headers['Authorization'] =
+                                    credentials.token_type + ' ' + credentials.access_token;
+                            }
+                        }
+                        return [3, 5];
+                    case 4:
+                        if (this._clientId && url.indexOf('client_id') < 0) {
+                            url += url.indexOf('?') < 0 ? '?' : '&';
+                            url += 'client_id=' + this._clientId;
+                        }
+                        _a.label = 5;
+                    case 5:
+                        if (url.startsWith('/')) {
+                            url = this._apiOrigin + url;
+                        }
+                        response = null;
+                        maxRequestTimes = retry + 1;
+                        requestTime = 0;
+                        _a.label = 6;
+                    case 6:
+                        if (!(requestTime < maxRequestTimes)) return [3, 13];
+                        _a.label = 7;
+                    case 7:
+                        _a.trys.push([7, 9, , 10]);
+                        return [4, this._baseRequest(url, options)];
+                    case 8:
+                        response = _a.sent();
+                        return [3, 13];
+                    case 9:
+                        responseError_1 = _a.sent();
+                        if (requestTime === retry ||
+                            !responseError_1 ||
+                            responseError_1.error !== 'unreachable') {
+                            return [2, Promise.reject(responseError_1)];
+                        }
+                        return [3, 10];
+                    case 10: return [4, this._sleep(OAuth2Client._retryInterval)];
+                    case 11:
+                        _a.sent();
+                        _a.label = 12;
+                    case 12:
+                        requestTime++;
+                        return [3, 6];
+                    case 13: return [2, response];
+                }
+            });
+        });
+    };
+    OAuth2Client.prototype._checkRetry = function (retry) {
+        var responseError = null;
+        if (typeof retry !== 'number' ||
+            retry < OAuth2Client._minRetry ||
+            retry > OAuth2Client._maxRetry) {
+            responseError = {
+                error: consts_1.ErrorType.UNREACHABLE,
+                error_description: 'wrong options param: retry',
+            };
+        }
+        if (responseError) {
+            throw responseError;
+        }
+        return retry;
+    };
+    OAuth2Client.prototype._formatRetry = function (retry, defaultVale) {
+        if (typeof retry === 'undefined') {
+            return defaultVale;
+        }
+        else {
+            return this._checkRetry(retry);
+        }
+    };
+    OAuth2Client.prototype._sleep = function (ms) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, new Promise(function (resolve) {
+                        setTimeout(function () {
+                            resolve();
+                        }, ms);
+                    })];
+            });
+        });
+    };
+    OAuth2Client.prototype._refreshToken = function (credentials) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2, this._singlePromise.run('_refreshToken', function () { return __awaiter(_this, void 0, void 0, function () {
+                        var newCredentials, error_3;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    if (!credentials || !credentials.refresh_token) {
+                                        return [2, this._unAuthenticatedError('no refresh token found in credentials')];
+                                    }
+                                    _a.label = 1;
+                                case 1:
+                                    _a.trys.push([1, 4, , 7]);
+                                    return [4, this._refreshTokenFunc(credentials.refresh_token)];
+                                case 2:
+                                    newCredentials = _a.sent();
+                                    return [4, this._localCredentials.setCredentials(newCredentials)];
+                                case 3:
+                                    _a.sent();
+                                    return [2, newCredentials];
+                                case 4:
+                                    error_3 = _a.sent();
+                                    if (!(error_3.error === consts_1.ErrorType.INVALID_GRANT)) return [3, 6];
+                                    return [4, this._localCredentials.setCredentials(null)];
+                                case 5:
+                                    _a.sent();
+                                    return [2, this._unAuthenticatedError(error_3.error_description)];
+                                case 6: return [2, Promise.reject(error_3)];
+                                case 7: return [2];
+                            }
+                        });
+                    }); })];
+            });
+        });
+    };
+    OAuth2Client.prototype._anonymousSignIn = function (credentials) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2, this._singlePromise.run('_anonymous', function () { return __awaiter(_this, void 0, void 0, function () {
+                        var newCredentials, error_4;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    if (!credentials || credentials.scope !== 'anonymous') {
+                                        return [2, this._unAuthenticatedError('no anonymous in credentials')];
+                                    }
+                                    _a.label = 1;
+                                case 1:
+                                    _a.trys.push([1, 4, , 7]);
+                                    return [4, this.request('/auth/v1/signin/anonymously', {
+                                            method: 'POST',
+                                            body: {
+                                                client_id: this._clientId,
+                                                client_secret: this._clientSecret,
+                                            },
+                                        })];
+                                case 2:
+                                    newCredentials = _a.sent();
+                                    return [4, this._localCredentials.setCredentials(newCredentials)];
+                                case 3:
+                                    _a.sent();
+                                    return [2, newCredentials];
+                                case 4:
+                                    error_4 = _a.sent();
+                                    if (!(error_4.error === consts_1.ErrorType.INVALID_GRANT)) return [3, 6];
+                                    return [4, this._localCredentials.setCredentials(null)];
+                                case 5:
+                                    _a.sent();
+                                    return [2, this._unAuthenticatedError(error_4.error_description)];
+                                case 6: return [2, Promise.reject(error_4)];
+                                case 7: return [2];
+                            }
+                        });
+                    }); })];
+            });
+        });
+    };
+    OAuth2Client.prototype._defaultRefreshTokenFunc = function (refreshToken) {
+        if (refreshToken === undefined || refreshToken === '') {
+            return this._unAuthenticatedError('refresh token not found');
+        }
+        return this.request('/auth/v1/token', {
+            method: 'POST',
+            body: {
+                client_id: this._clientId,
+                client_secret: this._clientSecret,
+                grant_type: 'refresh_token',
+                refresh_token: refreshToken,
+            },
+        });
+    };
+    OAuth2Client.prototype._getCredentials = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var credentials;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, this._localCredentials.getCredentials()];
+                    case 1:
+                        credentials = _a.sent();
+                        if (!isCredentialsExpired(credentials)) return [3, 5];
+                        if (!(credentials && credentials.scope === 'anonymous')) return [3, 3];
+                        return [4, this._anonymousSignIn(credentials)];
+                    case 2:
+                        credentials = _a.sent();
+                        return [3, 5];
+                    case 3: return [4, this._refreshToken(credentials)];
+                    case 4:
+                        credentials = _a.sent();
+                        _a.label = 5;
+                    case 5: return [2, credentials];
+                }
+            });
+        });
+    };
+    OAuth2Client.prototype.getCredentialsSync = function () {
+        var credentials = this._localCredentials._getStorageCredentialsSync();
+        return credentials;
+    };
+    OAuth2Client.prototype.getCredentialsAsync = function () {
+        return this._localCredentials.getCredentials();
+    };
+    OAuth2Client.prototype.getScope = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var credentials;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, this._localCredentials.getCredentials()];
+                    case 1:
+                        credentials = _a.sent();
+                        if (credentials == null) {
+                            return [2, this._unAuthenticatedError("credentials not found")];
+                        }
+                        return [2, credentials.scope];
+                }
+            });
+        });
+    };
+    OAuth2Client.prototype._getDeviceId = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var deviceId;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this._deviceID) {
+                            return [2, this._deviceID];
+                        }
+                        return [4, this._storage.getItem(DeviceIdSectionName)];
+                    case 1:
+                        deviceId = _a.sent();
+                        if (!!(typeof deviceId === 'string' &&
+                            deviceId.length >= 16 &&
+                            deviceId.length <= 48)) return [3, 3];
+                        deviceId = uuid_1.uuidv4();
+                        return [4, this._storage.setItem(DeviceIdSectionName, deviceId)];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        this._deviceID = deviceId;
+                        return [2, deviceId];
+                }
+            });
+        });
+    };
+    OAuth2Client.prototype._unAuthenticatedError = function (err) {
+        return Promise.reject({
+            error: consts_1.ErrorType.UNAUTHENTICATED,
+            error_description: err,
+        });
+    };
+    OAuth2Client._defaultRetry = 2;
+    OAuth2Client._minRetry = 0;
+    OAuth2Client._maxRetry = 5;
+    OAuth2Client._retryInterval = 1000;
+    return OAuth2Client;
+}());
+exports.OAuth2Client = OAuth2Client;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"oauth2client.js","sourceRoot":"","sources":["../../src/oauth2client/oauth2client.ts"],"names":[],"mappings":"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","sourcesContent":["import { ErrorType } from './consts';\n\nimport { AuthClient, SimpleStorage } from './interface';\n\nimport {\n  Credentials,\n  ResponseError,\n  RequestOptions,\n  RequestFunction,\n  OAuth2ClientOptions,\n  AuthClientRequestOptions,\n} from './models';\n\nimport { uuidv4 } from '../utils/uuid';\n\nimport { SinglePromise } from '../utils/function/single-promise';\n\nconst RequestIdHeaderName = 'x-request-id';\nconst DeviceIdHeaderName = 'x-device-id';\nconst DeviceIdSectionName = 'device_id';\n\nexport interface ToResponseErrorOptions {\n  error?: ErrorType;\n  error_description?: string | null;\n  error_uri?: string | null;\n  details?: any | null;\n}\n\nexport const defaultRequest: RequestFunction = async <T>(\n  url: string,\n  options?: RequestOptions,\n): Promise<T> => {\n  let result: T | null = null;\n  let responseError: ResponseError | null = null;\n  try {\n    // Objects must be copied to prevent modification of data such as body.\n    const copyOptions = Object.assign({}, options);\n    if (!copyOptions.method) {\n      copyOptions.method = 'GET';\n    }\n    if (copyOptions.body && typeof copyOptions.body !== 'string') {\n      copyOptions.body = JSON.stringify(copyOptions.body);\n    }\n    const responseResult: Response = await fetch(url, copyOptions);\n    const jsonResponse = await responseResult.json();\n    if (jsonResponse?.error) {\n      responseError = jsonResponse as ResponseError;\n      responseError.error_uri = new URL(url).pathname;\n    } else {\n      result = jsonResponse as T;\n    }\n  } catch (error) {\n    responseError = {\n      error: ErrorType.UNREACHABLE,\n      error_description: error.message,\n      error_uri: new URL(url).pathname,\n    };\n  }\n  if (responseError) {\n    throw responseError;\n  } else {\n    return result;\n  }\n};\n\nexport const toResponseError = (\n  error: ResponseError | Error,\n  options?: ToResponseErrorOptions,\n): ResponseError => {\n  let responseError: ResponseError;\n  const formatOptions: ToResponseErrorOptions = options || {};\n  if (error instanceof Error) {\n    responseError = {\n      error: formatOptions.error || ErrorType.LOCAL,\n      error_description: formatOptions.error_description || error.message,\n      error_uri: formatOptions.error_uri,\n      details: formatOptions.details || error.stack,\n    };\n  } else {\n    const formatError: ToResponseErrorOptions = error || {};\n    responseError = {\n      error: formatOptions.error || formatError.error || ErrorType.LOCAL,\n      error_description:\n        formatOptions.error_description || formatError.error_description,\n      error_uri: formatOptions.error_uri || formatError.error_uri,\n      details: formatOptions.details || formatError.details,\n    };\n  }\n  return responseError;\n};\n\n/**\n * Generate request id.\n * @return {string}\n */\nexport function generateRequestId(): string {\n  return uuidv4();\n}\n\n\n/**\n * Default Storage.\n */\nclass DefaultStorage implements SimpleStorage {\n  /**\n     * Get item.\n     * @param {string} key\n     */\n  async getItem(key: string): Promise<string | null> {\n    return window.localStorage.getItem(key);\n  }\n\n  /**\n     * Remove item.\n     * @param {string} key\n     */\n  async removeItem(key: string): Promise<void> {\n    window.localStorage.removeItem(key);\n  }\n\n  /**\n     * Set item.\n     * @param {string} key\n     * @param {string} value\n     */\n  async setItem(key: string, value: string): Promise<void> {\n    window.localStorage.setItem(key, value);\n  }\n\n  /**\n     * Get item sync.\n     * @param {string} key\n     */\n  getItemSync(key: string): string | null {\n    return window.localStorage.getItem(key);\n  }\n\n  /**\n     * Remove item sync.\n     * @param {string} key\n     */\n  removeItemSync(key: string): void {\n    window.localStorage.removeItem(key);\n  }\n\n  /**\n     * Set item sync.\n     * @param {string} key\n     * @param {string} value\n     */\n  setItemSync(key: string, value: string): void {\n    window.localStorage.setItem(key, value);\n  }\n}\n\nexport const defaultStorage = new DefaultStorage();\n\ninterface LocalCredentialsOptions {\n  tokenSectionName: string;\n  storage: SimpleStorage;\n}\n\n/**\n * Check if credentials is expired.\n * @param {Credentials} credentials\n * @return {boolean}\n */\nfunction isCredentialsExpired(credentials: Credentials): boolean {\n  let isExpired = true;\n  if (credentials?.expires_at && credentials?.access_token) {\n    isExpired = credentials.expires_at < new Date();\n  }\n  return isExpired;\n}\n\n/**\n * Local credentials.\n * Local credentials, with memory cache and storage cache.\n * If the memory cache expires, the storage cache is automatically loaded.\n */\nexport class LocalCredentials {\n  private _tokenSectionName: string;\n\n  private _storage: SimpleStorage;\n\n  private _credentials: Credentials | null = null;\n\n  private _singlePromise: SinglePromise = new SinglePromise();\n\n  /**\n   * constructor\n   * @param {LocalCredentialsOptions} options\n   */\n  constructor(options: LocalCredentialsOptions) {\n    this._tokenSectionName = options.tokenSectionName;\n    this._storage = options.storage;\n  }\n\n  /**\n   * setCredentials Provides an alternative fetch api request implementation with auth credentials\n   * @param {Credentials} credentials\n   */\n  public async setCredentials(credentials?: Credentials): Promise<void> {\n    if (credentials?.expires_in) {\n      credentials.expires_at = new Date(\n        Date.now() + (credentials.expires_in - 30) * 1000,\n      );\n      if (this._storage) {\n        const tokenStr: string = JSON.stringify(credentials);\n        await this._storage.setItem(this._tokenSectionName, tokenStr);\n      }\n      this._credentials = credentials;\n    } else {\n      if (this._storage) {\n        await this._storage.removeItem(this._tokenSectionName);\n      }\n      this._credentials = null;\n    }\n  }\n\n  /**\n   * Get credentials.\n   * @return {Promise<Credentials | null>}\n   */\n  public async getCredentials(): Promise<Credentials | null> {\n    return this._singlePromise.run('getCredentials', async () => {\n      if (isCredentialsExpired(this._credentials)) {\n        this._credentials = await this._getStorageCredentials();\n      }\n      return this._credentials;\n    });\n  }\n\n  /**\n   * Get storage credentials.\n   */\n  private async _getStorageCredentials(): Promise<Credentials | null> {\n    return this._singlePromise.run('_getStorageCredentials', async () => {\n      let credentials: Credentials = null;\n      const tokenStr: string = await this._storage.getItem(\n        this._tokenSectionName,\n      );\n      if (tokenStr !== undefined && tokenStr !== null) {\n        try {\n          credentials = JSON.parse(tokenStr);\n          if (credentials?.expires_at) {\n            credentials.expires_at = new Date(credentials.expires_at);\n          }\n        } catch (error) {\n          await this._storage.removeItem(this._tokenSectionName);\n          credentials = null;\n        }\n      }\n      return credentials;\n    });\n  }\n\n  public _getStorageCredentialsSync(): Credentials | null {\n    let credentials: Credentials = null;\n    const tokenStr: string = this._storage.getItemSync(\n      this._tokenSectionName,\n    );\n    if (tokenStr !== undefined && tokenStr !== null) {\n      try {\n        credentials = JSON.parse(tokenStr);\n        if (credentials?.expires_at) {\n          credentials.expires_at = new Date(credentials.expires_at);\n        }\n      } catch (error) {\n        this._storage.removeItem(this._tokenSectionName);\n        credentials = null;\n      }\n    }\n    return credentials\n  }\n\n}\n\n/**\n * OAuth2Client\n */\nexport class OAuth2Client implements AuthClient {\n  private static _defaultRetry = 2;\n  private static _minRetry = 0;\n  private static _maxRetry = 5;\n  private static _retryInterval = 1000;\n\n  private _apiOrigin: string;\n  private _clientId: string;\n  private _retry: number;\n  private _clientSecret?: string;\n  private _baseRequest: <T>(\n    url: string,\n    options?: RequestOptions,\n  ) => Promise<T>;\n  private _localCredentials: LocalCredentials;\n  private _storage: SimpleStorage;\n  private _deviceID?: string;\n  private _tokenInURL?: boolean;\n  private _refreshTokenFunc: (refreshToken?: string) => Promise<Credentials>;\n  private _headers?: { [key: string]: string };\n  private _singlePromise: SinglePromise = new SinglePromise();\n\n  /**\n   * constructor\n   * @param {OAuth2ClientOptions} options\n   */\n  constructor(options: OAuth2ClientOptions) {\n    this._apiOrigin = options.apiOrigin;\n    this._clientId = options.clientId;\n    this._retry = this._formatRetry(options.retry, OAuth2Client._defaultRetry);\n    if (options.baseRequest != undefined) {\n      this._baseRequest = options.baseRequest;\n    } else {\n      this._baseRequest = defaultRequest;\n    }\n    this._tokenInURL = options.tokenInURL;\n    this._headers = options.headers;\n    // @ts-ignore\n    this._storage = options.storage || defaultStorage;\n    this._localCredentials = new LocalCredentials({\n      tokenSectionName: 'credentials_' + options.clientId,\n      storage: this._storage,\n    });\n    this._clientSecret = options.clientSecret;\n    this._refreshTokenFunc =\n      options.refreshTokenFunc || this._defaultRefreshTokenFunc;\n  }\n\n  /**\n   * setCredentials Provides an alternative fetch api request implementation with auth credentials\n   * @param {Credentials} credentials\n   * @return {Promise<void>}\n   */\n  public setCredentials(credentials?: Credentials): Promise<void> {\n    return this._localCredentials.setCredentials(credentials);\n  }\n\n  /**\n   * getAccessToken return a validate access token\n   */\n  public async getAccessToken(): Promise<string> {\n    const credentials: Credentials = await this._getCredentials();\n    if (credentials?.access_token) {\n      return Promise.resolve(credentials.access_token);\n    }\n    return Promise.reject({ error: ErrorType.UNAUTHENTICATED } as ResponseError);\n  }\n\n  /**\n   * request http like simple fetch api, exp:request('/v1/user/me', {withCredentials:true})\n   * @param {string} url\n   * @param {AuthClientRequestOptions} options\n   */\n  public async request<T>(\n    url: string,\n    options?: AuthClientRequestOptions,\n  ): Promise<T> {\n    if (!options) {\n      options = {};\n    }\n    const retry: number = this._formatRetry(options.retry, this._retry);\n    options.headers = options.headers || {};\n    if (this._headers) {\n      options.headers = {\n        ...this._headers,\n        ...options.headers,\n      };\n    }\n    if (!options.headers[RequestIdHeaderName]) {\n      options.headers[RequestIdHeaderName] = generateRequestId();\n    }\n    if (!options.headers[DeviceIdHeaderName]) {\n      const deviceId = await this._getDeviceId();\n      options.headers[DeviceIdHeaderName] = deviceId;\n    }\n    if (options?.withCredentials) {\n      const credentials = await this._getCredentials();\n      if (credentials) {\n        if (this._tokenInURL) {\n          if (url.indexOf('?') < 0) {\n            url += '?';\n          }\n          url += 'access_token=' + credentials.access_token;\n        } else {\n          options.headers['Authorization'] =\n            credentials.token_type + ' ' + credentials.access_token;\n        }\n      }\n    } else {\n      if (this._clientId && url.indexOf('client_id') < 0) {\n        url += url.indexOf('?') < 0 ? '?' : '&';\n        url += 'client_id=' + this._clientId;\n      }\n    }\n    if (url.startsWith('/')) {\n      url = this._apiOrigin + url;\n    }\n    let response: T | null = null;\n    const maxRequestTimes: number = retry + 1;\n    for (\n      let requestTime = 0;\n      requestTime < maxRequestTimes;\n      requestTime++\n    ) {\n      try {\n        response = await this._baseRequest<T>(url, options);\n        break;\n      } catch (responseError) {\n        if (\n          requestTime === retry ||\n          !responseError ||\n          responseError.error !== 'unreachable'\n        ) {\n          return Promise.reject(responseError);\n        }\n      }\n      await this._sleep(OAuth2Client._retryInterval);\n    }\n    return response;\n  }\n\n  /**\n   * Check retry value.\n   * @param {number} retry\n   * @return {number}\n   */\n  private _checkRetry(retry: number): number {\n    let responseError: ResponseError | null = null;\n    if (\n      typeof retry !== 'number' ||\n      retry < OAuth2Client._minRetry ||\n      retry > OAuth2Client._maxRetry\n    ) {\n      responseError = {\n        error: ErrorType.UNREACHABLE,\n        error_description: 'wrong options param: retry',\n      };\n    }\n    if (responseError) {\n      throw responseError;\n    }\n    return retry;\n  }\n\n  /**\n   * Format retry value.\n   * @param {number} retry\n   * @param {number} defaultVale\n   * @return {number}\n   */\n  private _formatRetry(retry: number, defaultVale: number): number {\n    if (typeof retry === 'undefined') {\n      return defaultVale;\n    } else {\n      return this._checkRetry(retry);\n    }\n  }\n\n  /**\n   * Sleep.\n   * @param {number} ms\n   * @return {Promise<void>}\n   */\n  private async _sleep(ms: number): Promise<void> {\n    return new Promise<void>((resolve) => {\n      setTimeout(() => {\n        resolve();\n      }, ms);\n    });\n  }\n\n  /**\n   * Refresh expired token.\n   * @param {Credentials} credentials\n   * @return {Promise<Credentials>}\n   */\n  private async _refreshToken(credentials: Credentials): Promise<Credentials> {\n    return this._singlePromise.run('_refreshToken', async () => {\n      if (!credentials || !credentials.refresh_token) {\n        return this._unAuthenticatedError('no refresh token found in credentials');\n      }\n      try {\n        const newCredentials: Credentials = await this._refreshTokenFunc(\n          credentials.refresh_token,\n        );\n        await this._localCredentials.setCredentials(newCredentials);\n        return newCredentials\n      } catch (error) {\n        if (error.error === ErrorType.INVALID_GRANT) {\n          await this._localCredentials.setCredentials(null);\n          return this._unAuthenticatedError(error.error_description);\n        }\n        return Promise.reject(error);\n      }\n    });\n  }\n\n  /**\n   * anonymous signIn\n   * @param {Credentials} credentials\n   * @return {Promise<Credentials>}\n   */\n  private async _anonymousSignIn(credentials: Credentials): Promise<Credentials> {\n    return this._singlePromise.run('_anonymous', async () => {\n      if (!credentials || credentials.scope !== 'anonymous') {\n        return this._unAuthenticatedError('no anonymous in credentials');\n      }\n      try {\n        const newCredentials: Credentials = await this.request('/auth/v1/signin/anonymously', {\n          method: 'POST',\n          body: {\n            client_id: this._clientId,\n            client_secret: this._clientSecret,\n          },\n        });\n        await this._localCredentials.setCredentials(newCredentials);\n        return newCredentials\n      } catch (error) {\n        if (error.error === ErrorType.INVALID_GRANT) {\n          await this._localCredentials.setCredentials(null);\n          return this._unAuthenticatedError(error.error_description);\n        }\n        return Promise.reject(error);\n      }\n    });\n  }\n\n  /**\n   * Default refresh token function.\n   * @param {string} refreshToken\n   * @return {Promise<Credentials>}\n   */\n  private _defaultRefreshTokenFunc(\n    refreshToken?: string,\n  ): Promise<Credentials> {\n    if (refreshToken === undefined || refreshToken === '') {\n      return this._unAuthenticatedError('refresh token not found');\n    }\n    return this.request('/auth/v1/token', {\n      method: 'POST',\n      body: {\n        client_id: this._clientId,\n        client_secret: this._clientSecret,\n        grant_type: 'refresh_token',\n        refresh_token: refreshToken,\n      },\n    });\n  }\n\n  /**\n   * Get credentials.\n   */\n  public async _getCredentials(): Promise<Credentials | null> {\n    let credentials: Credentials = await this._localCredentials.getCredentials();\n    if (isCredentialsExpired(credentials)) {\n      if (credentials && credentials.scope === 'anonymous') {\n        credentials = await this._anonymousSignIn(credentials)\n      } else {\n        credentials = await this._refreshToken(credentials);\n      }\n    }\n    return credentials;\n  }\n\n  public getCredentialsSync(): Credentials | null {\n    const credentials: Credentials = this._localCredentials._getStorageCredentialsSync();\n    return credentials\n  }\n\n  public getCredentialsAsync(): Promise<Credentials | null> {\n    return this._localCredentials.getCredentials()\n  }\n\n  public async getScope(): Promise<string> {\n    let credentials: Credentials = await this._localCredentials.getCredentials();\n    if (credentials == null) {\n      return this._unAuthenticatedError(\"credentials not found\")\n    }\n    return credentials.scope;\n  }\n\n\n\n  /**\n   * Get deviceId\n   */\n  private async _getDeviceId(): Promise<string> {\n    if (this._deviceID) {\n      return this._deviceID;\n    }\n    let deviceId: string = await this._storage.getItem(\n      DeviceIdSectionName,\n    );\n    if (!(typeof deviceId === 'string' &&\n      deviceId.length >= 16 &&\n      deviceId.length <= 48)) {\n      deviceId = uuidv4();\n      await this._storage.setItem(DeviceIdSectionName, deviceId);\n    }\n    this._deviceID = deviceId;\n    return deviceId;\n  }\n  /**\n   * Generate unAuthenticated error.\n   * @param {string} err\n   * @return {Promise<T>}\n   */\n  private _unAuthenticatedError<T>(err?: string): Promise<T> {\n    return Promise.reject({\n      error: ErrorType.UNAUTHENTICATED,\n      error_description: err,\n    } as ResponseError);\n  }\n}\n"]}