@cloudbase/js-sdk 3.3.14-beta.3 → 3.3.14-beta.5

package/node_modules/@cloudbase/oauth/dist/esm/oauth2client/oauth2client.js

@@ -0,0 +1,711 @@
+import { ErrorType } from './consts';
+import { ApiUrls, ApiUrlsV2, AUTH_API_PREFIX, AUTH_STATE_CHANGED_TYPE, DEFAULT_NODE_ACCESS_SCOPE, EVENTS, } from '../auth/consts';
+import { uuidv4 } from '../utils/uuid';
+import { getPathName } from '../utils/index';
+import { SinglePromise } from '../utils/function/single-promise';
+import { weBtoa } from '../utils/base64';
+import { isMp } from '../utils/mp';
+import { langEvent } from '@cloudbase/utilities';
+const RequestIdHeaderName = 'x-request-id';
+const DeviceIdHeaderName = 'x-device-id';
+const DeviceIdSectionName = 'device_id';
+export const defaultRequest = async function (url, options) {
+    let result = null;
+    let responseError = null;
+    try {
+        const copyOptions = Object.assign({}, options);
+        if (!copyOptions.method) {
+            copyOptions.method = 'GET';
+        }
+        if (copyOptions.body && typeof copyOptions.body !== 'string') {
+            copyOptions.body = JSON.stringify(copyOptions.body);
+        }
+        const responseResult = await fetch(url, copyOptions);
+        const jsonResponse = await responseResult.json();
+        if (jsonResponse?.error) {
+            responseError = jsonResponse;
+            responseError.error_uri = new URL(url).pathname;
+        }
+        else {
+            result = jsonResponse;
+        }
+    }
+    catch (error) {
+        responseError = {
+            error: ErrorType.UNREACHABLE,
+            error_description: error.message,
+            error_uri: new URL(url).pathname,
+        };
+    }
+    if (responseError) {
+        throw responseError;
+    }
+    else {
+        return result;
+    }
+};
+export const toResponseError = (error, options) => {
+    let responseError;
+    const formatOptions = options || {};
+    if (error instanceof Error) {
+        responseError = {
+            error: formatOptions.error || ErrorType.LOCAL,
+            error_description: formatOptions.error_description || error.message,
+            error_uri: formatOptions.error_uri,
+            details: formatOptions.details || error.stack,
+        };
+    }
+    else {
+        const formatError = error || {};
+        responseError = {
+            error: formatOptions.error || formatError.error || 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;
+};
+export function generateRequestId() {
+    return uuidv4();
+}
+class DefaultStorage {
+    constructor(opts) {
+        this._env = opts?.env || '';
+    }
+    async getItem(key) {
+        return window.localStorage.getItem(`${key}${this._env}`);
+    }
+    async removeItem(key) {
+        window.localStorage.removeItem(`${key}${this._env}`);
+    }
+    async setItem(key, value) {
+        window.localStorage.setItem(`${key}${this._env}`, value);
+    }
+    getItemSync(key) {
+        return window.localStorage.getItem(`${key}${this._env}`);
+    }
+    removeItemSync(key) {
+        window.localStorage.removeItem(`${key}${this._env}`);
+    }
+    setItemSync(key, value) {
+        window.localStorage.setItem(`${key}${this._env}`, value);
+    }
+}
+export const defaultStorage = new DefaultStorage();
+function isCredentialsExpired(credentials) {
+    let isExpired = true;
+    if (credentials?.expires_at && credentials?.access_token) {
+        isExpired = credentials.expires_at < new Date();
+    }
+    return isExpired;
+}
+class LocalCredentials {
+    constructor(options) {
+        this.credentials = null;
+        this.accessKeyCredentials = null;
+        this.singlePromise = null;
+        this.tokenSectionName = options.tokenSectionName;
+        this.storage = options.storage;
+        this.clientId = options.clientId;
+        this.singlePromise = new SinglePromise({ clientId: this.clientId });
+        this.credentials = options.credentials || null;
+    }
+    getStorageCredentialsSync() {
+        let credentials = null;
+        const tokenStr = this.storage.getItemSync(this.tokenSectionName);
+        if (tokenStr !== undefined && tokenStr !== null) {
+            try {
+                credentials = JSON.parse(tokenStr);
+                if (credentials?.expires_at) {
+                    credentials.expires_at = new Date(credentials.expires_at);
+                }
+            }
+            catch (error) {
+                this.storage.removeItem(this.tokenSectionName);
+                credentials = null;
+            }
+        }
+        return credentials;
+    }
+    async setCredentials(credentials) {
+        if (credentials?.expires_in) {
+            if (!credentials?.expires_at) {
+                credentials.expires_at = new Date(Date.now() + (credentials.expires_in - 30) * 1000);
+            }
+            if (this.storage) {
+                const tokenStr = JSON.stringify(credentials);
+                await this.storage.setItem(this.tokenSectionName, tokenStr);
+            }
+            this.credentials = credentials;
+        }
+        else {
+            if (this.storage) {
+                await this.storage.removeItem(this.tokenSectionName);
+            }
+            this.credentials = null;
+        }
+    }
+    setAccessKeyCredentials(credentials) {
+        this.accessKeyCredentials = credentials;
+        if (credentials.scope === DEFAULT_NODE_ACCESS_SCOPE) {
+            this.credentials = credentials;
+        }
+    }
+    async getCredentials() {
+        return this.singlePromise.run('getCredentials', async () => {
+            if (isCredentialsExpired(this.credentials)) {
+                const { credentials, isAccessKeyCredentials } = await this.getStorageCredentials();
+                if (isAccessKeyCredentials) {
+                    return credentials;
+                }
+                this.credentials = credentials;
+            }
+            return this.credentials;
+        });
+    }
+    async getStorageCredentials() {
+        return this.singlePromise.run('_getStorageCredentials', async () => {
+            let credentials = null;
+            let isAccessKeyCredentials = false;
+            const tokenStr = await this.storage.getItem(this.tokenSectionName);
+            if (!!tokenStr) {
+                try {
+                    credentials = JSON.parse(tokenStr);
+                    if (credentials?.expires_at) {
+                        credentials.expires_at = new Date(credentials.expires_at);
+                    }
+                }
+                catch (error) {
+                    await this.storage.removeItem(this.tokenSectionName);
+                    credentials = null;
+                }
+            }
+            else {
+                credentials = this.accessKeyCredentials || null;
+                isAccessKeyCredentials = true;
+            }
+            return { credentials, isAccessKeyCredentials };
+        });
+    }
+}
+class OAuth2Client {
+    constructor(options) {
+        this.initializePromise = null;
+        this.lockAcquired = false;
+        this.pendingInLock = [];
+        this.singlePromise = null;
+        if (!options.clientSecret) {
+            options.clientSecret = '';
+        }
+        if (!options.clientId && options.env) {
+            options.clientId = options.env;
+        }
+        this.apiOrigin = options.apiOrigin;
+        this.apiPath = options.apiPath || AUTH_API_PREFIX;
+        this.clientId = options.clientId;
+        this.i18n = options.i18n;
+        this.eventBus = options.eventBus;
+        this.singlePromise = new SinglePromise({ clientId: this.clientId });
+        this.retry = this.formatRetry(options.retry, OAuth2Client.defaultRetry);
+        if (options.baseRequest) {
+            this.baseRequest = options.baseRequest;
+        }
+        else {
+            this.baseRequest = defaultRequest;
+        }
+        this.tokenInURL = options.tokenInURL;
+        this.headers = options.headers;
+        this.storage = options.storage || defaultStorage;
+        this.localCredentials = new LocalCredentials({
+            tokenSectionName: `credentials_${options.clientId}`,
+            storage: this.storage,
+            clientId: options.clientId,
+        });
+        this.clientSecret = options.clientSecret;
+        if (options.clientId) {
+            this.basicAuth = `Basic ${weBtoa(`${options.clientId}:${this.clientSecret}`)}`;
+        }
+        this.wxCloud = options.wxCloud;
+        try {
+            if (isMp()) {
+                this.useWxCloud = options.useWxCloud;
+                if (this.wxCloud === undefined && options.env) {
+                    wx.cloud.init({ env: options.env });
+                    this.wxCloud = wx.cloud;
+                }
+            }
+        }
+        catch (error) {
+        }
+        this.refreshTokenFunc = options.refreshTokenFunc || this.defaultRefreshTokenFunc;
+        this.anonymousSignInFunc = options.anonymousSignInFunc;
+        this.onCredentialsError = options.onCredentialsError;
+        this.getInitialSession = options.getInitialSession;
+        this.onInitialSessionObtained = options.onInitialSessionObtained;
+        this.logDebugMessages = options.debug ?? false;
+        langEvent.bus.on(langEvent.LANG_CHANGE_EVENT, (params) => {
+            this.i18n = params.data?.i18n || this.i18n;
+        });
+    }
+    setGetInitialSession(callback) {
+        this.getInitialSession = callback;
+    }
+    setOnInitialSessionObtained(callback) {
+        this.onInitialSessionObtained = callback;
+    }
+    async initialize(func) {
+        if (this.initializePromise) {
+            return await this.initializePromise;
+        }
+        if (func !== undefined) {
+            this.initializePromise = func;
+            return await this.initializePromise;
+        }
+        this.initializePromise = (async () => await this._acquireLock(-1, async () => await this._initialize()))();
+        return await this.initializePromise;
+    }
+    async setCredentials(credentials) {
+        await this.initializePromise;
+        return this._acquireLock(-1, async () => this.localCredentials.setCredentials(credentials));
+    }
+    setAccessKeyCredentials(credentials) {
+        return this.localCredentials.setAccessKeyCredentials(credentials);
+    }
+    async getAccessToken() {
+        await this.initializePromise;
+        const credentials = await this.getCredentials();
+        if (credentials?.scope === DEFAULT_NODE_ACCESS_SCOPE) {
+            return Promise.resolve(credentials.access_token);
+        }
+        if (credentials?.access_token) {
+            return Promise.resolve(credentials.access_token);
+        }
+        const respErr = { error: ErrorType.UNAUTHENTICATED };
+        return Promise.reject(respErr);
+    }
+    async request(url, options) {
+        if (!options) {
+            options = {};
+        }
+        const retry = this.formatRetry(options.retry, this.retry);
+        options.headers = { ...options.headers, [this.i18n?.LANG_HEADER_KEY]: this.i18n?.lang };
+        if (this.headers) {
+            options.headers = {
+                ...this.headers,
+                ...options.headers,
+            };
+        }
+        if (!options.headers[RequestIdHeaderName]) {
+            options.headers[RequestIdHeaderName] = generateRequestId();
+        }
+        if (!options.headers[DeviceIdHeaderName]) {
+            const deviceId = await this.getDeviceId();
+            options.headers[DeviceIdHeaderName] = deviceId;
+        }
+        if (options?.withBasicAuth && this.basicAuth) {
+            options.headers.Authorization = this.basicAuth;
+        }
+        if (options?.withCredentials) {
+            const credentials = options.getCredentials ? await options.getCredentials() : await this.getCredentials();
+            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}`;
+                }
+            }
+        }
+        else {
+            if (this.clientId && url.indexOf('client_id') < 0) {
+                url += url.indexOf('?') < 0 ? '?' : '&';
+                url += `client_id=${this.clientId}`;
+            }
+        }
+        if (url.startsWith('/')) {
+            url = `${this.apiOrigin}${this.apiPath}${url}`;
+        }
+        let response = null;
+        const maxRequestTimes = retry + 1;
+        for (let requestTime = 0; requestTime < maxRequestTimes; requestTime++) {
+            try {
+                if (options.useWxCloud || this.useWxCloud) {
+                    response = await this.wxCloudCallFunction(url, options);
+                }
+                else {
+                    response = await this.baseRequest(url, options);
+                }
+                if (!!response?.code) {
+                    throw {
+                        error: response.code,
+                        error_description: response.message,
+                        error_uri: new URL(url).pathname,
+                    };
+                }
+                break;
+            }
+            catch (responseError) {
+                try {
+                    responseError.requestId = responseError.requestId || options.headers[RequestIdHeaderName] || '';
+                }
+                catch (error) { }
+                if (options.withCredentials && responseError && responseError.error === ErrorType.UNAUTHENTICATED) {
+                    await this.setCredentials(null);
+                    return Promise.reject(responseError);
+                }
+                if (requestTime === retry || !responseError || responseError.error !== 'unreachable') {
+                    return Promise.reject(responseError);
+                }
+            }
+            await this.sleep(OAuth2Client.retryInterval);
+        }
+        return response;
+    }
+    async wxCloudCallFunction(url, options) {
+        let result = null;
+        let responseError = null;
+        try {
+            let userAgent = '';
+            try {
+                userAgent = await wx.getRendererUserAgent();
+            }
+            catch (error) { }
+            const { result: responseResult } = await this.wxCloud.callFunction({
+                name: 'httpOverCallFunction',
+                data: {
+                    url,
+                    method: options.method,
+                    headers: {
+                        origin: 'https://servicewechat.com',
+                        'User-Agent': userAgent,
+                        ...options.headers,
+                    },
+                    body: options.body,
+                },
+            });
+            if (responseResult?.body?.error_code) {
+                responseError = responseResult?.body;
+                responseError.error_uri = getPathName(url);
+            }
+            else {
+                result = responseResult?.body;
+            }
+        }
+        catch (error) {
+            responseError = {
+                error: ErrorType.UNREACHABLE,
+                error_description: error.message,
+                error_uri: getPathName(url),
+            };
+        }
+        if (responseError) {
+            throw responseError;
+        }
+        else {
+            return result;
+        }
+    }
+    async getCredentials() {
+        await this.initializePromise;
+        return this._acquireLock(-1, async () => this._getCredentials());
+    }
+    getCredentialsSync() {
+        const credentials = this.localCredentials.getStorageCredentialsSync();
+        return credentials;
+    }
+    getCredentialsAsync() {
+        return this.getCredentials();
+    }
+    async getScope() {
+        const credentials = await this.localCredentials.getCredentials();
+        if (!credentials) {
+            const msg = 'credentials not found';
+            this.onCredentialsError?.({ msg });
+            return this.unAuthenticatedError(msg);
+        }
+        return credentials.scope;
+    }
+    async getGroups() {
+        const credentials = await this.localCredentials.getCredentials();
+        if (!credentials) {
+            const msg = 'credentials not found';
+            this.onCredentialsError?.({ msg });
+            return this.unAuthenticatedError(msg);
+        }
+        return credentials.groups;
+    }
+    async refreshToken(credentials, options) {
+        await this.initializePromise;
+        return this._acquireLock(-1, async () => this._refreshToken(credentials, options));
+    }
+    async _refreshToken(credentials, options) {
+        return this.singlePromise.run('_refreshToken', async () => {
+            if (credentials?.scope === DEFAULT_NODE_ACCESS_SCOPE) {
+                return credentials;
+            }
+            if (!credentials || !credentials.refresh_token) {
+                const msg = 'no refresh token found in credentials';
+                this.onCredentialsError?.({ msg });
+                return this.unAuthenticatedError(msg);
+            }
+            try {
+                const newCredentials = await this.refreshTokenFunc(credentials.refresh_token, credentials);
+                await this.localCredentials.setCredentials(newCredentials);
+                this.eventBus?.fire(EVENTS.AUTH_STATE_CHANGED, { event: AUTH_STATE_CHANGED_TYPE.TOKEN_REFRESHED });
+                return newCredentials;
+            }
+            catch (error) {
+                if (options?.throwError) {
+                    throw error;
+                }
+                if (error.error === ErrorType.INVALID_GRANT) {
+                    await this.localCredentials.setCredentials(null);
+                    const msg = error.error_description;
+                    this.onCredentialsError?.({ msg });
+                    return this.unAuthenticatedError(msg);
+                }
+                this.onCredentialsError?.({ msg: error.error_description });
+                return Promise.reject(error);
+            }
+        });
+    }
+    async anonymousLogin(credentials) {
+        return this.singlePromise.run('_anonymousLogin', async () => {
+            if (this.anonymousSignInFunc) {
+                const c = await this.anonymousSignInFunc(credentials);
+                credentials = c || (await this.localCredentials.getCredentials());
+            }
+            else {
+                credentials = await this.anonymousSignIn(credentials);
+            }
+            return credentials;
+        });
+    }
+    checkRetry(retry) {
+        let responseError = null;
+        if (typeof retry !== 'number' || retry < OAuth2Client.minRetry || retry > OAuth2Client.maxRetry) {
+            responseError = {
+                error: ErrorType.UNREACHABLE,
+                error_description: 'wrong options param: retry',
+            };
+        }
+        if (responseError) {
+            throw responseError;
+        }
+        return retry;
+    }
+    formatRetry(retry, defaultVale) {
+        if (typeof retry === 'undefined') {
+            return defaultVale;
+        }
+        return this.checkRetry(retry);
+    }
+    async sleep(ms) {
+        return new Promise((resolve) => {
+            setTimeout(() => {
+                resolve();
+            }, ms);
+        });
+    }
+    async anonymousSignIn(credentials) {
+        return this.singlePromise.run('_anonymous', async () => {
+            if (!credentials || credentials.scope !== 'anonymous') {
+                return this.unAuthenticatedError('no anonymous in credentials');
+            }
+            try {
+                const newCredentials = await this.request(ApiUrls.AUTH_SIGN_IN_ANONYMOUSLY_URL, {
+                    method: 'POST',
+                    withBasicAuth: true,
+                    body: {},
+                });
+                await this.localCredentials.setCredentials(newCredentials);
+                return newCredentials;
+            }
+            catch (error) {
+                if (error.error === ErrorType.INVALID_GRANT) {
+                    await this.localCredentials.setCredentials(null);
+                    return this.unAuthenticatedError(error.error_description);
+                }
+                return Promise.reject(error);
+            }
+        });
+    }
+    async defaultRefreshTokenFunc(refreshToken, credentials) {
+        if (refreshToken === undefined || refreshToken === '') {
+            const msg = 'refresh token not found';
+            this.onCredentialsError?.({ msg });
+            return this.unAuthenticatedError(msg);
+        }
+        let url = ApiUrls.AUTH_TOKEN_URL;
+        if (credentials?.version === 'v2') {
+            url = ApiUrlsV2.AUTH_TOKEN_URL;
+        }
+        const newCredentials = await this.request(url, {
+            method: 'POST',
+            body: {
+                client_id: this.clientId,
+                client_secret: this.clientSecret,
+                grant_type: 'refresh_token',
+                refresh_token: refreshToken,
+            },
+        });
+        return { ...newCredentials, version: credentials?.version || 'v1' };
+    }
+    async getDeviceId() {
+        if (this.deviceID) {
+            return this.deviceID;
+        }
+        let deviceId = await this.storage.getItem(DeviceIdSectionName);
+        if (!(typeof deviceId === 'string' && deviceId.length >= 16 && deviceId.length <= 48)) {
+            deviceId = uuidv4();
+            await this.storage.setItem(DeviceIdSectionName, deviceId);
+        }
+        this.deviceID = deviceId;
+        return deviceId;
+    }
+    unAuthenticatedError(err) {
+        const respErr = {
+            error: ErrorType.UNAUTHENTICATED,
+            error_description: err,
+        };
+        return Promise.reject(respErr);
+    }
+    _debug(...args) {
+        if (this.logDebugMessages) {
+            console.log('[OAuth2Client]', ...args);
+        }
+    }
+    async _initialize() {
+        try {
+            if (!this.getInitialSession) {
+                this._debug('#_initialize()', 'no getInitialSession callback set, skipping');
+                return { error: null };
+            }
+            this._debug('#_initialize()', 'calling getInitialSession callback');
+            try {
+                const { data, error } = await this.getInitialSession();
+                if (data?.session) {
+                    this._debug('#_initialize()', 'session obtained from getInitialSession', data.session);
+                    await this.localCredentials.setCredentials(data?.session);
+                }
+                if (this.onInitialSessionObtained) {
+                    this._debug('#_initialize()', 'calling onInitialSessionObtained callback');
+                    try {
+                        await this.onInitialSessionObtained(data, error);
+                    }
+                    catch (callbackError) {
+                        this._debug('#_initialize()', 'error in onInitialSessionObtained', callbackError);
+                    }
+                }
+                if (error) {
+                    this._debug('#_initialize()', 'error from getInitialSession', error);
+                    return { error };
+                }
+                return { error: null };
+            }
+            catch (err) {
+                this._debug('#_initialize()', 'exception during getInitialSession', err);
+                return { error: err instanceof Error ? err : new Error(String(err)) };
+            }
+        }
+        catch (error) {
+            this._debug('#_initialize()', 'unexpected error', error);
+            return { error: error instanceof Error ? error : new Error(String(error)) };
+        }
+        finally {
+            this._debug('#_initialize()', 'end');
+        }
+    }
+    async _acquireLock(acquireTimeout, fn) {
+        this._debug('#_acquireLock', 'begin', acquireTimeout);
+        try {
+            if (this.lockAcquired) {
+                const last = this.pendingInLock.length ? this.pendingInLock[this.pendingInLock.length - 1] : Promise.resolve();
+                const result = (async () => {
+                    await last;
+                    return await fn();
+                })();
+                this.pendingInLock.push((async () => {
+                    try {
+                        await result;
+                    }
+                    catch (_e) {
+                    }
+                })());
+                return result;
+            }
+            this._debug('#_acquireLock', 'acquiring lock for client', this.clientId);
+            try {
+                this.lockAcquired = true;
+                const result = fn();
+                this.pendingInLock.push((async () => {
+                    try {
+                        await result;
+                    }
+                    catch (_e) {
+                    }
+                })());
+                await result;
+                while (this.pendingInLock.length) {
+                    const waitOn = [...this.pendingInLock];
+                    await Promise.all(waitOn);
+                    this.pendingInLock.splice(0, waitOn.length);
+                }
+                return await result;
+            }
+            finally {
+                this._debug('#_acquireLock', 'releasing lock for client', this.clientId);
+                this.lockAcquired = false;
+            }
+        }
+        finally {
+            this._debug('#_acquireLock', 'end');
+        }
+    }
+    async _getCredentials() {
+        let credentials = await this.localCredentials.getCredentials();
+        if (credentials?.scope === DEFAULT_NODE_ACCESS_SCOPE) {
+            return credentials;
+        }
+        if (!credentials) {
+            const msg = 'credentials not found';
+            this.onCredentialsError?.({ msg });
+            return this.unAuthenticatedError(msg);
+        }
+        if (isCredentialsExpired(credentials)) {
+            if (credentials.refresh_token) {
+                try {
+                    credentials = await this._refreshToken(credentials);
+                }
+                catch (error) {
+                    if (credentials.scope === 'anonymous') {
+                        credentials = await this.anonymousLogin(credentials);
+                    }
+                    else {
+                        this.onCredentialsError?.({ msg: error.error_description });
+                        return Promise.reject(error);
+                    }
+                }
+            }
+            else if (credentials.scope === 'anonymous') {
+                credentials = await this.anonymousLogin(credentials);
+            }
+            else {
+                const msg = 'no refresh token found in credentials';
+                this.onCredentialsError?.({ msg });
+                return this.unAuthenticatedError(msg);
+            }
+        }
+        return credentials;
+    }
+}
+OAuth2Client.defaultRetry = 2;
+OAuth2Client.minRetry = 0;
+OAuth2Client.maxRetry = 5;
+OAuth2Client.retryInterval = 1000;
+export { OAuth2Client };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"oauth2client.js","sourceRoot":"","sources":["../../../src/oauth2client/oauth2client.ts"],"names":[],"mappings":"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"}