feat: improve migrations

Author: mustkem

apps/api-gateway/src/modules/auth/auth.controller.ts

@@ -15,7 +15,6 @@ class LoginResponseBody {
 }
 
 class RegisterRequestBody {
-  @ApiProperty() username: string;
   @ApiProperty() email: string;
   @ApiProperty() password: string;
   @ApiProperty({ required: false }) name?: string;
@@ -25,22 +24,19 @@ class RegisterRequestBody {
 
 class RegisterResponseBody {
   @ApiProperty() id: string;
-  @ApiProperty() username: string;
   @ApiProperty({ required: false }) email?: string;
   @ApiProperty({ required: false }) name?: string;
   @ApiProperty({ required: false }) avatar?: string;
   @ApiProperty({ required: false }) bio?: string;
 
   constructor(params: {
     id: string;
-    username: string;
     email?: string;
     name?: string;
     avatar?: string;
     bio?: string;
   }) {
     this.id = params.id;
-    this.username = params.username;
     this.email = params.email;
     this.name = params.name;
     this.avatar = params.avatar;
@@ -69,7 +65,7 @@ export class AuthController {
     const user = await this.authService.registerNewUser(body);
     return new RegisterResponseBody({
       id: user.id,
-      username: user.username,
+      email: user.email,
       name: user.name,
       avatar: user.avatar,
       bio: user.bio,

apps/api-gateway/src/modules/auth/auth.service.ts

@@ -30,17 +30,17 @@ export class AuthService {
   public static PASSWORD_SALT_ROUNDS = 10;
 
   async registerNewUser(params: {
-    username: string;
+    email: string;
     password: string;
     name?: string;
     avatar?: string;
     bio?: string;
   }): Promise<UserEntity> {
-    const username = params.username?.trim();
+    const email = params.email?.trim();
     const { password, name, avatar, bio } = params;
 
-    if (!username || username.length < 5) {
-      throw new BadRequestException('Username must be of minimum 5 characters');
+    if (!email || email.length < 5) {
+      throw new BadRequestException('email must be of minimum 5 characters');
     }
 
     if (!password || password.length < 8) {
@@ -53,16 +53,16 @@ export class AuthService {
       );
     }
 
-    const usernameAlreadyExists = await this.userRepo.findOne({
-      where: { username },
+    const alreadyExists = await this.userRepo.findOne({
+      where: { email },
     });
 
-    if (usernameAlreadyExists) {
-      throw new ConflictException('This username is already taken!');
+    if (alreadyExists) {
+      throw new ConflictException('This account is already exists!');
     }
 
     const newUser = this.userRepo.create({
-      username,
+      email,
       name,
       avatar,
       bio,
@@ -79,15 +79,17 @@ export class AuthService {
     userId: string,
     password: string,
   ): Promise<PasswordEntity> {
-    const existing = await this.passwordRepo.findOne({ where: { userId } });
+    const existing = await this.passwordRepo.findOne({
+      where: { user_id: userId },
+    });
     if (existing) {
       throw new UnauthorizedException(
         'This user already has a password, cannot set new password',
       );
     }
 
     const newPassword = new PasswordEntity();
-    newPassword.userId = userId;
+    newPassword.user_id = userId;
     newPassword.password = await this.passToHash(password);
     return await this.passwordRepo.save(newPassword);
   }
@@ -96,24 +98,23 @@ export class AuthService {
     const user = await this.userRepo.findOne({ where: { email } });
 
     if (!user) {
-      throw new NotFoundException('Username does not exist');
+      throw new NotFoundException('Account does not exist');
     }
     const userPassword = await this.passwordRepo.findOne({
-      where: { userId: user.id },
+      where: { user_id: user.id },
     });
     const passMatch = await this.matchPassHash(password, userPassword.password);
     if (!passMatch) {
       throw new UnauthorizedException('Password is wrong');
     }
     const session = new SessionsEntity();
-    session.userId = userPassword.userId;
+    session.userId = userPassword.user_id;
     const savedSession = await this.sessionRepo.save(session);
     await this.kafkaProducer.produce(
       {
         userId: user.id,
         email: user.email,
         sessionId: savedSession.id,
-        username: user.username,
         loggedInAt: new Date().toISOString(),
       },
       KafkaTopics.UserLoggedIn,

apps/api-gateway/src/modules/auth/passwords.entity.ts

@@ -4,10 +4,10 @@ import { UserEntity } from '../users/users.entity';
 
 @Entity('passwords')
 export class PasswordEntity extends YooBaseEntity {
-  @Column()
-  userId: string;
+  @Column({ name: 'user_id' })
+  user_id: string;
 
-  @JoinColumn({ name: 'userId' })
+  @JoinColumn({ name: 'user_id' })
   @OneToOne(() => UserEntity)
   user: UserEntity;
 

apps/api-gateway/src/modules/commons/base.entity.ts

@@ -1,5 +1,6 @@
 import {
   CreateDateColumn,
+  PrimaryColumn,
   PrimaryGeneratedColumn,
   UpdateDateColumn,
 } from 'typeorm';
@@ -8,7 +9,7 @@ import {
  * Base entity which is extended by all entities in our application.
  */
 export abstract class YooBaseEntity {
-  @PrimaryGeneratedColumn('uuid')
+  @PrimaryColumn('uuid', { length: 36, unique: true })
   id: string;
 
   @CreateDateColumn({ name: 'created_at' })

apps/api-gateway/src/modules/commons/db.config.ts

@@ -10,6 +10,7 @@ import {
   TypeOrmModuleAsyncOptions,
   TypeOrmModuleOptions,
 } from '@nestjs/typeorm';
+import { migrations } from '../../../../../database/migrations';
 
 export const entities = [
   UserEntity,
@@ -32,7 +33,10 @@ export const typeOrmConfig: TypeOrmModuleAsyncOptions = {
     username: configService.get<string>('DB_USER'),
     password: configService.get<string>('DB_PASSWORD'),
     database: configService.get<string>('DB_DATABASE_NAME'),
-    synchronize: true,
+    // Schema comes from migrations to avoid destructive sync updates
+    synchronize: false,
+    migrationsRun: true,
+    migrations,
     logger: 'advanced-console',
     logging: 'all',
     namingStrategy: new SnakeNamingStrategy(),

apps/api-gateway/src/modules/commons/mocks/users.repository.mock.ts

@@ -6,6 +6,7 @@ export class MockUsersRepository extends Repository<UserEntity> {
   async findOne() {
     const mockUser: UserEntity = {
       id: 'test-uuid',
+      email: 'tE0xg@example.com',
       name: 'John Doe',
       followeeCount: 1,
       followerCount: 1,

apps/api-gateway/src/modules/users/users.controller.ts

@@ -27,7 +27,7 @@ import { CurrentUser } from '../commons/decorators/current-user.decorator';
 import { S3Service } from '../aws/s3.service';
 
 class UserCreateRequestBody {
-  @ApiProperty() username: string;
+  @ApiProperty() email: string;
   @ApiProperty() password: string;
   @ApiPropertyOptional() name?: string;
   @ApiPropertyOptional() avatar?: string;
@@ -49,14 +49,14 @@ export class UsersController {
     private readonly s3Service: S3Service,
   ) {}
 
-  @Get('/@:username')
-  async getUserByUsername(@Param('username') username: string): Promise<any> {
-    const user = await this.userService.getUserByUsername(username);
-    if (!user) {
-      throw new NotFoundException('User not found');
-    }
-    return user;
-  }
+  // @Get('/@:username')
+  // async getUserByUsername(@Param('username') username: string): Promise<any> {
+  //   const user = await this.userService.getUserByUsername(username);
+  //   if (!user) {
+  //     throw new NotFoundException('User not found');
+  //   }
+  //   return user;
+  // }
 
   @Get('/:userid')
   async getUserByUserid(@Param('userid') userid: string): Promise<UserEntity> {

apps/api-gateway/src/modules/users/users.entity.ts

@@ -4,7 +4,7 @@ import { YooBaseEntity } from '../commons/base.entity';
 
 @Entity('users')
 export class UserEntity extends YooBaseEntity {
-  @Column({ length: 30, nullable: false, unique: true })
+  @Column({ length: 30, nullable: true, unique: true })
   username: string;
 
   @Column({ length: 255, nullable: false, unique: true })

apps/api-gateway/src/modules/users/users.service.ts

@@ -27,7 +27,7 @@ export class UsersService {
    * @description find a user with a given username
    * @returns {Promise<UserEntity>} user if found
    */
-  public async getUserByUsername(username: string): Promise<UserEntity> {
+  public async getUserByEmail(username: string): Promise<UserEntity> {
     return await this.userRepo.findOne({ where: { username } });
   }
 
@@ -54,9 +54,6 @@ export class UsersService {
     user: Partial<UserEntity>,
     password: string,
   ): Promise<UserEntity> {
-    if (user.username.length < 5)
-      throw new BadRequestException('Username must be of minimum 5 characters');
-
     if (password.length < 8)
       throw new BadRequestException('Password must be of minimum 8 characters');
 
@@ -65,9 +62,9 @@ export class UsersService {
         'Password cannot contain the word password itself',
       );
 
-    const usernameAlreadyExists = await this.getUserByUsername(user.username);
-    if (usernameAlreadyExists)
-      throw new ConflictException('This username is already taken!');
+    const alreadyExists = await this.getUserByEmail(user.email);
+    if (alreadyExists)
+      throw new ConflictException('Account already exists for this email');
 
     const newUser = await this.userRepo.save(user);
 

database/drop.ts

@@ -0,0 +1,11 @@
+import { Logger } from '@nestjs/common';
+import dataSource from '../apps/api-gateway/src/modules/commons/data-source';
+
+export const dropDatabase = async () => {
+  const logger = new Logger('DBDrop');
+  logger.verbose('db.drop.started');
+  await dataSource.initialize();
+  await dataSource.dropDatabase();
+  await dataSource.destroy();
+  logger.verbose('db.drop.finished');
+};