@cloudbase/oauth 0.1.1-alpha → 0.1.1-alpha.2

package/src/auth/models.ts

@@ -0,0 +1,352 @@
+export interface SignInRequest {
+    username?: string;
+    password?: string;
+    verification_token?: string;
+    two_factor_password?: string;
+}
+
+export interface SignInWithProviderRequest {
+    provider_token: string;
+    provider_id?: string;
+}
+
+export interface SignUpRequest {
+    phone_number?: string;
+    email?: string;
+
+    verification_token?: string;
+    provider_token?: string;
+
+    username?: string;
+    password?: string;
+    name?: string;
+    gender?: string;
+    picture?: string;
+    locale?: string;
+
+    anonymous_token?: string;
+}
+
+export interface SendVerificationCodeRequest {
+    phone_number?: string;
+    email?: string;
+    // 可选 ANY，USER，NOT_USER, CUR_USER;
+    target?: string | 'ANY';
+    usage?: string;
+}
+
+export interface SendVerificationCodeResponse {
+    verification_id: string;
+    is_user: boolean | false;
+}
+
+export interface VerifyResponse {
+    verification_token: string;
+    expires_in: number;
+}
+
+export interface VerifyRequest {
+    verification_code: string;
+    verification_id: string;
+}
+
+
+export interface VerifyRequest {
+    verification_code: string;
+    verification_id: string;
+}
+
+
+export interface ResetPasswordRequest {
+    email: string;
+    phone_number: string;
+    new_password: string,
+    verification_token: string;
+}
+
+export interface ProviderBindRequest {
+    provider_token: string;
+    expires_in: number;
+}
+
+export interface GrantProviderTokenRequest {
+    provider_id: string;
+    provider_redirect_uri?: string;
+    provider_code?: string;
+    provider_access_token?: string;
+    provider_id_token?: string;
+}
+
+export interface GrantProviderTokenResponse {
+    provider_token: string;
+    expires_in: number;
+    provider_profile?: ProviderProfile;
+}
+
+export interface PatchProviderTokenRequest {
+    provider_token: string;
+    provider_params: Map<string, string>;
+}
+
+export interface PatchProviderTokenResponse {
+    provider_token: string;
+    expires_in: number;
+    provider_profile: ProviderProfile;
+}
+
+export interface GenProviderRedirectUriRequest {
+    provider_id: string;
+    redirect_uri: string;
+    state: string;
+    scope?: string;
+    response_type?: string;
+    other_params?: Map<string, string>;
+}
+
+export interface GenProviderRedirectUriResponse {
+    uri: string;
+    signout_uri?: string;
+}
+
+export interface BindWithProviderRequest {
+    provider_token: string;
+}
+
+export interface BindWithProviderRequest {
+    provider_token: string;
+}
+
+export interface UserProfileProvider {
+    id: string;
+    provider_user_id: string;
+    name?: string;
+}
+
+export interface UserProfile {
+    name?: string;
+    picture?: string;
+    username?: string;
+    email?: string;
+    email_verified?: boolean;
+    phone_number?: string;
+    groups?: [ProfileGroup];
+    providers?: [UserProfileProvider];
+    gender?: string;
+    birthdate?: string;
+    zoneinfo?: string;
+    locale?: string;
+    created_from?: string;
+}
+
+export interface ProvidersResponse {
+    total: number;
+    data: [UserProvider];
+}
+
+export interface UserProvider {
+    id: string;
+    name: string;
+    provider_user_name?: string;
+    bind: boolean;
+}
+
+export interface ProfileGroup {
+    id: string;
+    expires_at?: string;
+}
+
+
+export interface ProviderProfile {
+    provider_id: string;
+    name?: string;
+    picture?: string;
+    phone_number?: string;
+    email?: string;
+}
+
+export interface TransByProviderRequest {
+    provider_token: string;
+}
+
+export interface GrantTokenRequest {
+    grant_type: string;
+    code?: string,
+    refresh_token?: string,
+    username?: string,
+    password?: string,
+    scope?: string,
+    nonce?: string,
+    code_verifier?: string,
+    device_code?: string
+}
+
+export interface UnbindProviderRequest {
+    provider_id: string;
+}
+
+export interface CheckPasswordRequest {
+    password: string;
+}
+
+export interface CheckIfUserExistRequest {
+    username: string;
+}
+
+export interface CheckIfUserExistResponse {
+    exist: boolean;
+}
+
+
+export interface EditContactRequest {
+    phone_number?: string;
+    email?: string;
+    sudo_token: string;
+    verification_token: string;
+    // 冲突解决方案
+    // 可选：DEFAULT， 默认解决方案：提示用户该手机号已被其他人绑定
+    //      DELETE_ACCOUNT_TRANSFER，标记原来的账号为已注销，并将手机换绑给自己
+    //     TRANSFER 仅换绑手机号，不注销原有账号。（原有账号无法登录情况下，则自动标记为注销）
+    conflict_resolution?: string;
+}
+
+export interface SetPasswordRequest {
+    sudo_token: string;
+    new_password: string;
+}
+
+
+export interface SetPasswordRequest {
+    new_password: string;
+    sudo_token: string;
+}
+
+export interface UpdatePasswordRequest {
+    old_password: string;
+    new_password: string;
+}
+
+// password 和 verification_token 而选一，如果绑定了手机号，则必须使用verification_token 进行sudo
+export interface SudoRequest {
+    password?: string;
+    verification_token?: string
+}
+
+export interface SudoResponse {
+    sudo_token: string
+}
+
+export interface WithSudoRequest {
+    sudo_token: string
+}
+
+export interface ChangeBoundProviderRequest {
+    trans_token: string;
+    provider_id: string;
+}
+
+export interface ChangeBoundProviderResponse {
+    client_id: string;
+}
+
+export interface QueryUserProfileRequest {
+    id?: [string];
+    username?: string;
+    email?: string;
+    phone_number?: string;
+}
+
+export interface QueryUserProfileResponse {
+    total: number;
+    data?: [SimpleUserProfile];
+}
+
+export interface SimpleUserProfile {
+    sub: string;
+    name: string;
+    picture?: string;
+    gender?: string;
+    locale?: string;
+    email?: string;
+    phone_number?: string;
+}
+
+export interface AuthorizeRequest {
+    client_id: string,
+    response_type?: string,
+    redirect_uri?: string,
+    state?: string,
+    scope?: string,
+    code_challenge?: string,
+    code_challenge_method?: string,
+    sign_out_uri?: string
+}
+
+export interface AuthorizeResponse {
+    code?: string,
+    access_token?: string,
+    id_token?: string,
+    token_type?: string,
+    scope?: string,
+    state?: string,
+    expires_in?: number
+}
+
+export interface AuthorizeInfoRequest {
+    client_id: string,
+    response_type?: string,
+    redirect_uri?: string,
+    state?: string,
+    scope?: string,
+    sign_out_uri?: string,
+    locale?: string,
+}
+
+export interface AuthorizeInfoResponse {
+    client: Client;
+    scopes?: Scope[];
+}
+
+export interface Client {
+    id: string;
+    name: string;
+    description?: string;
+    picture?: string;
+    url?: string;
+}
+
+export interface Scope {
+    id: string;
+    name: string;
+    description?: string;
+    picture?: string;
+    url?: string;
+    children?: Scope[];
+}
+
+export interface RevokeDeviceRequest {
+    device_id: string;
+}
+
+export interface AuthorizeDeviceRequest {
+    client_id: string;
+    user_code: string;
+    scope?: string;
+    state?: string;
+}
+
+export interface DeviceAuthorizeRequest {
+    client_id?: string;
+    scope?: string;
+}
+
+``
+
+export interface DeviceAuthorizeResponse {
+    device_code: string;
+    user_code?: string;
+    expires_in: number;
+    interval: number;
+    verification_uri?: string;
+    verification_uri_complete?: string
+}
+

package/src/captcha/index.ts

@@ -0,0 +1,170 @@
+import {App, RequestOptions, RequestFn, Storage, OpenURIWithCallback} from "../app";
+import {_getComponent} from "../app/internal";
+
+export interface CaptchaOptions {
+    request: RequestFn;
+    storage: Storage;
+    openURIWithCallback: OpenURIWithCallback;
+}
+
+export interface CaptchaInitOptions {
+    request?: RequestFn;
+}
+
+export function getCaptcha(app: App, opts?: CaptchaInitOptions): Captcha {
+    return _getComponent<Captcha>(app, "captcha", (): Captcha => {
+        const initOpts = {
+            request: app.options.request,
+            storage: app.options.storage,
+            openURIWithCallback: app.options.openURIWithCallback,
+        }
+        if (opts && opts.request) {
+            initOpts.request = opts.request
+        }
+        return new Captcha(initOpts)
+    });
+}
+
+export interface CaptchaToken {
+    captcha_token: string
+    expires_in: number
+    expires_at?: Date | null;
+}
+
+export interface CaptchaRequestOptions extends RequestOptions {
+    withCaptcha?: boolean;
+}
+
+export interface GetCaptchaResponse {
+    captcha_token?: string
+    expires_in?: number
+    url?: string
+}
+
+const GET_CAPTCHA_URL = '/auth/v1/captcha/init'
+
+export class Captcha {
+    private _config: CaptchaOptions;
+    private _tokenSectionName: string;
+
+    /**
+     * constructor
+     * @param {CaptchaOptions} opts
+     */
+    constructor(opts: CaptchaOptions) {
+        this._config = opts
+        this._tokenSectionName = 'captcha_'
+    }
+
+    /**
+     * request http like simple fetch api, exp:request('/v1/user/me', {withCredentials:true})
+     * @param {string} url
+     * @param {AuthClientRequestOptions} options
+     */
+    public async request<T>(
+        url: string,
+        options?: CaptchaRequestOptions,
+    ): Promise<T> {
+        if (!options) {
+            options = {};
+        }
+        if (!options.method) {
+            options.method = 'GET'
+        }
+        const state = options.method + ":" + url
+        let reqURL = url;
+        if (options.withCaptcha) {
+            reqURL = await this._appendCaptchaTokenToURL(url, state, false);
+        }
+        let resp : T;
+        try {
+            resp = await this._config.request<T>(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<T>(url, options)
+            } else {
+                return Promise.reject(err)
+            }
+        }
+        return resp;
+    }
+
+    /**
+     * _getCaptchaToken get captcha token
+     */
+    private async _getCaptchaToken(forceNewToken: boolean, state: string): Promise<string> {
+        if (!forceNewToken) {
+            // if local has captcha token then return
+            const captchaToken = await this._findCaptchaToken()
+            if (captchaToken) {
+                return captchaToken
+            }
+        }
+        const redirectURL = window.location.origin + window.location.pathname
+        const captchaTokenResp = await this._config.request<GetCaptchaResponse>(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,
+            }
+            await this._saveCaptchaToken(captchaToken)
+            return captchaTokenResp.captcha_token
+        }
+        const callbackData = await this._config.openURIWithCallback(captchaTokenResp.url, {width:'355px', height: '355px'})
+        const captchaToken: CaptchaToken = {
+            captcha_token: callbackData.captcha_token,
+            expires_in: Number(callbackData.expires_in)
+        }
+        await this._saveCaptchaToken(captchaToken)
+        return captchaToken.captcha_token
+    }
+
+    private async _appendCaptchaTokenToURL(url: string, state: string, forceNewToken: boolean): Promise<string> {
+        const captchaToken = await this._getCaptchaToken(forceNewToken, state);
+        if (url.indexOf("?") > 0) {
+            url += "&captcha_token=" + captchaToken
+        } else {
+            url += "?captcha_token=" + captchaToken
+        }
+        return url
+    }
+
+    private async _saveCaptchaToken(token: CaptchaToken) {
+        token.expires_at = new Date(
+            Date.now() + (token.expires_in - 10) * 1000,
+        );
+        const tokenStr: string = JSON.stringify(token);
+        await this._config.storage.setItem(this._tokenSectionName, tokenStr);
+    }
+
+    private async _findCaptchaToken(): Promise<string> {
+        const tokenStr: string = await this._config.storage.getItem(
+            this._tokenSectionName,
+        );
+        if (tokenStr !== undefined && tokenStr !== null) {
+            try {
+                const captchaToken = JSON.parse(tokenStr);
+                if (captchaToken && captchaToken.expires_at) {
+                    captchaToken.expires_at = new Date(captchaToken.expires_at);
+                }
+                const isExpired = captchaToken.expires_at < new Date();
+                if (isExpired) {
+                    return null
+                }
+                return captchaToken.captcha_token
+            } catch (error) {
+                await this._config.storage.removeItem(this._tokenSectionName);
+                return null
+            }
+        }
+        return null
+    }
+}

package/src/function/index.ts

@@ -0,0 +1,103 @@
+import {App} from "../app";
+import {getOAuthClient, AuthClient, ErrorType} from "../oauthclient";
+import {uuidv4} from "../utils/uuid";
+import {_getComponent} from "../app/internal";
+
+export interface FunctionOptions {
+    credentialsClient: AuthClient;
+    env: string
+}
+
+/**
+ * Returns the existing `Auth` instance that is associated with the app
+ */
+export function getFunction(app: App): Function {
+    return _getComponent<Function>(app, "function", (): Function => {
+        const credentialsClient = getOAuthClient(app)
+        return new Function({
+            credentialsClient: credentialsClient,
+            env: app.options.clientId
+        })
+    });
+}
+
+
+export class Function {
+
+    private _config: FunctionOptions;
+
+    /**
+     * constructor
+     * @param {AuthOptions} opts
+     */
+    constructor(opts: FunctionOptions) {
+        this._config = {
+            credentialsClient: opts.credentialsClient,
+            env: opts.env,
+        }
+    }
+
+    /**
+     * callFunction call function
+     * @param {SignInRequest} params A SignInRequest Object.
+     * @return {Promise<Credentials>} A Promise<Credentials> object.
+     */
+    public async callFunction(params: FunctionRequest): Promise<FunctionResponse> {
+        let accessToken: string
+        try {
+            accessToken = await this._config.credentialsClient.getAccessToken()
+        } catch (e) {
+            if (e.error === ErrorType.UNAUTHENTICATED) {
+                accessToken = ""
+            } else {
+                return Promise.reject(e)
+            }
+        }
+        const requestId = uuidv4()
+        var reqBody = {
+            "action": "functions.invokeFunction",
+            "dataVersion": "2020-01-10",
+            "env": this._config.env,
+            "function_name": params.name,
+            "request_data": JSON.stringify(params.data),
+            "seqId": requestId,
+            "access_token": accessToken
+        }
+        const url = "/web?env=" + this._config.env
+        const resp = await this._config.credentialsClient.request<functionHTTPResponse>(url, {
+            method: 'POST',
+            body: reqBody,
+            headers: {
+                'content-type': 'application/json'
+            }
+        })
+        if (resp.code) {
+            return Promise.reject({
+                error: resp.code,
+                error_description: resp.message
+            })
+        }
+        return {
+            requestId: resp.requestId,
+            result: resp.data.response_data,
+        }
+    }
+}
+
+
+export interface FunctionRequest {
+    name: string;
+    data: any;
+}
+
+export interface FunctionResponse {
+    requestId: string;
+    result: any;
+}
+
+export interface functionHTTPResponse {
+    requestId: string;
+    data: any
+    code: string
+    message: string
+}

package/src/index.ts

@@ -0,0 +1,32 @@
+import { Auth, getAuth } from "./auth";
+import { App, initializeApp, Options } from "./app";
+
+export function initializeClient(options: Options): Client {
+  return new Client(options);
+}
+
+export class Client {
+  public auth: Auth;
+  public app: App;
+
+  constructor(initOptions: Options) {
+    this.app = initializeApp(initOptions);
+    this.auth = getAuth(this.app);
+  }
+}
+
+export {
+  RequestOptions,
+  ResponseError,
+  ErrorType,
+  RequestFn,
+} from "./app/request";
+export { Storage } from "./app/storage";
+export { initializeApp, Options } from "./app";
+export { Auth, getAuth } from "./auth";
+export {
+  UserProfile,
+  PatchProviderTokenResponse,
+  GrantProviderTokenResponse,
+} from "./auth/models";
+export { Credentials } from "./oauthclient/models";

package/src/oauthclient/consts.ts

@@ -0,0 +1,48 @@
+export enum Syntax {
+    CLIENT_ID = 'client_id',
+    CLIENT_SECRET = 'client_secret',
+    RESPONSE_TYPE = 'response_type',
+    SCOPE = 'scope',
+    STATE = 'state',
+    REDIRECT_URI = 'redirect_uri',
+    ERROR = 'error',
+    ERROR_DESCRIPTION = 'error_description',
+    ERROR_URI = 'error_uri',
+    GRANT_TYPE = 'grant_type',
+    CODE = 'code',
+    ACCESS_TOKEN = 'access_token',
+    TOKEN_TYPE = 'token_type',
+    EXPIRES_IN = 'expires_in',
+    USERNAME = 'username',
+    PASSWORD = 'password',
+    REFRESH_TOKEN = 'refresh_token',
+}
+
+export enum ErrorType {
+    UNREACHABLE = 'unreachable',
+    LOCAL = 'local',
+    CANCELLED = 'cancelled',
+    UNKNOWN = 'unknown',
+    INVALID_ARGUMENT = 'invalid_argument',
+    DEADLINE_EXCEEDED = 'deadline_exceeded',
+    NOT_FOUND = 'not_found',
+    ALREADY_EXISTS = 'already_exists',
+    PERMISSION_DENIED = 'permission_denied',
+    UNAUTHENTICATED = 'unauthenticated',
+    RESOURCE_EXHAUSTED = 'resource_exhausted',
+    FAILED_PRECONDITION = 'failed_precondition',
+    ABORTED = 'aborted',
+    OUT_OF_RANGE = 'out_of_range',
+    UNIMPLEMENTED = 'unimplemented',
+    INTERNAL = 'internal',
+    UNAVAILABLE = 'unavailable',
+    DATA_LOSS = 'data_loss',
+    // CommonError
+    ACCESS_DENIED = 'access_denied',
+    UNSUPPORTED_RESPONSE_TYPE = 'unsupported_response_type',
+    INVALID_SCOPE = 'invalid_scope',
+    INVALID_GRANT = 'invalid_grant',
+    SERVER_ERROR = 'server_error',
+    TEMPORARILY_UNAVAILABLE = 'temporarily_unavailable',
+    INTERACTION_REQUIRED = 'interaction_required',
+}