Many-to-one/One-To-Many 종합[nest.js]

1. user한명이 여러개의 jobs을 가질 수 있음.
2. User.entity | Jobs.entity
   OneToMany | ManyToOne
   jobsOwner[] | owner

1.user.entity
   @Field(type=>[Jobs])
    @ManyToOne(type=>Jobs, jobs=>jobs.owner, {nullable: true, onDelete: 'SET 	NULL', 
    eager: true})
    jobsOwner?: Jobs[];

2. jobs.entity
    @Field(type=>User)
    @ManyToOne(type=>User, user => user.jobsOwner, {onDelete: "CASCADE", nullable: true})
    owner: User

3. postico - 
user - jobsOwnerId NULL
jobs - ownerId - 7

1. user 한명이 여러개의 order를 시킨다. => One To Many
2. 등록된 많은 order들은 한명의 user를 가진다. => Many To One
3. User.entity | Order.entity
   OnetoMany | ManyToOne
   orders | user
   postico안보임 | postico에서 relationId로 설정하면 보임

첫번째는 위 내용을 이해하는 것이고
두번쨰는 ManyToOne에 eager:true의 옵션을 주고
세번째는 backend: service.ts에서 entity를 불러올때 options: {relation: ['orders']}넣고
네번째는 postico에서는 user의 entity에서는 많은 orderId 들은 보이지 않고 graphql에는 확인이 가능하다는 것임.

---

1. user 한명이 여러개의 order를 시킨다. => One To Many
2. 등록된 많은 order들은 한명의 user를 가진다. => Many To One
3. User.entity -> Order.entity
   OnetoMany ManyToOne
   orders user

1. container 하나가 여러개의 user를 가진다.
2. 등록된 많은 user들이 하나의 container로 등록한다.
3. container.entity -> user.entity
   OneToMany ManyToOne
   users container

1. 하나의 job에 많은 user가 등록한다.
2. 많은 candidates 가 하나의 job에 등록한다.
3. jobs.entity -> user.entity
   OneToMany ManyToOne
   users jobs

1. 하나의 Restaurant에 많은 Order가 들어온다.
2. 많은 Orders들이 하나의 Restaurant에 등록된다.
3. restaurant.entity -> order.entity
   OneToMany ManyToOne
   orders restaurant

Restarant.entity.ts

  @Field(type => [Order])
  @OneToMany(type=>Order, order => order.restaurant, {nullable: true, onDelete: "SET NULL"})
  orders?: Order[]

Order.entity.ts
    @Field(type=>Restaurant)
    @ManyToOne(type=>Restaurant, restaurant=>restaurant.orders  ,
    {nullable: true, onDelete: 'SET NULL', 
    eager: true})
    restaurant?: Restaurant;

*** order.entity 에서 중요한 부분은
eager: true를 해줘야 하는 것과

*** Backend에서 데이터를 불러올 때 Relations를 사용해줘야만 graphql에서 관련 데이터를 불러올수가 있다.

order.service.ts
...   const restaurants = await this.restaurants.find({
                    where: {
                        owner: user
                    }, relations: ['orders']
                });

MANY TO MANY

많은 Orders는 많은 orderItems가 있다.
orders.entity -> orderItem.entity
ManyToMany -> nothing
JoinTable -> nothing
items: OrderItem[] -> nothing

orders.entity
@Field(type=>[OrderItem])
   @ManyToMany(type=>OrderItem, {eager: true})
   @JoinTable()
   items: OrderItem[]

ONE TO ONE
하나의 Verification은 하나의 user만 있다
verification.entity -> user.entity
One -> nothing
JoinColumn -> nothing
user: User

verification.entity.ts

    @JoinColumn()
    @OneToOne(type => User, {onDelete: "CASCADE"})
    user: User;