@steedos/accounts 3.0.13-beta.9 → 3.0.13

package/lib/server/accounts-server.js

@@ -1,16 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AccountsServer = void 0;
-var tslib_1 = require("tslib");
-var lodash_1 = require("lodash");
-var jwt = require("jsonwebtoken");
-var Emittery = require("emittery");
-var tokens_1 = require("./utils/tokens");
-var email_1 = require("./utils/email");
-var server_hooks_1 = require("./utils/server-hooks");
-var auth_1 = require("@steedos/auth");
-var ismobilejs_1 = require("ismobilejs");
-var defaultOptions = {
+const lodash_1 = require("lodash");
+const jwt = require("jsonwebtoken");
+const Emittery = require("emittery");
+const tokens_1 = require("./utils/tokens");
+const email_1 = require("./utils/email");
+const server_hooks_1 = require("./utils/server-hooks");
+const auth_1 = require("@steedos/auth");
+const ismobilejs_1 = require("ismobilejs");
+const defaultOptions = {
     ambiguousErrorMessages: true,
     tokenSecret: (0, tokens_1.generateRandomToken)(),
     tokenConfigs: {
@@ -22,620 +21,460 @@ var defaultOptions = {
         },
     },
     emailTemplates: email_1.emailTemplates,
-    userObjectSanitizer: function (user) { return user; },
+    userObjectSanitizer: (user) => user,
     sendMail: email_1.sendMail,
     siteUrl: "http://localhost:3000",
 };
-var AccountsServer = (function () {
-    function AccountsServer(options, services) {
-        this.options = (0, lodash_1.merge)(tslib_1.__assign({}, defaultOptions), options);
+class AccountsServer {
+    options;
+    services;
+    db;
+    hooks;
+    constructor(options, services) {
+        this.options = (0, lodash_1.merge)({ ...defaultOptions }, options);
         if (!this.options.db) {
             throw new Error("A database driver is required");
         }
         this.services = services || {};
         this.db = this.options.db;
-        for (var service in this.services) {
+        for (const service in this.services) {
             this.services[service].setStore(this.db);
             this.services[service].server = this;
         }
         this.hooks = new Emittery();
     }
-    AccountsServer.prototype.getServices = function () {
+    getServices() {
         return this.services;
-    };
-    AccountsServer.prototype.getOptions = function () {
+    }
+    getOptions() {
         return this.options;
-    };
-    AccountsServer.prototype.getHooks = function () {
+    }
+    getHooks() {
         return this.hooks;
-    };
-    AccountsServer.prototype.on = function (eventName, callback) {
-        var _this = this;
+    }
+    on(eventName, callback) {
         this.hooks.on(eventName, callback);
-        return function () { return _this.hooks.off(eventName, callback); };
-    };
-    AccountsServer.prototype.getUserProfile = function (userId_1) {
-        return tslib_1.__awaiter(this, arguments, void 0, function (userId, serviceName) {
-            var service;
-            if (serviceName === void 0) { serviceName = 'password'; }
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        service = this.services[serviceName];
-                        if (!service) {
-                            throw new Error("Service ".concat(serviceName, " not found"));
-                        }
-                        return [4, service.getUserProfile(userId)];
-                    case 1: return [2, _a.sent()];
+        return () => this.hooks.off(eventName, callback);
+    }
+    async getUserProfile(userId, serviceName = 'password') {
+        const service = this.services[serviceName];
+        if (!service) {
+            throw new Error(`Service ${serviceName} not found`);
+        }
+        return await service.getUserProfile(userId);
+    }
+    async loginWithService(serviceName, params, infos) {
+        const hooksInfo = {
+            service: serviceName,
+            connection: infos,
+            params,
+        };
+        try {
+            if (!this.services[serviceName]) {
+                throw new Error(`No service with the name ${serviceName} was registered.`);
+            }
+            const user = await this.services[serviceName].authenticate(params);
+            hooksInfo.user = user;
+            if (!user) {
+                throw new Error(`Service ${serviceName} was not able to authenticate user`);
+            }
+            if (user.deactivated) {
+                throw new Error("Your account has been deactivated");
+            }
+            await this.hooks.emitSerial(server_hooks_1.ServerHooks.ValidateLogin, hooksInfo);
+            let enable_MFA = false;
+            let logout_other_clients = false;
+            let login_expiration_in_days = null;
+            let phone_logout_other_clients = false;
+            let phone_login_expiration_in_days = null;
+            let space = null;
+            const userProfile = await this.services[serviceName].getUserProfile(user.id);
+            if (userProfile) {
+                enable_MFA = userProfile.enable_MFA || false;
+                logout_other_clients = userProfile.logout_other_clients || false;
+                login_expiration_in_days = userProfile.login_expiration_in_days;
+                phone_logout_other_clients =
+                    userProfile.phone_logout_other_clients || false;
+                phone_login_expiration_in_days =
+                    userProfile.phone_login_expiration_in_days;
+                space = userProfile.space;
+            }
+            if (enable_MFA) {
+                if (!(params.user && params.token)) {
+                    let _next = "TO_MOBILE_CODE_LOGIN";
+                    return { _next, mobile: user.mobile, mobile_verified: user.mobile_verified };
                 }
+            }
+            const loginResult = await this.loginWithUser(user, Object.assign({}, infos, {
+                logout_other_clients,
+                login_expiration_in_days,
+                phone_logout_other_clients,
+                phone_login_expiration_in_days,
+                space,
+            }));
+            this.hooks.emit(server_hooks_1.ServerHooks.LoginSuccess, hooksInfo);
+            return loginResult;
+        }
+        catch (err) {
+            this.hooks.emit(server_hooks_1.ServerHooks.LoginError, { ...hooksInfo, error: err });
+            throw err;
+        }
+    }
+    async loginWithUser(user, infos) {
+        const { ip, userAgent, logout_other_clients, login_expiration_in_days, phone_logout_other_clients, phone_login_expiration_in_days, space, provider, jwtToken, } = infos;
+        let is_phone = false;
+        let is_tablet = false;
+        if (infos.userAgent) {
+            try {
+                const { phone, tablet } = (0, ismobilejs_1.default)(infos.userAgent);
+                is_phone = phone;
+                is_tablet = tablet;
+            }
+            catch (Exception) {
+                console.log(`Exception`, Exception);
+            }
+        }
+        if (logout_other_clients || phone_logout_other_clients) {
+            let query = null;
+            if (is_phone) {
+                query = { is_phone: true };
+            }
+            else {
+                query = { is_phone: { $ne: true } };
+            }
+            await this.db.updateUser(user.id, {
+                $pull: {
+                    "services.resume.loginTokens": query,
+                },
             });
-        });
-    };
-    AccountsServer.prototype.loginWithService = function (serviceName, params, infos) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var hooksInfo, user, enable_MFA, logout_other_clients, login_expiration_in_days, phone_logout_other_clients, phone_login_expiration_in_days, space, userProfile, _next, loginResult, err_1;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        hooksInfo = {
-                            service: serviceName,
-                            connection: infos,
-                            params: params,
-                        };
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 6, , 7]);
-                        if (!this.services[serviceName]) {
-                            throw new Error("No service with the name ".concat(serviceName, " was registered."));
-                        }
-                        return [4, this.services[serviceName].authenticate(params)];
-                    case 2:
-                        user = _a.sent();
-                        hooksInfo.user = user;
-                        if (!user) {
-                            throw new Error("Service ".concat(serviceName, " was not able to authenticate user"));
-                        }
-                        if (user.deactivated) {
-                            throw new Error("Your account has been deactivated");
-                        }
-                        return [4, this.hooks.emitSerial(server_hooks_1.ServerHooks.ValidateLogin, hooksInfo)];
-                    case 3:
-                        _a.sent();
-                        enable_MFA = false;
-                        logout_other_clients = false;
-                        login_expiration_in_days = null;
-                        phone_logout_other_clients = false;
-                        phone_login_expiration_in_days = null;
-                        space = null;
-                        return [4, this.services[serviceName].getUserProfile(user.id)];
-                    case 4:
-                        userProfile = _a.sent();
-                        if (userProfile) {
-                            enable_MFA = userProfile.enable_MFA || false;
-                            logout_other_clients = userProfile.logout_other_clients || false;
-                            login_expiration_in_days = userProfile.login_expiration_in_days;
-                            phone_logout_other_clients =
-                                userProfile.phone_logout_other_clients || false;
-                            phone_login_expiration_in_days =
-                                userProfile.phone_login_expiration_in_days;
-                            space = userProfile.space;
-                        }
-                        if (enable_MFA) {
-                            if (!(params.user && params.token)) {
-                                _next = "TO_MOBILE_CODE_LOGIN";
-                                return [2, { _next: _next, mobile: user.mobile, mobile_verified: user.mobile_verified }];
-                            }
-                        }
-                        return [4, this.loginWithUser(user, Object.assign({}, infos, {
-                                logout_other_clients: logout_other_clients,
-                                login_expiration_in_days: login_expiration_in_days,
-                                phone_logout_other_clients: phone_logout_other_clients,
-                                phone_login_expiration_in_days: phone_login_expiration_in_days,
-                                space: space,
-                            }))];
-                    case 5:
-                        loginResult = _a.sent();
-                        this.hooks.emit(server_hooks_1.ServerHooks.LoginSuccess, hooksInfo);
-                        return [2, loginResult];
-                    case 6:
-                        err_1 = _a.sent();
-                        this.hooks.emit(server_hooks_1.ServerHooks.LoginError, tslib_1.__assign(tslib_1.__assign({}, hooksInfo), { error: err_1 }));
-                        throw err_1;
-                    case 7: return [2];
+            const userSessions = await this.db.findValidSessionsByUserId(user.id, is_phone);
+            if (userSessions) {
+                for (const userSession of userSessions) {
+                    await this.db.invalidateSession(userSession.id);
                 }
-            });
+            }
+            (0, auth_1.removeUserSessionsCacheByUserId)(user.id, is_phone);
+        }
+        const token = jwtToken || (0, tokens_1.generateRandomToken)();
+        const sessionId = await this.db.createSession(user.id, token, {
+            ip,
+            userAgent,
+            login_expiration_in_days,
+            phone_login_expiration_in_days,
+            is_phone,
+            is_tablet,
+            space,
+            provider
         });
-    };
-    AccountsServer.prototype.loginWithUser = function (user, infos) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var ip, userAgent, logout_other_clients, login_expiration_in_days, phone_logout_other_clients, phone_login_expiration_in_days, space, provider, jwtToken, is_phone, is_tablet, _a, phone, tablet, query, userSessions, _i, userSessions_1, userSession, token, sessionId, _b, accessToken, refreshToken, spaces;
-            return tslib_1.__generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        ip = infos.ip, userAgent = infos.userAgent, logout_other_clients = infos.logout_other_clients, login_expiration_in_days = infos.login_expiration_in_days, phone_logout_other_clients = infos.phone_logout_other_clients, phone_login_expiration_in_days = infos.phone_login_expiration_in_days, space = infos.space, provider = infos.provider, jwtToken = infos.jwtToken;
-                        is_phone = false;
-                        is_tablet = false;
-                        if (infos.userAgent) {
-                            try {
-                                _a = (0, ismobilejs_1.default)(infos.userAgent), phone = _a.phone, tablet = _a.tablet;
-                                is_phone = phone;
-                                is_tablet = tablet;
-                            }
-                            catch (Exception) {
-                                console.log("Exception", Exception);
-                            }
-                        }
-                        if (!(logout_other_clients || phone_logout_other_clients)) return [3, 7];
-                        query = null;
-                        if (is_phone) {
-                            query = { is_phone: true };
-                        }
-                        else {
-                            query = { is_phone: { $ne: true } };
-                        }
-                        return [4, this.db.updateUser(user.id, {
-                                $pull: {
-                                    "services.resume.loginTokens": query,
-                                },
-                            })];
-                    case 1:
-                        _c.sent();
-                        return [4, this.db.findValidSessionsByUserId(user.id, is_phone)];
-                    case 2:
-                        userSessions = _c.sent();
-                        if (!userSessions) return [3, 6];
-                        _i = 0, userSessions_1 = userSessions;
-                        _c.label = 3;
-                    case 3:
-                        if (!(_i < userSessions_1.length)) return [3, 6];
-                        userSession = userSessions_1[_i];
-                        return [4, this.db.invalidateSession(userSession.id)];
-                    case 4:
-                        _c.sent();
-                        _c.label = 5;
-                    case 5:
-                        _i++;
-                        return [3, 3];
-                    case 6:
-                        (0, auth_1.removeUserSessionsCacheByUserId)(user.id, is_phone);
-                        _c.label = 7;
-                    case 7:
-                        token = jwtToken || (0, tokens_1.generateRandomToken)();
-                        return [4, this.db.createSession(user.id, token, {
-                                ip: ip,
-                                userAgent: userAgent,
-                                login_expiration_in_days: login_expiration_in_days,
-                                phone_login_expiration_in_days: phone_login_expiration_in_days,
-                                is_phone: is_phone,
-                                is_tablet: is_tablet,
-                                space: space,
-                                provider: provider
-                            })];
-                    case 8:
-                        sessionId = _c.sent();
-                        _b = this.createTokens({
-                            token: token,
-                            userId: user.id,
-                            name: user.name,
-                            email: user.email
-                        }), accessToken = _b.accessToken, refreshToken = _b.refreshToken;
-                        return [4, this.db.getMySpaces(user.id)];
-                    case 9:
-                        spaces = _c.sent();
-                        return [2, {
-                                sessionId: sessionId,
-                                token: token,
-                                tokens: {
-                                    refreshToken: refreshToken,
-                                    accessToken: accessToken,
-                                },
-                                space: space,
-                                spaces: spaces,
-                                user: user,
-                            }];
-                }
-            });
+        const { accessToken, refreshToken } = this.createTokens({
+            token,
+            userId: user.id,
+            name: user.name,
+            email: user.email
         });
-    };
-    AccountsServer.prototype.impersonate = function (accessToken, impersonated, ip, userAgent) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var session, user, impersonatedUser, isAuthorized, token, newSessionId, impersonationTokens, impersonationResult, e_1;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 11, , 12]);
-                        if (!(0, lodash_1.isString)(accessToken)) {
-                            throw new Error("An access token is required");
-                        }
-                        try {
-                            jwt.verify(accessToken, this.options.tokenSecret);
-                        }
-                        catch (err) {
-                            throw new Error("Access token is not valid");
-                        }
-                        return [4, this.findSessionByAccessToken(accessToken)];
-                    case 1:
-                        session = _a.sent();
-                        if (!session.valid) {
-                            throw new Error("Session is not valid for user");
-                        }
-                        return [4, this.db.findUserById(session.userId)];
-                    case 2:
-                        user = _a.sent();
-                        if (!user) {
-                            throw new Error("User not found");
-                        }
-                        impersonatedUser = void 0;
-                        if (!impersonated.userId) return [3, 4];
-                        return [4, this.db.findUserById(impersonated.userId)];
-                    case 3:
-                        impersonatedUser = _a.sent();
-                        return [3, 8];
-                    case 4:
-                        if (!impersonated.username) return [3, 6];
-                        return [4, this.db.findUserByUsername(impersonated.username)];
-                    case 5:
-                        impersonatedUser = _a.sent();
-                        return [3, 8];
-                    case 6:
-                        if (!impersonated.email) return [3, 8];
-                        return [4, this.db.findUserByEmail(impersonated.email)];
-                    case 7:
-                        impersonatedUser = _a.sent();
-                        _a.label = 8;
-                    case 8:
-                        if (!impersonatedUser) {
-                            if (this.options.ambiguousErrorMessages) {
-                                return [2, { authorized: false }];
-                            }
-                            throw new Error("Impersonated user not found");
-                        }
-                        if (!this.options.impersonationAuthorize) {
-                            return [2, { authorized: false }];
-                        }
-                        return [4, this.options.impersonationAuthorize(user, impersonatedUser)];
-                    case 9:
-                        isAuthorized = _a.sent();
-                        if (!isAuthorized) {
-                            return [2, { authorized: false }];
-                        }
-                        token = (0, tokens_1.generateRandomToken)();
-                        return [4, this.db.createSession(impersonatedUser.id, token, {
-                                ip: ip,
-                                userAgent: userAgent,
-                            }, { impersonatorUserId: user.id })];
-                    case 10:
-                        newSessionId = _a.sent();
-                        impersonationTokens = this.createTokens({
-                            token: newSessionId,
-                            isImpersonated: true,
-                            userId: user.id,
-                            name: user.name,
-                            email: user.email,
-                        });
-                        impersonationResult = {
-                            authorized: true,
-                            tokens: impersonationTokens,
-                            user: this.sanitizeUser(impersonatedUser),
-                        };
-                        this.hooks.emit(server_hooks_1.ServerHooks.ImpersonationSuccess, {
-                            user: user,
-                            impersonationResult: impersonationResult,
-                        });
-                        return [2, impersonationResult];
-                    case 11:
-                        e_1 = _a.sent();
-                        this.hooks.emit(server_hooks_1.ServerHooks.ImpersonationError, e_1);
-                        throw e_1;
-                    case 12: return [2];
+        const spaces = await this.db.getMySpaces(user.id);
+        return {
+            sessionId,
+            token,
+            tokens: {
+                refreshToken,
+                accessToken,
+            },
+            space,
+            spaces,
+            user,
+        };
+    }
+    async impersonate(accessToken, impersonated, ip, userAgent) {
+        try {
+            if (!(0, lodash_1.isString)(accessToken)) {
+                throw new Error("An access token is required");
+            }
+            try {
+                jwt.verify(accessToken, this.options.tokenSecret);
+            }
+            catch (err) {
+                throw new Error("Access token is not valid");
+            }
+            const session = await this.findSessionByAccessToken(accessToken);
+            if (!session.valid) {
+                throw new Error("Session is not valid for user");
+            }
+            const user = await this.db.findUserById(session.userId);
+            if (!user) {
+                throw new Error("User not found");
+            }
+            let impersonatedUser;
+            if (impersonated.userId) {
+                impersonatedUser = await this.db.findUserById(impersonated.userId);
+            }
+            else if (impersonated.username) {
+                impersonatedUser = await this.db.findUserByUsername(impersonated.username);
+            }
+            else if (impersonated.email) {
+                impersonatedUser = await this.db.findUserByEmail(impersonated.email);
+            }
+            if (!impersonatedUser) {
+                if (this.options.ambiguousErrorMessages) {
+                    return { authorized: false };
                 }
+                throw new Error(`Impersonated user not found`);
+            }
+            if (!this.options.impersonationAuthorize) {
+                return { authorized: false };
+            }
+            const isAuthorized = await this.options.impersonationAuthorize(user, impersonatedUser);
+            if (!isAuthorized) {
+                return { authorized: false };
+            }
+            const token = (0, tokens_1.generateRandomToken)();
+            const newSessionId = await this.db.createSession(impersonatedUser.id, token, {
+                ip,
+                userAgent,
+            }, { impersonatorUserId: user.id });
+            const impersonationTokens = this.createTokens({
+                token: newSessionId,
+                isImpersonated: true,
+                userId: user.id,
+                name: user.name,
+                email: user.email,
             });
-        });
-    };
-    AccountsServer.prototype.refreshTokens = function (accessToken, refreshToken, ip, userAgent) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var sessionToken, decodedAccessToken, session, user, tokens, result, err_2;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 6, , 7]);
-                        if (!(0, lodash_1.isString)(accessToken) || !(0, lodash_1.isString)(refreshToken)) {
-                            throw new Error("An accessToken and refreshToken are required");
-                        }
-                        sessionToken = void 0;
-                        try {
-                            jwt.verify(refreshToken, this.options.tokenSecret);
-                            decodedAccessToken = jwt.verify(accessToken, this.options.tokenSecret, {
-                                ignoreExpiration: true,
-                            });
-                            sessionToken = decodedAccessToken.data.token;
-                        }
-                        catch (err) {
-                            throw new Error("Tokens are not valid");
-                        }
-                        return [4, this.db.findSessionByToken(sessionToken)];
-                    case 1:
-                        session = _a.sent();
-                        if (!session) {
-                            throw new Error("Session not found");
-                        }
-                        if (!session.valid) return [3, 4];
-                        return [4, this.db.findUserById(session.userId)];
-                    case 2:
-                        user = _a.sent();
-                        if (!user) {
-                            throw new Error("User not found");
-                        }
-                        tokens = this.createTokens({
-                            token: sessionToken,
-                            userId: user.id,
-                            name: user.name,
-                            email: user.email
-                        });
-                        return [4, this.db.updateSession(session.id, { ip: ip, userAgent: userAgent })];
-                    case 3:
-                        _a.sent();
-                        result = {
-                            sessionId: session.id,
-                            user: this.sanitizeUser(user),
-                            token: sessionToken,
-                            tokens: tokens,
-                        };
-                        this.hooks.emit(server_hooks_1.ServerHooks.RefreshTokensSuccess, result);
-                        return [2, result];
-                    case 4: throw new Error("Session is no longer valid");
-                    case 5: return [3, 7];
-                    case 6:
-                        err_2 = _a.sent();
-                        this.hooks.emit(server_hooks_1.ServerHooks.RefreshTokensError, err_2);
-                        throw err_2;
-                    case 7: return [2];
-                }
+            const impersonationResult = {
+                authorized: true,
+                tokens: impersonationTokens,
+                user: this.sanitizeUser(impersonatedUser),
+            };
+            this.hooks.emit(server_hooks_1.ServerHooks.ImpersonationSuccess, {
+                user,
+                impersonationResult,
             });
-        });
-    };
-    AccountsServer.prototype.createTokens = function (_a) {
-        var token = _a.token, _b = _a.isImpersonated, isImpersonated = _b === void 0 ? false : _b, userId = _a.userId, name = _a.name, email = _a.email;
-        var _c = this.options, tokenSecret = _c.tokenSecret, tokenConfigs = _c.tokenConfigs;
-        var jwtData = {
-            isImpersonated: isImpersonated,
-            userId: userId,
-            name: name,
-            email: email
+            return impersonationResult;
+        }
+        catch (e) {
+            this.hooks.emit(server_hooks_1.ServerHooks.ImpersonationError, e);
+            throw e;
+        }
+    }
+    async refreshTokens(accessToken, refreshToken, ip, userAgent) {
+        try {
+            if (!(0, lodash_1.isString)(accessToken) || !(0, lodash_1.isString)(refreshToken)) {
+                throw new Error("An accessToken and refreshToken are required");
+            }
+            let sessionToken;
+            try {
+                jwt.verify(refreshToken, this.options.tokenSecret);
+                const decodedAccessToken = jwt.verify(accessToken, this.options.tokenSecret, {
+                    ignoreExpiration: true,
+                });
+                sessionToken = decodedAccessToken.data.token;
+            }
+            catch (err) {
+                throw new Error("Tokens are not valid");
+            }
+            const session = await this.db.findSessionByToken(sessionToken);
+            if (!session) {
+                throw new Error("Session not found");
+            }
+            if (session.valid) {
+                const user = await this.db.findUserById(session.userId);
+                if (!user) {
+                    throw new Error("User not found");
+                }
+                const tokens = this.createTokens({
+                    token: sessionToken,
+                    userId: user.id,
+                    name: user.name,
+                    email: user.email
+                });
+                await this.db.updateSession(session.id, { ip, userAgent });
+                const result = {
+                    sessionId: session.id,
+                    user: this.sanitizeUser(user),
+                    token: sessionToken,
+                    tokens,
+                };
+                this.hooks.emit(server_hooks_1.ServerHooks.RefreshTokensSuccess, result);
+                return result;
+            }
+            else {
+                throw new Error("Session is no longer valid");
+            }
+        }
+        catch (err) {
+            this.hooks.emit(server_hooks_1.ServerHooks.RefreshTokensError, err);
+            throw err;
+        }
+    }
+    createTokens({ token, isImpersonated = false, userId, name, email }) {
+        const { tokenSecret, tokenConfigs } = this.options;
+        const jwtData = {
+            isImpersonated,
+            userId,
+            name,
+            email
         };
-        var accessToken = (0, tokens_1.generateAccessToken)({
+        const accessToken = (0, tokens_1.generateAccessToken)({
             data: jwtData,
             secret: tokenSecret,
             config: tokenConfigs.accessToken,
         });
-        var refreshToken = (0, tokens_1.generateRefreshToken)({
+        const refreshToken = (0, tokens_1.generateRefreshToken)({
             secret: tokenSecret,
             config: tokenConfigs.refreshToken,
         });
-        return { accessToken: accessToken, refreshToken: refreshToken };
-    };
-    AccountsServer.prototype.logout = function (token) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var session, error_1;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 5, , 6]);
-                        return [4, this.db.findSessionByToken(token)];
-                    case 1:
-                        session = _a.sent();
-                        if (!(session && session.valid)) return [3, 3];
-                        return [4, this.db.invalidateSession(session.id)];
-                    case 2:
-                        _a.sent();
-                        this.hooks.emit(server_hooks_1.ServerHooks.LogoutSuccess, {
-                            session: session,
-                            token: token,
-                        });
-                        return [3, 4];
-                    case 3: throw new Error("Session is no longer valid");
-                    case 4: return [2, session];
-                    case 5:
-                        error_1 = _a.sent();
-                        this.hooks.emit(server_hooks_1.ServerHooks.LogoutError, error_1);
-                        throw error_1;
-                    case 6: return [2];
-                }
-            });
-        });
-    };
-    AccountsServer.prototype.logoutByAccessToken = function (accessToken) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var session, error_2;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 5, , 6]);
-                        return [4, this.findSessionByAccessToken(accessToken)];
-                    case 1:
-                        session = _a.sent();
-                        if (!session.valid) return [3, 3];
-                        return [4, this.db.invalidateSession(session.id)];
-                    case 2:
-                        _a.sent();
-                        this.hooks.emit(server_hooks_1.ServerHooks.LogoutSuccess, {
-                            session: session,
-                            accessToken: accessToken,
-                        });
-                        return [3, 4];
-                    case 3: throw new Error("Session is no longer valid");
-                    case 4: return [3, 6];
-                    case 5:
-                        error_2 = _a.sent();
-                        this.hooks.emit(server_hooks_1.ServerHooks.LogoutError, error_2);
-                        throw error_2;
-                    case 6: return [2];
+        return { accessToken, refreshToken };
+    }
+    async logout(token) {
+        try {
+            const session = await this.db.findSessionByToken(token);
+            if (session && session.valid) {
+                await this.db.invalidateSession(session.id);
+                this.hooks.emit(server_hooks_1.ServerHooks.LogoutSuccess, {
+                    session,
+                    token,
+                });
+            }
+            else {
+                throw new Error("Session is no longer valid");
+            }
+            return session;
+        }
+        catch (error) {
+            this.hooks.emit(server_hooks_1.ServerHooks.LogoutError, error);
+            throw error;
+        }
+    }
+    async logoutByAccessToken(accessToken) {
+        try {
+            const session = await this.findSessionByAccessToken(accessToken);
+            if (session.valid) {
+                await this.db.invalidateSession(session.id);
+                this.hooks.emit(server_hooks_1.ServerHooks.LogoutSuccess, {
+                    session,
+                    accessToken,
+                });
+            }
+            else {
+                throw new Error("Session is no longer valid");
+            }
+        }
+        catch (error) {
+            this.hooks.emit(server_hooks_1.ServerHooks.LogoutError, error);
+            throw error;
+        }
+    }
+    async resumeSession(token) {
+        try {
+            const session = await this.db.findSessionByToken(token);
+            if (session && session.valid) {
+                const user = await this.db.findUserById(session.userId);
+                if (!user) {
+                    throw new Error("User not found");
                 }
-            });
-        });
-    };
-    AccountsServer.prototype.resumeSession = function (token) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var session, user, e_2, e_3;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 8, , 9]);
-                        return [4, this.db.findSessionByToken(token)];
-                    case 1:
-                        session = _a.sent();
-                        if (!(session && session.valid)) return [3, 7];
-                        return [4, this.db.findUserById(session.userId)];
-                    case 2:
-                        user = _a.sent();
-                        if (!user) {
-                            throw new Error("User not found");
-                        }
-                        if (!this.options.resumeSessionValidator) return [3, 6];
-                        _a.label = 3;
-                    case 3:
-                        _a.trys.push([3, 5, , 6]);
-                        return [4, this.options.resumeSessionValidator(user, session)];
-                    case 4:
-                        _a.sent();
-                        return [3, 6];
-                    case 5:
-                        e_2 = _a.sent();
-                        throw new Error(e_2);
-                    case 6:
-                        this.hooks.emit(server_hooks_1.ServerHooks.ResumeSessionSuccess, { user: user, token: token });
-                        return [2, this.sanitizeUser(user)];
-                    case 7:
-                        this.hooks.emit(server_hooks_1.ServerHooks.ResumeSessionError, new Error("Invalid Session"));
-                        throw new Error("Invalid Session");
-                    case 8:
-                        e_3 = _a.sent();
-                        this.hooks.emit(server_hooks_1.ServerHooks.ResumeSessionError, e_3);
-                        throw e_3;
-                    case 9: return [2];
+                if (this.options.resumeSessionValidator) {
+                    try {
+                        await this.options.resumeSessionValidator(user, session);
+                    }
+                    catch (e) {
+                        throw new Error(e);
+                    }
                 }
-            });
-        });
-    };
-    AccountsServer.prototype.resumeSessionByAccessToken = function (accessToken) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var session, user, e_4, e_5;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 8, , 9]);
-                        return [4, this.findSessionByAccessToken(accessToken)];
-                    case 1:
-                        session = _a.sent();
-                        if (!session.valid) return [3, 7];
-                        return [4, this.db.findUserById(session.userId)];
-                    case 2:
-                        user = _a.sent();
-                        if (!user) {
-                            throw new Error("User not found");
-                        }
-                        if (!this.options.resumeSessionValidator) return [3, 6];
-                        _a.label = 3;
-                    case 3:
-                        _a.trys.push([3, 5, , 6]);
-                        return [4, this.options.resumeSessionValidator(user, session)];
-                    case 4:
-                        _a.sent();
-                        return [3, 6];
-                    case 5:
-                        e_4 = _a.sent();
-                        throw new Error(e_4);
-                    case 6:
-                        this.hooks.emit(server_hooks_1.ServerHooks.ResumeSessionSuccess, {
-                            user: user,
-                            accessToken: accessToken,
-                        });
-                        return [2, this.sanitizeUser(user)];
-                    case 7:
-                        this.hooks.emit(server_hooks_1.ServerHooks.ResumeSessionError, new Error("Invalid Session"));
-                        throw new Error("Invalid Session");
-                    case 8:
-                        e_5 = _a.sent();
-                        this.hooks.emit(server_hooks_1.ServerHooks.ResumeSessionError, e_5);
-                        throw e_5;
-                    case 9: return [2];
+                this.hooks.emit(server_hooks_1.ServerHooks.ResumeSessionSuccess, { user, token });
+                return this.sanitizeUser(user);
+            }
+            this.hooks.emit(server_hooks_1.ServerHooks.ResumeSessionError, new Error("Invalid Session"));
+            throw new Error("Invalid Session");
+        }
+        catch (e) {
+            this.hooks.emit(server_hooks_1.ServerHooks.ResumeSessionError, e);
+            throw e;
+        }
+    }
+    async resumeSessionByAccessToken(accessToken) {
+        try {
+            const session = await this.findSessionByAccessToken(accessToken);
+            if (session.valid) {
+                const user = await this.db.findUserById(session.userId);
+                if (!user) {
+                    throw new Error("User not found");
                 }
-            });
-        });
-    };
-    AccountsServer.prototype.findSessionByAccessToken = function (accessToken) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var sessionToken, decodedAccessToken, session;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!(0, lodash_1.isString)(accessToken)) {
-                            throw new Error("An accessToken is required");
-                        }
-                        try {
-                            decodedAccessToken = jwt.verify(accessToken, this.options.tokenSecret);
-                            sessionToken = decodedAccessToken.data.token;
-                        }
-                        catch (err) {
-                            throw new Error("Tokens are not valid");
-                        }
-                        return [4, this.db.findSessionByToken(sessionToken)];
-                    case 1:
-                        session = _a.sent();
-                        if (!session) {
-                            throw new Error("Session not found");
-                        }
-                        return [2, session];
+                if (this.options.resumeSessionValidator) {
+                    try {
+                        await this.options.resumeSessionValidator(user, session);
+                    }
+                    catch (e) {
+                        throw new Error(e);
+                    }
                 }
-            });
-        });
-    };
-    AccountsServer.prototype.findUserById = function (userId) {
+                this.hooks.emit(server_hooks_1.ServerHooks.ResumeSessionSuccess, {
+                    user,
+                    accessToken,
+                });
+                return this.sanitizeUser(user);
+            }
+            this.hooks.emit(server_hooks_1.ServerHooks.ResumeSessionError, new Error("Invalid Session"));
+            throw new Error("Invalid Session");
+        }
+        catch (e) {
+            this.hooks.emit(server_hooks_1.ServerHooks.ResumeSessionError, e);
+            throw e;
+        }
+    }
+    async findSessionByAccessToken(accessToken) {
+        if (!(0, lodash_1.isString)(accessToken)) {
+            throw new Error("An accessToken is required");
+        }
+        let sessionToken;
+        try {
+            const decodedAccessToken = jwt.verify(accessToken, this.options.tokenSecret);
+            sessionToken = decodedAccessToken.data.token;
+        }
+        catch (err) {
+            throw new Error("Tokens are not valid");
+        }
+        const session = await this.db.findSessionByToken(sessionToken);
+        if (!session) {
+            throw new Error("Session not found");
+        }
+        return session;
+    }
+    findUserById(userId) {
         return this.db.findUserById(userId);
-    };
-    AccountsServer.prototype.deactivateUser = function (userId) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                return [2, this.db.setUserDeactivated(userId, true)];
-            });
-        });
-    };
-    AccountsServer.prototype.activateUser = function (userId) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                return [2, this.db.setUserDeactivated(userId, false)];
-            });
-        });
-    };
-    AccountsServer.prototype.prepareMail = function (to, token, user, pathFragment, emailTemplate, from) {
+    }
+    async deactivateUser(userId) {
+        return this.db.setUserDeactivated(userId, true);
+    }
+    async activateUser(userId) {
+        return this.db.setUserDeactivated(userId, false);
+    }
+    prepareMail(to, token, user, pathFragment, emailTemplate, from) {
         if (this.options.prepareMail) {
             return this.options.prepareMail(to, token, user, pathFragment, emailTemplate, from);
         }
         return this.defaultPrepareEmail(to, token, user, pathFragment, emailTemplate, from);
-    };
-    AccountsServer.prototype.sanitizeUser = function (user) {
-        var userObjectSanitizer = this.options.userObjectSanitizer;
+    }
+    sanitizeUser(user) {
+        const { userObjectSanitizer } = this.options;
         return userObjectSanitizer(this.internalUserSanitizer(user), lodash_1.omit, lodash_1.pick);
-    };
-    AccountsServer.prototype.internalUserSanitizer = function (user) {
+    }
+    internalUserSanitizer(user) {
         return (0, lodash_1.omit)(user, ["services"]);
-    };
-    AccountsServer.prototype.defaultPrepareEmail = function (to, token, user, pathFragment, emailTemplate, from) {
-        var tokenizedUrl = this.defaultCreateTokenizedUrl(pathFragment, token);
+    }
+    defaultPrepareEmail(to, token, user, pathFragment, emailTemplate, from) {
+        const tokenizedUrl = this.defaultCreateTokenizedUrl(pathFragment, token);
         return {
             from: emailTemplate.from || from,
-            to: to,
+            to,
             subject: emailTemplate.subject(user, token),
             text: emailTemplate.text(user, tokenizedUrl, token),
             html: emailTemplate.html && emailTemplate.html(user, tokenizedUrl, token),
         };
-    };
-    AccountsServer.prototype.defaultCreateTokenizedUrl = function (pathFragment, token) {
-        var siteUrl = this.options.siteUrl;
-        return "".concat(siteUrl, "/").concat(pathFragment, "/").concat(token);
-    };
-    return AccountsServer;
-}());
+    }
+    defaultCreateTokenizedUrl(pathFragment, token) {
+        const siteUrl = this.options.siteUrl;
+        return `${siteUrl}/${pathFragment}/${token}`;
+    }
+}
 exports.AccountsServer = AccountsServer;
 exports.default = AccountsServer;
 //# sourceMappingURL=accounts-server.js.map