@cloudbase/oauth 0.1.1-alpha.7 → 0.1.1-alpha.9

package/dist/captcha/index.js

@@ -1,13 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Captcha = exports.getCaptcha = void 0;
+const consts_1 = require("../auth/consts");
 const internal_1 = require("../app/internal");
+const mp_1 = require("../utils/mp");
 function getCaptcha(app, opts) {
-    return (0, internal_1._getComponent)(app, "captcha", () => {
+    return (0, internal_1._getComponent)(app, 'captcha', () => {
         const initOpts = {
+            ...app.options.captchaOptions,
+            clientId: app.options.clientId,
             request: app.options.request,
             storage: app.options.storage,
-            openURIWithCallback: app.options.openURIWithCallback,
         };
         if (opts && opts.request) {
             initOpts.request = opts.request;
@@ -16,15 +19,14 @@ function getCaptcha(app, opts) {
     });
 }
 exports.getCaptcha = getCaptcha;
-const GET_CAPTCHA_URL = '/auth/v1/captcha/init';
 class Captcha {
     /**
      * constructor
      * @param {CaptchaOptions} opts
      */
     constructor(opts) {
-        this._config = opts;
-        this._tokenSectionName = 'captcha_';
+        this.config = opts;
+        this.tokenSectionName = `captcha_${opts.clientId || ''}`;
     }
     /**
      * request http like simple fetch api, exp:request('/v1/user/me', {withCredentials:true})
@@ -38,79 +40,97 @@ class Captcha {
         if (!options.method) {
             options.method = 'GET';
         }
-        const state = options.method + ":" + url;
+        const state = `${options.method}:${url}`;
         let reqURL = url;
         if (options.withCaptcha) {
-            reqURL = await this._appendCaptchaTokenToURL(url, state, false);
+            reqURL = await this.appendCaptchaTokenToURL(url, state, false);
         }
         let resp;
         try {
-            resp = await this._config.request(reqURL, options);
+            resp = await this.config.request(reqURL, options);
         }
         catch (err) {
-            if (err.error === 'captcha_required' || err.error === 'captcha_invalid') {
-                url = await this._appendCaptchaTokenToURL(url, state, err.error === 'captcha_invalid');
-                return this._config.request(url, options);
-            }
-            else {
-                return Promise.reject(err);
+            if (err.error === consts_1.ErrorType.CAPTCHA_REQUIRED || err.error === consts_1.ErrorType.CAPTCHA_INVALID) {
+                url = await this.appendCaptchaTokenToURL(url, state, err.error === consts_1.ErrorType.CAPTCHA_INVALID);
+                return this.config.request(url, options);
             }
+            return Promise.reject(err);
         }
         return resp;
     }
     /**
-     * _getCaptchaToken get captcha token
+     * getCaptchaToken 获取captchaToken
      */
-    async _getCaptchaToken(forceNewToken, state) {
+    async getCaptchaToken(forceNewToken, state) {
         if (!forceNewToken) {
-            // if local has captcha token then return
-            const captchaToken = await this._findCaptchaToken();
+            // 如果本地存在，则直接返回
+            const captchaToken = await this.findCaptchaToken();
             if (captchaToken) {
                 return captchaToken;
             }
         }
-        const redirectURL = window.location.origin + window.location.pathname;
-        const captchaTokenResp = await this._config.request(GET_CAPTCHA_URL, {
-            method: 'POST',
-            body: {
-                redirect_uri: redirectURL,
-                state: state
-            },
-            withBasicAuth: true,
-        });
-        if (captchaTokenResp.captcha_token) {
-            const captchaToken = {
-                captcha_token: captchaTokenResp.captcha_token,
-                expires_in: captchaTokenResp.expires_in,
+        let captchaTokenResp;
+        if ((0, mp_1.isMp)() || (0, mp_1.isInMpWebView)()) {
+            /**
+             * https://iwiki.woa.com/p/4010699417
+             */
+            const captchaDataResp = await this.config.request(consts_1.ApiUrls.CAPTCHA_DATA_URL, {
+                method: 'POST',
+                body: {
+                    state,
+                    redirect_uri: '',
+                },
+                withBasicAuth: true,
+                withCredentials: false,
+            });
+            captchaTokenResp = {
+                url: `${captchaDataResp.data}?state=${encodeURIComponent(state)}&token=${captchaDataResp.token}`,
             };
-            await this._saveCaptchaToken(captchaToken);
-            return captchaTokenResp.captcha_token;
         }
-        const callbackData = await this._config.openURIWithCallback(captchaTokenResp.url, { width: '355px', height: '355px' });
-        const captchaToken = {
-            captcha_token: callbackData.captcha_token,
-            expires_in: Number(callbackData.expires_in)
-        };
-        await this._saveCaptchaToken(captchaToken);
+        else {
+            const redirect_uri = `${window.location.origin + window.location.pathname}?__captcha=on`;
+            captchaTokenResp = await this.config.request(consts_1.ApiUrls.GET_CAPTCHA_URL, {
+                method: 'POST',
+                body: {
+                    client_id: this.config.clientId,
+                    redirect_uri,
+                    state,
+                },
+                withBasicAuth: true,
+            });
+        }
+        const captchaToken = captchaTokenResp.captcha_token
+            ? {
+                captcha_token: captchaTokenResp.captcha_token,
+                expires_in: captchaTokenResp.expires_in,
+            }
+            : await this.config.openURIWithCallback(captchaTokenResp.url, {
+                width: '355px',
+                height: '355px',
+            });
+        await this.saveCaptchaToken({
+            captcha_token: captchaToken.captcha_token,
+            expires_in: Number(captchaToken.expires_in),
+        });
         return captchaToken.captcha_token;
     }
-    async _appendCaptchaTokenToURL(url, state, forceNewToken) {
-        const captchaToken = await this._getCaptchaToken(forceNewToken, state);
-        if (url.indexOf("?") > 0) {
-            url += "&captcha_token=" + captchaToken;
+    async appendCaptchaTokenToURL(url, state, forceNewToken) {
+        const captchaToken = await this.getCaptchaToken(forceNewToken, state);
+        if (url.indexOf('?') > 0) {
+            url += `&captcha_token=${captchaToken}`;
         }
         else {
-            url += "?captcha_token=" + captchaToken;
+            url += `?captcha_token=${captchaToken}`;
         }
         return url;
     }
-    async _saveCaptchaToken(token) {
+    async saveCaptchaToken(token) {
         token.expires_at = new Date(Date.now() + (token.expires_in - 10) * 1000);
         const tokenStr = JSON.stringify(token);
-        await this._config.storage.setItem(this._tokenSectionName, tokenStr);
+        await this.config.storage.setItem(this.tokenSectionName, tokenStr);
     }
-    async _findCaptchaToken() {
-        const tokenStr = await this._config.storage.getItem(this._tokenSectionName);
+    async findCaptchaToken() {
+        const tokenStr = await this.config.storage.getItem(this.tokenSectionName);
         if (tokenStr !== undefined && tokenStr !== null) {
             try {
                 const captchaToken = JSON.parse(tokenStr);
@@ -124,7 +144,7 @@ class Captcha {
                 return captchaToken.captcha_token;
             }
             catch (error) {
-                await this._config.storage.removeItem(this._tokenSectionName);
+                await this.config.storage.removeItem(this.tokenSectionName);
                 return null;
             }
         }
@@ -132,4 +152,3 @@ class Captcha {
     }
 }
 exports.Captcha = Captcha;
-//# sourceMappingURL=index.js.map

package/dist/function/index.js

@@ -77,4 +77,3 @@ class Function {
     }
 }
 exports.Function = Function;
-//# sourceMappingURL=index.js.map

package/dist/index.js

@@ -21,4 +21,3 @@ Object.defineProperty(exports, "initializeApp", { enumerable: true, get: functio
 var auth_2 = require("./auth");
 Object.defineProperty(exports, "Auth", { enumerable: true, get: function () { return auth_2.Auth; } });
 Object.defineProperty(exports, "getAuth", { enumerable: true, get: function () { return auth_2.getAuth; } });
-//# sourceMappingURL=index.js.map

package/dist/oauthclient/consts.js

@@ -50,4 +50,3 @@ var ErrorType;
     ErrorType["TEMPORARILY_UNAVAILABLE"] = "temporarily_unavailable";
     ErrorType["INTERACTION_REQUIRED"] = "interaction_required";
 })(ErrorType = exports.ErrorType || (exports.ErrorType = {}));
-//# sourceMappingURL=consts.js.map

package/dist/oauthclient/index.js

@@ -18,4 +18,3 @@ function getOAuthClient(app, opts) {
     });
 }
 exports.getOAuthClient = getOAuthClient;
-//# sourceMappingURL=index.js.map

package/dist/oauthclient/interface.js

@@ -7,4 +7,3 @@ exports.AuthClient = void 0;
 class AuthClient {
 }
 exports.AuthClient = AuthClient;
-//# sourceMappingURL=interface.js.map

package/dist/oauthclient/models.js

@@ -1,3 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=models.js.map

package/dist/oauthclient/oauthclient.js

@@ -412,4 +412,3 @@ OAuth2Client._defaultRetry = 2;
 OAuth2Client._minRetry = 0;
 OAuth2Client._maxRetry = 5;
 OAuth2Client._retryInterval = 1000;
-//# sourceMappingURL=oauthclient.js.map

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudbase/oauth",
-  "version": "0.1.1-alpha.7",
+  "version": "0.1.1-alpha.9",
   "description": "auth apis for cloudbase",
   "author": "xbase",
   "main": "./dist/index.js",

package/dist/utils/base64.js

@@ -91,4 +91,3 @@ function weappJwtDecode(token, options) {
     }
 }
 exports.weappJwtDecode = weappJwtDecode;
-//# sourceMappingURL=base64.js.map

package/dist/utils/mp.d.ts

@@ -0,0 +1,2 @@
+export declare function isMp(): boolean;
+export declare function isInMpWebView(): boolean;

package/dist/utils/mp.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInMpWebView = exports.isMp = void 0;
+function isMp() {
+    const wx = globalThis.wx;
+    if (typeof wx === 'undefined') {
+        return false;
+    }
+    if (globalThis.Page === undefined) {
+        return false;
+    }
+    if (!wx.getSystemInfoSync) {
+        return false;
+    }
+    if (!wx.getStorageSync) {
+        return false;
+    }
+    if (!wx.setStorageSync) {
+        return false;
+    }
+    if (!wx.connectSocket) {
+        return false;
+    }
+    if (!wx.request) {
+        return false;
+    }
+    try {
+        if (!wx.getSystemInfoSync()) {
+            return false;
+        }
+        if (wx.getSystemInfoSync().AppPlatform === 'qq') {
+            return false;
+        }
+    }
+    catch (e) {
+        return false;
+    }
+    return true;
+}
+exports.isMp = isMp;
+let IS_IN_MP_WEBVIEW = !!navigator.userAgent.match(/miniprogram/i) || window.__wxjs_environment === 'miniprogram';
+if (!isMp()) {
+    function ready() {
+        IS_IN_MP_WEBVIEW =
+            IS_IN_MP_WEBVIEW || (typeof window !== undefined && window.__wxjs_environment === 'miniprogram');
+    }
+    if (window?.WeixinJSBridge?.invoke) {
+        ready();
+    }
+    else if (typeof document !== 'undefined') {
+        document.addEventListener?.('WeixinJSBridgeReady', ready, false);
+    }
+}
+function isInMpWebView() {
+    return IS_IN_MP_WEBVIEW;
+}
+exports.isInMpWebView = isInMpWebView;

package/dist/utils/promise.js

@@ -45,4 +45,3 @@ class PromiseOnce {
     }
 }
 exports.PromiseOnce = PromiseOnce;
-//# sourceMappingURL=promise.js.map

package/dist/utils/uuid.js

@@ -13,4 +13,3 @@ function uuidv4() {
     });
 }
 exports.uuidv4 = uuidv4;
-//# sourceMappingURL=uuid.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudbase/oauth",
-  "version": "0.1.1-alpha.7",
+  "version": "0.1.1-alpha.9",
   "description": "auth apis for cloudbase",
   "author": "xbase",
   "main": "./dist/index.js",

package/src/app/index.ts

@@ -1,83 +1,83 @@
-import {defaultRequest, RequestFn as requestFn, RequestOptions as requestOptions} from "./request";
-import {OpenURIWithCallback as openURIWithCallback, defaultOpenURIWithCallback} from "./openuri";
-import {DefaultStorage, Storage as storage} from "./storage";
+import { defaultRequest, RequestFn as requestFn, RequestOptions as requestOptions } from './request';
+import { OpenURIWithCallback as openURIWithCallback, defaultOpenURIWithCallback } from './openuri';
+import { DefaultStorage, Storage as storage } from './storage';
 
 export interface Options {
-    env: string,
-    region?: string,
-    apiOrigin?: string;
-    clientId?: string;
-    clientSecret?: string;
-    custom?: any;
+  env: string;
+  region?: string;
+  apiOrigin?: string;
+  clientId?: string;
+  clientSecret?: string;
+  custom?: any;
 
-    // plugins can set platform functions
-    request?: requestFn;
-    storage?: storage;
+  // plugins can set platform functions
+  request?: requestFn;
+  baseRequest?: requestFn;
+  storage?: storage;
+  captchaOptions?: {
     openURIWithCallback?: openURIWithCallback;
+  };
 }
 
-export function initializeApp(
-    options: Options,
-): App {
-    return new AppImpl(options);
+export function initializeApp(options: Options): App {
+  return new AppImpl(options);
 }
 
 export interface App {
-    readonly options: Options;
+  readonly options: Options;
 }
 
 export class AppImpl implements App {
-    private readonly _options: Options;
-    private readonly _container = new Map<string, any>();
+  private readonly _options: Options;
+  private readonly _container = new Map<string, any>();
 
-    constructor(options: Options) {
-        if (!options.region) {
-            options.region = 'ap-shanghai'
-        }
-        if (!options.apiOrigin) {
-            options.apiOrigin = `https://${options.env}.${options.region}.tcb-api.tencentcloudapi.com`
-        }
-        let storageEnv = options.env
-        if (!options.clientId) {
-            options.clientId = ''
-        } else {
-            storageEnv = options.clientId
-        }
-        if (!options.storage) {
-            options.storage = new DefaultStorage({env: storageEnv});
-        }
-        if (!options.openURIWithCallback) {
-            options.openURIWithCallback = defaultOpenURIWithCallback;
-        }
-        let baseRequest = options.request
-        if (!baseRequest) {
-            baseRequest = defaultRequest
-        }
-        const apiOrigin = options.apiOrigin
-        options.request = async <T>(
-            url: string,
-            options?: RequestOptions,
-        ): Promise<T> => {
-            if (url.startsWith('/')) {
-                url = apiOrigin + url;
-            }
-            return baseRequest<T>(url, options)
-        }
-        this._options = options;
+  constructor(options: Options) {
+    if (!options.region) {
+      options.region = 'ap-shanghai';
     }
-
-    get options(): Options {
-        return this._options;
+    if (!options.apiOrigin) {
+      options.apiOrigin = `https://${options.env}.${options.region}.tcb-api.tencentcloudapi.com`;
     }
-
-    get container(): Map<string, any> {
-        return this._container;
+    let storageEnv = options.env;
+    if (!options.clientId) {
+      options.clientId = '';
+    } else {
+      storageEnv = options.clientId;
     }
-}
+    if (!options.storage) {
+      options.storage = new DefaultStorage({ env: storageEnv });
+    }
+    if (!options.captchaOptions) {
+      options.captchaOptions = {};
+    }
+    if (!options.captchaOptions.openURIWithCallback) {
+      // 兼容之前的传参方式，options.openURIWithCallback
+      options.captchaOptions.openURIWithCallback = (options as any).openURIWithCallback || defaultOpenURIWithCallback;
+    }
+    let baseRequest: requestFn = options.baseRequest || options.request || defaultRequest;
+    if (!baseRequest) {
+      baseRequest = defaultRequest;
+    }
+    const apiOrigin = options.apiOrigin;
+    options.request = async <T>(url: string, options?: RequestOptions): Promise<T> => {
+      if (url.startsWith('/')) {
+        url = apiOrigin + url;
+      }
+      return baseRequest<T>(url, options);
+    };
+    this._options = options;
+  }
 
+  get options(): Options {
+    return this._options;
+  }
 
-export type RequestFn = requestFn
-export type RequestOptions = requestOptions
-export type OpenURIWithCallback = openURIWithCallback
-export type Storage = storage
+  get container(): Map<string, any> {
+    return this._container;
+  }
+}
 
+export type RequestFn = requestFn;
+export type RequestOptions = requestOptions;
+export type OpenURIWithCallback = openURIWithCallback;
+export type Storage = storage;

package/src/app/openuri.ts

@@ -1,8 +1,11 @@
+import { ErrorType } from '../auth/consts';
+
 export type OpenURIWithCallback = (url: string, opts?: OpenURIOptions) => Promise<{ [key: string]: string }>;
 
 export interface OpenURIOptions {
   width: string;
   height: string;
+  request?: any;
 }
 
 /**
@@ -22,15 +25,19 @@ export const defaultOpenURIWithCallback: OpenURIWithCallback = (
   opts?: OpenURIOptions,
 ): Promise<{ [key: string]: string }> => {
   let iframeTag = '__iframe';
+  const { width = '355px', height = '355px' } = opts || {};
+
+  const matched = url.match(/^(data:.*)$/);
+  if (matched) {
+    return Promise.reject({
+      error: ErrorType.UNIMPLEMENTED,
+      error_description: `need to impl captcha data`,
+    });
+  }
+
   if (window.location.search.indexOf(iframeTag) > 0) {
     document.body.style.display = 'none';
   }
-  if (!opts) {
-    opts = {
-      width: '355px',
-      height: '355px',
-    };
-  }
   if (document.getElementById('_iframe_panel_wrap') === null) {
     var elementDiv = document.createElement('div');
     elementDiv.style.cssText =
@@ -58,7 +65,7 @@ export const defaultOpenURIWithCallback: OpenURIWithCallback = (
   }
   iframe.setAttribute('src', url);
   iframe.setAttribute('id', '_iframe_panel_wrap_iframe');
-  iframe.style.cssText = `min-width:${opts.width};display:block;height:${opts.height};margin:0 auto;background-color: rgb(255, 255, 255);border: none;`;
+  iframe.style.cssText = `min-width:${width};display:block;height:${height};margin:0 auto;background-color: rgb(255, 255, 255);border: none;`;
   target.appendChild(iframe);
   target.style.display = 'block';