아주 기초 시작

기본 entity 제작
export class 클래스명{}이 가장 기본적인 베이스 역할을 하게 된다

@Entity()
export class 클래스명{
	@PrimaryColumn()
    id:number
    
	@Column()
    base: number
}

이게 진짜 최소 형태
여기서 number같은 것은 integer로 자동 변환을 하는 것같은 처리를 해준다

@PrimaryGeneratedColumn()

이 데코레이터는 primaryColumn인데 AutoIncrement를 통해서 관리를 했던 id같은 것들을 만들어 줌
(this is known as auto-increment / sequence / serial / generated identity column)

@Column()

이 데코레이터는 단순하게 column표시 대신, 많은 것들을 해줄 수 있는데, 예를 들면 데이터 타입을 한정할 수 있다.
@Column({length:100})
text:string
같은 것으로 길이 제한을 둘 수 있는데, 원래 기본적으로 255길이인 string을 갖는 것과 차이가 있다
@Column("double")을 통해서 number를 double형으로 고정하는 것도 가능

import { Entity, Column, PrimaryGeneratedColumn } from "typeorm"

@Entity()
export class Photo {
    @PrimaryGeneratedColumn()
    id: number

    @Column({
        length: 100,
    })
    name: string

    @Column("text")
    description: string

    @Column()
    filename: string

    @Column("double")
    views: number

    @Column()
    isPublished: boolean
}

를 통해 생성되는
테이블은

+-------------+--------------+----------------------------+
|                         photo                           |
+-------------+--------------+----------------------------+
| id          | int(11)      | PRIMARY KEY AUTO_INCREMENT |
| name        | varchar(100) |                            |
| description | text         |                            |
| filename    | varchar(255) |                            |
| views       | int(11)      |                            |
| isPublished | boolean      |                            |
+-------------+--------------+----------------------------+

형태가 됨

import { Photo } from "./entity/Photo"
import { AppDataSource } from "./index"

const photo = new Photo()
photo.name = "Me and Bears"
photo.description = "I am near polar bears"
photo.filename = "photo-with-bears.jpg"
photo.views = 1
photo.isPublished = true

await AppDataSource.manager.save(photo)
console.log("Photo has been saved. Photo id is", photo.id)

create 부분은 이렇게 코딩이 된다
new 클래스()로 생성하고, 하나하나 채운 다음 save한다

Entity Manager

Entity Manager를 통해서 접근한다는 점이 있었음
AppDataSource라는게 가장 커다란 덩어리
그리고 나온 부분이

const savedPhotos = await AppDataSource.manager.find(Photo)

라고 entity 부분을 통째로 집어 넣어서 전체를 다 찾을 수 있다

entity Manager는 Repository들의 총 합. 각각의 Entity는 repository를 갖고 있음

const photoRepository = AppDataSource.getRepository(Photo)

const photoToUpdate=photoRepository.findOneBy({
    id: 1,
})
await photoRepository.save(photoToUpdate)

같은 무난한 코드를 넣는 것도 가능함
저장도 이렇게 가능함
remove도 가능함

One to One

export class PhotoMetadata {
    /* ... other columns */

    @OneToOne(() => Photo, (photo) => photo.metadata)
    @JoinColumn()
    photo: Photo
}
export class Photo {
    /* ... other columns */

    @OneToOne(() => PhotoMetadata, (photoMetadata) => photoMetadata.photo)
    metadata: PhotoMetadata
}

여기서 owner 즉 foreign key를 가지고 있는 쪽은 Photo Metadat이다.
이런 형태로 one to one을 만들어 낸다
여기서 중요하게 보아야 할 점은 ()=>Photo인지, ()=>PhotoMetadata인지 이다
그리고 어느쪽에 join column이 붙는지도 알아야 한다

이때 circular dependency 가 날 수 있기에

@Entity()
export class PhotoMetadata {
    /* ... other columns */

    @OneToOne(() => Photo, (photo) => photo.metadata)
    @JoinColumn()
    photo: Relation<Photo>
}
import {
    Entity,
    Column,
    PrimaryGeneratedColumn,
    OneToOne,
    Relation,
} from "typeorm"
import { PhotoMetadata } from "./PhotoMetadata"

@Entity()
export class Photo {
    /* ... other columns */

    @OneToOne(() => PhotoMetadata, (photoMetadata) => photoMetadata.photo)
    metadata: Relation<PhotoMetadata>
}

이렇게 Relation<데이터>같은 방향의 처리를 꼭 해줘야 합니다

const photoRepository = AppDataSource.getRepository(Photo)
const photos = await photoRepository.find({
    relations: {
        metadata: true,
    },
}
const photos = await AppDataSource.getRepository(Photo)
    .createQueryBuilder("photo")
    .innerJoinAndSelect("photo.metadata", "metadata")
    .getMany()

탐색 방법은 이런 두 가지 방법이 있는데,
knex같은 쿼리 빌더를 이용하는 것과, 자체 제공하는 relations:{relation명:true}
같은 것들이다

웬만함 typeorm에서는 cascade옵션을 켜둔다