emails entity

src/app.module.ts

@@ -17,6 +17,7 @@ import {graphqlModuleOptions} from './graphql-module.options'
 import {ConfigModule} from './config/config.module'
 import {EmailVerificationModule} from './email-verification/email-verification.module'
 import {RefreshTokenModule} from './refresh-token/refresh-token.module'
+import {EmailsModule} from './emails/emails.module'
 
 @Module({
   imports: [
@@ -27,6 +28,7 @@ import {RefreshTokenModule} from './refresh-token/refresh-token.module'
     GraphQLModule.forRootAsync(graphqlModuleOptions),
     EmailVerificationModule,
     RefreshTokenModule,
+    EmailsModule,
   ],
   providers: [
     ComplexityPlugin,

src/email-verification/email-verification.service.spec.ts

@@ -99,23 +99,5 @@ describe('EmailVerificationService', () => {
     ).resolves.toBeDefined()
 
     expect(verificationCode.status).toBe('used')
-    expect(usersService.activateUserById).not.toHaveBeenCalled()
-  })
-
-  it('should activate user when verifying email', async () => {
-    const user = new User()
-    user.status = 'unconfirmed'
-    const verificationCode = new EmailVerificationCode()
-    verificationCode.code = 123456
-
-    jest.spyOn(usersService, 'getUserByEmail').mockResolvedValue(user)
-    jest.spyOn(verificationCodeRepository, 'findOne').mockResolvedValue(verificationCode)
-    jest.spyOn(usersService, 'activateUserById').mockResolvedValue(undefined as any)
-    jest.spyOn(tokenService, 'generateAndSaveTokens').mockResolvedValue(new Tokens())
-    jest.spyOn(verificationCodeRepository, 'save').mockResolvedValue(undefined as any)
-
-    await service.verifyEmail('[email protected]', 123456, 'deviceInfo')
-
-    expect(usersService.activateUserById).toHaveBeenCalledWith(user.id)
   })
 })

src/email-verification/email-verification.service.ts

@@ -44,11 +44,6 @@ export class EmailVerificationService {
       throw new UnauthorizedException('Invalid verification code')
     }
 
-    if (user.status === 'unconfirmed') {
-      this.logger.debug(`Activating user "${user.id}"`)
-      await this.usersService.activateUserById(user.id)
-    }
-
     verificationCode.status = 'used'
     await this.verificationCodeRepository.save(verificationCode)
     return this.tokenService.generateAndSaveTokens(user, deviceInfo)

src/emails/emails.module.ts

@@ -0,0 +1,8 @@
+import {Module} from '@nestjs/common'
+import {TypeOrmModule} from '@nestjs/typeorm'
+import {Email} from './entities/email.entity'
+
+@Module({
+  imports: [TypeOrmModule.forFeature([Email])],
+})
+export class EmailsModule {}

src/emails/entities/email.entity.ts

@@ -0,0 +1,32 @@
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn,
+  OneToOne,
+  JoinColumn,
+} from 'typeorm'
+import {User} from '../../users/entities/user.entity'
+
+@Entity()
+export class Email {
+  @PrimaryGeneratedColumn('uuid')
+  id: string
+
+  @Column({unique: true})
+  email: string
+
+  // Email does not have a status field because it is not necessary to deactivate/activate it
+  //  and email notifications will be realized by another service and another entity
+
+  @OneToOne(() => User, {onDelete: 'CASCADE', nullable: false})
+  @JoinColumn()
+  user: User
+
+  @CreateDateColumn({type: 'timestamp with time zone'})
+  createdAt: Date
+
+  @UpdateDateColumn({type: 'timestamp with time zone'})
+  updatedAt: Date
+}

src/refresh-token/strategies/jwt-access-token.strategy.spec.ts

@@ -5,6 +5,7 @@ import {getRepositoryToken} from '@nestjs/typeorm'
 import {User} from '../../users/entities/user.entity'
 import {ConfigModule} from '../../config/config.module'
 import {UnauthorizedException} from '@nestjs/common'
+import {Email} from '../../emails/entities/email.entity'
 
 describe(JwtAccessTokenStrategy.name, () => {
   let jwtStrategy: JwtAccessTokenStrategy
@@ -37,7 +38,9 @@ describe(JwtAccessTokenStrategy.name, () => {
     it('should return a user when user exists', async () => {
       const expected = new User()
       expected.id = 'test-id'
-      expected.email = 'test-email'
+      const email = new Email()
+      email.email = 'test-email'
+      expected.email = email
 
       jest.spyOn(usersService, 'getUserById').mockResolvedValue(expected)
 

src/users/entities/user.entity.ts

@@ -1,20 +1,21 @@
-import {Column, CreateDateColumn, Entity, PrimaryGeneratedColumn, UpdateDateColumn} from 'typeorm'
+import {
+  CreateDateColumn,
+  Entity,
+  JoinColumn,
+  OneToOne,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn,
+} from 'typeorm'
+import {Email} from '../../emails/entities/email.entity'
 
 @Entity()
 export class User {
   @PrimaryGeneratedColumn('uuid')
   id: string
 
-  @Column({unique: true})
-  email: string
-
-  @Column({
-    comment: 'Status of the user',
-    type: 'enum',
-    enum: ['active', 'unconfirmed'],
-    default: 'unconfirmed',
-  })
-  status: 'active' | 'unconfirmed'
+  @OneToOne(() => Email, {nullable: true})
+  @JoinColumn()
+  email: Email | null
 
   @CreateDateColumn({type: 'timestamp with time zone'})
   createdAt: Date

src/users/users.service.spec.ts

@@ -1,8 +1,9 @@
+import {User} from './entities/user.entity'
 import {UsersService} from './users.service'
 import {Repository} from 'typeorm'
-import {User} from './entities/user.entity'
 import {Test, TestingModule} from '@nestjs/testing'
 import {getRepositoryToken} from '@nestjs/typeorm'
+import {Email} from '../emails/entities/email.entity'
 
 describe('UsersService', () => {
   let service: UsersService
@@ -25,7 +26,9 @@ describe('UsersService', () => {
 
   it('should create a user by email', async () => {
     const testUser = new User()
-    testUser.email = '[email protected]'
+    const email = new Email()
+    email.email = '[email protected]'
+    testUser.email = email
 
     jest.spyOn(repo, 'create').mockReturnValueOnce(testUser)
     jest.spyOn(repo, 'save').mockResolvedValueOnce(testUser)
@@ -36,11 +39,13 @@ describe('UsersService', () => {
 
   it('should not create a user by email if it already exists', async () => {
     const testUser = new User()
-    testUser.email = '[email protected]'
+    const email = new Email()
+    email.email = '[email protected]'
+    testUser.email = email
     jest.spyOn(repo, 'findOne').mockResolvedValueOnce(testUser)
     jest.spyOn(repo, 'create')
     jest.spyOn(repo, 'save')
-    expect(await service.getOrCreateUserByEmail(testUser.email)).toEqual(testUser)
+    expect(await service.getOrCreateUserByEmail(testUser.email.email)).toEqual(testUser)
     expect(repo.create).not.toHaveBeenCalled()
     expect(repo.save).not.toHaveBeenCalled()
   })
@@ -56,22 +61,12 @@ describe('UsersService', () => {
 
   it('should get a user by email', async () => {
     const testUser = new User()
-    testUser.email = '[email protected]'
+    const email = new Email()
+    email.email = '[email protected]'
+    testUser.email = email
 
     jest.spyOn(repo, 'findOne').mockResolvedValueOnce(testUser)
 
     expect(await service.getUserByEmail('[email protected]')).toEqual(testUser)
   })
-
-  it('should activate a user by id', async () => {
-    const testUser = new User()
-    testUser.id = '1'
-    testUser.status = 'unconfirmed'
-
-    jest.spyOn(repo, 'update').mockResolvedValueOnce(undefined as any)
-
-    await service.activateUserById('1')
-
-    expect(repo.update).toHaveBeenCalledWith({id: '1'}, {status: 'active'})
-  })
 })

src/users/users.service.ts

@@ -10,35 +10,19 @@ export class UsersService {
   public async getOrCreateUserByEmail(email: string): Promise<User> {
     const user = await this.getUserByEmail(email)
     if (user) return user
-    return this.createUser({email})
+    return this.createUserByEmail(email)
   }
 
   public getUserById(id: string): Promise<User | null> {
-    return this.getUser('id', id)
+    return this.usersRepository.findOne({where: {id}})
   }
 
   public getUserByEmail(email: string): Promise<User | null> {
-    return this.getUser('email', email)
+    return this.usersRepository.findOne({where: {email: {email}}})
   }
 
-  public async activateUserById(id: string): Promise<void> {
-    await this.updateUser('id', id, {status: 'active'})
-  }
-
-  private async createUser(data: Partial<User>): Promise<User> {
-    const newUser = this.usersRepository.create(data)
+  private async createUserByEmail(email: string): Promise<User> {
+    const newUser = this.usersRepository.create({email: {email}})
     return this.usersRepository.save(newUser)
   }
-
-  private async updateUser(
-    field: keyof User,
-    value: User[keyof User],
-    data: Partial<User>,
-  ): Promise<void> {
-    await this.usersRepository.update({[field]: value}, data)
-  }
-
-  private getUser(field: keyof User, value: User[keyof User]): Promise<User | null> {
-    return this.usersRepository.findOne({where: {[field]: value}})
-  }
 }