NestJS-Follow

jaegeunsong97·2024년 2월 23일

follow nest.js typeOrm typescript

NestJS

목록 보기

36/37

🖊️이론

인스타그램 기반의 팔로우 시스템을 적용하겠습니다.

Following Many to Many Relation

Mnay To Many 관계에서는 중간 테이블을 만들어야 합니다. 하지만 Follow의 경우, User User 형태가 됩니다. 따라서 다음과 같이 만들어야 합니다.

User 테이블이 Follwer와 Follwee 역할을 담당하게 됩니다.

🖊️Followers & Followees 프로퍼티 생성

users.entity.ts

.
.
// 내가 팔로우 하고 있는 사람들
@ManyToMany(() => UsersModel, (user) => user.followees)
@JoinTable()
followers: UsersModel[];

// 나를 팔로우 하고 있는 사람들
@ManyToMany(() => UsersModel, (user) => user.followers)
followees: UsersModel[];

pgadmin으로 확인을 하면 다음과 같이 생성이 됩니다.

🖊️Follow 시스템 로직 작성 및 테스트

팔로우를 하는 로직을 작성하겠습니다.

users.controller.ts

@Post('follow/:id')
async postFollow(
    @User() user: UsersModel, // follower
    @Param('id', ParseIntPipe) followeeId: number,
) {
    await this.usersService.followUser(
        user.id,
        followeeId
    );
    return true;
}

users.service.ts

async followUser(followerId: number, followeeId: number) {
    const user = await this.usersRepository.findOne({
        where: {
          	id: followerId
        },
        relations: {
          	followees: true
        }
    });
    if (!user) throw new BadRequestException(`존재하지 않는 팔로워 입니다. `);

    await this.usersRepository.save({
        ...user,
        followees: [
            ...user.followees,
            {
              	id: followeeId,
            }
        ]
    })
}

이번에는 팔로워들을 가져오는 API를 만들겠습니다.

users.controller.ts

@Get('follow/me')
async getFollow(
  	@User() user: UsersModel
) {
  	return this.usersService.getFollowers(user.id);
}

users.service.ts

async getFollowers(userId: number): Promise<UsersModel[]> {
    const user = await this.usersRepository.findOne({
        where: {
        	id: userId,
        },
        relations: {
          	followers: true
        }
    });
    return user.followers;
}

포스트맨으로 테스트를 하겠습니다.

1번 codefactory로 2번 codefactory1를 팔로우 하겠습니다. 먼저 1번 사용자로 로그인을 하겠습니다. 후에 2번을 팔로우 하겠습니다.

2번 사용자로 로그인을 다시 하고, 나의 팔로워 가져오는 API를 호출합니다.

[
    {
        "id": 1,
        "updatedAt": "2024-01-26T05:58:10.800Z",
        "createdAt": "2024-01-26T05:58:10.800Z",
        "nickname": "codefactory",
        "email": "codefactory@codefactory.ai",
        "role": "USER"
    }
]

만약 3번 사용자로 1번을 팔로우하고 1번 사용자로 로그인 후 나의 팔로워 가져오는 API를 호출하면 다음과 같이 나오게 됩니다.

[
    {
        "id": 2,
        "updatedAt": "2024-01-26T06:48:51.110Z",
        "createdAt": "2024-01-26T06:48:51.110Z",
        "nickname": "codefactory1",
        "email": "codefactory1@codefactory.ai",
        "role": "USER"
    },
    {
        "id": 3,
        "updatedAt": "2024-01-27T18:34:48.009Z",
        "createdAt": "2024-01-27T18:34:48.009Z",
        "nickname": "codefactory19",
        "email": "codefactory19@codefactory.ai",
        "role": "ADMIN"
    }
]

매우 정석적인 방법입니다. 이런 방법으로 하면 중간 테이블에 데이터를 추가할 수 없고 오로지 follower와 followee만 컬럼으로 지정할 수 있습니다. 예를 들면 내가 팔로우를 했을 때, 상대방이 confirm을 했는지 이런 데이터를 넣을 수가 없습니다.

🖊️Follow 테이블 직접 생성

따라서 직접 중간 테이블을 만들겠습니다. 직접 테이블을 구현해서 ManyToMany 형식으로 만들겠습니다.

users/entity/user-followers.entity.ts

import { BaseModel } from "src/common/entity/base.entity";
import { UsersModel } from "./users.entity";
import { Column, Entity, ManyToOne } from "typeorm";

@Entity()
export class UserFollowersModel extends BaseModel {

    @ManyToOne(() => UsersModel, (user) => user.followers)
    follower: UsersModel;

    @ManyToOne(() => UsersModel, (user) => user.followees)
    followee: UsersModel;

    @Column({
      	default: false
    })
    isConfirmed: boolean;
}

users.entity.ts

.
.
@OneToMany(() => UserFollowersModel, (ufm) => ufm.follower) // 변경
followers: UserFollowersModel[];

@OneToMany(() => UserFollowersModel, (ufm) => ufm.followee) // 변경
followees: UserFollowersModel[];

그리고 app.module.ts에 UserFollowersModel를 등록합니다.

app.module.ts

entities: [
    PostsModel,
    UsersModel,
    ImageModel,
    ChatsModel,
    MessagesModel,
    CommentsModel,
    UserFollowersModel // 추가
],

정석적인 방법으로 하면 컬럼은 2개로 고정이 되지만, 직접 테이블을 생성하면 여러 컬럼을 넣을 수 있습니다.

🖊️Custom Table에 맞춰서 로직 변경

이전 팔로우를 하는 기능에서는 relation이 ManyToMany라는 가정하에 직접 followee를 넣었습니다.

users.service.ts

async followUser(followerId: number, followeeId: number) {
    const user = await this.usersRepository.findOne({
        where: {
          	id: followerId
        },
        relations: {
          	followees: true
        }
    });
    if (!user) throw new BadRequestException(`존재하지 않는 팔로워 입니다. `);

    await this.usersRepository.save({
        ...user,
        followees: [
            ...user.followees,
            {
              	id: followeeId,
            }
      ]
    })
}

따라서 기존 코드를 삭제하고 새로운 코드를 작성하겠습니다.

constructor(
    @InjectRepository(UsersModel)
    private readonly usersRepository: Repository<UsersModel>,
    @InjectRepository(UserFollowersModel)
    private readonly userFollowersRepository: Repository<UserFollowersModel>,
) {}
.
.
async followUser(followerId: number, followeeId: number) {
    const result = await this.userFollowersRepository.save({
        follower: {
          	id: followerId
        },
        followee: {
          	id: followeeId
        }
    });

    return true;
}

async getFollowers(userId: number): Promise<UsersModel[]> {
    const result = await this.userFollowersRepository.find({
        where: {
            // 팔로우하는 대상
            followee: {
            	id: userId
            }
        },
        relations: {
            follower: true,
            followee: true
        }
    });
    return result.map((x) => x.follower); // follower만 뽑아서 리스트만들기
}

포스트맨으로 테스트를 하겠습니다.

2번, 3번 사용자로 1번 사용자를 팔로우 하겠습니다.

[
    {
        "id": 3,
        "updatedAt": "2024-01-27T18:34:48.009Z",
        "createdAt": "2024-01-27T18:34:48.009Z",
        "nickname": "codefactory19",
        "email": "codefactory19@codefactory.ai",
        "role": "ADMIN"
    },
    {
        "id": 2,
        "updatedAt": "2024-01-26T06:48:51.110Z",
        "createdAt": "2024-01-26T06:48:51.110Z",
        "nickname": "codefactory1",
        "email": "codefactory1@codefactory.ai",
        "role": "USER"
    }
]

🖊️Confirm Follow 로직 추가

users.controller.ts

@Patch('follow/:id/confirm') // 나를 팔로우 하려는 상대 id
async patchFollowConfirm(
    @User() user: UsersModel,
    @Param('id', ParseIntPipe) followerId: number,
) {
    await this.usersService.confirmFollow(followerId, user.id);
    return true;
}

users.service.ts

async confirmFollow(followerId: number, followeeId: number) {
    // 중간테이블에 데이터가 존재하는지 확인
    const existing = await this.userFollowersRepository.findOne({
        where: {
            follower: {
              	id: followerId
            },
            followee: {
              	id: followeeId
            }
        },
        relations: {
            follower: true,
            followee: true
        },
    });
    if (!existing) throw new BadRequestException(`존재하지 않는 팔로우 요청입니다. `);

    // save값을 넣으면, 변경된 부분만 update한다.
    await this.userFollowersRepository.save({
        ...existing,
        isConfirmed: true,
    });
    return true;
}

그리고 팔로우를 가져오는 API에서는 isConfirmed가 true인것만 가져와야합니다.

async getFollowers(userId: number): Promise<UsersModel[]> {
    const result = await this.userFollowersRepository.find({
        where: {
            followee: {
            	id: userId,
        	},
        	isConfirmed: true, // 추가
        },
        relations: {
            follower: true,
            followee: true,
        },
    });
  return result.map((x) => x.follower);
}

포스트맨으로 확인을 하겠습니다. 1번 사용자로 로그인을 하고 팔로워를 가져오는 기능을 호출하면 아무것도 나오지 않습니다.

왜냐하면 우리가 허가한 팔로우 요청이 없기 때문입니다. 그러면 2번과 3번이 팔로우 요청을 한 것을 confirm을 하도록 하겠습니다.

2번 사용자가 팔로우 요청한 것을 허가를 하면 확인이 되는 것을 알 수 있습니다.

[
    {
        "id": 2,
        "updatedAt": "2024-01-26T06:48:51.110Z",
        "createdAt": "2024-01-26T06:48:51.110Z",
        "nickname": "codefactory1",
        "email": "codefactory1@codefactory.ai",
        "role": "USER"
    }
]

이번에는 getFollow()를 팔로우 요청이 온 것들을 포함해서 보여주는 것과 포함하지 않고 보여주는 코드로 수정하겠습니다.

users.controller.ts

@Get('follow/me')
async getFollow(
    @User() user: UsersModel,
    @Query('includeNotConfirmed', new DefaultValuePipe(false), ParseBoolPipe) includeNotConfirmed: boolean
) {
  	return this.usersService.getFollowers(user.id, includeNotConfirmed);
}

users.service.ts

async getFollowers(userId: number, includeNotConfirmed: boolean): Promise<UsersModel[]> {
    const where = {
        // 팔로우하는 대상
        followee: {
        	id: userId
        }
  	};

    // 허가 한것들만 추가를 해라!
    if (!includeNotConfirmed) {
      	where['isConfirmed'] = true;
    }

    const result = await this.userFollowersRepository.find({
        where,
        relations: {
            follower: true,
            followee: true
        }
    });
    return result.map((x) => x.follower);
}

포스트맨으로 테스트를 하겠습니다.

[
    {
        "id": 3,
        "updatedAt": "2024-01-27T18:34:48.009Z",
        "createdAt": "2024-01-27T18:34:48.009Z",
        "nickname": "codefactory19",
        "email": "codefactory19@codefactory.ai",
        "role": "ADMIN"
    },
    {
        "id": 2,
        "updatedAt": "2024-01-26T06:48:51.110Z",
        "createdAt": "2024-01-26T06:48:51.110Z",
        "nickname": "codefactory1",
        "email": "codefactory1@codefactory.ai",
        "role": "USER"
    }
]

응답 데이터 형태를 바꾸겠습니다.

async getFollowers(userId: number, includeNotConfirmed: boolean): Promise<UsersModel[]> {
    const where = {
        followee: {
        	id: userId
        }
  	};

    if (!includeNotConfirmed) {
      	where['isConfirmed'] = true;
    }

    const result = await this.userFollowersRepository.find({
        where,
        relations: {
            follower: true,
            followee: true
        }
    });
    return result.map((x) => ({
        id: x.follower.id,
        nickname: x.follower.nickname,
        email: x.follower.email,
        isConfirmed: x.isConfirmed,
    })); // follower만 뽑아서 리스트만들기
}

[
    {
        "id": 3,
        "nickname": "codefactory19",
        "email": "codefactory19@codefactory.ai",
        "isConfirmed": false
    },
    {
        "id": 2,
        "nickname": "codefactory1",
        "email": "codefactory1@codefactory.ai",
        "isConfirmed": true
    }
]

[
    {
        "id": 2,
        "nickname": "codefactory1",
        "email": "codefactory1@codefactory.ai",
        "isConfirmed": true
    }
]

🖊️Follow 취소 요청 작업

users.controller.ts

@Delete('follow/:id')
async deleteFollow(
    @User() user: UsersModel,
    @Param('id', ParseIntPipe) followeeId: number, // 내가 팔로우하는 상대
) {
    await this.usersService.deleteFollow(user.id, followeeId);
    return true;
}

users.service.ts

async deleteFollow(followerId: number, followeeId: number) {
    await this.userFollowersRepository.delete({
        follower: {
          	id: followerId,
        },
        followee: {
          	id: followeeId,
        },
    });
    return true;
}

포스트맨으로 테스트하겠습니다. 2번 사용자는 1번 사용자를 팔로우 하고 있습니다.

2번 사용자로 로그인을 해서 1번 사용자를 언팔로우 해보겠습니다.

[
    {
        "id": 3,
        "nickname": "codefactory19",
        "email": "codefactory19@codefactory.ai",
        "isConfirmed": false
    }
]

jaegeunsong97

블로그 이전 : https://medium.com/@jaegeunsong97

이전 포스트

NestJS-Authorization

다음 포스트

NestJS-Follow

NestJS

🖊️이론

🖊️Followers & Followees 프로퍼티 생성

🖊️Follow 시스템 로직 작성 및 테스트

🖊️Follow 테이블 직접 생성

🖊️Custom Table에 맞춰서 로직 변경

🖊️Confirm Follow 로직 추가

🖊️Follow 취소 요청 작업

NestJS-Authorization

NestJS-Follow count

0개의 댓글