@taon-dev/session 21.0.216 → 21.0.240

package/lib/taon-session/taon-session.controller.js

@@ -14,39 +14,312 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaonSessionController = void 0;
 //#region imports
-const jsonwebtoken_1 = require("jsonwebtoken"); // @backend
-const lib_1 = require("taon/lib");
-const taon_session_kv_repository_1 = require("./taon-session-kv.repository");
-const taon_session_user_repository_1 = require("./taon-session-user.repository");
+const lib_1 = require("@taon-dev/i18n/lib");
+const index_1 = require("../index");
+const lib_2 = require("taon/lib");
+const lib_3 = require("tnp-core/lib");
+const taon_session_user_1 = require("../taon-session-user");
+const taon_session_user_identity_repository_1 = require("../taon-session-user/taon-session-user-identity.repository");
+const taon_session_user_repository_1 = require("../taon-session-user/taon-session-user.repository");
+const taon_session_entity_1 = require("./taon-session.entity");
+const taon_session_kv_repository_1 = require("./taon-session.kv.repository");
 const taon_session_middleware_1 = require("./taon-session.middleware");
-const taon_session_models_1 = require("./taon-session.models");
 const taon_session_provider_1 = require("./taon-session.provider");
+const taon_session_repository_1 = require("./taon-session.repository");
+const taon_session_utils_1 = require("./taon-session.utils");
 //#endregion
-let TaonSessionController = class TaonSessionController extends lib_1.TaonBaseController {
+const t = lib_1.Translation.for('src/lib/taon-session/taon-session.controller.ts', {});
+let TaonSessionController = class TaonSessionController extends lib_2.TaonBaseController {
+    //#region fields & getters
     taonSessionKvRepository = this.injectKvRepository(taon_session_kv_repository_1.TaonSessionKvRepository);
+    taonSessionUserIdentityRepository = this.injectCustomRepo(taon_session_user_identity_repository_1.TaonSessionUserIdentityRepository);
     taonSessionProvider = this.injectProvider(taon_session_provider_1.TaonSessionProvider);
     taonSessionUserRepository = this.injectCustomRepo(taon_session_user_repository_1.TaonSessionUserRepository);
-    //#region login
-    login(data) {
+    taonAuthContextRepository = this.injectCustomRepo(index_1.TaonAuthContextRepository);
+    taonSessionRepository = this.injectCustomRepo(taon_session_repository_1.TaonSessionRepository);
+    //#endregion
+    //#region createUser
+    createUser(email, password) {
+        //#region @websqlFunc
+        return async (req, res) => {
+            if (this.taonSessionProvider.login.diableLoginByEmail) {
+                lib_2.Taon.error({
+                    message: t.gettext('Login by email is disalbed'),
+                    status: (0, lib_2.getStatusCode)(lib_2.HttpStatusEnum.UNAUTHORIZED),
+                });
+                return null;
+            }
+            return this.taonSessionUserIdentityRepository.registerPasswordUser(email, password);
+        };
+        //#endregion
+    }
+    //#endregion
+    //#region userExists
+    userExists(email) {
+        //#region @websqlFunc
+        return async (req, res) => {
+            if (this.taonSessionProvider.login.diableLoginByEmail) {
+                lib_2.Taon.error({
+                    message: t.gettext('Login by email is disalbed'),
+                    status: (0, lib_2.getStatusCode)(lib_2.HttpStatusEnum.UNAUTHORIZED),
+                });
+                return true;
+            }
+            const identity = await this.taonSessionUserIdentityRepository.findPasswordIdentity(email);
+            return (!!identity ||
+                (this.taonSessionProvider.linkSocialAccountEmail === true &&
+                    (await this.taonSessionUserIdentityRepository.findUserIdByEmail(email)) !== undefined));
+        };
+        //#endregion
+    }
+    //#endregion
+    //#region get google identity
+    async getGoogleIdentity(data) {
         //#region @backendFunc
+        const { googleCode } = data;
+        let googleData;
+        try {
+            googleData = await taon_session_utils_1.TaonSessionUtils.verifyGoogleAuthorizationCode(this.taonSessionProvider.socialLogin.google.googleClientId, this.taonSessionProvider.socialLogin.google.googleSecret, googleCode);
+        }
+        catch (error) {
+            lib_2.Taon.error({
+                status: (0, lib_2.getStatusCode)(lib_2.HttpStatusEnum.INVALID_CREDENTIALS),
+                message: (0, lib_2.getStatusText)(lib_2.HttpStatusEnum.INVALID_CREDENTIALS),
+            });
+            return { error: true };
+        }
+        if (!googleData?.sub ||
+            !googleData?.email ||
+            googleData?.emailVerified !== true) {
+            lib_2.Taon.error({
+                status: (0, lib_2.getStatusCode)(lib_2.HttpStatusEnum.INVALID_CREDENTIALS),
+                message: 'Invalid Google authentication.',
+            });
+            return { error: true };
+        }
+        let identity = await this.taonSessionUserIdentityRepository.findSocialIdentity(taon_session_user_1.TaonSessionIdentityProvider.GOOGLE, googleData.sub);
+        return { identity, error: false, googleData };
+        //#endregion
+    }
+    //#endregion
+    //#region connect identity
+    connectIdentity(data) {
+        //#region @websqlFunc
         return async (req, res) => {
-            const { email, password } = data || {};
-            const user = await this.taonSessionUserRepository.findOne({
+            const userId = Number(req.userId);
+            const provider = data.googleCode
+                ? taon_session_user_1.TaonSessionIdentityProvider.GOOGLE
+                : data.email && data.password
+                    ? taon_session_user_1.TaonSessionIdentityProvider.PASSWORD
+                    : void 0;
+            switch (provider) {
+                case taon_session_user_1.TaonSessionIdentityProvider.PASSWORD: {
+                    if (this.taonSessionProvider.login.diableLoginByEmail) {
+                        lib_2.Taon.error({
+                            context: 'connectIdentity diableLoginByEmail',
+                            status: (0, lib_2.getStatusCode)(lib_2.HttpStatusEnum.UNAUTHORIZED),
+                            message: t.gettext('Login by email is disabled.'),
+                        });
+                    }
+                    if (typeof data.password !== 'string' ||
+                        data.password.length < 8 ||
+                        data.password.length > 128) {
+                        lib_2.Taon.error({
+                            context: 'connectIdentity data.password',
+                            status: (0, lib_2.getStatusCode)(lib_2.HttpStatusEnum.BAD_REQUEST),
+                            message: t.gettext('Password must contain between 8 and 128 characters.'),
+                        });
+                    }
+                    await this.taonSessionUserIdentityRepository.connectPasswordIdentity(userId, data.email, data.password);
+                    return true;
+                }
+                case taon_session_user_1.TaonSessionIdentityProvider.GOOGLE: {
+                    const { identity, error, googleData } = await this.getGoogleIdentity({
+                        googleCode: data.googleCode,
+                    });
+                    if (error) {
+                        return false;
+                    }
+                    if (identity) {
+                        if (identity.userId === userId) {
+                            // Already connected to this user.
+                            return true;
+                        }
+                        lib_2.Taon.error({
+                            status: (0, lib_2.getStatusCode)(lib_2.HttpStatusEnum.CONFLICT),
+                            message: t.gettext('This Google account is already connected to another user.'),
+                        });
+                        return false;
+                    }
+                    await this.taonSessionUserIdentityRepository.createSocialIdentity(userId, taon_session_user_1.TaonSessionIdentityProvider.GOOGLE, googleData.sub, googleData.email, googleData.emailVerified);
+                    return true;
+                }
+                default: {
+                    lib_2.Taon.error({
+                        status: (0, lib_2.getStatusCode)(lib_2.HttpStatusEnum.BAD_REQUEST),
+                        message: t.gettext('Unsupported identity provider.'),
+                    });
+                    return false;
+                }
+            }
+        };
+        //#endregion
+    }
+    //#endregion
+    //#region username available
+    usernameAvailable(username) {
+        //#region @websqlFunc
+        return async (req) => this.taonSessionUserRepository.isUsernameAvailable(username, Number('userId' in req ? req.userId : undefined));
+        //#endregion
+    }
+    //#endregion
+    //#region change username
+    changeUsername(username) {
+        //#region @websqlFunc
+        return async (req) => {
+            await this.taonSessionUserRepository.changeUsername(Number('userId' in req ? req.userId : undefined), username);
+            return true;
+        };
+        //#endregion
+    }
+    //#endregion
+    //#region disconnect identity
+    disconnectIdentity(provider) {
+        //#region @websqlFunc
+        return async (req, res) => {
+            const userId = Number(req.userId);
+            const identity = await this.taonSessionUserIdentityRepository.findOne({
                 where: {
-                    email,
-                    password,
+                    userId,
+                    provider,
                 },
             });
-            if (!user) {
-                lib_1.Taon.error({
-                    status: 401,
-                    message: 'Invalid credentials',
+            if (!identity) {
+                lib_2.Taon.error({
+                    status: (0, lib_2.getStatusCode)(lib_2.HttpStatusEnum.NOT_FOUND),
+                    message: t.gettext('Identity not found.'),
                 });
                 return false;
             }
-            const accessToken = this.taonSessionKvRepository.createAccessToken(user.id);
-            const refreshToken = this.taonSessionKvRepository.createRefreshToken(user.id);
+            const identities = await this.taonSessionUserIdentityRepository.find({
+                where: {
+                    userId,
+                },
+            });
+            if (identities.length <= 1) {
+                lib_2.Taon.error({
+                    status: (0, lib_2.getStatusCode)(lib_2.HttpStatusEnum.BAD_REQUEST),
+                    message: t.gettext('You cannot disconnect your only sign-in method.'),
+                });
+                return false;
+            }
+            await this.taonSessionUserIdentityRepository.remove(identity);
+            return true;
+        };
+        //#endregion
+    }
+    //#endregion
+    //#region login
+    login(data) {
+        //#region @websqlFunc
+        return async (req, res) => {
+            let { email, password, googleCode } = data || {};
+            const isSocialLogin = !!googleCode;
+            let user = null;
+            let loginIdentity;
+            if (isSocialLogin) {
+                //#region google login
+                let { identity, error, googleData } = await this.getGoogleIdentity(data);
+                if (error) {
+                    return false;
+                }
+                if (!identity) {
+                    identity =
+                        await this.taonSessionUserIdentityRepository.resolveSocialIdentity(taon_session_user_1.TaonSessionIdentityProvider.GOOGLE, googleData.sub, googleData.email, googleData.emailVerified);
+                }
+                loginIdentity = identity;
+                user = await this.taonSessionUserRepository.findOne({
+                    where: { id: identity.userId },
+                });
+                //#endregion
+            }
+            else {
+                //#region password login
+                if (this.taonSessionProvider.login.diableLoginByEmail) {
+                    lib_2.Taon.error({
+                        status: (0, lib_2.getStatusCode)(lib_2.HttpStatusEnum.UNAUTHORIZED),
+                        message: t.gettext('Login by email is disabled.'),
+                    });
+                }
+                if (!email || !password) {
+                    lib_2.Taon.error({
+                        status: (0, lib_2.getStatusCode)(lib_2.HttpStatusEnum.INVALID_CREDENTIALS),
+                        message: (0, lib_2.getStatusText)(lib_2.HttpStatusEnum.INVALID_CREDENTIALS),
+                    });
+                    return false;
+                }
+                const identity = await this.taonSessionUserIdentityRepository.verifyPassword(email, password);
+                if (!identity) {
+                    lib_2.Taon.error({
+                        status: (0, lib_2.getStatusCode)(lib_2.HttpStatusEnum.INVALID_CREDENTIALS),
+                        message: (0, lib_2.getStatusText)(lib_2.HttpStatusEnum.INVALID_CREDENTIALS),
+                    });
+                    return false;
+                }
+                user = await this.taonSessionUserRepository.findOne({
+                    where: {
+                        id: identity.userId,
+                    },
+                });
+                loginIdentity = identity;
+                //#endregion
+            }
+            //#region validate user
+            if (!user || !user.isActive) {
+                lib_2.Taon.error({
+                    status: (0, lib_2.getStatusCode)(lib_2.HttpStatusEnum.INVALID_CREDENTIALS),
+                    message: t.gettext(`User is not active`),
+                });
+                return false;
+            }
+            //#endregion
+            // await (async () => {
+            //   const session = new TaonSessionEntity();
+            //   session.userId = 1;
+            //   session.lastActivityAt = new Date();
+            //   session.expiresAt = new Date(Date.now() + 60_000);
+            //   console.log('BEFORE', {
+            //     lastActivityAt: session.lastActivityAt,
+            //     expiresAt: session.expiresAt,
+            //   });
+            //   const saved = await this.taonSessionRepository.save(session);
+            //   console.log('AFTER', {
+            //     lastActivityAt: saved.lastActivityAt,
+            //     expiresAt: saved.expiresAt,
+            //   });
+            // })();
+            //#region create session
+            const sessionObjToSave = new taon_session_entity_1.TaonSessionEntity().clone({
+                userId: user.id,
+                identityId: loginIdentity.id,
+                authenticationProvider: loginIdentity.provider,
+                ...taon_session_utils_1.TaonSessionUtils.getRequestMetadata(req),
+                lastActivityAt: new Date(),
+                expiresAt: new Date(Date.now() +
+                    this.taonSessionProvider.cookies.REFRESH_TOKEN_EXPIRES_SECONDS *
+                        1000),
+            });
+            const session = await this.taonSessionRepository.createSession(sessionObjToSave);
+            // const loaded = await this.taonSessionRepository.findOne({
+            //   where: { id: session.id },
+            // });
+            // console.log('RELOADED SESSION', loaded);
+            //#endregion
+            //#region create auth tokens
+            const accessToken = await this.taonSessionKvRepository.createAccessToken(user.id, session.id);
+            const refreshToken = await this.taonSessionKvRepository.createRefreshToken(user.id, session.id);
             this.taonSessionKvRepository.setAuthCookies(res, accessToken, refreshToken);
+            //#endregion
             return true;
         };
         //#endregion
@@ -54,66 +327,108 @@ let TaonSessionController = class TaonSessionController extends lib_1.TaonBaseCo
     //#endregion
     //#region refresh
     refresh() {
-        //#region @backendFunc
+        //#region @websqlFunc
         return async (req, res) => {
             const token = req.cookies?.refreshToken;
             if (!token) {
-                lib_1.Taon.error({
+                lib_2.Taon.error({
                     status: 401,
+                    context: 'refresh',
                     message: 'No refresh token',
                 });
                 return false;
             }
+            let payload;
             try {
-                const payload = jsonwebtoken_1.default.verify(token, this.taonSessionProvider.REFRESH_TOKEN_SECRET);
-                const session = await this.taonSessionKvRepository.get(payload.rtId);
-                if (!session) {
-                    lib_1.Taon.error({
-                        status: 401,
-                        message: 'Invalid refresh token',
-                    });
-                    return false;
-                }
-                if (session.expiresAt < Date.now()) {
-                    await this.taonSessionKvRepository.delete(payload.rtId);
-                    lib_1.Taon.error({
-                        status: 401,
-                        message: 'Expired refresh token',
-                    });
-                    return false;
-                }
-                // ROTATION (important)
-                await this.taonSessionKvRepository.delete(payload.rtId);
-                const newAccessToken = this.taonSessionKvRepository.createAccessToken(session.userId);
-                const newRefreshToken = this.taonSessionKvRepository.createRefreshToken(session.userId);
-                this.taonSessionKvRepository.setAuthCookies(res, newAccessToken, newRefreshToken);
-                return true;
+                payload = await lib_3.UtilsJwt.verify(token, this.taonSessionProvider.cookies.REFRESH_TOKEN_SECRET);
             }
             catch {
-                lib_1.Taon.error({
+                lib_2.Taon.error({
                     status: 401,
+                    context: 'refresh verification',
                     message: 'Invalid refresh token',
                 });
                 return false;
             }
+            if (typeof payload.rtId !== 'string' || !payload.rtId) {
+                lib_2.Taon.error({
+                    status: 401,
+                    context: 'refresh rotation',
+                    message: 'Invalid refresh token',
+                });
+                return false;
+            }
+            const session = await this.taonSessionKvRepository.get(payload.rtId);
+            if (!session) {
+                lib_2.Taon.error({
+                    status: 401,
+                    message: 'Invalid refresh token',
+                });
+                return false;
+            }
+            if (session.expiresAt <= Date.now()) {
+                await this.taonSessionKvRepository.delete(payload.rtId);
+                lib_2.Taon.error({
+                    status: 401,
+                    message: 'Expired refresh token',
+                });
+                return false;
+            }
+            if (session.sessionId !== undefined) {
+                await this.taonSessionRepository.touchSession(session.sessionId, session.userId, true);
+            }
+            // ROTATION (important)
+            await this.taonSessionKvRepository.delete(payload.rtId);
+            const newAccessToken = await this.taonSessionKvRepository.createAccessToken(session.userId, session.sessionId);
+            const newRefreshToken = await this.taonSessionKvRepository.createRefreshToken(session.userId, session.sessionId);
+            this.taonSessionKvRepository.setAuthCookies(res, newAccessToken, newRefreshToken);
+            return true;
         };
         //#endregion
     }
     //#endregion
     //#region logout
     logout() {
-        //#region @backendFunc
+        //#region @websqlFunc
         return async (req, res) => {
-            const token = req.cookies?.refreshToken;
+            const refreshToken = req.cookies?.refreshToken;
+            const token = refreshToken || this.taonSessionKvRepository.getTokenFromRequest(req);
             if (token) {
+                let payload;
                 try {
-                    const payload = jsonwebtoken_1.default.verify(token, this.taonSessionProvider.REFRESH_TOKEN_SECRET);
-                    await this.taonSessionKvRepository.delete(payload.rtId);
+                    payload = await lib_3.UtilsJwt.verify(token, refreshToken
+                        ? this.taonSessionProvider.cookies.REFRESH_TOKEN_SECRET
+                        : this.taonSessionProvider.cookies.ACCESS_TOKEN_SECRET);
                 }
                 catch (error) {
                     console.error(error);
+                    this.taonSessionKvRepository.clearAuthCookies(res);
+                    lib_2.Taon.error({
+                        status: 401,
+                        context: 'logout',
+                        message: (0, lib_2.getStatusText)(lib_2.HttpStatusEnum.INVALID_TOKEN),
+                    });
                     return false;
                 }
+                if (refreshToken) {
+                    if (typeof payload.rtId !== 'string' || !payload.rtId) {
+                        lib_2.Taon.error({
+                            status: 401,
+                            context: 'logout',
+                            message: 'Invalid refresh token',
+                        });
+                        return false;
+                    }
+                    const session = await this.taonSessionKvRepository.get(payload.rtId);
+                    if (session?.sessionId !== undefined) {
+                        await this.taonSessionRepository.revokeSession(session.sessionId, session.userId);
+                    }
+                    await this.taonSessionKvRepository.delete(payload.rtId);
+                }
+                else if (typeof payload.sessionId === 'number' &&
+                    typeof payload.userId === 'number') {
+                    await this.taonSessionRepository.revokeSession(payload.sessionId, payload.userId);
+                }
             }
             this.taonSessionKvRepository.clearAuthCookies(res);
             return true;
@@ -121,38 +436,139 @@ let TaonSessionController = class TaonSessionController extends lib_1.TaonBaseCo
         //#endregion
     }
     //#endregion
-    //#region me
-    me() {
-        //#region @backendFunc
+    //#region context
+    context() {
+        //#region @websqlFunc
+        return async (req, res) => {
+            const userId = req.userId;
+            const context = await this.taonAuthContextRepository.getContext(userId);
+            return context;
+        };
+        //#endregion
+    }
+    //#endregion
+    //#region empty context
+    emptyContext() {
+        //#region @websqlFunc
+        return async (req, res) => {
+            const context = await this.taonAuthContextRepository.getContext();
+            return context;
+        };
+        //#endregion
+    }
+    //#endregion
+    //#region get current user id
+    getCurrentUserId() {
+        //#region @websqlFunc
         return async (req, res) => {
             const userId = req.userId;
-            return userId;
+            return Number(userId);
         };
         //#endregion
     }
 };
 exports.TaonSessionController = TaonSessionController;
 __decorate([
-    (0, lib_1.POST)(),
-    __param(0, (0, lib_1.Body)()),
+    (0, lib_2.POST)(),
+    __param(0, (0, lib_2.Body)('email')),
+    __param(1, (0, lib_2.Body)('password')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Object)
+], TaonSessionController.prototype, "createUser", null);
+__decorate([
+    (0, lib_2.POST)(),
+    __param(0, (0, lib_2.Body)('email')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Object)
+], TaonSessionController.prototype, "userExists", null);
+__decorate([
+    (0, lib_2.POST)({
+        middlewares: ({ parentMiddlewares }) => ({
+            TaonSessionMiddleware: taon_session_middleware_1.TaonSessionMiddleware,
+            ...parentMiddlewares,
+        }),
+    }),
+    __param(0, (0, lib_2.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], TaonSessionController.prototype, "connectIdentity", null);
+__decorate([
+    (0, lib_2.POST)({
+        middlewares: ({ parentMiddlewares }) => ({
+            TaonSessionMiddleware: taon_session_middleware_1.TaonSessionMiddleware,
+            ...parentMiddlewares,
+        }),
+    }),
+    __param(0, (0, lib_2.Body)('username')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Object)
+], TaonSessionController.prototype, "usernameAvailable", null);
+__decorate([
+    (0, lib_2.POST)({
+        middlewares: ({ parentMiddlewares }) => ({
+            TaonSessionMiddleware: taon_session_middleware_1.TaonSessionMiddleware,
+            ...parentMiddlewares,
+        }),
+    }),
+    __param(0, (0, lib_2.Body)('username')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Object)
+], TaonSessionController.prototype, "changeUsername", null);
+__decorate([
+    (0, lib_2.POST)({
+        middlewares: ({ parentMiddlewares }) => ({
+            TaonSessionMiddleware: taon_session_middleware_1.TaonSessionMiddleware,
+            ...parentMiddlewares,
+        }),
+    }),
+    __param(0, (0, lib_2.Body)('provider')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Object)
+], TaonSessionController.prototype, "disconnectIdentity", null);
+__decorate([
+    (0, lib_2.POST)(),
+    __param(0, (0, lib_2.Body)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Object)
 ], TaonSessionController.prototype, "login", null);
 __decorate([
-    (0, lib_1.POST)(),
+    (0, lib_2.POST)(),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Object)
 ], TaonSessionController.prototype, "refresh", null);
 __decorate([
-    (0, lib_1.POST)(),
+    (0, lib_2.POST)(),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Object)
 ], TaonSessionController.prototype, "logout", null);
 __decorate([
-    (0, lib_1.GET)({
+    (0, lib_2.GET)({
+        middlewares: ({ parentMiddlewares }) => ({
+            TaonSessionMiddleware: taon_session_middleware_1.TaonSessionMiddleware,
+            ...parentMiddlewares,
+        }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Object)
+], TaonSessionController.prototype, "context", null);
+__decorate([
+    (0, lib_2.GET)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Object)
+], TaonSessionController.prototype, "emptyContext", null);
+__decorate([
+    (0, lib_2.GET)({
         middlewares: ({ parentMiddlewares }) => ({
             TaonSessionMiddleware: taon_session_middleware_1.TaonSessionMiddleware,
             ...parentMiddlewares,
@@ -161,10 +577,26 @@ __decorate([
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Object)
-], TaonSessionController.prototype, "me", null);
+], TaonSessionController.prototype, "getCurrentUserId", null);
 exports.TaonSessionController = TaonSessionController = __decorate([
-    (0, lib_1.TaonController)({
+    (0, lib_2.TaonController)({
         className: 'TaonSessionController',
+        allowedMethods: [
+            //#region allowed method
+            'createUser',
+            'userExists',
+            'getCurrentUserId',
+            'login',
+            'logout',
+            'refresh',
+            'context',
+            'emptyContext',
+            'connectIdentity',
+            'disconnectIdentity',
+            'usernameAvailable',
+            'changeUsername',
+            //#endregion
+        ],
     })
 ], TaonSessionController);
 //# sourceMappingURL=taon-session.controller.js.map