ORM 사용

nest new my-nestjs-typeorm-app
cd my-nestjs-typeorm-app

npm install @nestjs/typeorm typeorm pg
npm install --save-dev @types/pg

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { User } from './user/entities/user.entity'; // User 엔티티 임포트 예정

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'postgres', // 사용하는 데이터베이스 타입 (mysql, sqlite, mongodb 등)
      host: 'localhost',
      port: 5432,
      username: 'your_username', // 실제 DB 사용자 이름
      password: 'your_password', // 실제 DB 비밀번호
      database: 'your_database_name', // 사용할 데이터베이스 이름
      entities: [User], // 애플리케이션에서 사용할 엔티티 클래스 배열
      synchronize: true, // 개발 환경에서만 true: 애플리케이션 시작 시 DB 스키마 자동 동기화
      logging: true, // SQL 쿼리 로깅
    }),
    // TypeOrmModule.forFeature([User]), // 각 모듈에서 사용할 엔티티를 등록 (아래 user 모듈에서 등록)
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';

@Entity() // 이 클래스가 데이터베이스 테이블과 매핑되는 엔티티임을 선언
export class User {
  @PrimaryGeneratedColumn() // 기본 키(Primary Key)로 자동 생성되는 숫자 ID
  id!: number; // !는 definite assignment assertion (타입스크립트가 초기화될 것임을 확신)

  @Column({ type: 'varchar', length: 100, unique: true }) // 문자열 컬럼, 최대 길이 100, 유니크 제약조건
  email!: string;

  @Column({ type: 'varchar', length: 50 })
  name!: string;

  @Column({ type: 'int', nullable: true }) // 선택적(nullable) 숫자 컬럼
  age?: number;

  @Column({ type: 'timestamp', default: () => 'CURRENT_TIMESTAMP' }) // 생성 시간 자동 기록
  createdAt!: Date;
}

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { User } from './entities/user.entity';
import { CreateUserDto } from './dto/create-user.dto'; // DTO 정의 예정

@Injectable()
export class UserService {
  constructor(
    // User 엔티티에 대한 Repository를 주입받습니다.
    @InjectRepository(User)
    private usersRepository: Repository<User>,
  ) {}

  async create(createUserDto: CreateUserDto): Promise<User> {
    const newUser = this.usersRepository.create(createUserDto); // 엔티티 인스턴스 생성
    return this.usersRepository.save(newUser); // 데이터베이스에 저장 (INSERT)
  }

  async findAll(): Promise<User[]> {
    return this.usersRepository.find(); // 모든 사용자 조회 (SELECT *)
  }

  async findOne(id: number): Promise<User | null> {
    // findOneBy 또는 findOne({ where: { id }})
    return this.usersRepository.findOneBy({ id }); // 특정 ID의 사용자 조회
  }

  async update(id: number, updateUserDto: Partial<User>): Promise<User | null> {
    const user = await this.usersRepository.findOneBy({ id });
    if (!user) {
      return null;
    }
    // Object.assign(user, updateUserDto); // 객체 병합
    this.usersRepository.merge(user, updateUserDto); // TypeORM의 merge 사용
    return this.usersRepository.save(user); // 업데이트 (UPDATE)
  }

  async remove(id: number): Promise<void> {
    await this.usersRepository.delete(id); // 삭제 (DELETE)
  }
}

import { IsEmail, IsString, IsInt, Min, Max, IsOptional } from 'class-validator';

export class CreateUserDto {
  @IsString()
  name!: string;

  @IsEmail()
  email!: string;

  @IsOptional() // 선택적 필드
  @IsInt()
  @Min(0)
  @Max(120)
  age?: number;
}

nest g module user
nest g service user
nest g controller user

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { UserService } from './user.service';
import { UserController } from './user.controller';
import { User } from './entities/user.entity';

@Module({
  imports: [TypeOrmModule.forFeature([User])], // 이 모듈에서 User 엔티티를 사용할 수 있도록 등록
  controllers: [UserController],
  providers: [UserService],
  exports: [UserService], // 다른 모듈에서 UserService를 사용하려면 exports에 추가
})
export class UserModule {}

// src/user/user.controller.ts
import { Controller, Get, Post, Body, Param, Put, Delete, HttpCode, HttpStatus } from '@nestjs/common';
import { UserService } from './user.service';
import { CreateUserDto } from './dto/create-user.dto';
import { User } from './entities/user.entity';

@Controller('users')
export class UserController {
  constructor(private readonly userService: UserService) {}

  @Post()
  @HttpCode(HttpStatus.CREATED) // 201 Created 응답
  async create(@Body() createUserDto: CreateUserDto): Promise<User> {
    return this.userService.create(createUserDto);
  }

  @Get()
  async findAll(): Promise<User[]> {
    return this.userService.findAll();
  }

  @Get(':id')
  async findOne(@Param('id') id: string): Promise<User | null> {
    return this.userService.findOne(+id); // '+' 연산자로 string을 number로 변환
  }

  @Put(':id')
  async update(@Param('id') id: string, @Body() updateUserDto: Partial<User>): Promise<User | null> {
    return this.userService.update(+id, updateUserDto);
  }

  @Delete(':id')
  @HttpCode(HttpStatus.NO_CONTENT) // 204 No Content 응답
  async remove(@Param('id') id: string): Promise<void> {
    await this.userService.remove(+id);
  }
}

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { User } from './user/entities/user.entity';
import { UserModule } from './user/user.module'; // UserModule 임포트

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'postgres',
      host: 'localhost',
      port: 5432,
      username: 'your_username',
      password: 'your_password',
      database: 'your_database_name',
      entities: [User], // 엔티티 배열에 User 엔티티 포함
      synchronize: true,
      logging: true,
    }),
    UserModule, // UserModule 등록
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}