Create

2가지 방법으로 생성할 수 있다.

1. relation

   async createAlbum(createAlbumRequestDto: CreateAlbumRequestDto): Promise<string> {
       const { groupId, albumName } = createAlbumRequestDto;
       const group = await this.groupRepository.findOne(groupId, { relations: ["albums"] });
       if (!group) throw new NotFoundException(`Not found group with the id ${groupId}`);
   
       const album = new Album();
       album.albumName = albumName;
       album.base = false;
   
       group.albums.push(album);
       await group.save();
   
       return album.albumName;
     }
   

2. 직접 접근

   async createAlbum(createAlbumRequestDto: CreateAlbumRequestDto): Promise<string> {
       const { groupId, albumName } = createAlbumRequestDto;
       const group = await this.groupRepository.findOne({ groupId });
       if (!group) throw new NotFoundException(`Not found group with the id ${groupId}`);
   
       const album = await this.albumRepository.save({
         albumName: albumName,
         base: false,
         group: group,
       });
   
       return album.albumName;
     }
   

• 내 생각에는 2번이 더 깔끔해보이고 group 조회시 album까지 가져오지 않아도 되니 속도 면에서도 더 좋을듯...하다

• 원래는 group - album - post 로 연관 관계가 있어서 1번처럼 구현했을 때 group 삭제하면 album이 삭제되고 album과 연관된 post까지 삭제되는줄 알았는데 그냥 둘다 album만 삭제됨

• 그래서 2번으로 사용하기로 함

• 팁으로 ManyToMany에서 create 시 1,2번을 같이 사용함

  • ex) group과 user가 ManyToMany 일 때, group 생성 코드

  async createGroup(createGroupRequestDto: CreateGroupRequestDto): Promise<number> {
      const { userId, groupImage, groupName } = createGroupRequestDto;
      const groupCode = await this.createInvitaionCode();
  
      const group = await this.groupRepository.save({
        groupImage: groupImage,
        groupName: groupName,
        groupCode: groupCode,
      });
  
      this.albumRepository.save({
        albumName: "기본 앨범",
        base: true,
        group: group,
      });
  
      const user = await this.userRepository.findOne(userId, { relations: ["groups"] });
      user.groups.push(group);
      this.userRepository.save(user);
  
      return group.groupId;
    }
  

  • 그룹 생성은 2번으로 유저에 묶어줄 때는 1번으로 진행한다.

  Find

  • relations을 이용하거나 createQueryBuilder를 이용할 수 있다.
  • post는 user와 album, image와 연관되어 있다.

  1. relations

     • 연관된 모든 컬럼을 가져온다.
     • 아래 코드는 post와 연관된 컬럼들만 가져온다.

     const post = await this.postRepository.findOne(postId);
     

     • 아래 코드는 post와 post가 가지고 있는 user와 연관된 컬럼들만 가져온다.

     const post = await this.postRepository.findOne(postId, { relations: ["user"] });
     

     • 아래 코드는 post와 post가 가지고 있는 image와 연관된 컬럼들만 가져온다.

     const post = await this.postRepository.findOne(postId, { relations: ["images"] });
     

     • 아래 코드는 post와 post가 가지고 있는 user, image와 연관된 컬럼들만 가져온다.

     const post = await this.postRepository.findOne(postId, { relations: ["user", "images"] });
     

  2. createQueryBuilder

     • 원하는 컬럼만 가져올 수 있다.
     • leftJoin으로 연관된 FK를 설정하고 select으로 원하는 컬럼을 가져올 수 있다.

     async readPostQuery(postId: number): Promise<Post> {
         return await this.createQueryBuilder("post")
           .leftJoin("post.images", "image")
           .leftJoin("post.user", "user")
           .select([
             "post.postTitle",
             "post.postContent",
             "post.postDate",
             "post.postLocation",
             "image.imageUrl",
             "image.imageId",
             "user.userId",
             "user.userNickname",
           ])
           .where("post.postId = :id", { id: postId })
           .getOne();
       }
     

     • post에서 원하는 컬럼을 가져오고 싶으면 leftJoin할 필요가 없다.
     • post와 post가 가지고 있는 user에서 원하는 컬럼을 가져오고 싶으면 leftJoin으로 user만 걸어주면 된다.
     • 나머지도 마찬가지

Delete

• CASCADE를 설정했다고 가정

  @Entity({ name: "posts" })
  export class Post extends TimeStampEntity {
  ...
  
  @OneToMany(() => Image, image => image.post, { cascade: true })
    images: Image[];
  }
  

  @Entity({ name: "images" })
  export class Image extends TimeStampEntity {
  ...
  
    @ManyToOne(() => Post, post => post.images, { onDelete: "CASCADE" })
    @JoinColumn({ name: "post_id" })
    post: Post;
  }
  

• 반드시 같이 지우고자 하는 relations를 지정해 가져와야한다.

• 아래 코드와 같이 작성하면 post 삭제시 post와 연관된 image들도 모두 삭제된다.

async deletePost(postId: number): Promise<string> {
    const post = await this.postRepository.findOne(postId, { relations: ["images"] });
    if (!post) throw new NotFoundException(`Not found post with the id ${postId}`);

    this.postRepository.softRemove(post);

    return "Post delete success!!";
  }

• 아래 코드처럼 relations를 빼먹으면 아무리 CASCADE를 설정해주었다고 해도 post만 삭제되고 image들은 삭제되지 않는다.

async deletePost(postId: number): Promise<string> {
    const post = await this.postRepository.findOne(postId);
    if (!post) throw new NotFoundException(`Not found post with the id ${postId}`);

    this.postRepository.softRemove(post);

    return "Post delete success!!";
  }

group안에 있는 앨범과 앨범에 연관된 게시글들 가져오는 쿼리

• InnerJoin vs LeftJoin

  • innerJoin
    • 서로 관계된 두 테이블 정보를 불러오는데 join된 테이블에 원하는 정보가 존재하지 않으면 data를 반환하지 않는다.
  • leftJoin
    • innerJoin과 다르게 존재하지 않아도 반환한다.
  • 즉, 데이터가 없으면 반환하지 않아야할 때 innerJoin을 반환해야할 때는 leftJoin을 사용한다.

• 사용 예시

  return await this.createQueryBuilder("group")
        .innerJoin("group.albums", "album")
        .leftJoin("album.posts", "post")
        .select(["group.groupId", "album.albumId", "album.albumName", "post.postId"])
        .where("group.groupId = :id", { id: groupId })
        .getOne();
  

  • group안에 앨범이 없으면 굳이 반환할 필요가 없으니 innerJoin
  • album안에 게시글이 없어도 텅 비어있는 album을 반환해야하므로 leftJoin으로 처리해야한다.