@skroz/profile-api 1.0.5

package/dist/entities/TypeOrmBaseUser.js

@@ -0,0 +1,117 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var TypeOrmBaseUser_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeOrmBaseUser = void 0;
+const typeorm_1 = require("typeorm");
+const type_graphql_1 = require("type-graphql");
+let TypeOrmBaseUser = TypeOrmBaseUser_1 = class TypeOrmBaseUser extends typeorm_1.BaseEntity {
+    checkOnline(seconds) {
+        if (!this.lastSeenAt)
+            return false;
+        const filterDate = new Date();
+        filterDate.setSeconds(filterDate.getSeconds() - seconds);
+        return this.lastSeenAt > filterDate;
+    }
+    get isOnline() {
+        return this.checkOnline(TypeOrmBaseUser_1.config.isOnlineSeconds);
+    }
+    get isOnlineRecently() {
+        return this.checkOnline(TypeOrmBaseUser_1.config.isOnlineRecentlySeconds);
+    }
+};
+exports.TypeOrmBaseUser = TypeOrmBaseUser;
+TypeOrmBaseUser.config = {
+    isOnlineSeconds: 60,
+    isOnlineRecentlySeconds: 300,
+};
+__decorate([
+    (0, type_graphql_1.Field)(() => type_graphql_1.ID),
+    (0, typeorm_1.PrimaryGeneratedColumn)(),
+    __metadata("design:type", Number)
+], TypeOrmBaseUser.prototype, "id", void 0);
+__decorate([
+    (0, type_graphql_1.Field)(() => type_graphql_1.GraphQLTimestamp),
+    (0, typeorm_1.CreateDateColumn)({ type: 'timestamptz' }),
+    __metadata("design:type", Date)
+], TypeOrmBaseUser.prototype, "createdAt", void 0);
+__decorate([
+    (0, type_graphql_1.Field)(() => type_graphql_1.GraphQLTimestamp),
+    (0, typeorm_1.UpdateDateColumn)({ type: 'timestamptz' }),
+    __metadata("design:type", Date)
+], TypeOrmBaseUser.prototype, "updatedAt", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'varchar', nullable: true, unique: true }),
+    __metadata("design:type", Object)
+], TypeOrmBaseUser.prototype, "email", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", String)
+], TypeOrmBaseUser.prototype, "password", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ default: false }),
+    __metadata("design:type", Boolean)
+], TypeOrmBaseUser.prototype, "isTempPassword", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ default: false }),
+    __metadata("design:type", Boolean)
+], TypeOrmBaseUser.prototype, "isEmailConfirmed", void 0);
+__decorate([
+    (0, type_graphql_1.Field)(() => Boolean),
+    (0, typeorm_1.Column)({ default: true }),
+    __metadata("design:type", Boolean)
+], TypeOrmBaseUser.prototype, "isEmailNotificationEnabled", void 0);
+__decorate([
+    (0, type_graphql_1.Field)(() => Boolean),
+    (0, typeorm_1.Column)({ default: true }),
+    __metadata("design:type", Boolean)
+], TypeOrmBaseUser.prototype, "isTelegramNotificationEnabled", void 0);
+__decorate([
+    (0, type_graphql_1.Field)(() => Boolean),
+    (0, typeorm_1.Column)({ default: false }),
+    __metadata("design:type", Boolean)
+], TypeOrmBaseUser.prototype, "isBanned", void 0);
+__decorate([
+    (0, type_graphql_1.Field)(() => Boolean),
+    (0, typeorm_1.Column)({ default: false }),
+    __metadata("design:type", Boolean)
+], TypeOrmBaseUser.prototype, "isDeleted", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'varchar', nullable: true, unique: true }),
+    __metadata("design:type", String)
+], TypeOrmBaseUser.prototype, "urlSlug", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'varchar', nullable: true, unique: true }),
+    __metadata("design:type", Object)
+], TypeOrmBaseUser.prototype, "telegramId", void 0);
+__decorate([
+    (0, type_graphql_1.Field)(() => String, { nullable: true }),
+    (0, typeorm_1.Column)({ type: 'varchar', nullable: true }),
+    __metadata("design:type", Object)
+], TypeOrmBaseUser.prototype, "avatar", void 0);
+__decorate([
+    (0, type_graphql_1.Field)(() => type_graphql_1.GraphQLTimestamp),
+    (0, typeorm_1.Column)({ type: 'timestamp', default: () => 'CURRENT_TIMESTAMP' }),
+    __metadata("design:type", Date)
+], TypeOrmBaseUser.prototype, "lastSeenAt", void 0);
+__decorate([
+    (0, type_graphql_1.Field)(() => Boolean),
+    __metadata("design:type", Boolean),
+    __metadata("design:paramtypes", [])
+], TypeOrmBaseUser.prototype, "isOnline", null);
+__decorate([
+    (0, type_graphql_1.Field)(() => Boolean),
+    __metadata("design:type", Boolean),
+    __metadata("design:paramtypes", [])
+], TypeOrmBaseUser.prototype, "isOnlineRecently", null);
+exports.TypeOrmBaseUser = TypeOrmBaseUser = TypeOrmBaseUser_1 = __decorate([
+    (0, type_graphql_1.ObjectType)({ isAbstract: true })
+], TypeOrmBaseUser);

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from './types';
+export * from './adapters/TypeOrmProfileAdapter';
+export * from './entities/TypeOrmBaseUser';
+export * from './services/ProfileAuthService';
+export * from './services/ProfileEmailService';
+export * from './dto';
+export * from './resolvers/AuthResolver';
+export * from './resolvers/ProfileResolver';

package/dist/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./adapters/TypeOrmProfileAdapter"), exports);
+__exportStar(require("./entities/TypeOrmBaseUser"), exports);
+__exportStar(require("./services/ProfileAuthService"), exports);
+__exportStar(require("./services/ProfileEmailService"), exports);
+__exportStar(require("./dto"), exports);
+__exportStar(require("./resolvers/AuthResolver"), exports);
+__exportStar(require("./resolvers/ProfileResolver"), exports);

package/dist/resolvers/AuthResolver.d.ts

@@ -0,0 +1,38 @@
+import { ProfileAuthService } from '../services/ProfileAuthService';
+import { ProfileContext } from '../types';
+import { RegisterInput, LoginInput, ConfirmEmailInput, ForgotPasswordInput, RecoverPasswordInput } from '../dto';
+export interface AuthResolverDependencies<TContext extends ProfileContext = ProfileContext> {
+    authService: ProfileAuthService;
+    userType: any;
+    onUserCreated?: (user: any, ctx: TContext) => Promise<void>;
+    onLogin?: (user: any, ctx: TContext) => Promise<void>;
+    onLogout?: (user: any, ctx: TContext) => Promise<void>;
+    onEmailConfirmed?: (user: any, ctx: TContext) => Promise<void>;
+    onPasswordRecovered?: (user: any, ctx: TContext) => Promise<void>;
+    logTelegramBot?: {
+        sendError: (msg: string) => Promise<any>;
+    };
+}
+export declare function createAuthResolver<TContext extends ProfileContext = ProfileContext>(deps: AuthResolverDependencies<TContext>): {
+    new (): {
+        register(input: RegisterInput, ctx: TContext): Promise<{
+            ok: boolean;
+        }>;
+        login(input: LoginInput, ctx: TContext): Promise<{
+            ok: boolean;
+        }>;
+        logout(ctx: TContext): Promise<{
+            ok: boolean;
+        }>;
+        confirmEmail(input: ConfirmEmailInput, ctx: TContext): Promise<{
+            ok: boolean;
+        }>;
+        forgotPassword(input: ForgotPasswordInput, ctx: TContext): Promise<{
+            confirmationLinkIsSent: boolean;
+            limitExpiresAt: number;
+        }>;
+        recoverPassword(input: RecoverPasswordInput, ctx: TContext): Promise<{
+            ok: boolean;
+        }>;
+    };
+};

package/dist/resolvers/AuthResolver.js

@@ -0,0 +1,219 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAuthResolver = createAuthResolver;
+const type_graphql_1 = require("type-graphql");
+const graphql_utils_1 = require("@os-team/graphql-utils");
+const graphql_transformers_1 = require("@os-team/graphql-transformers");
+const graphql_validators_1 = require("@os-team/graphql-validators");
+const ProfileAuthService_1 = require("../services/ProfileAuthService");
+const dto_1 = require("../dto");
+function createAuthResolver(deps) {
+    const { authService, onUserCreated, onLogin, onLogout, onEmailConfirmed, onPasswordRecovered, logTelegramBot, userType } = deps;
+    let AuthResolver = class AuthResolver {
+        register(input, ctx) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const { t } = ctx;
+                if (yield authService.db.isEmailTaken(input.email)) {
+                    throw new Error(t('validation:auth.emailExists'));
+                }
+                const passwordHash = yield authService.hashPassword(input.password);
+                const user = yield authService.db.createUser({
+                    email: input.email,
+                    passwordHash,
+                });
+                if (onUserCreated)
+                    yield onUserCreated(user, ctx);
+                if (logTelegramBot)
+                    yield logTelegramBot.sendError(`Новый пользователь ${input.email}`);
+                // Создаем сессию
+                const userAgent = decodeURI(ctx.req.get('user-agent') || '');
+                yield ctx.req.session.create({
+                    userId: user.id,
+                    ip: ctx.req.ip,
+                    userAgent: userAgent.slice(0, 500),
+                });
+                return { ok: true };
+            });
+        }
+        login(input, ctx) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const { t } = ctx;
+                const user = yield authService.db.findUserByEmail(input.email);
+                if (!user)
+                    throw new Error(t('validation:user.notFound'));
+                if (user.isBanned)
+                    throw new Error(t('validation:user.banned'));
+                const isPasswordOk = yield authService.verifyPassword(user.password, input.password);
+                if (!isPasswordOk)
+                    throw new Error(t('validation:login.wrongPassword'));
+                const userAgent = decodeURI(ctx.req.get('user-agent') || '');
+                yield ctx.req.session.create({
+                    userId: user.id,
+                    ip: ctx.req.ip,
+                    userAgent: userAgent.slice(0, 500),
+                });
+                if (onLogin)
+                    yield onLogin(user, ctx);
+                if (logTelegramBot) {
+                    yield logTelegramBot.sendError(`${user.email || user.urlSlug} вошел(ла) на сайт`);
+                }
+                return { ok: true };
+            });
+        }
+        logout(ctx) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const { user } = ctx;
+                if (onLogout)
+                    yield onLogout(user, ctx);
+                if (logTelegramBot) {
+                    yield logTelegramBot.sendError(`${user && (user.email || user.urlSlug)} разлогинился(лась)`);
+                }
+                yield ctx.req.session.destroy();
+                return { ok: true };
+            });
+        }
+        confirmEmail(input, ctx) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const user = yield authService.getUserByToken(ProfileAuthService_1.CONFIRMATION_REDIS_PREFIX, input.token);
+                if (!user)
+                    throw new Error(ctx.t('validation:error.wrongCode'));
+                user.isEmailConfirmed = true;
+                yield user.save();
+                yield authService.removeTokenFromRedis(ProfileAuthService_1.CONFIRMATION_REDIS_PREFIX, user, input.token);
+                const userAgent = decodeURI(ctx.req.get('user-agent') || '');
+                yield ctx.req.session.create({
+                    userId: user.id,
+                    ip: ctx.req.ip,
+                    userAgent: userAgent.slice(0, 500),
+                });
+                if (onEmailConfirmed)
+                    yield onEmailConfirmed(user, ctx);
+                if (logTelegramBot) {
+                    yield logTelegramBot.sendError(`${user.email || user.urlSlug} подтвердил(а) email`);
+                }
+                return { ok: true };
+            });
+        }
+        forgotPassword(input, ctx) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const { t } = ctx;
+                const user = yield authService.db.findUserByEmail(input.email);
+                if (!user)
+                    throw new Error(t('validation:forgot.errors.notRegistered'));
+                const res = yield authService.sendLink(user, 'recovery');
+                if (logTelegramBot) {
+                    yield logTelegramBot.sendError(`${user.email || user.urlSlug} запросил(а) восстановление пароля`);
+                }
+                return {
+                    confirmationLinkIsSent: res.ok,
+                    limitExpiresAt: res.limitExpiresAt,
+                };
+            });
+        }
+        recoverPassword(input, ctx) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const user = yield authService.getUserByToken(ProfileAuthService_1.RECOVERY_REDIS_PREFIX, input.token);
+                if (!user)
+                    throw new Error(ctx.t('validation:error.wrongCode'));
+                user.password = yield authService.hashPassword(input.password);
+                user.isTempPassword = false;
+                yield user.save();
+                yield authService.removeTokenFromRedis(ProfileAuthService_1.RECOVERY_REDIS_PREFIX, user, input.token);
+                const userAgent = decodeURI(ctx.req.get('user-agent') || '');
+                yield ctx.req.session.create({
+                    userId: user.id,
+                    ip: ctx.req.ip,
+                    userAgent: userAgent.slice(0, 500),
+                });
+                if (onPasswordRecovered)
+                    yield onPasswordRecovered(user, ctx);
+                if (logTelegramBot) {
+                    yield logTelegramBot.sendError(`${user.email || user.urlSlug} восстановил(а) пароль`);
+                }
+                return { ok: true };
+            });
+        }
+    };
+    __decorate([
+        (0, graphql_transformers_1.TransformArgs)(dto_1.registerTransformers, { arg: 'input' }),
+        (0, graphql_validators_1.ValidateArgs)(dto_1.registerValidators, { arg: 'input', tKey: 'register' }),
+        (0, type_graphql_1.Mutation)(() => graphql_utils_1.StatusPayload),
+        __param(0, (0, type_graphql_1.Arg)('input')),
+        __param(1, (0, type_graphql_1.Ctx)()),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [dto_1.RegisterInput, Object]),
+        __metadata("design:returntype", Promise)
+    ], AuthResolver.prototype, "register", null);
+    __decorate([
+        (0, graphql_transformers_1.TransformArgs)(dto_1.loginTransformers, { arg: 'input' }),
+        (0, graphql_validators_1.ValidateArgs)(dto_1.loginValidators, { arg: 'input', tKey: 'register' }),
+        (0, type_graphql_1.Mutation)(() => graphql_utils_1.StatusPayload),
+        __param(0, (0, type_graphql_1.Arg)('input')),
+        __param(1, (0, type_graphql_1.Ctx)()),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [dto_1.LoginInput, Object]),
+        __metadata("design:returntype", Promise)
+    ], AuthResolver.prototype, "login", null);
+    __decorate([
+        (0, type_graphql_1.Authorized)(),
+        (0, type_graphql_1.Mutation)(() => graphql_utils_1.StatusPayload),
+        __param(0, (0, type_graphql_1.Ctx)()),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", Promise)
+    ], AuthResolver.prototype, "logout", null);
+    __decorate([
+        (0, graphql_validators_1.ValidateArgs)(dto_1.confirmEmailValidators, { arg: 'input', tKey: 'confirmEmail' }),
+        (0, type_graphql_1.Mutation)(() => graphql_utils_1.StatusPayload),
+        __param(0, (0, type_graphql_1.Arg)('input')),
+        __param(1, (0, type_graphql_1.Ctx)()),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [dto_1.ConfirmEmailInput, Object]),
+        __metadata("design:returntype", Promise)
+    ], AuthResolver.prototype, "confirmEmail", null);
+    __decorate([
+        (0, graphql_transformers_1.TransformArgs)(dto_1.forgotPasswordTransformers, { arg: 'input' }),
+        (0, graphql_validators_1.ValidateArgs)(dto_1.forgotPasswordValidators, { arg: 'input', tKey: 'forgot' }),
+        (0, type_graphql_1.Mutation)(() => dto_1.SendTokenPayload),
+        __param(0, (0, type_graphql_1.Arg)('input')),
+        __param(1, (0, type_graphql_1.Ctx)()),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [dto_1.ForgotPasswordInput, Object]),
+        __metadata("design:returntype", Promise)
+    ], AuthResolver.prototype, "forgotPassword", null);
+    __decorate([
+        (0, graphql_transformers_1.TransformArgs)(dto_1.recoverPasswordTransformers, { arg: 'input' }),
+        (0, graphql_validators_1.ValidateArgs)(dto_1.recoverPasswordValidators, { arg: 'input', tKey: 'recover' }),
+        (0, type_graphql_1.Mutation)(() => graphql_utils_1.StatusPayload),
+        __param(0, (0, type_graphql_1.Arg)('input')),
+        __param(1, (0, type_graphql_1.Ctx)()),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [dto_1.RecoverPasswordInput, Object]),
+        __metadata("design:returntype", Promise)
+    ], AuthResolver.prototype, "recoverPassword", null);
+    AuthResolver = __decorate([
+        (0, type_graphql_1.Resolver)(() => userType)
+    ], AuthResolver);
+    return AuthResolver;
+}

package/dist/resolvers/ProfileResolver.d.ts

@@ -0,0 +1,24 @@
+import { ProfileAuthService } from '../services/ProfileAuthService';
+import { ProfileContext } from '../types';
+import { UpdateEmailInput, UpdatePasswordInput, UpdateProfileInput } from '../dto';
+export interface ProfileResolverDependencies {
+    authService: ProfileAuthService;
+    userType: any;
+}
+export declare function createProfileResolver<TContext extends ProfileContext = ProfileContext>(deps: ProfileResolverDependencies): {
+    new (): {
+        updateEmail(input: UpdateEmailInput, ctx: TContext): Promise<{
+            ok: boolean;
+        }>;
+        updatePassword(input: UpdatePasswordInput, ctx: TContext): Promise<{
+            ok: boolean;
+        }>;
+        updateProfile(input: UpdateProfileInput, ctx: TContext): Promise<import("../types").AuthUser>;
+        toggleEmailNotification(ctx: TContext): Promise<{
+            ok: boolean;
+        }>;
+        toggleTelegramNotification(ctx: TContext): Promise<{
+            ok: boolean;
+        }>;
+    };
+};

package/dist/resolvers/ProfileResolver.js

@@ -0,0 +1,145 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProfileResolver = createProfileResolver;
+const type_graphql_1 = require("type-graphql");
+const graphql_utils_1 = require("@os-team/graphql-utils");
+const graphql_transformers_1 = require("@os-team/graphql-transformers");
+const graphql_validators_1 = require("@os-team/graphql-validators");
+const dto_1 = require("../dto");
+function createProfileResolver(deps) {
+    const { authService, userType } = deps;
+    let ProfileResolver = class ProfileResolver {
+        updateEmail(input, ctx) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const { user, t } = ctx;
+                if (!user)
+                    throw new type_graphql_1.UnauthorizedError();
+                if (yield authService.db.isEmailTaken(input.email, user.id)) {
+                    throw new Error(t('validation:updateEmail.emailExists'));
+                }
+                user.email = input.email;
+                user.isEmailConfirmed = false;
+                yield user.save();
+                return { ok: true };
+            });
+        }
+        updatePassword(input, ctx) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const { user, t } = ctx;
+                if (!user)
+                    throw new type_graphql_1.UnauthorizedError();
+                const isOldPasswordOk = yield authService.verifyPassword(user.password, input.oldPassword);
+                if (!isOldPasswordOk)
+                    throw new Error(t('validation:updatePassword.wrongPassword'));
+                user.password = yield authService.hashPassword(input.password);
+                user.isTempPassword = false;
+                yield user.save();
+                return { ok: true };
+            });
+        }
+        updateProfile(input, ctx) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const { user } = ctx;
+                if (!user)
+                    throw new type_graphql_1.UnauthorizedError();
+                user.name = input.name;
+                yield user.save();
+                return user;
+            });
+        }
+        toggleEmailNotification(ctx) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const { user } = ctx;
+                if (!user)
+                    throw new type_graphql_1.UnauthorizedError();
+                user.isEmailNotificationEnabled = !user.isEmailNotificationEnabled;
+                yield user.save();
+                return { ok: true };
+            });
+        }
+        toggleTelegramNotification(ctx) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const { user } = ctx;
+                if (!user)
+                    throw new type_graphql_1.UnauthorizedError();
+                user.isTelegramNotificationEnabled = !user.isTelegramNotificationEnabled;
+                yield user.save();
+                return { ok: true };
+            });
+        }
+    };
+    __decorate([
+        (0, type_graphql_1.Authorized)(),
+        (0, graphql_transformers_1.TransformArgs)(dto_1.updateEmailTransformers, { arg: 'input' }),
+        (0, graphql_validators_1.ValidateArgs)(dto_1.updateEmailValidators, { arg: 'input', tKey: 'updateEmail' }),
+        (0, type_graphql_1.Mutation)(() => graphql_utils_1.StatusPayload),
+        __param(0, (0, type_graphql_1.Arg)('input')),
+        __param(1, (0, type_graphql_1.Ctx)()),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [dto_1.UpdateEmailInput, Object]),
+        __metadata("design:returntype", Promise)
+    ], ProfileResolver.prototype, "updateEmail", null);
+    __decorate([
+        (0, type_graphql_1.Authorized)(),
+        (0, graphql_transformers_1.TransformArgs)(dto_1.updatePasswordTransformers, { arg: 'input' }),
+        (0, graphql_validators_1.ValidateArgs)(dto_1.updatePasswordValidators, { arg: 'input', tKey: 'updatePassword' }),
+        (0, type_graphql_1.Mutation)(() => graphql_utils_1.StatusPayload),
+        __param(0, (0, type_graphql_1.Arg)('input')),
+        __param(1, (0, type_graphql_1.Ctx)()),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [dto_1.UpdatePasswordInput, Object]),
+        __metadata("design:returntype", Promise)
+    ], ProfileResolver.prototype, "updatePassword", null);
+    __decorate([
+        (0, type_graphql_1.Authorized)(),
+        (0, graphql_transformers_1.TransformArgs)(dto_1.updateProfileTransformers, { arg: 'input' }),
+        (0, graphql_validators_1.ValidateArgs)(dto_1.updateProfileValidators, { arg: 'input', tKey: 'updateProfile' }),
+        (0, type_graphql_1.Mutation)(() => userType),
+        __param(0, (0, type_graphql_1.Arg)('input')),
+        __param(1, (0, type_graphql_1.Ctx)()),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [dto_1.UpdateProfileInput, Object]),
+        __metadata("design:returntype", Promise)
+    ], ProfileResolver.prototype, "updateProfile", null);
+    __decorate([
+        (0, type_graphql_1.Authorized)(),
+        (0, type_graphql_1.Mutation)(() => graphql_utils_1.StatusPayload),
+        __param(0, (0, type_graphql_1.Ctx)()),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", Promise)
+    ], ProfileResolver.prototype, "toggleEmailNotification", null);
+    __decorate([
+        (0, type_graphql_1.Authorized)(),
+        (0, type_graphql_1.Mutation)(() => graphql_utils_1.StatusPayload),
+        __param(0, (0, type_graphql_1.Ctx)()),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", Promise)
+    ], ProfileResolver.prototype, "toggleTelegramNotification", null);
+    ProfileResolver = __decorate([
+        (0, type_graphql_1.Resolver)(() => userType)
+    ], ProfileResolver);
+    return ProfileResolver;
+}

package/dist/services/ProfileAuthService.d.ts

@@ -0,0 +1,24 @@
+import { Redis } from 'ioredis';
+import { AuthUser, ProfileAuthConfig, ProfileDbAdapter } from '../types';
+import { ProfileEmailService } from './ProfileEmailService';
+export declare const CONFIRMATION_REDIS_PREFIX = "conf";
+export declare const RECOVERY_REDIS_PREFIX = "rec";
+export declare const TOKEN_REDIS_POSTFIX = "token";
+export declare const LAST_SENT_AT_REDIS_POSTFIX = "lastSentAt";
+export declare class ProfileAuthService {
+    db: ProfileDbAdapter;
+    email: ProfileEmailService;
+    redis: Redis;
+    config: ProfileAuthConfig;
+    constructor(db: ProfileDbAdapter, email: ProfileEmailService, redis: Redis, config: ProfileAuthConfig);
+    hashPassword(password: string): Promise<string>;
+    verifyPassword(hash: string, password: string): Promise<boolean>;
+    private getLimitMs;
+    setTokenToRedis(prefix: string, user: AuthUser, token: string, ttlMinutes: number): Promise<void>;
+    sendLink(user: AuthUser, type: 'confirmation' | 'recovery'): Promise<{
+        ok: boolean;
+        limitExpiresAt: number;
+    }>;
+    getUserByToken(prefix: string, token: string): Promise<AuthUser | null>;
+    removeTokenFromRedis(prefix: string, user: AuthUser, token: string): Promise<void>;
+}