1
@Entity()
2
export class UsersModel extends BaseModel {
3
  // 생략
4

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

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

1
// **** 4) 팔로우 요청
2
async followUser(followerId: number, followeeId: number) {
3
  const user = await this.userRepository.findOne({
4
    where: {
5
      id: followerId,
6
    },
7
    relations: {
8
      followees: true,
9
    },
10
  })
11

12
  if (!user) {
13
    throw new BadRequestException('존재하지 않는 팔로워입니다.')
14
  }
15

16
  await this.userRepository.save({
17
    ...user,
18
    followees: [...user.followees, { id: followeeId }],
19
  })
20

21
  return true
22
}
23

24
// **** 5) 팔로워들 조회
25
async getFollowers(userId: number): Promise<UsersModel[]> {
26
  const user = await this.userRepository.findOne({
27
    where: { id: userId },
28
    relations: {
29
      followers: true,
30
    },
31
  })
32

33
  return user.followers
34
}

1
@Get('follow/me')
2
async getFollow(
3
  @User() user: UsersModel, //
4
) {
5
  return this.usersService.getFollowers(user.id)
6
}
7

8
@Post('follow/:id')
9
async postFollow(
10
  @User() user: UsersModel, //
11
  @Param('id', ParseIntPipe) followeeId: number,
12
) {
13
  await this.usersService.followUser(user.id, followeeId)
14
  return true
15
}

1
import { BaseModel } from 'src/common/entity/base.entity'
2
import { UsersModel } from './users.entity'
3
import { Column, Entity, ManyToOne } from 'typeorm'
4

5
@Entity()
6
export class UserFollowersModel extends BaseModel {
7
  @ManyToOne(() => UsersModel, user => user.followers)
8
  follower: UsersModel
9

10
  @ManyToOne(() => UsersModel, user => user.followees)
11
  followee: UsersModel
12

13
  @Column({ default: false })
14
  isConfirmed: boolean
15
}

1
// 내가 팔로우 하고 있는 사람들
2
@OneToMany(() => UserFollowersModel, ufm => ufm.follower)
3
followers: UsersModel[]
4

5
// 나를 팔로우 하고 있는 사람들
6
@OneToMany(() => UserFollowersModel, ufm => ufm.followee)
7
followees: UsersModel[]

1
// 생략
2
TypeOrmModule.forRoot({
3
  // 생략
4
  // entities폴더에 작성한 PostsModel 가져오기
5
  entities: [
6
    PostsModel, //
7
    UsersModel,
8
    ImageModel,
9
    ChatsModel,
10
    MessagesModel,
11
    CommentsModel,
12
    UserFollowersModel,
13
  ],
14
  synchronize: true,
15
}),

1
// 내가 팔로우 하고 있는 사람들
2
@OneToMany(() => UserFollowersModel, ufm => ufm.follower)
3
followers: UserFollowersModel[]
4

5
// 나를 팔로우 하고 있는 사람들
6
@OneToMany(() => UserFollowersModel, ufm => ufm.followee)
7
followees: UserFollowersModel[]

1
@Injectable()
2
export class UsersService {
3
  constructor(
4
    @InjectRepository(UsersModel)
5
    private readonly userRepository: Repository<UsersModel>,
6
    @InjectRepository(UserFollowersModel)
7
    private readonly userFollowersRepository: Repository<UserFollowersModel>,
8
  ) {}
9

10
  // 생략
11

12
  // **** 4) 팔로우 요청
13
  async followUser(followerId: number, followeeId: number) {
14
    return await this.userFollowersRepository.save({
15
      follower: {
16
        id: followerId,
17
      },
18
      followee: {
19
        id: followeeId,
20
      },
21
    })
22
  }
23

24
  // **** 5) 팔로워들 조회
25
  async getFollowers(userId: number): Promise<UsersModel[]> {
26
    const result = await this.userFollowersRepository.find({
27
      where: {
28
        followee: {
29
          id: userId,
30
        },
31
      },
32
      relations: {
33
        follower: true,
34
      },
35
    })
36

37
    return result.map(userFollow => userFollow.follower)
38
  }
39
}

1
@Module({
2
  // 이 모듈 안에서 UsersModel을 어디서든 사용 가능
3
  imports: [
4
    TypeOrmModule.forFeature([
5
      UsersModel, //
6
      UserFollowersModel,
7
    ]),
8
  ],
9
  exports: [UsersService],
10
  controllers: [UsersController],
11
  providers: [UsersService],
12
})
13
export class UsersModule {}

1
// **** 내 팔로워들 조회
2
@Get('follow/me')
3
async getFollow(
4
  @User() user: UsersModel, //
5
  @Query('includeNotConfirmed', new DefaultValuePipe(false), ParseBoolPipe) includeNotConfirmed: boolean,
6
) {
7
  return this.usersService.getFollowers(user.id, includeNotConfirmed)
8
}
9

10
// **** 팔로우 요청 승인
11
@Patch('follow/:id/confirm')
12
async patchFollowConfirm(
13
  @User('id') followeeId: number, //
14
  @Param('id', ParseIntPipe) followerId: number,
15
) {
16
  await this.usersService.confirmFollow(followerId, followeeId)
17
  return true
18
}

1
// **** 5) 팔로워들 조회
2
async getFollowers(userId: number, includeNotConfirmed: boolean) {
3
  const where = {
4
    followee: { id: userId },
5
  }
6

7
  if (!includeNotConfirmed) {
8
    where['isConfirmed'] = true
9
  }
10

11
  const result = await this.userFollowersRepository.find({
12
    where,
13
    relations: {
14
      follower: true,
15
      followee: true,
16
    },
17
  })
18

19
  return result.map(el => ({
20
    id: el.follower.id,
21
    nickname: el.follower.nickname,
22
    email: el.follower.email,
23
    isConfirmed: el.isConfirmed,
24
  }))
25
}
26

27
// **** 팔로우 요청 승인
28
async confirmFollow(followerId: number, followeeId: number) {
29
  const existing = await this.userFollowersRepository.findOne({
30
    where: {
31
      follower: { id: followerId },
32
      followee: { id: followeeId },
33
    },
34
    relations: {
35
      follower: true,
36
      followee: true,
37
    },
38
  })
39

40
  if (!existing) {
41
    throw new BadRequestException('존재하지 않는 팔로우 요청입니다!')
42
  }
43

44
  await this.userFollowersRepository.save({
45
    ...existing,
46
    isConfirmed: true,
47
  })
48

49
  return true
50
}

1
// **** 팔로우 요청 삭제
2
@Delete('follow/:id')
3
async deleteFollow(
4
  @User() user: UsersModel, //
5
  @Param('id', ParseIntPipe) followeeId: number,
6
) {
7
  await this.usersService.deleteFollow(user.id, followeeId)
8
  return true
9
}

1
// **** 팔로우 요청 삭제
2
async deleteFollow(followerId: number, followeeId: number) {
3
  await this.userFollowersRepository.delete({
4
    follower: { id: followerId },
5
    followee: { id: followeeId },
6
  })
7

8
  return true
9
}