@cloudbase/oauth 0.1.1-alpha.12 → 0.1.1-alpha.13

package/packages/app/dist/esm/libs/request.js

@@ -0,0 +1,293 @@
+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 (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 { DATA_VERSION, getSdkVersion, getEndPoint, getBaseEndPoint, } from '../constants/common';
+import { utils, constants } from '@cloudbase/utilities';
+import { getLocalCache } from './cache';
+import { Platform } from './adapter';
+var ERRORS = constants.ERRORS;
+var genSeqId = utils.genSeqId, isFormData = utils.isFormData, formatUrl = utils.formatUrl;
+var ACTIONS_WITHOUT_ACCESSTOKEN = [
+    'auth.getJwt',
+    'auth.logout',
+    'auth.signInWithTicket',
+    'auth.signInAnonymously',
+    'auth.signIn',
+    'auth.signInWithWechat',
+    'auth.fetchAccessTokenWithRefreshToken',
+    'auth.signUpWithEmailAndPassword',
+    'auth.activateEndUserMail',
+    'auth.sendPasswordResetEmail',
+    'auth.resetPasswordWithToken',
+    'auth.isUsernameRegistered',
+];
+function bindHooks(instance, name, hooks) {
+    var originMethod = instance[name];
+    instance[name] = function (options) {
+        var data = {};
+        var headers = {};
+        hooks.forEach(function (hook) {
+            var _a = hook.call(instance, options), appendedData = _a.data, appendedHeaders = _a.headers;
+            Object.assign(data, appendedData);
+            Object.assign(headers, appendedHeaders);
+        });
+        var originData = options.data;
+        originData && (function () {
+            if (isFormData(originData)) {
+                Object.keys(data).forEach(function (key) {
+                    originData.append(key, data[key]);
+                });
+                return;
+            }
+            options.data = __assign(__assign({}, originData), data);
+        })();
+        options.headers = __assign(__assign({}, (options.headers || {})), headers);
+        return originMethod.call(instance, options);
+    };
+}
+function beforeEach() {
+    var seqId = genSeqId();
+    return {
+        data: {
+            seqId: seqId,
+        },
+        headers: {
+            'X-SDK-Version': "@cloudbase/js-sdk/".concat(getSdkVersion()),
+            'x-seqid': seqId,
+        },
+    };
+}
+var CloudbaseRequest = (function () {
+    function CloudbaseRequest(config) {
+        this.throwWhenRequestFail = false;
+        this.config = config;
+        var reqConfig = {
+            timeout: this.config.timeout,
+            timeoutMsg: "[@cloudbase/js-sdk] \u8BF7\u6C42\u5728".concat(this.config.timeout / 1000, "s\u5185\u672A\u5B8C\u6210\uFF0C\u5DF2\u4E2D\u65AD"),
+            restrictedMethods: ['post', 'put'],
+        };
+        this.reqClass = new Platform.adapter.reqClass(reqConfig);
+        this.throwWhenRequestFail = config.throw || false;
+        this.localCache = getLocalCache(this.config.env);
+        bindHooks(this.reqClass, 'post', [beforeEach]);
+        bindHooks(this.reqClass, 'upload', [beforeEach]);
+        bindHooks(this.reqClass, 'download', [beforeEach]);
+    }
+    CloudbaseRequest.prototype.post = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var res;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, this.reqClass.post(options)];
+                    case 1:
+                        res = _a.sent();
+                        return [2, res];
+                }
+            });
+        });
+    };
+    CloudbaseRequest.prototype.upload = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var res;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, this.reqClass.upload(options)];
+                    case 1:
+                        res = _a.sent();
+                        return [2, res];
+                }
+            });
+        });
+    };
+    CloudbaseRequest.prototype.download = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var res;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, this.reqClass.download(options)];
+                    case 1:
+                        res = _a.sent();
+                        return [2, res];
+                }
+            });
+        });
+    };
+    CloudbaseRequest.prototype.getBaseEndPoint = function () {
+        return getBaseEndPoint();
+    };
+    CloudbaseRequest.prototype.getOauthAccessTokenV2 = function (oauthClient) {
+        return __awaiter(this, void 0, void 0, function () {
+            var validAccessToken, credentials;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, oauthClient.getAccessToken()];
+                    case 1:
+                        validAccessToken = _a.sent();
+                        return [4, oauthClient.getCredentials()];
+                    case 2:
+                        credentials = _a.sent();
+                        return [2, {
+                                accessToken: validAccessToken,
+                                accessTokenExpire: new Date(credentials.expires_at).getTime(),
+                            }];
+                }
+            });
+        });
+    };
+    CloudbaseRequest.prototype.request = function (action, params, options) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var tcbTraceKey, contentType, tmpObj, app, oauthInstance, oauthClient, _b, payload, opts, traceHeader, parse, inQuery, search, formatQuery, _c, BASE_URL, PROTOCOL, newUrl, res, resTraceHeader;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        tcbTraceKey = "x-tcb-trace_".concat(this.config.env);
+                        contentType = 'application/x-www-form-urlencoded';
+                        tmpObj = __assign({ action: action, dataVersion: DATA_VERSION, env: this.config.env }, params);
+                        if (!(ACTIONS_WITHOUT_ACCESSTOKEN.indexOf(action) === -1)) return [3, 2];
+                        app = this.config._fromApp;
+                        if (!app.oauthInstance) {
+                            throw new Error('you can\'t request without auth');
+                        }
+                        oauthInstance = app.oauthInstance;
+                        oauthClient = oauthInstance.oauth2client;
+                        _b = tmpObj;
+                        return [4, this.getOauthAccessTokenV2(oauthClient)];
+                    case 1:
+                        _b.access_token = (_d.sent()).accessToken;
+                        _d.label = 2;
+                    case 2:
+                        if (action === 'storage.uploadFile') {
+                            payload = new FormData();
+                            Object.keys(payload).forEach(function (key) {
+                                if (Object.prototype.hasOwnProperty.call(payload, key) && payload[key] !== undefined) {
+                                    payload.append(key, tmpObj[key]);
+                                }
+                            });
+                            contentType = 'multipart/form-data';
+                        }
+                        else {
+                            contentType = 'application/json;charset=UTF-8';
+                            payload = {};
+                            Object.keys(tmpObj).forEach(function (key) {
+                                if (tmpObj[key] !== undefined) {
+                                    payload[key] = tmpObj[key];
+                                }
+                            });
+                        }
+                        opts = {
+                            headers: {
+                                'content-type': contentType,
+                            },
+                        };
+                        if (options === null || options === void 0 ? void 0 : options.onUploadProgress) {
+                            opts.onUploadProgress = options.onUploadProgress;
+                        }
+                        if (this.config.region) {
+                            opts.headers['X-TCB-Region'] = this.config.region;
+                        }
+                        traceHeader = this.localCache.getStore(tcbTraceKey);
+                        if (traceHeader) {
+                            opts.headers['X-TCB-Trace'] = traceHeader;
+                        }
+                        parse = params.parse, inQuery = params.inQuery, search = params.search;
+                        formatQuery = {
+                            env: this.config.env,
+                        };
+                        parse && (formatQuery.parse = true);
+                        inQuery && (formatQuery = __assign(__assign({}, inQuery), formatQuery));
+                        _c = getEndPoint(), BASE_URL = _c.BASE_URL, PROTOCOL = _c.PROTOCOL;
+                        newUrl = formatUrl(PROTOCOL, BASE_URL, formatQuery);
+                        if (search) {
+                            newUrl += search;
+                        }
+                        return [4, this.post(__assign({ url: newUrl, data: payload }, opts))];
+                    case 3:
+                        res = _d.sent();
+                        resTraceHeader = (_a = res.header) === null || _a === void 0 ? void 0 : _a['x-tcb-trace'];
+                        if (resTraceHeader) {
+                            this.localCache.setStore(tcbTraceKey, resTraceHeader);
+                        }
+                        if ((Number(res.status) !== 200 && Number(res.statusCode) !== 200) || !res.data) {
+                            throw new Error('network request error');
+                        }
+                        return [2, res];
+                }
+            });
+        });
+    };
+    CloudbaseRequest.prototype.send = function (action, data) {
+        if (data === void 0) { data = {}; }
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, this.request(action, data, { onUploadProgress: data.onUploadProgress })];
+                    case 1:
+                        response = _a.sent();
+                        if (response.data.code && this.throwWhenRequestFail) {
+                            throw new Error(JSON.stringify({
+                                code: ERRORS.OPERATION_FAIL,
+                                msg: "[".concat(response.data.code, "] ").concat(response.data.message),
+                            }));
+                        }
+                        return [2, response.data];
+                }
+            });
+        });
+    };
+    return CloudbaseRequest;
+}());
+export { CloudbaseRequest };
+var requestMap = {};
+export function initRequest(config) {
+    requestMap[config.env] = new CloudbaseRequest(__assign(__assign({}, config), { throw: true }));
+}
+export function getRequestByEnvId(env) {
+    return requestMap[env];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"request.js","sourceRoot":"","sources":["../../../src/libs/request.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,EACL,YAAY,EACZ,aAAa,EACb,WAAW,EACX,eAAe,GAChB,MAAM,qBAAqB,CAAA;AAQ5B,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAA;AAIvD,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAC5B,IAAA,MAAM,GAAK,SAAS,OAAd,CAAc;AACpB,IAAA,QAAQ,GAA4B,KAAK,SAAjC,EAAE,UAAU,GAAgB,KAAK,WAArB,EAAE,SAAS,GAAK,KAAK,UAAV,CAAU;AAGjD,IAAM,2BAA2B,GAAG;IAClC,aAAa;IACb,aAAa;IACb,uBAAuB;IACvB,wBAAwB;IACxB,aAAa;IACb,uBAAuB;IACvB,uCAAuC;IACvC,iCAAiC;IACjC,0BAA0B;IAC1B,6BAA6B;IAC7B,6BAA6B;IAC7B,2BAA2B;CAC5B,CAAA;AAED,SAAS,SAAS,CAAC,QAA6B,EAAE,IAAY,EAAE,KAA2B;IACzF,IAAM,YAAY,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAA;IACnC,QAAQ,CAAC,IAAI,CAAC,GAAG,UAAU,OAAwB;QACjD,IAAM,IAAI,GAAG,EAAE,CAAA;QACf,IAAM,OAAO,GAAG,EAAE,CAAA;QAClB,KAAK,CAAC,OAAO,CAAC,UAAC,IAAI;YACX,IAAA,KAAmD,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,OAAO,CAAC,EAAvE,YAAY,UAAA,EAAW,eAAe,aAAiC,CAAA;YACrF,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,YAAY,CAAC,CAAA;YACjC,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,eAAe,CAAC,CAAA;QACzC,CAAC,CAAC,CAAA;QACF,IAAM,UAAU,GAAG,OAAO,CAAC,IAAI,CAAA;QAC/B,UAAU,IAAI,CAAC;YACb,IAAI,UAAU,CAAC,UAAU,CAAC,EAAE;gBAC1B,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,UAAC,GAAG;oBAC3B,UAAuB,CAAC,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAA;gBACjD,CAAC,CAAC,CAAA;gBACF,OAAM;aACP;YACD,OAAO,CAAC,IAAI,yBACP,UAAU,GACV,IAAI,CACR,CAAA;QACH,CAAC,CAAC,EAAE,CAAA;QACJ,OAAO,CAAC,OAAO,yBACV,CAAC,OAAO,CAAC,OAAO,IAAI,EAAE,CAAC,GACvB,OAAO,CACX,CAAA;QACD,OAAQ,YAAyB,CAAC,IAAI,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAA;IAC3D,CAAC,CAAA;AACH,CAAC;AACD,SAAS,UAAU;IACjB,IAAM,KAAK,GAAG,QAAQ,EAAE,CAAA;IACxB,OAAO;QACL,IAAI,EAAE;YACJ,KAAK,OAAA;SACN;QACD,OAAO,EAAE;YACP,eAAe,EAAE,4BAAqB,aAAa,EAAE,CAAE;YACvD,SAAS,EAAE,KAAK;SACjB;KACF,CAAA;AACH,CAAC;AAYD;IAWE,0BAAY,MAAqD;QAPzD,yBAAoB,GAAG,KAAK,CAAA;QAQlC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;QACpB,IAAM,SAAS,GAAmB;YAChC,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,OAAO;YAC5B,UAAU,EAAE,gDAA0B,IAAI,CAAC,MAAM,CAAC,OAAO,GAAG,IAAI,sDAAW;YAC3E,iBAAiB,EAAE,CAAC,MAAM,EAAE,KAAK,CAAC;SACnC,CAAA;QACD,IAAI,CAAC,QAAQ,GAAG,IAAI,QAAQ,CAAC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAA;QACxD,IAAI,CAAC,oBAAoB,GAAG,MAAM,CAAC,KAAK,IAAI,KAAK,CAAA;QACjD,IAAI,CAAC,UAAU,GAAG,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;QAChD,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAC,UAAU,CAAC,CAAC,CAAA;QAC9C,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ,EAAE,CAAC,UAAU,CAAC,CAAC,CAAA;QAChD,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,UAAU,EAAE,CAAC,UAAU,CAAC,CAAC,CAAA;IACpD,CAAC;IAEY,+BAAI,GAAjB,UAAkB,OAAwB;;;;;4BAC5B,WAAM,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,EAAA;;wBAAvC,GAAG,GAAG,SAAiC;wBAC7C,WAAO,GAAG,EAAA;;;;KACX;IACY,iCAAM,GAAnB,UAAoB,OAA8B;;;;;4BACpC,WAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,EAAA;;wBAAzC,GAAG,GAAG,SAAmC;wBAC/C,WAAO,GAAG,EAAA;;;;KACX;IACY,mCAAQ,GAArB,UAAsB,OAAwB;;;;;4BAChC,WAAM,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAA;;wBAA3C,GAAG,GAAG,SAAqC;wBACjD,WAAO,GAAG,EAAA;;;;KACX;IAEM,0CAAe,GAAtB;QACE,OAAO,eAAe,EAAE,CAAA;IAC1B,CAAC;IAEY,gDAAqB,GAAlC,UAAmC,WAAgB;;;;;4BACxB,WAAM,WAAW,CAAC,cAAc,EAAE,EAAA;;wBAArD,gBAAgB,GAAG,SAAkC;wBACvC,WAAM,WAAW,CAAC,cAAc,EAAE,EAAA;;wBAAhD,WAAW,GAAG,SAAkC;wBACtD,WAAO;gCACL,WAAW,EAAE,gBAAgB;gCAC7B,iBAAiB,EAAE,IAAI,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC,OAAO,EAAE;6BAC9D,EAAA;;;;KACF;IAIY,kCAAO,GAApB,UAAqB,MAAc,EAAE,MAAe,EAAE,OAAiB;;;;;;;wBAC/D,WAAW,GAAG,sBAAe,IAAI,CAAC,MAAM,CAAC,GAAG,CAAE,CAAA;wBAChD,WAAW,GAAG,mCAAmC,CAAA;wBAC/C,MAAM,cACV,MAAM,QAAA,EACN,WAAW,EAAE,YAAY,EACzB,GAAG,EAAE,IAAI,CAAC,MAAM,CAAC,GAAG,IACjB,MAAM,CACV,CAAA;6BAEG,CAAA,2BAA2B,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAA,EAAlD,cAAkD;wBAC9C,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAA;wBAEhC,IAAI,CAAC,GAAG,CAAC,aAAa,EAAE;4BACtB,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAA;yBACnD;wBAEO,aAAa,GAAK,GAAG,cAAR,CAAQ;wBACvB,WAAW,GAAG,aAAa,CAAC,YAAY,CAAA;wBAC9C,KAAA,MAAM,CAAA;wBAAiB,WAAM,IAAI,CAAC,qBAAqB,CAAC,WAAW,CAAC,EAAA;;wBAApE,GAAO,YAAY,GAAG,CAAC,SAA6C,CAAC,CAAC,WAAW,CAAA;;;wBAKnF,IAAI,MAAM,KAAK,oBAAoB,EAAE;4BACnC,OAAO,GAAG,IAAI,QAAQ,EAAE,CAAA;4BACxB,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,UAAC,GAAG;gCAC/B,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,CAAC,IAAI,OAAO,CAAC,GAAG,CAAC,KAAK,SAAS,EAAE;oCACpF,OAAO,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAA;iCACjC;4BACH,CAAC,CAAC,CAAA;4BACF,WAAW,GAAG,qBAAqB,CAAA;yBACpC;6BAAM;4BACL,WAAW,GAAG,gCAAgC,CAAA;4BAC9C,OAAO,GAAG,EAAE,CAAA;4BACZ,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,UAAC,GAAG;gCAC9B,IAAI,MAAM,CAAC,GAAG,CAAC,KAAK,SAAS,EAAE;oCAC7B,OAAO,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAA;iCAC3B;4BACH,CAAC,CAAC,CAAA;yBACH;wBACK,IAAI,GAAQ;4BAChB,OAAO,EAAE;gCACP,cAAc,EAAE,WAAW;6BAC5B;yBACF,CAAA;wBACD,IAAI,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,gBAAgB,EAAE;4BAC7B,IAAI,CAAC,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAA;yBACjD;wBAED,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE;4BACtB,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAA;yBAClD;wBAEK,WAAW,GAAG,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAA;wBACzD,IAAI,WAAW,EAAE;4BACf,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,GAAG,WAAW,CAAA;yBAC1C;wBAKO,KAAK,GAAsB,MAAM,MAA5B,EAAE,OAAO,GAAa,MAAM,QAAnB,EAAE,MAAM,GAAK,MAAM,OAAX,CAAW;wBACrC,WAAW,GAAwB;4BACrC,GAAG,EAAE,IAAI,CAAC,MAAM,CAAC,GAAG;yBACrB,CAAA;wBAED,KAAK,IAAI,CAAC,WAAW,CAAC,KAAK,GAAG,IAAI,CAAC,CAAA;wBACnC,OAAO,IAAI,CAAC,WAAW,yBAClB,OAAO,GACP,WAAW,CACf,CAAC,CAAA;wBACI,KAAyB,WAAW,EAAE,EAApC,QAAQ,cAAA,EAAE,QAAQ,cAAA,CAAkB;wBAExC,MAAM,GAAG,SAAS,CAAC,QAAQ,EAAE,QAAQ,EAAE,WAAW,CAAC,CAAA;wBAEvD,IAAI,MAAM,EAAE;4BACV,MAAM,IAAI,MAAM,CAAA;yBACjB;wBAE2B,WAAM,IAAI,CAAC,IAAI,YACzC,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,OAAO,IACV,IAAI,EACP,EAAA;;wBAJI,GAAG,GAAmB,SAI1B;wBAGI,cAAc,GAAG,MAAA,GAAG,CAAC,MAAM,0CAAG,aAAa,CAAC,CAAA;wBAClD,IAAI,cAAc,EAAE;4BAClB,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,WAAW,EAAE,cAAc,CAAC,CAAA;yBACtD;wBAED,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,GAAG,IAAI,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,KAAK,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE;4BAC/E,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAA;yBACzC;wBAED,WAAO,GAAG,EAAA;;;;KACX;IAEY,+BAAI,GAAjB,UAAkB,MAAc,EAAE,IAAkB;QAAlB,qBAAA,EAAA,SAAkB;;;;;4BACjC,WAAM,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE,gBAAgB,EAAE,IAAI,CAAC,gBAAgB,EAAE,CAAC,EAAA;;wBAAxF,QAAQ,GAAG,SAA6E;wBAE9F,IAAI,QAAQ,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,oBAAoB,EAAE;4BACnD,MAAM,IAAI,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC;gCAC7B,IAAI,EAAE,MAAM,CAAC,cAAc;gCAC3B,GAAG,EAAE,WAAI,QAAQ,CAAC,IAAI,CAAC,IAAI,eAAK,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAE;6BACxD,CAAC,CAAC,CAAA;yBACJ;wBAED,WAAO,QAAQ,CAAC,IAAI,EAAA;;;;KACrB;IACH,uBAAC;AAAD,CAAC,AArKD,IAqKC;;AAED,IAAM,UAAU,GAAyB,EAAE,CAAA;AAE3C,MAAM,UAAU,WAAW,CAAC,MAA+B;IACzD,UAAU,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI,gBAAgB,uBACxC,MAAM,KACT,KAAK,EAAE,IAAI,IACX,CAAA;AACJ,CAAC;AAED,MAAM,UAAU,iBAAiB,CAAC,GAAW;IAC3C,OAAO,UAAU,CAAC,GAAG,CAAC,CAAA;AACxB,CAAC","sourcesContent":["import {\n  DATA_VERSION,\n  getSdkVersion,\n  getEndPoint,\n  getBaseEndPoint,\n} from '../constants/common'\nimport {\n  IRequestOptions,\n  SDKRequestInterface,\n  ResponseObject,\n  IUploadRequestOptions,\n  IRequestConfig,\n} from '@cloudbase/adapter-interface'\nimport { utils, constants } from '@cloudbase/utilities'\nimport { KV } from '@cloudbase/types'\nimport { IGetAccessTokenResult, ICloudbaseRequestConfig, IAppendedRequestInfo, IRequestBeforeHook } from '@cloudbase/types/request'\nimport { ICloudbaseCache } from '@cloudbase/types/cache'\nimport { getLocalCache } from './cache'\nimport { Platform } from './adapter'\nconst { ERRORS } = constants\nconst { genSeqId, isFormData, formatUrl } = utils\n\n// 下面几种 action 不需要 access token\nconst ACTIONS_WITHOUT_ACCESSTOKEN = [\n  'auth.getJwt',\n  'auth.logout',\n  'auth.signInWithTicket',\n  'auth.signInAnonymously',\n  'auth.signIn',\n  'auth.signInWithWechat',\n  'auth.fetchAccessTokenWithRefreshToken',\n  'auth.signUpWithEmailAndPassword',\n  'auth.activateEndUserMail',\n  'auth.sendPasswordResetEmail',\n  'auth.resetPasswordWithToken',\n  'auth.isUsernameRegistered',\n]\n\nfunction bindHooks(instance: SDKRequestInterface, name: string, hooks: IRequestBeforeHook[]) {\n  const originMethod = instance[name]\n  instance[name] = function (options: IRequestOptions) {\n    const data = {}\n    const headers = {}\n    hooks.forEach((hook) => {\n      const { data: appendedData, headers: appendedHeaders } = hook.call(instance, options)\n      Object.assign(data, appendedData)\n      Object.assign(headers, appendedHeaders)\n    })\n    const originData = options.data\n    originData && (() => {\n      if (isFormData(originData)) {\n        Object.keys(data).forEach((key) => {\n          (originData as FormData).append(key, data[key])\n        })\n        return\n      }\n      options.data = {\n        ...originData,\n        ...data,\n      }\n    })()\n    options.headers = {\n      ...(options.headers || {}),\n      ...headers,\n    }\n    return (originMethod as Function).call(instance, options)\n  }\n}\nfunction beforeEach(): IAppendedRequestInfo {\n  const seqId = genSeqId()\n  return {\n    data: {\n      seqId,\n    },\n    headers: {\n      'X-SDK-Version': `@cloudbase/js-sdk/${getSdkVersion()}`,\n      'x-seqid': seqId,\n    },\n  }\n}\nexport interface ICloudbaseRequest {\n  post: (options: IRequestOptions) => Promise<ResponseObject>;\n  upload: (options: IUploadRequestOptions) => Promise<ResponseObject>;\n  download: (options: IRequestOptions) => Promise<ResponseObject>;\n  request: (action: string, params: KV<any>, options?: KV<any>) => Promise<ResponseObject>;\n  send: (action: string, data: KV<any>) => Promise<any>;\n}\n\n/**\n * @class CloudbaseRequest\n */\nexport class CloudbaseRequest implements ICloudbaseRequest {\n  config: ICloudbaseRequestConfig\n  private reqClass: SDKRequestInterface\n  // 请求失败是否抛出Error\n  private throwWhenRequestFail = false\n  // 持久化本地存储\n  private localCache: ICloudbaseCache\n  /**\n   * 初始化\n   * @param config\n   */\n  constructor(config: ICloudbaseRequestConfig & { throw?: boolean }) {\n    this.config = config\n    const reqConfig: IRequestConfig = {\n      timeout: this.config.timeout,\n      timeoutMsg: `[@cloudbase/js-sdk] 请求在${this.config.timeout / 1000}s内未完成，已中断`,\n      restrictedMethods: ['post', 'put'],\n    }\n    this.reqClass = new Platform.adapter.reqClass(reqConfig)\n    this.throwWhenRequestFail = config.throw || false\n    this.localCache = getLocalCache(this.config.env)\n    bindHooks(this.reqClass, 'post', [beforeEach])\n    bindHooks(this.reqClass, 'upload', [beforeEach])\n    bindHooks(this.reqClass, 'download', [beforeEach])\n  }\n\n  public async post(options: IRequestOptions): Promise<ResponseObject> {\n    const res = await this.reqClass.post(options)\n    return res\n  }\n  public async upload(options: IUploadRequestOptions): Promise<ResponseObject> {\n    const res = await this.reqClass.upload(options)\n    return res\n  }\n  public async download(options: IRequestOptions): Promise<ResponseObject> {\n    const res = await this.reqClass.download(options)\n    return res\n  }\n\n  public getBaseEndPoint() {\n    return getBaseEndPoint()\n  }\n\n  public async getOauthAccessTokenV2(oauthClient: any): Promise<IGetAccessTokenResult> {\n    const validAccessToken = await oauthClient.getAccessToken()\n    const credentials = await oauthClient.getCredentials()\n    return {\n      accessToken: validAccessToken,\n      accessTokenExpire: new Date(credentials.expires_at).getTime(),\n    }\n  }\n\n\n  /* eslint-disable complexity */\n  public async request(action: string, params: KV<any>, options?: KV<any>): Promise<ResponseObject> {\n    const tcbTraceKey = `x-tcb-trace_${this.config.env}`\n    let contentType = 'application/x-www-form-urlencoded'\n    const tmpObj: KV<any> = {\n      action,\n      dataVersion: DATA_VERSION,\n      env: this.config.env,\n      ...params,\n    }\n\n    if (ACTIONS_WITHOUT_ACCESSTOKEN.indexOf(action) === -1) {\n      const app = this.config._fromApp\n\n      if (!app.oauthInstance) {\n        throw new Error('you can\\'t request without auth')\n      }\n\n      const { oauthInstance } = app\n      const oauthClient = oauthInstance.oauth2client\n      tmpObj.access_token = (await this.getOauthAccessTokenV2(oauthClient)).accessToken\n    }\n\n    // 拼body和content-type\n    let payload\n    if (action === 'storage.uploadFile') {\n      payload = new FormData()\n      Object.keys(payload).forEach((key) => {\n        if (Object.prototype.hasOwnProperty.call(payload, key) && payload[key] !== undefined) {\n          payload.append(key, tmpObj[key])\n        }\n      })\n      contentType = 'multipart/form-data'\n    } else {\n      contentType = 'application/json;charset=UTF-8'\n      payload = {}\n      Object.keys(tmpObj).forEach((key) => {\n        if (tmpObj[key] !== undefined) {\n          payload[key] = tmpObj[key]\n        }\n      })\n    }\n    const opts: any = {\n      headers: {\n        'content-type': contentType,\n      },\n    }\n    if (options?.onUploadProgress) {\n      opts.onUploadProgress = options.onUploadProgress\n    }\n\n    if (this.config.region) {\n      opts.headers['X-TCB-Region'] = this.config.region\n    }\n\n    const traceHeader = this.localCache.getStore(tcbTraceKey)\n    if (traceHeader) {\n      opts.headers['X-TCB-Trace'] = traceHeader\n    }\n\n    // 发出请求\n    // 新的 url 需要携带 env 参数进行 CORS 校验\n    // 请求链接支持添加动态 query 参数，方便用户调试定位请求\n    const { parse, inQuery, search } = params\n    let formatQuery: Record<string, any> = {\n      env: this.config.env,\n    }\n    // 尝试解析响应数据为 JSON\n    parse && (formatQuery.parse = true)\n    inQuery && (formatQuery = {\n      ...inQuery,\n      ...formatQuery,\n    })\n    const { BASE_URL, PROTOCOL } = getEndPoint()\n    // 生成请求 url\n    let newUrl = formatUrl(PROTOCOL, BASE_URL, formatQuery)\n\n    if (search) {\n      newUrl += search\n    }\n\n    const res: ResponseObject = await this.post({\n      url: newUrl,\n      data: payload,\n      ...opts,\n    })\n\n    // 保存 trace header\n    const resTraceHeader = res.header?.['x-tcb-trace']\n    if (resTraceHeader) {\n      this.localCache.setStore(tcbTraceKey, resTraceHeader)\n    }\n\n    if ((Number(res.status) !== 200 && Number(res.statusCode) !== 200) || !res.data) {\n      throw new Error('network request error')\n    }\n\n    return res\n  }\n\n  public async send(action: string, data: KV<any> = {}): Promise<any> {\n    const response = await this.request(action, data, { onUploadProgress: data.onUploadProgress })\n\n    if (response.data.code && this.throwWhenRequestFail) {\n      throw new Error(JSON.stringify({\n        code: ERRORS.OPERATION_FAIL,\n        msg: `[${response.data.code}] ${response.data.message}`,\n      }))\n    }\n\n    return response.data\n  }\n}\n\nconst requestMap: KV<CloudbaseRequest> = {}\n\nexport function initRequest(config: ICloudbaseRequestConfig) {\n  requestMap[config.env] = new CloudbaseRequest({\n    ...config,\n    throw: true,\n  })\n}\n\nexport function getRequestByEnvId(env: string): CloudbaseRequest {\n  return requestMap[env]\n}\n"]}

package/packages/auth/dist/cjs/index.d.ts

@@ -0,0 +1,117 @@
+import { ICloudbase } from '@cloudbase/types';
+import { ICloudbaseCache } from '@cloudbase/types/cache';
+import { ICloudbaseRequest } from '@cloudbase/types/request';
+import { ICloudbaseAuthConfig, IUser, IUserInfo, ILoginState } from '@cloudbase/types/auth';
+import { authModels, CloudbaseOAuth, Credentials } from '@cloudbase/oauth';
+import { ProviderSubType } from '@cloudbase/oauth/dist/cjs/auth/models';
+interface UserInfo {
+    uid?: string;
+    gender?: string;
+    picture?: string;
+    email?: string;
+    email_verified?: boolean;
+    phone_number?: string;
+    username?: string;
+    name?: string;
+    birthdate?: string;
+    zoneinfo?: string;
+    locale?: string;
+    sub?: string;
+    created_from?: string;
+}
+interface IUserOptions {
+    cache: ICloudbaseCache;
+    oauthInstance: CloudbaseOAuth;
+}
+interface ILoginStateOptions extends IUserOptions {
+    envId: string;
+}
+export declare class LoginState implements ILoginState {
+    user: IUser;
+    oauthLoginState: any;
+    private oauthInstance;
+    private cache;
+    constructor(options: ILoginStateOptions);
+    checkLocalState(): void;
+    checkLocalStateAsync(): Promise<void>;
+}
+declare class Auth {
+    private readonly config;
+    private readonly cache;
+    private oauthInstance;
+    constructor(config: ICloudbaseAuthConfig & {
+        cache: ICloudbaseCache;
+        request?: ICloudbaseRequest;
+        runtime?: string;
+    });
+    bindPhoneNumber(params: authModels.BindPhoneRequest): Promise<void>;
+    unbindProvider(params: authModels.UnbindProviderRequest): Promise<void>;
+    bindEmail(params: authModels.BindEmailRequest): Promise<void>;
+    verify(params: authModels.VerifyRequest): Promise<authModels.VerifyResponse>;
+    getVerification(params: authModels.GetVerificationRequest): Promise<authModels.GetVerificationResponse>;
+    get currentUser(): IUser;
+    getCurrentUser(): Promise<IUser>;
+    signInAnonymously(data?: {
+        provider_token?: string;
+    }): Promise<LoginState>;
+    signInWithWechat(params?: any): Promise<LoginState>;
+    setCustomSignFunc(getTickFn: authModels.GetCustomSignTicketFn): void;
+    signInWithCustomTicket(params?: {
+        version?: string;
+    }): Promise<LoginState>;
+    signIn(params: authModels.SignInRequest): Promise<LoginState>;
+    signUp(params: authModels.SignUpRequest): Promise<LoginState>;
+    setPassword(params: authModels.SetPasswordRequest): Promise<void>;
+    isUsernameRegistered(username: string): Promise<boolean>;
+    signOut(): Promise<void>;
+    hasLoginState(): LoginState | null;
+    getLoginState(): Promise<LoginState>;
+    getUserInfo(params?: {
+        version?: string;
+    }): Promise<IUserInfo>;
+    getWedaUserInfo(): Promise<any>;
+    getAuthHeader(): {};
+    bindWithProvider(params: authModels.BindWithProviderRequest): Promise<void>;
+    queryUser(queryObj: authModels.QueryUserProfileRequest): Promise<authModels.QueryUserProfileResponse>;
+    getAccessToken(): Promise<{
+        accessToken: string;
+        env: string;
+    }>;
+    grantProviderToken(params: authModels.GrantProviderTokenRequest): Promise<authModels.GrantProviderTokenResponse>;
+    patchProviderToken(params: authModels.PatchProviderTokenRequest): Promise<authModels.PatchProviderTokenResponse>;
+    signInWithProvider(params: authModels.SignInWithProviderRequest): Promise<LoginState>;
+    grantToken(params: authModels.GrantTokenRequest): Promise<LoginState>;
+    genProviderRedirectUri(params: authModels.GenProviderRedirectUriRequest): Promise<authModels.GenProviderRedirectUriResponse>;
+    resetPassword(params: authModels.ResetPasswordRequest): Promise<void>;
+    deviceAuthorize(params: authModels.DeviceAuthorizeRequest): Promise<authModels.DeviceAuthorizeResponse>;
+    sudo(params: authModels.SudoRequest): Promise<authModels.SudoResponse>;
+    deleteMe(params: authModels.WithSudoRequest): Promise<authModels.UserProfile>;
+    getProviders(): Promise<authModels.UserProfileProvider>;
+    loginScope(): Promise<string>;
+    loginGroups(): Promise<string[]>;
+    onLoginStateChanged(callback: Function): Promise<void>;
+    refreshTokenForce(params: {
+        version?: string;
+    }): Promise<Credentials>;
+    getCredentials(): Promise<Credentials>;
+    getProviderSubType(): Promise<ProviderSubType>;
+    createCaptchaData(params: {
+        state: string;
+        redirect_uri?: string;
+    }): Promise<{
+        captcha_token: string;
+        expires_in: number;
+    }>;
+    verifyCaptchaData(params: {
+        token: string;
+        key: string;
+    }): Promise<{
+        captcha_token: string;
+        expires_in: number;
+    }>;
+    getMiniProgramCode(params: authModels.GetMiniProgramCodeRequest): Promise<authModels.GetMiniProgramCodeResponse>;
+    checkMiniProgramCode(params: authModels.CheckMiniProgramCodeRequest): Promise<authModels.CheckMiniProgramCodeResponse>;
+    private createLoginState;
+}
+export { UserInfo, Auth };
+export declare function registerAuth(app: Pick<ICloudbase, 'registerComponent'>): void;