@skroz/profile-api 1.0.6 → 1.0.8

package/src/email-templates/base/header.pug

@@ -0,0 +1,28 @@
+table(
+    width='100%'
+    bgcolor='#ff0066'
+    border='0'
+    cellspacing='0'
+    cellpadding='0'
+    style={
+      'border-radius': '25px 25px 0 0',
+      '-webkit-border-radius': '25px 25px 0 0',
+      '-moz-border-radius': '25px 25px 0 0'
+    }
+)
+    tr
+        td(
+            align='center'
+            height='60px'
+            style={
+              'line-height': '1',
+            }
+        )
+            a(href=websiteUrl)
+                img(
+                    src=logoUrl
+                    height='26px'
+                    style={
+                      'margin-top': '2px',
+                    }
+                )

package/src/email-templates/base/layout.pug

@@ -0,0 +1,34 @@
+doctype html
+html
+    head
+        meta(http-equiv='Content-Type' content='text/html; charset=utf-8')
+        meta(name='viewport' content='width=device-width, initial-scale=1.0')
+
+    body(
+        style={
+          'margin': '0',
+          'padding': '0',
+          'width': '100% !important',
+          'height': '100% !important',
+          'max-width': '100%',
+          'font-family': '"Helvetica Neue", Helvetica, Arial, sans-serif',
+          'font-size': '16px',
+          'line-height': '1.5',
+          'color': '#222',
+          'border-collapse': 'collapse',
+          '-webkit-font-smoothing': 'antialiased',
+          '-webkit-text-size-adjust': 'none',
+          '-ms-text-size-adjust': '100%',
+          'border-spacing': '0'
+        }
+    )
+        table(
+            width='100%'
+            align='center'
+            border='0'
+            cellspacing='0'
+            cellpadding='0'
+        )
+            tr
+                td(align='center' valign='top')
+                    include content

package/src/email-templates/base/mixins.pug

@@ -0,0 +1,16 @@
+mixin header(title)
+    h1(style={
+      'font-size': '26px',
+      'font-weight': '500',
+      'margin-top': '20px',
+      'margin-bottom': '15px',
+    })= title
+
+mixin link(href, title)
+    if href
+        a(
+            href=href
+            style={
+              'color': '#1890ff'
+            }
+        )= title

package/src/email-templates/confirmEmail.pug

@@ -0,0 +1,16 @@
+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}
+    //    br
+    //    | #{mistakeText}
+    div(style='margin-top: 30px; background-color: white; border-radius: 25px; padding: 20px; text-align: center; font-size: 30px ')
+        strong #{confirmationToken}
+    div(style='margin-top: 30px; text-align: center; font-size: 25px ')
+        p #{header}

package/src/email-templates/forgotPassword.pug

@@ -0,0 +1,16 @@
+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}
+    //    br
+    //    | #{mistakeText}
+    div(style='margin-top: 30px; background-color: white; border-radius: 25px; padding: 20px; text-align: center; font-size: 30px ')
+        strong #{confirmationToken}
+    div(style='margin-top: 30px; text-align: center; font-size: 25px ')
+        p #{header}

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,27 +1,35 @@
-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> {
-    authService: ProfileAuthService;
+export interface AuthResolverDependencies<
+    TContext extends ProfileContext = ProfileContext
+> {
+    authService: ProfileAuthService | (() => ProfileAuthService);
     userType: any;
     onUserCreated?: (user: any, ctx: TContext) => Promise<void>;
     onLogin?: (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,9 +50,14 @@ export function createAuthResolver<TContext extends ProfileContext = ProfileCont
         onEmailConfirmed,
         onPasswordRecovered,
         logTelegramBot,
-        userType
+        userType,
     } = deps;
 
+    const getAuthService = (): ProfileAuthService => {
+        if (typeof authService === 'function') return authService();
+        return authService;
+    };
+
     @Resolver(() => userType)
     class AuthResolver {
         @TransformArgs(registerTransformers, { arg: 'input' })
@@ -50,18 +65,20 @@ export function createAuthResolver<TContext extends ProfileContext = ProfileCont
         @Mutation(() => StatusPayload)
         async register(@Arg('input') input: RegisterInput, @Ctx() ctx: TContext) {
             const { t } = ctx;
-            if (await authService.db.isEmailTaken(input.email)) {
+            const service = getAuthService();
+            if (await service.db.isEmailTaken(input.email)) {
                 throw new Error(t('validation:auth.emailExists'));
             }
 
-            const passwordHash = await authService.hashPassword(input.password);
-            const user = await authService.db.createUser({
+            const passwordHash = await service.hashPassword(input.password);
+            const user = await service.db.createUser({
                 email: input.email,
                 passwordHash,
             });
 
             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') || '');
@@ -79,12 +96,16 @@ export function createAuthResolver<TContext extends ProfileContext = ProfileCont
         @Mutation(() => StatusPayload)
         async login(@Arg('input') input: LoginInput, @Ctx() ctx: TContext) {
             const { t } = ctx;
-            const user = await authService.db.findUserByEmail(input.email);
+            const service = getAuthService();
+            const user = await service.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 = await authService.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') || '');
@@ -118,15 +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) {
-            const user = await authService.getUserByToken(CONFIRMATION_REDIS_PREFIX, input.token);
+        async confirmEmail(
+            @Arg('input') input: ConfirmEmailInput,
+            @Ctx() ctx: TContext
+        ) {
+            const service = getAuthService();
+            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 authService.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({
@@ -137,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 };
@@ -146,19 +183,25 @@ 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 user = await authService.db.findUserByEmail(input.email);
+            const service = getAuthService();
+            const user = await service.db.findUserByEmail(input.email);
             if (!user) throw new Error(t('validation:forgot.errors.notRegistered'));
 
-            const res = await authService.sendLink(user, 'recovery');
+            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,
             };
         }
@@ -166,14 +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) {
-            const user = await authService.getUserByToken(RECOVERY_REDIS_PREFIX, input.token);
+        async recoverPassword(
+            @Arg('input') input: RecoverPasswordInput,
+            @Ctx() ctx: TContext
+        ) {
+            const service = getAuthService();
+            const user = await service.getUserByToken(
+                RECOVERY_REDIS_PREFIX,
+                input.token
+            );
             if (!user) throw new Error(ctx.t('validation:error.wrongCode'));
 
-            user.password = await authService.hashPassword(input.password);
+            user.password = await service.hashPassword(input.password);
             user.isTempPassword = false;
             await user.save();
-            await authService.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({
@@ -184,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,96 +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;
-    userType: any;
+  authService: ProfileAuthService | (() => ProfileAuthService);
+  userType: any;
 }
 
-export function createProfileResolver<TContext extends ProfileContext = ProfileContext>(deps: ProfileResolverDependencies) {
-    const { authService, userType } = deps;
-
-    @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();
-
-            if (await authService.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 isOldPasswordOk = await authService.verifyPassword(user.password!, input.oldPassword);
-            if (!isOldPasswordOk) throw new Error(t('validation:updatePassword.wrongPassword'));
-
-            user.password = await authService.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;
 }