@skroz/profile-api 1.0.7 → 1.0.8

package/src/email-templates/notification.pug

@@ -0,0 +1,14 @@
+extends base/layout
+include base/mixins
+
+block content
+    +header(header)
+    p #{' ' + text}
+    if (link)
+        +link(link.href, link.label)
+    div(style='margin-top: 30px;')
+        strong #{mistakeHeader}
+        a(href=unsubscribeLink)
+            strong Отписаться
+        br
+        | #{mistakeText}

package/src/email-templates/tempPassword.pug

@@ -0,0 +1,14 @@
+extends base/layout
+include base/mixins
+
+block content
+    +header(header)
+    p #{' ' + text}
+    if (link)
+        +link(link.href, link.label)
+    div(style='margin-top: 30px;')
+        strong #{mistakeHeader}
+        a(href=unsubscribeLink)
+            strong Отписаться
+        br
+        | #{mistakeText}

package/src/resolvers/AuthResolver.ts

@@ -1,26 +1,34 @@
-import {
-    Arg,
-    Authorized,
-    Ctx,
-    Mutation,
-    Resolver,
-} from 'type-graphql';
+import { Arg, Authorized, Ctx, Mutation, Resolver } from 'type-graphql';
 import { StatusPayload } from '@os-team/graphql-utils';
 import { TransformArgs } from '@os-team/graphql-transformers';
 import { ValidateArgs } from '@os-team/graphql-validators';
-import { ProfileAuthService, CONFIRMATION_REDIS_PREFIX, RECOVERY_REDIS_PREFIX } from '../services/ProfileAuthService';
+import {
+    ProfileAuthService,
+    CONFIRMATION_REDIS_PREFIX,
+    RECOVERY_REDIS_PREFIX,
+} from '../services/ProfileAuthService';
 import { ProfileContext } from '../types';
 import {
-    RegisterInput, registerTransformers, registerValidators,
-    LoginInput, loginTransformers, loginValidators,
+    RegisterInput,
+    registerTransformers,
+    registerValidators,
+    LoginInput,
+    loginTransformers,
+    loginValidators,
     ConfirmEmailInput,
-    ForgotPasswordInput, forgotPasswordTransformers, forgotPasswordValidators,
-    RecoverPasswordInput, recoverPasswordTransformers, recoverPasswordValidators,
+    ForgotPasswordInput,
+    forgotPasswordTransformers,
+    forgotPasswordValidators,
+    RecoverPasswordInput,
+    recoverPasswordTransformers,
+    recoverPasswordValidators,
     SendTokenPayload,
-    confirmEmailValidators
+    confirmEmailValidators,
 } from '../dto';
 
-export interface AuthResolverDependencies<TContext extends ProfileContext = ProfileContext> {
+export interface AuthResolverDependencies<
+    TContext extends ProfileContext = ProfileContext
+> {
     authService: ProfileAuthService | (() => ProfileAuthService);
     userType: any;
     onUserCreated?: (user: any, ctx: TContext) => Promise<void>;
@@ -31,7 +39,9 @@ export interface AuthResolverDependencies<TContext extends ProfileContext = Prof
     logTelegramBot?: { sendError: (msg: string) => Promise<any> };
 }
 
-export function createAuthResolver<TContext extends ProfileContext = ProfileContext>(deps: AuthResolverDependencies<TContext>) {
+export function createAuthResolver<
+    TContext extends ProfileContext = ProfileContext
+>(deps: AuthResolverDependencies<TContext>): any {
     const {
         authService,
         onUserCreated,
@@ -40,7 +50,7 @@ export function createAuthResolver<TContext extends ProfileContext = ProfileCont
         onEmailConfirmed,
         onPasswordRecovered,
         logTelegramBot,
-        userType
+        userType,
     } = deps;
 
     const getAuthService = (): ProfileAuthService => {
@@ -67,7 +77,8 @@ export function createAuthResolver<TContext extends ProfileContext = ProfileCont
             });
 
             if (onUserCreated) await onUserCreated(user, ctx);
-            if (logTelegramBot) await logTelegramBot.sendError(`Новый пользователь ${input.email}`);
+            if (logTelegramBot)
+                await logTelegramBot.sendError(`Новый пользователь ${input.email}`);
 
             // Создаем сессию
             const userAgent = decodeURI(ctx.req.get('user-agent') || '');
@@ -91,7 +102,10 @@ export function createAuthResolver<TContext extends ProfileContext = ProfileCont
 
             if (user.isBanned) throw new Error(t('validation:user.banned'));
 
-            const isPasswordOk = await service.verifyPassword(user.password!, input.password);
+            const isPasswordOk = await service.verifyPassword(
+                user.password!,
+                input.password
+            );
             if (!isPasswordOk) throw new Error(t('validation:login.wrongPassword'));
 
             const userAgent = decodeURI(ctx.req.get('user-agent') || '');
@@ -125,16 +139,29 @@ export function createAuthResolver<TContext extends ProfileContext = ProfileCont
             return { ok: true };
         }
 
-        @ValidateArgs(confirmEmailValidators, { arg: 'input', tKey: 'confirmEmail' })
+        @ValidateArgs(confirmEmailValidators, {
+            arg: 'input',
+            tKey: 'confirmEmail',
+        })
         @Mutation(() => StatusPayload)
-        async confirmEmail(@Arg('input') input: ConfirmEmailInput, @Ctx() ctx: TContext) {
+        async confirmEmail(
+            @Arg('input') input: ConfirmEmailInput,
+            @Ctx() ctx: TContext
+        ) {
             const service = getAuthService();
-            const user = await service.getUserByToken(CONFIRMATION_REDIS_PREFIX, input.token);
+            const user = await service.getUserByToken(
+                CONFIRMATION_REDIS_PREFIX,
+                input.token
+            );
             if (!user) throw new Error(ctx.t('validation:error.wrongCode'));
 
             user.isEmailConfirmed = true;
             await user.save();
-            await service.removeTokenFromRedis(CONFIRMATION_REDIS_PREFIX, user, input.token);
+            await service.removeTokenFromRedis(
+                CONFIRMATION_REDIS_PREFIX,
+                user,
+                input.token
+            );
 
             const userAgent = decodeURI(ctx.req.get('user-agent') || '');
             await ctx.req.session.create({
@@ -145,7 +172,9 @@ export function createAuthResolver<TContext extends ProfileContext = ProfileCont
 
             if (onEmailConfirmed) await onEmailConfirmed(user, ctx);
             if (logTelegramBot) {
-                await logTelegramBot.sendError(`${user.email || user.urlSlug} подтвердил(а) email`);
+                await logTelegramBot.sendError(
+                    `${user.email || user.urlSlug} подтвердил(а) email`
+                );
             }
 
             return { ok: true };
@@ -154,7 +183,10 @@ export function createAuthResolver<TContext extends ProfileContext = ProfileCont
         @TransformArgs(forgotPasswordTransformers, { arg: 'input' })
         @ValidateArgs(forgotPasswordValidators, { arg: 'input', tKey: 'forgot' })
         @Mutation(() => SendTokenPayload)
-        async forgotPassword(@Arg('input') input: ForgotPasswordInput, @Ctx() ctx: TContext) {
+        async forgotPassword(
+            @Arg('input') input: ForgotPasswordInput,
+            @Ctx() ctx: TContext
+        ) {
             const { t } = ctx;
             const service = getAuthService();
             const user = await service.db.findUserByEmail(input.email);
@@ -163,11 +195,13 @@ export function createAuthResolver<TContext extends ProfileContext = ProfileCont
             const res = await service.sendLink(user, 'recovery');
 
             if (logTelegramBot) {
-                await logTelegramBot.sendError(`${user.email || user.urlSlug} запросил(а) восстановление пароля`);
+                await logTelegramBot.sendError(
+                    `${user.email || user.urlSlug} запросил(а) восстановление пароля`
+                );
             }
 
             return {
-                confirmationLinkIsSent: res.ok,
+                recoveryLinkIsSent: res.ok,
                 limitExpiresAt: res.limitExpiresAt,
             };
         }
@@ -175,15 +209,25 @@ export function createAuthResolver<TContext extends ProfileContext = ProfileCont
         @TransformArgs(recoverPasswordTransformers, { arg: 'input' })
         @ValidateArgs(recoverPasswordValidators, { arg: 'input', tKey: 'recover' })
         @Mutation(() => StatusPayload)
-        async recoverPassword(@Arg('input') input: RecoverPasswordInput, @Ctx() ctx: TContext) {
+        async recoverPassword(
+            @Arg('input') input: RecoverPasswordInput,
+            @Ctx() ctx: TContext
+        ) {
             const service = getAuthService();
-            const user = await service.getUserByToken(RECOVERY_REDIS_PREFIX, input.token);
+            const user = await service.getUserByToken(
+                RECOVERY_REDIS_PREFIX,
+                input.token
+            );
             if (!user) throw new Error(ctx.t('validation:error.wrongCode'));
 
             user.password = await service.hashPassword(input.password);
             user.isTempPassword = false;
             await user.save();
-            await service.removeTokenFromRedis(RECOVERY_REDIS_PREFIX, user, input.token);
+            await service.removeTokenFromRedis(
+                RECOVERY_REDIS_PREFIX,
+                user,
+                input.token
+            );
 
             const userAgent = decodeURI(ctx.req.get('user-agent') || '');
             await ctx.req.session.create({
@@ -194,7 +238,9 @@ export function createAuthResolver<TContext extends ProfileContext = ProfileCont
 
             if (onPasswordRecovered) await onPasswordRecovered(user, ctx);
             if (logTelegramBot) {
-                await logTelegramBot.sendError(`${user.email || user.urlSlug} восстановил(а) пароль`);
+                await logTelegramBot.sendError(
+                    `${user.email || user.urlSlug} восстановил(а) пароль`
+                );
             }
 
             return { ok: true };

package/src/resolvers/ProfileResolver.ts

@@ -1,10 +1,10 @@
 import {
-    Arg,
-    Authorized,
-    Ctx,
-    Mutation,
-    Resolver,
-    UnauthorizedError,
+  Arg,
+  Authorized,
+  Ctx,
+  Mutation,
+  Resolver,
+  UnauthorizedError,
 } from 'type-graphql';
 import { StatusPayload } from '@os-team/graphql-utils';
 import { TransformArgs } from '@os-team/graphql-transformers';
@@ -12,103 +12,130 @@ import { ValidateArgs } from '@os-team/graphql-validators';
 import { ProfileAuthService } from '../services/ProfileAuthService';
 import { ProfileContext } from '../types';
 import {
-    UpdateEmailInput, updateEmailTransformers, updateEmailValidators,
-    UpdatePasswordInput, updatePasswordTransformers, updatePasswordValidators,
-    UpdateProfileInput, updateProfileTransformers, updateProfileValidators,
+  UpdateEmailInput,
+  updateEmailTransformers,
+  updateEmailValidators,
+  UpdatePasswordInput,
+  updatePasswordTransformers,
+  updatePasswordValidators,
+  UpdateProfileInput,
+  updateProfileTransformers,
+  updateProfileValidators,
 } from '../dto';
 
 export interface ProfileResolverDependencies {
-    authService: ProfileAuthService | (() => ProfileAuthService);
-    userType: any;
+  authService: ProfileAuthService | (() => ProfileAuthService);
+  userType: any;
 }
 
-export function createProfileResolver<TContext extends ProfileContext = ProfileContext>(deps: ProfileResolverDependencies) {
-    const { authService, userType } = deps;
-
-    const getAuthService = (): ProfileAuthService => {
-        if (typeof authService === 'function') return authService();
-        return authService;
-    };
-
-    @Resolver(() => userType)
-    class ProfileResolver {
-        @Authorized()
-        @TransformArgs(updateEmailTransformers, { arg: 'input' })
-        @ValidateArgs(updateEmailValidators, { arg: 'input', tKey: 'updateEmail' })
-        @Mutation(() => StatusPayload)
-        async updateEmail(@Arg('input') input: UpdateEmailInput, @Ctx() ctx: TContext) {
-            const { user, t } = ctx;
-            if (!user) throw new UnauthorizedError();
-
-            const service = getAuthService();
-            if (await service.db.isEmailTaken(input.email, user.id)) {
-                throw new Error(t('validation:updateEmail.emailExists'));
-            }
-
-            user.email = input.email;
-            user.isEmailConfirmed = false;
-            await user.save();
-
-            return { ok: true };
-        }
-
-        @Authorized()
-        @TransformArgs(updatePasswordTransformers, { arg: 'input' })
-        @ValidateArgs(updatePasswordValidators, { arg: 'input', tKey: 'updatePassword' })
-        @Mutation(() => StatusPayload)
-        async updatePassword(@Arg('input') input: UpdatePasswordInput, @Ctx() ctx: TContext) {
-            const { user, t } = ctx;
-            if (!user) throw new UnauthorizedError();
-
-            const service = getAuthService();
-            const isOldPasswordOk = await service.verifyPassword(user.password!, input.oldPassword);
-            if (!isOldPasswordOk) throw new Error(t('validation:updatePassword.wrongPassword'));
-
-            user.password = await service.hashPassword(input.password);
-            user.isTempPassword = false;
-            await user.save();
-
-            return { ok: true };
-        }
-
-        @Authorized()
-        @TransformArgs(updateProfileTransformers, { arg: 'input' })
-        @ValidateArgs(updateProfileValidators, { arg: 'input', tKey: 'updateProfile' })
-        @Mutation(() => userType)
-        async updateProfile(@Arg('input') input: UpdateProfileInput, @Ctx() ctx: TContext) {
-            const { user } = ctx;
-            if (!user) throw new UnauthorizedError();
-
-            user.name = input.name;
-            await user.save();
-
-            return user;
-        }
-
-        @Authorized()
-        @Mutation(() => StatusPayload)
-        async toggleEmailNotification(@Ctx() ctx: TContext) {
-            const { user } = ctx;
-            if (!user) throw new UnauthorizedError();
-
-            user.isEmailNotificationEnabled = !user.isEmailNotificationEnabled;
-            await user.save();
-
-            return { ok: true };
-        }
-
-        @Authorized()
-        @Mutation(() => StatusPayload)
-        async toggleTelegramNotification(@Ctx() ctx: TContext) {
-            const { user } = ctx;
-            if (!user) throw new UnauthorizedError();
-
-            user.isTelegramNotificationEnabled = !user.isTelegramNotificationEnabled;
-            await user.save();
-
-            return { ok: true };
-        }
+export function createProfileResolver<
+  TContext extends ProfileContext = ProfileContext
+>(deps: ProfileResolverDependencies): any {
+  const { authService, userType } = deps;
+
+  const getAuthService = (): ProfileAuthService => {
+    if (typeof authService === 'function') return authService();
+    return authService;
+  };
+
+  @Resolver(() => userType)
+  class ProfileResolver {
+    @Authorized()
+    @TransformArgs(updateEmailTransformers, { arg: 'input' })
+    @ValidateArgs(updateEmailValidators, { arg: 'input', tKey: 'updateEmail' })
+    @Mutation(() => StatusPayload)
+    async updateEmail(
+      @Arg('input') input: UpdateEmailInput,
+      @Ctx() ctx: TContext
+    ) {
+      const { user, t } = ctx;
+      if (!user) throw new UnauthorizedError();
+
+      const service = getAuthService();
+      if (await service.db.isEmailTaken(input.email, user.id)) {
+        throw new Error(t('validation:updateEmail.emailExists'));
+      }
+
+      user.email = input.email;
+      user.isEmailConfirmed = false;
+      await user.save();
+
+      return { ok: true };
     }
 
-    return ProfileResolver;
+    @Authorized()
+    @TransformArgs(updatePasswordTransformers, { arg: 'input' })
+    @ValidateArgs(updatePasswordValidators, {
+      arg: 'input',
+      tKey: 'updatePassword',
+    })
+    @Mutation(() => StatusPayload)
+    async updatePassword(
+      @Arg('input') input: UpdatePasswordInput,
+      @Ctx() ctx: TContext
+    ) {
+      const { user, t } = ctx;
+      if (!user) throw new UnauthorizedError();
+
+      const service = getAuthService();
+      const isOldPasswordOk = await service.verifyPassword(
+        user.password!,
+        input.oldPassword
+      );
+      if (!isOldPasswordOk)
+        throw new Error(t('validation:updatePassword.wrongPassword'));
+
+      user.password = await service.hashPassword(input.password);
+      user.isTempPassword = false;
+      await user.save();
+
+      return { ok: true };
+    }
+
+    @Authorized()
+    @TransformArgs(updateProfileTransformers, { arg: 'input' })
+    @ValidateArgs(updateProfileValidators, {
+      arg: 'input',
+      tKey: 'updateProfile',
+    })
+    @Mutation(() => userType)
+    async updateProfile(
+      @Arg('input') input: UpdateProfileInput,
+      @Ctx() ctx: TContext
+    ) {
+      const { user } = ctx;
+      if (!user) throw new UnauthorizedError();
+
+      user.name = input.name;
+      await user.save();
+
+      return user;
+    }
+
+    @Authorized()
+    @Mutation(() => StatusPayload)
+    async toggleEmailNotification(@Ctx() ctx: TContext) {
+      const { user } = ctx;
+      if (!user) throw new UnauthorizedError();
+
+      user.isEmailNotificationEnabled = !user.isEmailNotificationEnabled;
+      await user.save();
+
+      return { ok: true };
+    }
+
+    @Authorized()
+    @Mutation(() => StatusPayload)
+    async toggleTelegramNotification(@Ctx() ctx: TContext) {
+      const { user } = ctx;
+      if (!user) throw new UnauthorizedError();
+
+      user.isTelegramNotificationEnabled = !user.isTelegramNotificationEnabled;
+      await user.save();
+
+      return { ok: true };
+    }
+  }
+
+  return ProfileResolver;
 }