1
nest new typeorm
2
yarn add @nestjs/typeorm typeorm pg

1
# 서비스정의
2
services:
3
  postgres:
4
    image: postgres:15
5
    # 실행시마다 재시작
6
    restart: always
7
    # 도커컴포즈 파일에 존재하는 위치에 실제 데이터를 hostOS에 저장
8
    volumes:
9
      # 현재 도커컴포즈 파일이 존재하는 경로 : 이미지안에존재하는 경로 매핑
10
      - ./postgres-data:/var/lib/postgresql/data
11
    ports:
12
      # hostport:이미지의포트
13
      # 5432포트 요청 -> 이미지의 포트로 요쳥
14
      - '5808:5432'
15
    environment:
16
      POSTGRES_USER: postgres
17
      POSTGRES_PASSWORD: postgres
18
      POSTGRES_DB: typeormstudy

1
import { Module } from '@nestjs/common'
2
import { TypeOrmModule } from '@nestjs/typeorm'
3

4
import { AppController } from './app.controller'
5
import { AppService } from './app.service'
6

7
@Module({
8
  imports: [
9
    TypeOrmModule.forRoot({
10
      // 데이터베이스 타입
11
      type: 'postgres',
12
      host: '127.0.0.1',
13
      port: 5808,
14
      username: 'postgres',
15
      password: 'postgres',
16
      database: 'typeormstudy',
17
      // entities폴더에 작성한 PostsModel 가져오기
18
      entities: [],
19
      synchronize: true,
20
    }),
21
  ],
22
  controllers: [AppController],
23
  providers: [AppService],
24
})
25
export class AppModule {}

1
import {
2
  Column,
3
  CreateDateColumn,
4
  Entity,
5
  Generated,
6
  PrimaryGeneratedColumn,
7
  UpdateDateColumn,
8
  VersionColumn,
9
} from 'typeorm'
10

11
@Entity()
12
export class UserModel {
13
  /*** ID
14
   * 자동으로 ID를 생성한다.
15
   *
16
   * 📌 @PrimaryGeneratedColumn()
17
   * Primary Column은 모든 테이블에서 기본적으로 존재해야 한다
18
   * 테이블 안에서 각각의 Row를 구분할 수 있는 컬럼이다.
19
   * @PrimaryColumn()
20
   *
21
   * 📌 @PrimaryGeneratedColumn('uuid')
22
   * PrimaryGeneratedColumn => 순서대로 위로 올라간다.
23
   * 1, 2, 3, 4, 5 -> 999999
24
   *
25
   * UUID : 절대로 겹치지 않는 고유한 값을 만들어줌
26
   * ea36ed96-8d1c-44d9-9fbe-4ec6960e95a8
27
   */
28
  @PrimaryGeneratedColumn()
29
  id: number
30

31
  @Column()
32
  title: string
33

34
  /** 데이터 생성 일자
35
   * 데이터가 생성되는 날짜와 시간이 자동으로 찍힌다.
36
   */
37
  @CreateDateColumn()
38
  createdAt: Date
39

40
  /** 데이터 수정 일자
41
   * 데이터가 업데이트되는 날짜와 시간이 자동으로 찍힌다.
42
   */
43
  @UpdateDateColumn()
44
  updateAt: Date
45

46
  /** 데이터가 업데이트 될 떄마다 1씩 올라간다
47
   * 처음 생성되면 값은 1이다.
48
   * save() 함수가 몇 번 불렸는지 기억한다.
49
   */
50
  @VersionColumn()
51
  version: number
52

53
  /**
54
   * 📌 @Generated('increment')
55
   * additionalId: number
56
   * PrimaryColumn은 아닌데, 데이터 생성할 떄마다, 1씩 올라가는 컬럼
57
   *
58
   * 📌 Generated('uuid')
59
   * additionalId: string
60
   * 는 마찬가지로,
61
   * PrimaryColumn은 아닌데, 데이터 생성할 떄마다, 고유값을 가지는 컬럼
62
   */
63
  @Column()
64
  @Generated('uuid')
65
  additionalId: string
66
}

1
import { Module } from '@nestjs/common'
2
import { TypeOrmModule } from '@nestjs/typeorm'
3

4
import { AppController } from './app.controller'
5
import { AppService } from './app.service'
6
import { UserModel } from './entity/user.entity'
7

8
@Module({
9
  imports: [
10
    TypeOrmModule.forFeature([UserModel]),
11
    TypeOrmModule.forRoot({
12
      // 데이터베이스 타입
13
      type: 'postgres',
14
      host: '127.0.0.1',
15
      port: 5808,
16
      username: 'postgres',
17
      password: 'postgres',
18
      database: 'typeormstudy',
19
      // entities폴더에 작성한 Model 가져오기
20
      entities: [UserModel],
21
      synchronize: true,
22
    }),
23
  ],
24
  controllers: [AppController],
25
  providers: [AppService],
26
})
27
export class AppModule {}

1
import { Controller, Get, Param, Patch, Post } from '@nestjs/common'
2
import { InjectRepository } from '@nestjs/typeorm'
3
import { UserModel } from './entity/user.entity'
4
import { Repository } from 'typeorm'
5

6
@Controller()
7
export class AppController {
8
  constructor(
9
    @InjectRepository(UserModel)
10
    private readonly userRepository: Repository<UserModel>
11
  ) {}
12

13
  @Post('users')
14
  postUser() {
15
    return this.userRepository.save({
16
      title: 'test title',
17
    })
18
  }
19

20
  @Get('users')
21
  getUsers() {
22
    return this.userRepository.find()
23
  }
24

25
  @Patch('users/:id')
26
  async patchUser(@Param('id') id: string) {
27
    const user = await this.userRepository.findOne({
28
      where: { id: parseInt(id) },
29
    })
30

31
    return this.userRepository.save({
32
      ...user,
33
      title: user.title + '0',
34
    })
35
  }
36
}

1
// user.entity.ts 생략
2
@Column({
3
  type: 'varchar',
4
  name: 'title',
5
  length: 300,
6
  nullable: true,
7
  update: true,
8
  select: false,
9
  default: 'default value',
10
  unique: false,
11
})
12
title: string

1
// app.controller.ts 생략
2
@Post('users')
3
postUser() {
4
  return this.userRepository.save({
5
    // title: 'test title',
6
  })
7
}
8

9
@Get('users')
10
getUsers() {
11
  return this.userRepository.find({
12
    select: { id: true, title: true },
13
  })
14
}

1
export enum Role {
2
  USER = 'user',
3
  ADMIN = 'admin',
4
}
5

6
@Entity()
7
export class UserModel {
8
  // 생략
9
  title: string
10

11
  @Column({
12
    type: 'enum',
13
    enum: Role,
14
    default: Role.USER,
15
  })
16
  role: Role
17

18
  // 생략
19
}

1
@Post('users')
2
postUser() {
3
  return this.userRepository.save({
4
    // title: 'test title',
5
    role: Role.ADMIN, // 관리자 역할을 넣고싶을 떄
6
  })
7
}
8

9
// app.controller.ts의 select옵션 지우기
10
@Get('users')
11
getUsers() {
12
  return this.userRepository.find({})
13
}

1
import { Column, Entity, PrimaryColumn } from 'typeorm'
2

3
export class Name {
4
  @Column()
5
  first: string
6

7
  @Column()
8
  last: string
9
}
10

11
@Entity()
12
export class StudentModel {
13
  @PrimaryColumn()
14
  id: number
15

16
  @Column(() => Name)
17
  name: Name
18

19
  @Column()
20
  class: string
21
}
22

23
@Entity()
24
export class TeacherModel {
25
  @PrimaryColumn()
26
  id: number
27

28
  @Column(() => Name)
29
  name: Name
30

31
  @Column()
32
  salary: number
33
}

1
// 생략
2
@Module({
3
  imports: [
4
    TypeOrmModule.forFeature([UserModel]),
5
    TypeOrmModule.forRoot({
6
      // 데이터베이스 타입
7
      type: 'postgres',
8
      host: '127.0.0.1',
9
      port: 5808,
10
      username: 'postgres',
11
      password: 'postgres',
12
      database: 'typeormstudy',
13
      // entities폴더에 작성한 Model 가져오기
14
      entities: [UserModel, StudentModel, TeacherModel],
15
      synchronize: true,
16
    }),
17
  ],
18
  controllers: [AppController],
19
  providers: [AppService],
20
})
21
export class AppModule {}

1
import { Column, CreateDateColumn, Entity, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm'
2

3
export class BaseModel {
4
  @PrimaryGeneratedColumn()
5
  id: number
6

7
  @CreateDateColumn()
8
  createdAt: Date
9

10
  @UpdateDateColumn()
11
  updateat: Date
12
}
13

14
@Entity()
15
export class BookModel extends BaseModel {
16
  @Column()
17
  name: string
18
}
19

20
@Entity()
21
export class CarModel extends BaseModel {
22
  @Column()
23
  brand: string
24
}

1
@Module({
2
  imports: [
3
    TypeOrmModule.forFeature([UserModel]),
4
    TypeOrmModule.forRoot({
5
      // 데이터베이스 타입
6
      type: 'postgres',
7
      host: '127.0.0.1',
8
      port: 5808,
9
      username: 'postgres',
10
      password: 'postgres',
11
      database: 'typeormstudy',
12
      // entities폴더에 작성한 Model 가져오기
13
      entities: [
14
        UserModel,
15
        StudentModel, //
16
        TeacherModel,
17
        BookModel,
18
        CarModel,
19
      ],
20
      synchronize: true,
21
    }),
22
  ],
23
  controllers: [AppController],
24
  providers: [AppService],
25
})
26
export class AppModule {}

1
import {
2
  ChildEntity,
3
  Column,
4
  CreateDateColumn,
5
  Entity,
6
  PrimaryGeneratedColumn,
7
  TableInheritance,
8
  UpdateDateColumn,
9
} from 'typeorm'
10

11
export class BaseModel {
12
  @PrimaryGeneratedColumn()
13
  id: number
14

15
  @CreateDateColumn()
16
  createdAt: Date
17

18
  @UpdateDateColumn()
19
  updateat: Date
20
}
21

22
@Entity()
23
export class BookModel extends BaseModel {
24
  @Column()
25
  name: string
26
}
27

28
@Entity()
29
export class CarModel extends BaseModel {
30
  @Column()
31
  brand: string
32
}
33

34
@Entity()
35
@TableInheritance({
36
  column: {
37
    name: 'type',
38
    type: 'varchar',
39
  },
40
})
41
export class SingleBaseModel {
42
  @PrimaryGeneratedColumn()
43
  id: number
44

45
  @CreateDateColumn()
46
  createdAt: Date
47

48
  @UpdateDateColumn()
49
  updateat: Date
50
}
51

52
@ChildEntity()
53
export class ComputerModel extends SingleBaseModel {
54
  @Column()
55
  brand: string
56
}
57

58
@ChildEntity()
59
export class AirplaneModel extends SingleBaseModel {
60
  @Column()
61
  country: string
62
}

1
@Module({
2
  imports: [
3
    TypeOrmModule.forFeature([UserModel]),
4
    TypeOrmModule.forRoot({
5
      // 데이터베이스 타입
6
      type: 'postgres',
7
      host: '127.0.0.1',
8
      port: 5808,
9
      username: 'postgres',
10
      password: 'postgres',
11
      database: 'typeormstudy',
12
      // entities폴더에 작성한 Model 가져오기
13
      entities: [
14
        UserModel,
15
        StudentModel, //
16
        TeacherModel,
17
        BookModel,
18
        CarModel,
19
        SingleBaseModel,
20
        ComputerModel,
21
        AirplaneModel,
22
      ],
23
      synchronize: true,
24
    }),
25
  ],
26
  controllers: [AppController],
27
  providers: [AppService],
28
})
29
export class AppModule {}

1
@Entity()
2
export class Photo {
3
  @PrimaryGeneratedColumn()
4
  id: number
5

6
  @Column()
7
  url: string
8

9
  // 첫번째 파라미터 : 타입을 반환하는 함수
10
  // 두번째 파라미터 : 첫번째 파라미터에 입력한 클래스의 칼럼중 하나를 입력
11
  @ManyToOne(() => User, (user) => user.photos)
12
  user: User
13
}

1
@Entity()
2
export class User {
3
  @PrimaryGeneratedColumn()
4
  id: number
5

6
  @Column()
7
  name: string
8

9
  @OneToMany(() => Photo, (photo) => photo.user)
10
  photos: Photo[]
11
}

1
@Entity()
2
export class Profile {
3
  @PrimaryGeneratedColumn()
4
  id: number
5

6
  @Column()
7
  gender: string
8

9
  @Column()
10
  photos: string
11

12
  @OneToOne(() => User, (user) => user.profile)
13
  user: User
14
}

1
@Entity()
2
export class User {
3
  @PrimaryGeneratedColumn()
4
  id: number
5

6
  @Column()
7
  name: string
8

9
  @OneToOne(() => Profile)
10
  @JoinColumn()
11
  profile: Profile
12
}

1
@Entity()
2
export class Category {
3
  @PrimaryGeneratedColumn()
4
  id: number
5

6
  @Column()
7
  name: string
8

9
  @ManyToMany(() => Question)
10
  questions: Question[]
11
}

1
@Entity()
2
export class Question {
3
  @PrimaryGeneratedColumn()
4
  id: number
5

6
  @Column()
7
  title: string
8

9
  @Column()
10
  text: string
11

12
  @ManyToMany(() => Category)
13
  @JoinTable()
14
  categories: Category[]
15
}

1
import { Column, Entity, JoinColumn, OneToOne, PrimaryGeneratedColumn } from 'typeorm'
2
import { UserModel } from './user.entity'
3

4
@Entity()
5
export class ProfileModel {
6
  @PrimaryGeneratedColumn()
7
  id: number
8

9
  // UserModel에 user의 profile 컬럼과 1:1 연결
10
  @OneToOne(() => UserModel, (user) => user.profile)
11
  // 상대방 테이블의 id를 가지고 있기(만약 상대방이 갖고있으면 상대방이 이 테이블 id를 가짐)
12
  @JoinColumn()
13
  user: UserModel
14

15
  @Column()
16
  profileImg: string
17
}

1
// 생략
2
// ProfileModel에 profile의 user 컬럼과 1:1 연결
3
@OneToOne(() => ProfileModel, profile => profile.user)
4
profile: ProfileModel

1
@Module({
2
  imports: [
3
    // ProfileModel 추가
4
    TypeOrmModule.forFeature([UserModel, ProfileModel]),
5
    TypeOrmModule.forRoot({
6
      // 생략
7
      // entities폴더에 작성한 Model 가져오기
8
      entities: [
9
        // 생략
10
        ProfileModel,
11
      ],
12
      synchronize: true,
13
    }),
14
  ],
15
  controllers: [AppController],
16
  providers: [AppService],
17
})

1
// user.entity.ts
2
// title: string은 주석처리
3
@Column()
4
email: string

1
// 생략
2
@Controller()
3
export class AppController {
4
  constructor(
5
    @InjectRepository(UserModel)
6
    private readonly userRepository: Repository<UserModel>,
7
    @InjectRepository(ProfileModel)
8
    private readonly profileRepository: Repository<ProfileModel>
9
  ) {}
10

11
  @Post('users')
12
  postUser() {
13
    return this.userRepository.save({})
14
  }
15

16
  @Get('users')
17
  getUsers() {
18
    return this.userRepository.find({
19
      // 연동된 데이터 컬럼(profile)도 가져오기
20
      relations: {
21
        profile: true,
22
      },
23
    })
24
  }
25

26
  @Patch('users/:id')
27
  async patchUser(@Param('id') id: string) {
28
    const user = await this.userRepository.findOne({
29
      where: { id: parseInt(id) },
30
    })
31

32
    return this.userRepository.save({
33
      ...user,
34
    })
35
  }
36

37
  @Post('user/profile')
38
  async createUserAndProfile() {
39
    const user = await this.userRepository.save({
40
      email: 'asd@gmail.ai',
41
    })
42
    const profile = await this.profileRepository.save({
43
      profileImg: 'asdf.png',
44
      user,
45
    })
46
    return user
47
  }
48
}

1
import { Column, Entity, ManyToOne, PrimaryGeneratedColumn } from 'typeorm'
2
import { UserModel } from './user.entity'
3

4
@Entity()
5
export class PostModel {
6
  @PrimaryGeneratedColumn()
7
  id: number
8

9
  // 1:M 관계이니 posts로 복수형으로 선언
10
  @ManyToOne(() => UserModel, (user) => user.posts)
11
  author: UserModel
12

13
  @Column()
14
  title: string
15
}

1
// user.entity.ts 생략
2
@OneToMany(() => PostModel, post => post.author)
3
posts: PostModel[]

1
@Module({
2
  imports: [
3
    TypeOrmModule.forFeature([
4
      UserModel,
5
      ProfileModel,
6
      PostModel, // 추가
7
    ]),
8
    TypeOrmModule.forRoot({
9
      // 생략
10
      // entities폴더에 작성한 Model 가져오기
11
      entities: [
12
        // 생략
13
        PostModel,
14
      ],
15
      synchronize: true,
16
    }),
17
  ],
18
  controllers: [AppController],
19
  providers: [AppService],
20
})

1
// 생략
2

3
@Controller()
4
export class AppController {
5
  constructor(
6
    @InjectRepository(UserModel)
7
    private readonly userRepository: Repository<UserModel>,
8
    @InjectRepository(ProfileModel)
9
    private readonly profileRepository: Repository<ProfileModel>,
10
    @InjectRepository(PostModel)
11
    private readonly postRepository: Repository<PostModel>
12
  ) {}
13

14
  // 생략
15
  @Get('users')
16
  getUsers() {
17
    return this.userRepository.find({
18
      relations: {
19
        profile: true,
20
        posts: true, // 추가
21
      },
22
    })
23
  }
24

25
  @Post('user/post')
26
  async createUserAndPost() {
27
    const user = await this.userRepository.save({
28
      email: 'postuser@gmail.ai',
29
    })
30
    await this.postRepository.save({
31
      author: user,
32
      title: 'post 1',
33
    })
34
    await this.postRepository.save({
35
      author: user,
36
      title: 'post 2',
37
    })
38

39
    return user
40
  }
41
}

1
import { Column, Entity, ManyToMany, PrimaryGeneratedColumn } from 'typeorm'
2
import { PostModel } from './post.entity'
3

4
@Entity()
5
export class TagModel {
6
  @PrimaryGeneratedColumn()
7
  id: number
8

9
  // M:M 연결이기 때문에 둘 다 복수로 선언
10
  @ManyToMany(() => PostModel, (post) => post.tags)
11
  posts: PostModel[]
12

13
  @Column()
14
  name: string
15
}

1
import { Column, Entity, JoinTable, ManyToMany, ManyToOne, PrimaryGeneratedColumn } from 'typeorm'
2
import { UserModel } from './user.entity'
3
import { TagModel } from './tag.entity'
4

5
@Entity()
6
export class PostModel {
7
  @PrimaryGeneratedColumn()
8
  id: number
9

10
  // 1:M 관계이니 posts로 복수형으로 선언
11
  @ManyToOne(() => UserModel, (user) => user.posts)
12
  author: UserModel
13

14
  // M:M 연결이기 때문에 둘 다 복수로 선언
15
  @ManyToMany(() => TagModel, (tag) => tag.posts)
16
  // M:M 연결에서 JoinTable은 둘 중 하나 아무군데 선언해주면 된다
17
  @JoinTable()
18
  tags: TagModel[]
19

20
  @Column()
21
  title: string
22
}

1
// 생략
2
@Module({
3
  imports: [
4
    TypeOrmModule.forFeature([
5
      UserModel,
6
      ProfileModel, //
7
      PostModel,
8
      TagModel,
9
    ]),
10
    TypeOrmModule.forRoot({
11
      // 생략
12
      // entities폴더에 작성한 Model 가져오기
13
      entities: [
14
        // 생략
15
        TagModel,
16
      ],
17
      synchronize: true,
18
    }),
19
  ],
20
  controllers: [AppController],
21
  providers: [AppService],
22
})
23
export class AppModule {}

1
// 생략
2
@Controller()
3
export class AppController {
4
  constructor(
5
    @InjectRepository(UserModel)
6
    private readonly userRepository: Repository<UserModel>,
7
    @InjectRepository(ProfileModel)
8
    private readonly profileRepository: Repository<ProfileModel>,
9
    @InjectRepository(PostModel)
10
    private readonly postRepository: Repository<PostModel>,
11
    @InjectRepository(TagModel)
12
    private readonly tagRepository: Repository<TagModel>
13
  ) {}
14

15
  // 생략
16

17
  @Post('posts/tags')
18
  async createPostsTags() {
19
    const post1 = await this.postRepository.save({
20
      title: 'NestJS 수업',
21
    })
22

23
    const post2 = await this.postRepository.save({
24
      title: '프로그래밍 수업',
25
    })
26

27
    const tag1 = await this.tagRepository.save({
28
      name: 'Javascript',
29
      posts: [post1, post2],
30
    })
31

32
    const tag2 = await this.tagRepository.save({
33
      name: 'Typescript',
34
      posts: [post1],
35
    })
36

37
    const post3 = await this.postRepository.save({
38
      title: 'NextJS 수업',
39
      tags: [tag1, tag2],
40
    })
41

42
    return true
43
  }
44

45
  @Get('posts')
46
  getPosts() {
47
    return this.postRepository.find({
48
      relations: {
49
        tags: true,
50
      },
51
    })
52
  }
53

54
  @Get('tags')
55
  getTags() {
56
    return this.tagRepository.find({
57
      relations: {
58
        posts: true,
59
      },
60
    })
61
  }
62
}

1
// ProfileModel에 profile의 user 컬럼과 1:1 연결
2
@OneToOne(() => ProfileModel, profile => profile.user, {
3
  // find() 실행할 때마다 항상 같이 가져올 relation 설정(기본값 false)
4
  eager: true,
5
  // 저장할 떄, relation을 한 번에 같이 저장(기본값 false)
6
  cascade: true,
7
  // null이 가능한지 여부(기본값 true)
8
  nullable: true,
9
  // 관계를 삭제했을 떄, 어떻게 삭제할 것인지
10
  // - NO ACTION : 아무것도 안함
11
  // - CASCADE : 참조하는 row도 같이 삭제
12
  // - SET NULL : 참조하는 row에서 참조 id를 null로 변경
13
  // - set default : 기본 세팅으로 설정(테이블의 기본 세팅)
14
  // - RESTRICT : 참조하고 있는 row가 있는 경우 참조당하는 row 삭제 불가
15
  onDelete: 'NO ACTION',
16
})
17
profile: ProfileModel

1
@Delete('user/profile/:id')
2
async deleteProfile(@Param('id') id: string) {
3
  await this.profileRepository.delete(+id)
4
}

1
@Get('users')
2
getUsers() {
3
  return this.userRepository.find({
4
    // 어떤 속성을 선택할지 (기본은 모든 속성을 가져옴)
5
    // select를 정의하면, 정의한 속성만 가져온다
6
    select: {
7
      id: true,
8
      email: true,
9
      version: true,
10
      profile: {
11
        id: true,
12
      },
13
    },
14
    // 필터링할 조건을 입력한다 ({}안에서는 전부 and 조건으로 필터링)
15
    where: [
16
      // id가 3이거나 or version이 1
17
      {
18
        id: 3,
19
      },
20
      {
21
        version: 1,
22
      },
23
    ],
24
    // ------ 다른 관계를 필터링하는 법
25
    // where: {
26
    //   profile: {
27
    //     id: 3,
28
    //   },
29
    // },
30
    // 관계를 가져오는 법
31
    relations: {
32
      profile: true,
33
    },
34
    // 오름차(ASC)-기본, 내림차(DESC)
35
    order: {
36
      id: 'DESC',
37
    },
38
    // 처음 몇 개를 제외할 지 (기본은 0) 1이면 1개 스킵
39
    skip: 0,
40
    // 몇 개를 가져올지 (기본값은 0, 전체) 1이면 1개만 가져옴
41
    take: 0,
42
  })
43
}

1
@Post('users')
2
async postUser() {
3
  for (let i = 0; i < 100; i++) {
4
    await this.userRepository.save({
5
      email: `user-${i}@google.com`,
6
    })
7
  }
8
}
9

10
@Get('users')
11
getUsers() {
12
  return this.userRepository.find({
13
    where: {
14
      // 📌 (1) 1이 아닌 경우 가져오기
15
      id: Not(1),
16

17
      // 📌 (2) 30 미만의 적은 경우 가져오기
18
      id: LessThan(30),
19

20
      // 📌 (3) 30 이하의 적은 경우 가져오기
21
      id: LessThanOrEqual(30),
22

23
      // 📌 (4) 30 초과의 많은 경우 가져오기
24
      id: MoreThan(30)
25

26
      // 📌 (5) 30 이상의 많은 경우 가져오기
27
      id: MoreThanOrEqual(30)
28

29
      // 📌 (6) 같은 경우 가져오기
30
      id: Equal(30)
31

32
      // 📌 (7) 유사값, %로 유사한 문자 찾기 (대소문자 구분함)
33
      email: Like('%0@google%'),
34

35
      // 📌 (8) 유사값, %로 유사한 문자 찾기 (대소문자 구분안함)
36
      email: ILike('%GOOGLE%'),
37

38
      // 📌 (9) 사이값, 10~15번 사이까지의 값
39
      id: Between(10, 15),
40

41
      // 📌 (10) 해당되는 여러 개의 값, 1, 3, 5, 7, 99의 id 찾기
42
      id: In([1, 3, 5, 7, 99]),
43

44
      // 📌 (11) ID가 null인 경우 찾기
45
      id: IsNull(),
46
    },
47
    // 주석 생략
48
  })
49
}

1
const userRepository = dataSources.getRepository(User)
2
const user = await userRepository.findOne({ id: 1 })
3
user.name = '뭐시기'
4
await userRepository.save(user)

1
// const user = new User();
2
const user = repository.create()
3
const user = repository.create({
4
  id: 1,
5
  firstName: 'Timber',
6
  lastName: 'Saw',
7
})

1
await repository.save(user)
2
await repository.save([category1, category2, category3])

1
await repository.upsert(
2
  [
3
    { externalId: 'abc123', firstName: 'Timber' },
4
    { externalId: 'bca321', firstName: 'Saw' },
5
  ],
6
  ['externalId']
7
)
8
/** executes
9
 * INSERT INTO user
10
 * VALUES
11
 *  (externalId: "abc123", firstName: 'Timber'),
12
 *  (externalId: "bca321", firstName: 'Saw')
13
 * ON CONFLICT (externalId) DO UPDATE firstName = EXCLUDED.firstName
14
 */

1
await repository.delete(1)
2
await repository.delete([1, 2, 3])
3
await repository.delete({ firstName: 'Timber' })

1
await repository.softDelete(1) // 삭제
2
await repository.restore(1) // 복구

1
// UPDATE user
2
// SET category = ADULT
3
// WHERE age = 18
4
await repository.update({ age: 18 }, { category: 'ADULT' })
5

6
// UPDATE user
7
// SET firstName = 뭐시기
8
// WHERE id = 1
9
await repository.update(1, { firstName: '뭐시기' })

1
const rows = await repository.find({
2
  where: { firstName: 'Timber' },
3
})
4
const rows = await repository.findOne({
5
  where: { firstName: 'Timber' },
6
})
7
const rows = await repository.findAndCount({
8
  where: { firstName: 'Timber' },
9
})

1
export interface FindOneOptions<Entity = any> {
2
  select?: FindOneOptionsSelect<Entity> // 불러올 Column을 지정
3
  where?: FindOptionsWhere<Entity>[] // 필터링할 조건을 설정
4
  relations?: FindOptionsRelations<Entity> // 불러올 관계 테이블을 지정
5
  order?: FindOneOptionsOrder<Entity> // 정렬을 지정
6
  cache?: boolean | number // 캐싱 기간을 지정
7
}
8

9
export interface FindManyOptions<Entity = any> extends FindOneOptions<Entity> {
10
  skip?: number
11
  take?: number
12
}

1
// 기본 사용법
2
const users = await userRepository.find({
3
  where: { isActive: true },
4
})
5

6
// 다중조건 사용법
7
const users = await userRepository.find({
8
  where: [
9
    { firstName: 'John', lastName: 'Doe' },
10
    { firstName: 'Jane', lastName: 'Smith' },
11
  ],
12
})
13

14
// 중첩 사용법
15
const users = await userRepository.find({
16
  where: [
17
    isActive: true,
18
    profile : { age: MoreThan(25) },
19
  ],
20
})

1
//  단일 정렬 사용법
2
const users = await userRrepository.find({
3
  order: { firstName: 'ASC' },
4
})
5

6
// 복수 정렬 사용법
7
const users = await userRrepository.find({
8
  order: { lastName: 'ASC', firstName: 'DESC' },
9
})

1
const users = await userRepository.find({
2
  relations: ['profile', 'photos'],
3
})

1
const users = await userRepository.find({
2
  select: ['firstName', 'lastName'],
3
})

1
// 기본 사용법
2
const users = await userRepository.find({
3
  cache: true,
4
})
5

6
// 기간 직접 정의
7
const users = await userRepository.find({
8
  cache: 60000, // 60초
9
})

1
const users = await userRepository.find({
2
  skip: 10, // 처음 10개를 제외하고 가져온다
3
  take: 5, // 처음 5개만 가져온다
4
})

1
// Equal : 같은 값을 찾을때 사용
2
const users = await userRepository.find({
3
  where: { age: Equal(25) },
4
})

1
// Not : 아닌 값을 찾을때 사용
2
const users = await userRepository.find({
3
  where: { age: Not(25) },
4
})

1
// 적은값 & 적거나 같은 값을 찾을때 사용
2
const users = await userRepository.find({
3
  where: { age: LessThan(30) },
4
})
5
const users = await userRepository.find({
6
  where: { age: LessThanOrEqual(30) },
7
})

1
// 더 큰값 & 크거나 같은 값을 찾을때 사용
2
const users = await userRepository.find({
3
  where: { age: MoreThan(20) },
4
})
5
const users = await userRepository.find({
6
  where: { age: MoreThanOrEqual(20) },
7
})

1
// 사이 값을 찾을때 사용
2
const users = await userRepository.find({
3
  where: { age: Between(20, 30) },
4
})

1
// 스트링에 매칭되는 값을 찾을때 사용한다. Like는 대소문자 구분할때, ILike는 대소문자 구분하지 않을때 사용
2
const users = await userRepository.find({
3
  where: { firstName: Like('Co%') },
4
})
5
const users = await userRepository.find({
6
  where: { firstName: ILike('co%') },
7
})

1
// 리스트에 매칭되는 값을 찾는다
2
const users = await userRepository.find({
3
  where: { age: In([20, 25, 30]) },
4
})

1
// ArrayContains : 엔티티 리스트 값이 타겟 리스트와 완전 똑같은 경우를 필터링
2
const users = await userRepository.find({
3
  where: { roles: ArrayContains(['admin']) },
4
})
5

6
// ArrayContainedBy : 엔티티 리스트 값이 타겟 리스트 안에 모두 포함되는 경우를 필터링
7
const users = await userRepository.find({
8
  where: { roles: ArrayContainedBy(['admin', 'user']) },
9
})
10

11
// ArrayOverlap : 엔티티 리스트 값이 하나라도 타겟 리스트와 겹치는 경우를 필터링
12
const users = await userRepository.find({
13
  where: { roles: ArrayOverlap(['admin', 'guest']) },
14
})

1
// Record 1
2
{
3
  id: 1,
4
  tags: ['admin', 'user', 'manager'],
5
}
6
// Record 2
7
{
8
  id: 2,
9
  roles: ['user', 'guest'],
10
}

1
const users = await getRepository(User).find({
2
  // Record 2의 Tags가 완전히 같으니 Record 2만 반환
3
  tags: ArrayContains(['user', 'guest']),
4
})

1
// Record 1
2
{
3
  id: 1,
4
  tags: ['admin', 'user', 'manager'],
5
}
6
// Record 2
7
{
8
  id: 2,
9
  roles: ['user', 'guest'],
10
}

1
const users = await getRepository(User).find({
2
  // Record 1과 Record 2의 Tags들이 모두 필터 리스트에 포함되기 때문에 둘 다 반환
3
  tags: ArrayContainedBy(['admin', 'user', 'guest', 'manager']),
4
})

1
// Record 1
2
{
3
  id: 1,
4
  tags: ['admin', 'user', 'manager'],
5
}
6
// Record 2
7
{
8
  id: 2,
9
  roles: ['user', 'guest'],
10
}

1
const users = await getRepository(User).find({
2
  // Record 1의 Tags와 Record 2의 Tags가 모두 필터 리스트와 겹치는 부분이 있기 때문에 둘 다 반환
3
  tags: ArrayOverlap(['guest', 'admin']),
4
})

1
const users = await userRepository.find({
2
  where: { age: IsNull() }, // age가 null인 경우
3
})

1
const loadedPosts = await dataSource.getRepository(Post).findBy({
2
  // 2개의 조건 중 하나라도 만족하면 반환
3
  title: Or(Equal('About #2'), ILike('About%')),
4
})

1
const loadedPosts = await dataSource.getRepository(Post).findBy({
2
  // 2개의 조건 모두 만족하면 반환
3
  title: And(Not(Equal('About #2'), ILike('About%'))),
4
})

1
const users = await userRepository.find({
2
  where: [
3
    { isActive: true, age: MoreThan(25) },
4
    { firstName: 'John', age: LessThan(50) },
5
  ],
6
  order: { fistName: 'ASC' },
7
  relations: ['profile'],
8
  select: ['firstName', 'lastName'],
9
  skip: 0,
10
  take: 10,
11
  cache: true,
12
  loadRelationIds: true,
13
  loadEagerRelations: false,
14
  withDeleted: false,
15
})

1
const exists = await repository.exists({
2
  where: {
3
    firstName: 'Timber',
4
  },
5
})

1
const partiaIUser = {
2
  id: 1,
3
  firstName: 'Timber',
4
  profile: { id: 1 },
5
}
6
const user = await repository.preload(partiaIUser)

1
// firstName이 Timber인 값들의 개수
2
const count = await repository.count({
3
  where: { firstName: 'Timber' },
4
})
5
// age 컬럼의 firstName이 Timber인 값들의 합계
6
const sum = await repository.sum('age', {
7
  firstName: 'Timber',
8
})
9
// age 컬럼의 firstName이 Timber인 값들의 평균값
10
const average = await repository.average('age', {
11
  firstName: 'Timber',
12
})
13
// age 컬럼의 firstName이 Timber인 값들의 최소값
14
const minimum = await repository.minimum('age', {
15
  firstName: 'Timber',
16
})
17
// age 컬럼의 firstName이 Timber인 값들의 최대값
18
const maximum = await repository.maximum('age', {
19
  firstName: 'Timber',
20
})

1
@Column({ default: 0 })
2
count: number

1
 @Post('sample')
2
async sample() {
3
  // 📌 (1) 모델에 해당되는 객체 생성 - 저장은 안함
4
  const user1 = await this.userRepository.create({
5
    email: 'test@gmail.ai',
6
  })
7

8
  // 📌 (2) 모델에 해당되는 객체 생성 - DB에 저장함
9
  const user2 = await this.userRepository.save({
10
    email: 'test@gmail.ai',
11
  })
12

13
  /*** 📌 (3) preload
14
   * 입력된 값을 기반으로 DB에 데이터를 불러오고,
15
   * 추가입력된 값으로 DB에 가져온 값들을 대체함
16
   * 저장하지는 않음
17
   */
18
  const user3 = await this.userRepository.preload({
19
    id: 101,
20
    email: 'test변경-저장x@gmail.ai',
21
  })
22

23
  // 📌 (4) 삭제하기
24
  await this.userRepository.delete(101)
25

26
  // 📌 (5) 숫자형 컬럼 증가 (id가 1인 count 컬럼을 2만큼 증가)
27
  await this.userRepository.increment(
28
    { id: 1 }, //
29
    'count',
30
    2,
31
  )
32

33
  // 📌 (6) 숫자형 컬럼 감소 (id가 1인 count 컬럼을 1만큼 감소)
34
  await this.userRepository.decrement(
35
    { id: 1 }, //
36
    'count',
37
    1,
38
  )
39

40
  // 📌 (7) 개수 카운팅하기
41
  const count = await this.userRepository.count({
42
    where: {
43
      email: ILike('%0%'),
44
    },
45
  })
46

47
  // 📌 (8) sum : 속성들의 값 전부 합치기
48
  const sum = await this.userRepository.sum('count', {
49
    email: ILike('%0%'),
50
  })
51

52
  // 📌 (9) average : 속성의 평균값 구하기
53
  const average = await this.userRepository.average('count', {
54
    id: LessThan(4),
55
  })
56

57
  // 📌 (10) min : 속성의 최소값 구하기
58
  const min = await this.userRepository.minimum('count', {
59
    id: LessThan(4),
60
  })
61

62
  // 📌 (10) max : 속성의 최대값 구하기
63
  const max = await this.userRepository.maximum('count', {
64
    id: LessThan(4),
65
  })
66

67
  // 📌 (11) find와 findOne도 있음(많이 다뤘으니 생략)
68
  const userOne = await this.userRepository.findOne({
69
    where: { id: 3 },
70
  })
71

72
  // 📌 (12) 3개의 값을 가져오는데, 전체 행 개수도 반환해줌
73
  const usersAndCount = await this.userRepository.findAndCount({
74
    take: 3,
75
  })
76

77
  return usersAndCount
78
}