skapi-js 0.2.0 → 0.2.2

package/js/methods/user.js

@@ -0,0 +1,747 @@
+import SkapiError from '../main/error';
+import { CognitoUserAttribute, CognitoUser, AuthenticationDetails, CognitoUserPool } from 'amazon-cognito-identity-js';
+import validator from '../utils/validator';
+import { request } from './request';
+import { MD5 } from '../utils/utils';
+let cognitoUser = null;
+export let userPool = null;
+export function setUserPool(params) {
+    userPool = new CognitoUserPool(params);
+}
+export function authentication() {
+    if (!userPool)
+        throw new SkapiError('User pool is missing', { code: 'INVALID_REQUEST' });
+    const normalizeUserAttributes = (attr) => {
+        let user = {};
+        if (Array.isArray(attr)) {
+            let normalized_user_attribute_keys = {};
+            for (let i of attr) {
+                normalized_user_attribute_keys[i.Name] = i.Value;
+                if (i.Name === 'custom:service' && normalized_user_attribute_keys[i.Name] !== this.service) {
+                    throw new SkapiError('The user is not registered to the service.', { code: 'INVALID_REQUEST' });
+                }
+            }
+            attr = normalized_user_attribute_keys;
+        }
+        for (let k in attr) {
+            if (k.includes('custom:')) {
+                if (k === 'custom:service' && attr[k] !== this.service) {
+                    throw new SkapiError('The user is not registered to the service.', { code: 'INVALID_REQUEST' });
+                }
+                user[k.replace('custom:', '')] = attr[k];
+            }
+            else {
+                if (k === 'address') {
+                    let addr_main = attr[k];
+                    if (addr_main && typeof addr_main === 'object' && Object.keys(addr_main).length) {
+                        if (addr_main?.formatted) {
+                            try {
+                                attr[k] = JSON.parse(addr_main.formatted);
+                            }
+                            catch (err) {
+                                attr[k] = addr_main.formatted;
+                            }
+                        }
+                    }
+                }
+                user[k] = attr[k];
+            }
+        }
+        for (let k of [
+            'address_public',
+            'birthdate_public',
+            'email_public',
+            'gender_public',
+            'phone_number_public',
+            'access_group'
+        ]) {
+            if (k.includes('_public')) {
+                if (user.hasOwnProperty(k.split('_')[0]))
+                    user[k] = user.hasOwnProperty(k) ? !!Number(user[k]) : false;
+                else
+                    delete user[k];
+            }
+            else
+                user[k] = user.hasOwnProperty(k) ? Number(user[k]) : 0;
+        }
+        for (let k of [
+            'email',
+            'phone_number'
+        ]) {
+            if (user.hasOwnProperty(k)) {
+                if (user[k + '_verified'] === true || user[k + '_verified'] === 'true') {
+                    user[k + '_verified'] = true;
+                }
+                else {
+                    user[k + '_verified'] = false;
+                }
+            }
+            else {
+                delete user[k + '_verified'];
+            }
+        }
+        for (let k of [
+            'aud',
+            { from: 'auth_time', to: 'log' },
+            'cognito:username',
+            'event_id',
+            'exp',
+            'iat',
+            'iss',
+            'jti',
+            'origin_jti',
+            'secret_key',
+            { from: 'sub', to: 'user_id' },
+            'token_use'
+        ]) {
+            if (typeof k === 'string') {
+                delete user[k];
+            }
+            else {
+                user[k.to] = user[k.from];
+                delete user[k.from];
+            }
+        }
+        ;
+        this.__user = user;
+    };
+    const getUser = () => {
+        return new Promise((res, rej) => {
+            if (!this.session) {
+                res(null);
+            }
+            if (cognitoUser === null) {
+                rej(new SkapiError('Invalid session', { code: 'INVALID_REQUEST' }));
+            }
+            else {
+                cognitoUser.getUserAttributes((attrErr, attributes) => {
+                    if (attrErr)
+                        rej(attrErr);
+                    else {
+                        normalizeUserAttributes(attributes);
+                        res(this.user);
+                    }
+                });
+            }
+        });
+    };
+    const getSession = (option) => {
+        let { refreshToken = false } = option || {};
+        return new Promise((res, rej) => {
+            cognitoUser = userPool?.getCurrentUser() || null;
+            if (cognitoUser === null) {
+                rej(null);
+                return;
+            }
+            cognitoUser.getSession((err, session) => {
+                if (err) {
+                    rej(err);
+                    return;
+                }
+                if (!session) {
+                    rej(new SkapiError('Current session does not exist.', { code: 'INVALID_REQUEST' }));
+                    return;
+                }
+                if (refreshToken || !session.isValid()) {
+                    let signedOut = false;
+                    try {
+                        let idToken = session.getIdToken().payload;
+                        if (idToken['custom:service'] !== this.service) {
+                            cognitoUser.signOut();
+                            this.session = null;
+                            signedOut = true;
+                            res(null);
+                        }
+                    }
+                    catch (err) {
+                    }
+                    if (!signedOut) {
+                        cognitoUser.refreshSession(session.getRefreshToken(), (refreshErr, refreshedSession) => {
+                            if (refreshErr)
+                                rej(refreshErr);
+                            else {
+                                if (refreshedSession.isValid()) {
+                                    this.session = refreshedSession;
+                                    normalizeUserAttributes(refreshedSession.getIdToken().payload);
+                                    res(refreshedSession);
+                                }
+                                else {
+                                    rej(new SkapiError('Invalid session.', { code: 'INVALID_REQUEST' }));
+                                    return;
+                                }
+                            }
+                        });
+                    }
+                }
+                else {
+                    let idToken = session.getIdToken().payload;
+                    if (idToken['custom:service'] !== this.service) {
+                        cognitoUser.signOut();
+                        this.session = null;
+                        res(null);
+                    }
+                    else {
+                        this.session = session;
+                        normalizeUserAttributes(idToken);
+                        res(session);
+                    }
+                }
+            });
+        });
+    };
+    const createCognitoUser = async (email) => {
+        if (!email)
+            throw new SkapiError('E-Mail is required.', { code: 'INVALID_PARAMETER' });
+        let username = this.service + '-' + MD5.hash(email);
+        return {
+            cognitoUser: new CognitoUser({
+                Username: username,
+                Pool: userPool
+            }),
+            cognitoUsername: username
+        };
+    };
+    const authenticateUser = (email, password) => {
+        return new Promise((res, rej) => {
+            this.__request_signup_confirmation = null;
+            this.__disabledAccount = null;
+            createCognitoUser(email).then(initUser => {
+                cognitoUser = initUser.cognitoUser;
+                let username = initUser.cognitoUsername;
+                let authenticationDetails = new AuthenticationDetails({
+                    Username: username,
+                    Password: password
+                });
+                cognitoUser.authenticateUser(authenticationDetails, {
+                    newPasswordRequired: (userAttributes, requiredAttributes) => {
+                        this.__request_signup_confirmation = username;
+                        rej(new SkapiError("User's signup confirmation is required.", { code: 'SIGNUP_CONFIRMATION_NEEDED' }));
+                    },
+                    onSuccess: (logged) => getSession().then(session => res(this.user)),
+                    onFailure: (err) => {
+                        let error = [err.message || 'Failed to authenticate user.', err?.code || 'INVALID_REQUEST'];
+                        if (err.code === "NotAuthorizedException") {
+                            if (err.message === "User is disabled.") {
+                                this.__disabledAccount = username;
+                                error = ['This account is disabled.', 'USER_IS_DISABLED'];
+                            }
+                            else {
+                                error = ['Incorrect username or password.', 'INCORRECT_USERNAME_OR_PASSWORD'];
+                            }
+                        }
+                        let errCode = error[1];
+                        let errMsg = error[0];
+                        let customErr = error[0].split('#');
+                        if (customErr.length > 1) {
+                            customErr = customErr[customErr.length - 1].split(':');
+                            errCode = customErr[0];
+                            errMsg = customErr[1];
+                        }
+                        rej(new SkapiError(errMsg, { code: errCode, cause: err }));
+                    }
+                });
+            });
+        });
+    };
+    return { getSession, authenticateUser, createCognitoUser, getUser };
+}
+export async function getProfile(options) {
+    await this.__connection;
+    try {
+        await authentication.bind(this)().getSession(options);
+        return this.user;
+    }
+    catch (err) {
+        return null;
+    }
+}
+export async function checkAdmin() {
+    await this.__connection;
+    if (this.__user?.service === this.service) {
+        return this.__user?.owner === this.host;
+    }
+    else {
+        await logout.bind(this)();
+    }
+    return false;
+}
+export async function logout(e) {
+    await this.__connection;
+    if (cognitoUser) {
+        cognitoUser.signOut();
+    }
+    let to_be_erased = {
+        'session': null,
+        '__startKeyHistory': {},
+        '__cached_requests': {},
+        '__user': null
+    };
+    for (let k in to_be_erased) {
+        this[k] = to_be_erased[k];
+    }
+    return 'SUCCESS: The user has been logged out.';
+}
+export async function resendSignupConfirmation(redirect) {
+    if (!this.__request_signup_confirmation) {
+        throw new SkapiError('Least one login attempt is required.', { code: 'INVALID_REQUEST' });
+    }
+    if (redirect) {
+        redirect = validator.Url(redirect);
+    }
+    else {
+        redirect = undefined;
+    }
+    let resend = await request.bind(this)("confirm-signup", {
+        username: this.__request_signup_confirmation,
+        redirect
+    });
+    return resend;
+}
+export async function recoverAccount(redirect = false) {
+    if (typeof redirect === 'string') {
+        validator.Url(redirect);
+    }
+    else if (typeof redirect !== 'boolean') {
+        throw new SkapiError('Argument should be type: <boolean | string>.', { code: 'INVALID_REQUEST' });
+    }
+    if (!this.__disabledAccount) {
+        throw new SkapiError('Least one signin attempt of disabled account is required.', { code: 'INVALID_REQUEST' });
+    }
+    await request.bind(this)("recover-account", { username: this.__disabledAccount, redirect });
+    this.__disabledAccount = null;
+    return 'SUCCESS: Recovery e-mail has been sent.';
+}
+export async function login(form, option) {
+    await this.__connection;
+    if (option?.logout === false) {
+        let to_be_erased = {
+            '__startKeyHistory': {},
+            '__cached_requests': {}
+        };
+        for (let k in to_be_erased) {
+            this[k] = to_be_erased[k];
+        }
+    }
+    else {
+        await logout.bind(this)();
+    }
+    let params = validator.Params(form, {
+        email: (v) => validator.Email(v),
+        password: (v) => validator.Password(v)
+    }, ['email', 'password']);
+    return authentication.bind(this)().authenticateUser(params.email, params.password);
+}
+export async function signup(form, option) {
+    await this.logout();
+    let params = validator.Params(form || {}, {
+        email: (v) => validator.Email(v),
+        password: (v) => validator.Password(v),
+        name: 'string',
+        address: 'string',
+        gender: 'string',
+        birthdate: (v) => validator.Birthdate(v),
+        phone_number: (v) => validator.PhoneNumber(v),
+        email_public: ['boolean', () => false],
+        address_public: ['boolean', () => false],
+        gender_public: ['boolean', () => false],
+        birthdate_public: ['boolean', () => false],
+        phone_number_public: ['boolean', () => false],
+        misc: 'string'
+    }, ['email', 'password']);
+    option = validator.Params(option || {}, {
+        email_subscription: (v) => {
+            if (typeof v !== 'boolean') {
+                throw new SkapiError('"option.email_subscription" should be type: <boolean>.', { code: 'INVALID_PARAMETER' });
+            }
+            if (!option?.signup_confirmation) {
+                throw new SkapiError('"option.signup_confirmation" is required for email subscription.', { code: 'INVALID_PARAMETER' });
+            }
+            return v;
+        },
+        signup_confirmation: (v) => {
+            if (typeof v === 'string') {
+                return validator.Url(v);
+            }
+            else if (typeof v === 'boolean') {
+                return v;
+            }
+            else {
+                throw new SkapiError('"option.signup_confirmation" should be type: <string | boolean>.', { code: 'INVALID_PARAMETER' });
+            }
+        },
+        login: (v) => {
+            if (typeof v === 'boolean') {
+                if (option.signup_confirmation && v) {
+                    throw new SkapiError('"login" is not allowed when "option.signup_confirmation" is true.', { code: 'INVALID_PARAMETER' });
+                }
+                return v;
+            }
+            throw new SkapiError('"option.login" should be type: boolean.', { code: 'INVALID_PARAMETER' });
+        }
+    });
+    let logUser = option?.login || false;
+    let signup_confirmation = option?.signup_confirmation || false;
+    if (params.email_public && !signup_confirmation) {
+        throw new SkapiError('"option.signup_confirmation" should be true if "email_public" is set to true.', { code: 'INVALID_PARAMETER' });
+    }
+    params.signup_confirmation = signup_confirmation;
+    params.email_subscription = option?.email_subscription || false;
+    await request.bind(this)("signup", params);
+    if (signup_confirmation) {
+        let u = await authentication.bind(this)().createCognitoUser(params.email);
+        cognitoUser = u.cognitoUser;
+        this.__request_signup_confirmation = u.cognitoUsername;
+        return "SUCCESS: The account has been created. User's signup confirmation is required.";
+    }
+    if (logUser) {
+        return login.bind(this)({ email: params.email, password: params.password });
+    }
+    return 'SUCCESS: The account has been created.';
+}
+export async function disableAccount() {
+    await this.__connection;
+    let result = await request.bind(this)('remove-account', { disable: this.__user.user_id }, { auth: true });
+    await logout.bind(this)();
+    return result;
+}
+export async function resetPassword(form, option) {
+    await this.__connection;
+    let params = validator.Params(form, {
+        email: (v) => validator.Email(v),
+        code: ['number', 'string'],
+        new_password: (v) => validator.Password(v)
+    }, ['email', 'code', 'new_password']);
+    let code = params.code, new_password = params.new_password;
+    if (typeof code === 'number') {
+        code = code.toString();
+    }
+    return new Promise(async (res, rej) => {
+        let cognitoUser = (await authentication.bind(this)().createCognitoUser(params.email)).cognitoUser;
+        cognitoUser.confirmPassword(code, new_password, {
+            onSuccess: result => {
+                res("SUCCESS: New password has been set.");
+            },
+            onFailure: (err) => {
+                rej(new SkapiError(err?.message || 'Failed to reset password.', { code: err?.code }));
+            }
+        });
+    });
+}
+async function verifyAttribute(attribute, form) {
+    await this.__connection;
+    let code;
+    if (!cognitoUser) {
+        throw new SkapiError('The user has to be logged in.', { code: 'INVALID_REQUEST' });
+    }
+    if (attribute === 'email' || attribute === 'phone_number') {
+        if (!this.__user.hasOwnProperty(attribute)) {
+            throw new SkapiError(`No ${attribute === 'email' ? 'e-mail' : 'phone number'} to verify`, { code: 'INVALID_REQUEST' });
+        }
+        if (this.__user?.[`${attribute}_verified`]) {
+            return `SUCCESS: "${attribute}" is verified.`;
+        }
+        code = (form ? validator.Params(form, {
+            code: ['string']
+        }) : {}).code || '';
+    }
+    else {
+        return;
+    }
+    return new Promise((res, rej) => {
+        let callback = {
+            onSuccess: (result) => {
+                if (code) {
+                    authentication.bind(this)().getSession({ refreshToken: true }).then(() => {
+                        if (this.__user) {
+                            this.__user[attribute + '_verified'] = true;
+                        }
+                        res(`SUCCESS: "${attribute}" is verified.`);
+                    }).catch(err => {
+                        rej(err);
+                    });
+                }
+                else {
+                    res('SUCCESS: Verification code has been sent.');
+                }
+            },
+            onFailure: (err) => {
+                rej(new SkapiError(err.message || 'Failed to request verification code.', {
+                    code: err?.code
+                }));
+            }
+        };
+        if (code) {
+            cognitoUser?.verifyAttribute(attribute, code, callback);
+        }
+        else {
+            callback.inputVerificationCode = null;
+            cognitoUser?.getAttributeVerificationCode(attribute, callback);
+        }
+    });
+}
+export function verifyPhoneNumber(form) {
+    return verifyAttribute.bind(this)('phone_number', form);
+}
+export function verifyEmail(form) {
+    return verifyAttribute.bind(this)('email', form);
+}
+export async function forgotPassword(form, option) {
+    await this.__connection;
+    let params = validator.Params(form, {
+        email: (v) => validator.Email(v)
+    }, ['email']);
+    return new Promise(async (res, rej) => {
+        let cognitoUser = (await authentication.bind(this)().createCognitoUser(params.email)).cognitoUser;
+        cognitoUser.forgotPassword({
+            onSuccess: result => {
+                res("SUCCESS: Verification code has been sent.");
+            },
+            onFailure: (err) => {
+                rej(new SkapiError(err?.message || 'Failed to send verification code.', { code: err?.code || 'ERROR' }));
+            }
+        });
+    });
+}
+export async function changePassword(params) {
+    await this.__connection;
+    if (!this.session) {
+        throw new SkapiError('User login is required.', { code: 'INVALID_REQUEST' });
+    }
+    let p = validator.Params(params, {
+        'current_password': 'string',
+        'new_password': 'string'
+    });
+    if (!p?.current_password) {
+        throw new SkapiError('"current_password" is required to change password.', { code: 'INVALID_PARAMETER' });
+    }
+    if (!p?.new_password) {
+        throw new SkapiError('"new_password" is required to change password.', { code: 'INVALID_PARAMETER' });
+    }
+    validator.Password(p.current_password);
+    validator.Password(p.new_password);
+    return new Promise((res, rej) => {
+        cognitoUser.changePassword(p.current_password, p.new_password, (err, result) => {
+            if (err) {
+                if (err?.code === "InvalidParameterException") {
+                    rej(new SkapiError('Invalid password parameter.', { code: 'INVALID_PARAMETER' }));
+                }
+                else if (err?.code === "NotAuthorizedException") {
+                    rej(new SkapiError('Incorrect password.', { code: 'INVALID_REQUEST' }));
+                }
+                else {
+                    rej(new SkapiError(err?.message || 'Failed to change user password.', { code: err?.code || err?.name }));
+                }
+            }
+            res('SUCCESS: Password has been changed.');
+        });
+    });
+}
+export async function updateProfile(form, option) {
+    await this.__connection;
+    if (!this.session) {
+        throw new SkapiError('User login is required.', { code: 'INVALID_REQUEST' });
+    }
+    let params = validator.Params(form || {}, {
+        email: (v) => validator.Email(v),
+        address: (v) => {
+            if (!v)
+                return '';
+            if (typeof v === 'string') {
+                return v;
+            }
+            if (typeof v === 'object') {
+                return JSON.stringify(v);
+            }
+            return '';
+        },
+        name: 'string',
+        gender: 'string',
+        birthdate: (v) => validator.Birthdate(v),
+        phone_number: (v) => validator.PhoneNumber(v),
+        email_public: 'boolean',
+        phone_number_public: 'boolean',
+        address_public: 'boolean',
+        gender_public: 'boolean',
+        birthdate_public: 'boolean',
+        misc: 'string'
+    });
+    if (params && typeof params === 'object' && !Object.keys(params).length) {
+        return this.user;
+    }
+    if (params.email) {
+        params['preferred_username'] = this.service + '-' + MD5.hash(params.email);
+    }
+    let collision = [
+        ['email_public', 'email_verified', "User's E-Mail should be verified to set"],
+        ['phone_number_public', 'phone_number_verified', "User's phone number should be verified to set"]
+    ];
+    if (this.__user) {
+        for (let c of collision) {
+            if (params[c[0]] && !this.__user[c[1]]) {
+                throw new SkapiError(`${c[2]} "${c[0]}" to true.`, { code: 'INVALID_REQUEST' });
+            }
+        }
+    }
+    let toRemove = [];
+    for (let k in params) {
+        if (params[k] === this.user[k]) {
+            toRemove.push(k);
+            continue;
+        }
+        let customAttr = [
+            'email_public',
+            'phone_number_public',
+            'address_public',
+            'gender_public',
+            'birthdate_public',
+            'misc'
+        ];
+        if (customAttr.includes(k)) {
+            let parseValue = params[k];
+            if (typeof parseValue === 'boolean') {
+                parseValue = parseValue ? '1' : '0';
+            }
+            params['custom:' + k] = parseValue;
+            toRemove.push(k);
+        }
+    }
+    for (let k of toRemove) {
+        delete params[k];
+    }
+    if (params && typeof params === 'object' && Object.keys(params).length) {
+        let toSet = [];
+        for (let key in params) {
+            toSet.push(new CognitoUserAttribute({
+                Name: key,
+                Value: params[key]
+            }));
+        }
+        await new Promise((res, rej) => {
+            cognitoUser?.updateAttributes(toSet, (err, result) => {
+                if (err) {
+                    rej([
+                        err?.code || err?.name,
+                        err?.message || `Failed to update user settings.`
+                    ]);
+                }
+                res(result);
+            });
+        });
+        await authentication.bind(this)().getSession({ refreshToken: true });
+        return this.user;
+    }
+    return this.user;
+}
+export async function getUsers(params, fetchOptions) {
+    if (!params) {
+        params = {
+            searchFor: 'timestamp',
+            condition: '>',
+            value: 0
+        };
+        if (!fetchOptions) {
+            fetchOptions = {};
+        }
+        fetchOptions.ascending = false;
+    }
+    let isAdmin = await checkAdmin.bind(this)();
+    if (isAdmin && !params.hasOwnProperty('service')) {
+        throw new SkapiError('Service ID is required.', { code: 'INVALID_PARAMETER' });
+    }
+    const searchForTypes = {
+        'user_id': (v) => validator.UserId(v),
+        'name': 'string',
+        'email': (v) => validator.Email(v),
+        'phone_number': (v) => validator.PhoneNumber(v),
+        'address': 'string',
+        'gender': 'string',
+        'birthdate': (v) => validator.Birthdate(v),
+        'locale': (v) => {
+            if (typeof v !== 'string' || typeof v === 'string' && v.length > 5) {
+                throw new SkapiError('Value of "locale" should be a country code.', { code: 'INVALID_PARAMETER' });
+            }
+            return v;
+        },
+        'timestamp': 'number',
+        'access_group': 'number',
+        'approved': (v) => {
+            if (v) {
+                return 'by_admin:approved';
+            }
+            else {
+                return 'by_admin:suspended';
+            }
+        }
+    };
+    let required = ['searchFor', 'value'];
+    params = validator.Params(params, {
+        searchFor: [
+            'user_id',
+            'name',
+            'email',
+            'phone_number',
+            'address',
+            'gender',
+            'birthdate',
+            'locale',
+            'subscribers',
+            'timestamp',
+            'access_group',
+            'approved'
+        ],
+        condition: ['>', '>=', '=', '<', '<=', 'gt', 'gte', 'eq', 'lt', 'lte', () => '='],
+        value: (v) => {
+            let checker = searchForTypes[params.searchFor];
+            if (typeof checker === 'function') {
+                return checker(v);
+            }
+            else if (typeof v !== checker) {
+                throw new SkapiError(`Value does not match the type of "${params.searchFor}" index.`, { code: 'INVALID_PARAMETER' });
+            }
+            return v;
+        },
+        range: (v) => {
+            let checker = searchForTypes[params.searchFor];
+            if (typeof checker === 'function') {
+                return checker(v);
+            }
+            else if (typeof v !== checker) {
+                throw new SkapiError(`Range does not match the type of "${params.searchFor}" index.`, { code: 'INVALID_PARAMETER' });
+            }
+            return v;
+        }
+    }, required);
+    if (params?.condition && params?.condition !== '=' && params.hasOwnProperty('range')) {
+        throw new SkapiError('Conditions does not apply on range search.', { code: 'INVALID_PARAMETER' });
+    }
+    if (params.searchFor === 'user_id' && params.condition !== '=') {
+        throw new SkapiError(`Conditions are not allowed on "user_id"`, { code: 'INVALID_PARAMETER' });
+    }
+    if (params.searchFor === 'access_group') {
+        params.searchFor = 'group';
+    }
+    if (typeof params?.value === 'string' && !params?.value) {
+        throw new SkapiError('Value should not be an empty string.', { code: 'INVALID_PARAMETER' });
+    }
+    if (typeof params?.searchFor === 'string' && !params?.searchFor) {
+        throw new SkapiError('"searchFor" should not be an empty string.', { code: 'INVALID_PARAMETER' });
+    }
+    return request.bind(this)('get-users', params, { auth: true, fetchOptions });
+}
+export async function lastVerifiedEmail(params) {
+    await this.__connection;
+    let res = await request.bind(this)('last-verified-email', params, { auth: true });
+    if (res.includes('SUCCESS')) {
+        await authentication.bind(this)().getSession({ refreshToken: true });
+        return this.user;
+    }
+    return res;
+}
+export async function requestUsernameChange(params) {
+    await this.__connection;
+    params = validator.Params(params, {
+        username: validator.Email,
+        redirect: validator.Url
+    }, ['username']);
+    return await request.bind(this)('request-username-change', params, { auth: true });
+}