반응형

이전 post 에서 Multiple database connection 설정 방법에 대해서 알아보았습니다.

@InjectRepository에서 아래와 같이 connection을 명시적으로 작성을 해주었습니다.

@InjectRepository(Slider, 'sliderConnection')
private sliderRepository: Repository<Slider>

 

그런데 @InjectDataSource()를 사용시에는 database schema를 찾지 못하는 문제가 발생합니다.

@InjectDataSource()
private dataSource: DataSource

 

이럴 경우에는 @Entity에 스키마 정보를 명시적으로 작성해주면 됩니다.

@Entity({ name: 'slider', database: 'slider' })

 

database 에 작성된 slider는 shema name입니다.

반응형
반응형

https://youtu.be/k7UtpY7uqDE

 

 

Application을 개발시 여러개의 DB에 접속하여 데이터를 핸들링 해야 하는 경우가 있습니다.
Nestjs에서는 TypeORM의 Multiple Connection을 이용하여 이러한 구현이 가능합니다.

예제에서는 다음과 같이 두개의 database를 사용합니다.

  • Database #1 : cat
  • Database #2 : slider

Table 정보

사용하는 테이블 생성 정보는 다음과 같습니다.

cat

CREATE TABLE `cat` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) NOT NULL COMMENT '고양이 이름',
  `age` int(11) NOT NULL COMMENT '고양이 나이',
  `breed` varchar(255) NOT NULL COMMENT '고양이 종류',
  PRIMARY KEY (`id`)
);

slider

CREATE TABLE `slider` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `image_url` varchar(200) NOT NULL,
  `created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
  `updated_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
  PRIMARY KEY (`id`)
);

 

프로젝트 생성

아래와 같이 프로젝트를 생성합니다.

nest new multi-connection

 

폴더로 이동 후 Visual Studio Code를 실행합니다.

cd multi-connection
code .

패키지 설치

아래와 같이 TypeORM 패키지를 설치합니다.

yarn add @nestjs/typeorm typeorm mysql2

 

첫번째 database 연결하기

ORM 설정파일

프로젝트에 orm 환경 설정 파일을 만듭니다.

  • 소스 폴더 : src/config/orm.config.ts
import { TypeOrmModuleOptions } from "@nestjs/typeorm";

function ormConfig(): TypeOrmModuleOptions {
    return {
        name: 'default',
        type: 'mysql',
        database: 'cat',
        host: 'localhost',
        port: Number(13306),
        username: 'cat',
        password: 'cat',
        logging: (process.env.NODE_ENV === 'local'),
        synchronize: true,
        entities: [__dirname + '/domain/*.entity.{ts,js}'],
        migrations: [__dirname + '/migrations/**/*.{ts,js}'],
        migrationsRun: false,
    };
}
function ormConfigSlider(): TypeOrmModuleOptions {
    return {
        name: 'sliderConnection',
        type: 'mysql',
        database: 'slider',
        host: 'localhost',
        port: Number(13306),
        username: 'slider',
        password: 'slider',
        logging: (process.env.NODE_ENV === 'local'),
        synchronize: true,
        entities: [__dirname + '/domain/*.entity.{ts,js}'],
        migrations: [__dirname + '/migrations/**/*.{ts,js}'],
        migrationsRun: true,
    };
}
export { ormConfig, ormConfigSlider };

 

orm config import 하기

app.module.ts 에 orm config를 import 합니다.

import { ormConfig } from './config/orm.config';

imports: [
    TypeOrmModule.forRootAsync({
      useFactory: ormConfig
    }),
    TypeOrmModule.forRootAsync({
      name: 'sliderConnection',
      useFactory: ormConfigSlider
    })
  ],

 

Entity 생성

typeorm-model-generator를 사용해서 테이블에 있는 cat, slider entity를 생성합니다.

사용법은 아래 포스트에서 확인하실 수 있습니다.
https://codegear.tistory.com/122

 

typeorm-model-generator 사용법

TypeORM 사용시 Entity 파일을 자동으로 생성해주는 tool이 있습니다.바로 typeorm-model-generator 입니다.이 tool을 사용하면 테이블을 참조하여 손쉽게 entity 파일을 만들 수 있습니다. typeorm-model-generator에

codegear.tistory.com

typeorm-model-generator -h localhost -d cat -p 13306 -u cat -x cat -e mysql -o ./gen_models
typeorm-model-generator -h localhost -d slider -p 13306 -u slider -x slider -e mysql -o ./gen_models

gen_models 폴더에 생성된 entity 파일을 domain 폴더로 복사합니다.

파일 이름을 아래와 같이 변경합니다.(ormConfig에서 설정한 파일명 형식)

Cat.ts -> Cat.entity.ts
Slider.ts -> Slider.entity.ts

Module에 Entity 선언하기

app.module.ts의 import 아래에 다음을 추가합니다.

(TypeOrmModule.forRootAsync 아래에 추가하면 됩니다)

TypeOrmModule.forFeature([Cat]),
TypeOrmModule.forFeature([Slider], 'sliderConnection')

Cat & Slider 데이터 조회하기

app.controller.ts에 다음을 추가합니다.

@Get('/cats')
async getCats(){
  return await this.appService.getCats();
}

@Get('/sliders')
async getSliders(){
  return await this.appService.getSliders();
}

app.service.ts에 다음을 추가합니다. (getCats, getSliders)

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Cat } from './domain/Cat.entity';
import { Slider } from './domain/Slider.entity';

@Injectable()
export class AppService {
  constructor(
    @InjectRepository(Cat)
    private catRepository: Repository<Cat>,
    @InjectRepository(Slider, 'sliderConnection')
    private sliderRepository: Repository<Slider>
  ){}
  
  getHello(): string {
    return 'Hello World!';
  }
  async getCats() {
    return await this.catRepository.find(); 
  }
  async getSliders() {
    return await this.sliderRepository.find();
  }
}

 

브라우저에서 다음을 각각 호출합니다.

http://localhost:3000/cats
http://localhost:3000/sliders

결과는 다음과 같습니다.

[
   {
      "id":1,
      "name":"kitty",
      "age":1,
      "breed":"cyprus"
   },
   {
      "id":2,
      "name":"pitty",
      "age":2,
      "breed":"percian"
   }
]
[
   {
      "id":1,
      "imageUrl":"https://..../images/test.jpg",
      "createdAt":"2024-08-19T14:08:20.000Z",
      "updatedAt":"2024-08-19T14:08:20.000Z"
   }
]

 

이상으로 Nestjs에서 TypeORM을 사용해서 여러개의 DB를 사용하는 방법에 대해 알아보았습니다.

반응형
반응형

https://youtu.be/KwqP314OpxQ

 

 

TypeORM 사용시 Entity 파일을 자동으로 생성해주는 tool이 있습니다.
바로 typeorm-model-generator 입니다.

이 tool을 사용하면 테이블을 참조하여 손쉽게 entity 파일을 만들 수 있습니다.

 

typeorm-model-generator에 대한 자세한 설명은 아래 링크에서 확인하실 수 있습니다.

https://www.npmjs.com/package/typeorm-model-generator

 

typeorm-model-generator

Generates models for TypeORM from existing databases.. Latest version: 0.4.6, last published: 3 years ago. Start using typeorm-model-generator in your project by running `npm i typeorm-model-generator`. There are 5 other projects in the npm registry using

www.npmjs.com

 

typeorm-model-generator는 아래와 같이 여러 db engine을 지원합니다.

  • Microsoft SQL Server
  • PostgreSQL
  • MySQL
  • MariaDB
  • Oracle Database
  • SQLite

 

우선 typeorm-model-generator를 설치합니다.

npm i -g typeorm-model-generator

 

사용법은 다음과 같습니다.

Usage: typeorm-model-generator -h <host> -d <database> -p [port] -u <user> -x
[password] -e [engine]

Options:
  --help                 Show help                                     [boolean]
  --version              Show version number                           [boolean]
  -h, --host             IP address/Hostname for database server
                                                          [default: "127.0.0.1"]
  -d, --database         Database name(or path for sqlite)            [required]
  -u, --user             Username for database server
  -x, --pass             Password for database server              [default: ""]
  -p, --port             Port number for database server
  -e, --engine           Database engine
          [choices: "mssql", "postgres", "mysql", "mariadb", "oracle", "sqlite"]
                                                              [default: "mssql"]
  -o, --output           Where to place generated models
                            [default: "./output"]
  -s, --schema           Schema name to create model from. Only for mssql
                         and postgres. You can pass multiple values
                         separated by comma eg. -s scheme1,scheme2,scheme3
  --ssl                                               [boolean] [default: false]

 

예를 들면 다음과 같습니다.

typeorm-model-generator -h localhost -d test -p 3306 -u root -x root -e mysql -o ./generated_models

 

옵션 사용법은 다음과 같습니다.

  • -h : 테이터베이스 호스트 IP (localhost)
  • -d : 데이터베이스 이름 (test)
  • -p : 데이터베이스 포트 (3306)
  • -u : 데이터베이스 username (root)
  • -x : 데이터베이스 password (root)
  • -e : 데이터베이스 engine (mysql)
  • 마지막은 파일 생성위치입니다(./generated_models)

실행하면 아래와 같이 entity 파일이 생성 됩니다.

  • 폴더 : generated_models/entities/Cat.ts
import { Column, Entity, PrimaryGeneratedColumn } from "typeorm";

@Entity("cat", { schema: "test" })
export class Cat {
  @PrimaryGeneratedColumn({ type: "int", name: "id" })
  id: number;

  @Column("varchar", { name: "name", comment: "고양이 이름", length: 255 })
  name: string;

  @Column("int", { name: "age", comment: "고양이 나이" })
  age: number;

  @Column("varchar", { name: "breed", comment: "고양이 종류", length: 255 })
  breed: string;
}

 

typeorm-model-generator를 사용해 좀 더 빠르고 편한 개발 생활 되시길 바랍니다. 

반응형
반응형

Repository는 Entity에 대한 CRUD를 추상화한 객체입니다.

여기서 추상화라고 하면,
사용이 복잡한 것들을 핵심적인 기능만 간추려서 사용하기 쉽게 만든 것을 의미합니다.

 

예를 들면,

고양이의 정보를 Database에 저장하기 위해서는 다음과 같은 SQL을 사용합니다.

insert into cat(name, age, breed)
values('꼼지', 5, '스코티시폴드');

 

이것을 Repository 패턴으로 표현하면 다음과 같습니다.

const cat = new CreateCatDto();
cat.name = '꼼지';
cat.age = 5;
cat.breed = '스코티시폴더';
catRepository.save(cat);

SQL을 잘 아는 사람 입장에서는 쿼리를 사용하는 것이 훨씬 가독성이 좋습니다.

하지만 SQL을 잘 모르는 사람도 코딩 방법만 알면 쉽게 Database 핸들링이 가능해집니다.

 

Repository 패턴을 보시면 쿼리를 객체로 만들어서 사용하고 있는 것을 알 수 있습니다.

이렇듯 Repository 패턴은 좀 더 프로그래밍에 가깝게 쿼리를 사용할 수 있게 만든 것입니다.

 

쿼리를 잘 모르거나 간단한 쿼리를 사용하고자 할 경우에는 정말 쉽게 사용을 할 수 있습니다.

 

반응형
반응형

이 글은 TypeORM의 기본적인 사용법에 대해 설명합니다.

다음은 이 글을 설명한 유튜브 영상입니다.

https://youtu.be/IfcnR7TtbCw

목차

  • table 생성
  • 소스 생성
  • 사용법

테이블 생성

다음과 같이 cats table을 생성합니다.

create table cat
(
    id    int auto_increment
        primary key,
    name  varchar(255) not null comment '고양이 이름',
    age   int          not null comment '고양이 나이',
    breed varchar(255) not null comment '고양이 종류'
);

소스 생성

  • Nestjs의 Generator(소스 자동 생성)를 사용하여 cats module을 생성합니다.
nest g resource cats
  • resource 옵션은 module, controller, service, entities, dto를 한 번에 자동으로 생성합니다.

Entity 객체 생성

  • domain/cats.entity.ts
import { Column, Entity, PrimaryGeneratedColumn } from "typeorm";

@Entity()
export class Cat {
    @PrimaryGeneratedColumn()
    id: number;

    @Column()
    name: string;

    @Column()
    age: number;

    @Column()
    breed: string;
}

DTO 수정

  • cats/dto/create-cat.dto.ts 를 다음과 같이 만듭니다.
export class CreateCatDto {
    name: string;
    age: number;
    breed: string;
}

모듈에 Entity 임포트

  • cats/cats.module.ts에 cats.entity를 임포트 해주어야 사용할 수 있습니다.
import { Module } from '@nestjs/common';
import { CatsService } from './cats.service';
import { CatsController } from './cats.controller';
import { TypeOrmModule } from '@nestjs/typeorm';
import { Cat } from 'src/domain/cat.entity';

@Module({
  imports: [TypeOrmModule.forFeature([Cat])],
  controllers: [CatsController],
  providers: [CatsService]
})
export class CatsModule {}

서비스에서 Repository 사용하기

cats service에서 constructor에 repository를 주입합니다.

  • cats/cats.service.ts
constructor(
  @InjectRepository(Cat)
  private catRepository: Repository<Cat>
){}
  • cats/cats.service.ts를 다음과 같이 수정합니다.
async create(createCatDto: CreateCatDto) {
  return await this.catRepository.save(createCatDto);
}

async findOne(id: number) {
  return await this.catRepository.findOne({where: {id}});
}

async update(id: number, updateCatDto: UpdateCatDto) {
  const cat = await this.findOne(id);
  if(!cat){
    throw new Error('cat not found');
  }
  Object.assign(cat, updateCatDto);
  return await this.catRepository.save(cat);
}

async remove(id: number) {
  const cat = await this.findOne(id);
  if(!cat){
    throw new Error('cat not found');
  }
  return await this.catRepository.remove(cat);
}

테스트

포스트맨을 사용하여 테스트를 합니다.

  • 생성
    • POST http://localhost:3000/cats
    • Data는 다음과 같습니다.
{
    "name": "엄지",
    "age": 7,
    "breed": "스코티시폴드"
}

  • 전체 목록 조회
    • GET http://localhost:3000/cats

  • 아이디로 조회
    • GET http://localhost:3000/cats/1

  • 업데이트
    • PATCH http://localhost:3000/cats/1
    • Data
{
    "name": "엄지양이",
    "age": 5,
    "breed": "스코티시폴드"
}

  •  삭제
    • DELETE http://localhost:3000/cats/2

이상으로 TypeORM에서 CRUD를 사용하는 방법에 대해서 알아보았습니다.

반응형
반응형

이 글은 TypeORM의 기본적인 개념에 대해 설명하고, 샘플 소스를 통해 TypeORM의 기본적인 사용법에 대해 설명합니다.

 

이 글의 동영상 강의를 보고 싶으시면 아래를 클릭하세요.

https://youtu.be/yzsN620ZYpw

목차

  • ORM(TypeORM) 개념
  • ORM(TypeORM)의 장단점
  • TypeORM 셋팅하기

 

ORM(TypeORM) 개념

  • TypeORM = "Typescript + ORM"을 의미합니다. 즉, typescript에서 orm을 사용할 수 있도록 만든 프레임워크입니다.
  • ORM은 Object-Relational Mapping의 약자입니다. 
  • Object = 객체지향언어에서 말하는 객체(Object)를 의미합니다.
  • Relational =  관계형 데이터베이스(Relational Database)를 의미합니다.
  • 즉, 객체와 관계형 데이터베이스를 자동으로 맵핑 시켜주는 기술을 ORM이라고 합니다.
  • ORM을 사용하면 DB의 종류에 상관없이 코딩을 할 수 있습니다. 즉, MySQL, PostgreSQL, Oracle등 어떤 Database를 사용하더라도 동일 코드로 작성하여 사용할 수 있도록 만들어진 프레임워크입니다.
  • 결론 : TypeORM은 Typescript에서 사용하는 ORM 프레임워크입니다.

ORM(TypeORM)의 장단점

  • Database의 쿼리문을 사용하는 대신, 기존과 유사한 방식으로 코드를 작성하므로 사용이 편리하다.
  • 독립적인 코드를 사용하므로 재사용성이 증가한다.
  • DBMS에 종속적인 쿼리를 사용하지 않으므로, DB 변경이 용이하다.
  • 테이블간의 관계가 복잡해지고 쿼리가 복잡해질 수록 구현이 어렵다.
  • 쿼리를 많이 사용해본 사람일 경우, 쿼리를 사용했을때 보다 직관성이 떨어진다.

TypeORM 셋팅하기

  • Nestjs 프로젝트를 만듭니다.
nest new typeorm2023
  • TypeORM 관련 패키지를 설치합니다.
npm install --save @nestjs/typeorm typeorm mysql2
  • root 폴더에 orm.config.ts를 만들고 다음과 같이 추가합니다.
import { TypeOrmModuleOptions } from "@nestjs/typeorm";

function ormConfig(): TypeOrmModuleOptions {
    const commonConf = {
        SYNCRONIZE: false,
        ENTITIES: [__dirname + '/domain/*{.ts,.js}'],
        MIGRATIONS: [__dirname + '/migrations/**/*{.ts,.js}'],
        MIGRATIONS_RUN: false,
    };

    return {
        name: 'default',
        type: 'mysql',
        database: 'test',
        host: 'localhost',
        port: Number(3306),
        username: 'root',
        password: 'root',
        logging: true,
        synchronize: commonConf.SYNCRONIZE,
        entities: commonConf.ENTITIES,
        migrations: commonConf.MIGRATIONS,
        migrationsRun: commonConf.MIGRATIONS_RUN,
    };
}

export { ormConfig };
  • 세부사항들을 설명하면 다음과 같습니다.
    • SYNCRONIZE는 객체와 테이블을 동기화 할때 사용합니다. 즉, 객체가 변경되면 테이블에 자동 반영이 되고, 테이블이 변경되면 객체가 자동 변경되는 기능입니다. 이 기능을 운영서버에서 사용할 때는 주의가 필요합니다. 운영중인 데이터는 용량이 크고, 이런 변화가 있을 경우 문제가 생길 수 있으므로, 만약의 사고를 예방하기 위해서는 이 기능을 "false"로 설정하는 것이 좋습니다.
    • ENTITIES는 객체가 위치하는 폴더를 의미합니다. 즉, 테이블의 schema를 객체로 만들어 저장하는 파일들이 위치하는 곳입니다.

 

셋팅이 완료되면 다음과 같이 최상위 모듈에 ormConfig를 추가해 줌으로써 사용이 가능하게 됩니다.

  • app.module.ts에 ormConfig를 추가합니다.
import { ormConfig } from './orm.config';
@Module({
  imports: [
    TypeOrmModule.forRootAsync({ useFactory: ormConfig }),
    ...
  ],
  ...
})

다음은 TypeORM 기초 사용법에 대해 알아보도록 하겠습니다.

반응형
반응형

이 글의 동영상 강좌

https://youtu.be/P9fvgGHd_Jg

Backend의 Nestjs에서 Database(MySQL)를 연결하기 위해 TypeORM을 설정해봅니다.

 

진행 순서는 다음과 같습니다.

MySQL Schema와 User 생성

MySQL Workbench를 이용해서 Schema와 User를 생성합니다.

- Schema : slider

- User : slider

- Password : 1234

자세한 내용은 이전에 작성한 내용을 참조하시기 바랍니다.

https://codegear.tistory.com/32

 

데이터베이스기초-02.MySQL-Schema, User, Table 생성하기

이 글의 동영상 강의입니다. https://youtu.be/hOOiqk8Z1gQ MySQL Workbench를 이용하여 가장 기본적인 Schema와 User를 생성하고, User에게 Schema의 권한을 주는법과, Schema에 Table을 생성하는 법을 알아보겠..

codegear.tistory.com

 

패키지 설치

TypeORM과 MySQL 패키지를 설치합니다.

yarn add @nestjs/typeorm typeorm mysql2

 

TypeORM 설정

/src/orm.config.ts 파일을 아래와 같이 생성합니다.

import { TypeOrmModuleOptions } from '@nestjs/typeorm';

function ormConfig(): TypeOrmModuleOptions {
  const commonConf = {
    SYNCRONIZE: false,
    ENTITIES: [__dirname + '/domain/*.entity{.ts,.js}'],
    MIGRATIONS: [__dirname + '/migrations/**/*{.ts,.js}'],
    MIGRATIONS_RUN: false,
  };

  return {
    name: 'default',
    type: 'mysql',
    database: process.env.DB_NAME,
    host: process.env.DB_HOST,
    port: Number(process.env.DB_PORT),
    username: process.env.DB_USER,
    password: process.env.DB_PASS,
    logging: true,
    synchronize: commonConf.SYNCRONIZE,
    entities: commonConf.ENTITIES,
    migrations: commonConf.MIGRATIONS,
    migrationsRun: commonConf.MIGRATIONS_RUN,
  };
}

export { ormConfig };

 

Main Module에 typeorm config 설정 추가

/src/app.module.ts에서 @Module -> imports 아래에 다음 내용을 추가합니다.

....
import { TypeOrmModule } from '@nestjs/typeorm';
import { ormConfig } from './orm.config';

@Module({
    imports: [
    	TypeOrmModule.forRootAsync({ useFactory: ormConfig }),
    ]
....

 

환경 설정 파일(.env) 생성

orm.config.ts에서 process.env.DB_NAME과 같은 형태로 환경변수를 참조하도록 했습니다.

/.env 파일을 아래와 같이 생성합니다.(.env는 dotenv라고 읽습니다.)

NODE_ENV=local
DB_HOST=localhost
DB_PORT=3306
DB_USER=slider
DB_PASS=1234
DB_NAME=slider

- local db에 설정한데로 값을 입력하면 됩니다.

 

@nestjs/config 모듈 추가

.env 파일을 사용하기 위해서는 dotenv모듈이 필요합니다.
nestjs에서는 @nestjs/config 모듈을 설치하면 dotenv모듈을 사용할 수 있습니다.

아래와 같이 설치를 합니다.

yarn add @nestjs/config

아래와 같이 main module에 ConfigModule 관련 설정을 추가합니다.

/src/app.module.ts

import { ConfigModule } from '@nestjs/config';
...

@Module({
  imports: [
    ConfigModule.forRoot({
      isGlobal: true
    }),
    ....]
...

 

로그 확인

이제 application을 실행해봅니다.

yarn start

application이 정상적으로 실행되면 아래와 같은 로그를 확인할 수 있습니다.

 

Entity 생성

위에서 typeorm 설정 파일의 entity 파일 위치를 아래와 같이 설정했습니다.

ENTITIES: [__dirname + '/domain/*.entity{.ts,.js}'],

따라서 src/domain이라는 폴더를 만들고 entity 파일들을 만들면 됩니다.

 

/src/domain/user.entity.ts 를 아래와 같이 만듭니다.

import { Column, Entity, PrimaryGeneratedColumn, OneToMany } from 'typeorm';
import {UserAuthority} from "./user-authority.entity";

@Entity('user', { schema: 'slider' })
export class User {
    @PrimaryGeneratedColumn({ type: 'int', name: 'id' })
    id: number;

    @Column('varchar', { name: 'kakao_id', length: 45 })
    kakaoId: string;

    @Column('varchar', { name: 'email', length: 100 })
    email: string;

    @Column('varchar', { name: 'name', nullable: true, length: 45 })
    name: string | null;

    @Column('varchar', { name: 'gender', length: 10 })
    gender: string;

    @Column('varchar', { name: 'phone', length: 20 })
    phone: string;

    @Column('varchar', { name: 'birth', length: 10 })
    birth: string;

    @Column('varchar', { name: 'profile_image', nullable: true, length: 200 })
    profileImage: string | null;

    @Column('timestamp', {
        name: 'created_at',
        nullable: true,
        default: () => 'CURRENT_TIMESTAMP',
    })
    createdAt: Date | null;

    @Column('timestamp', {
        name: 'updated_at',
        nullable: true,
        default: () => 'CURRENT_TIMESTAMP',
    })
    updatedAt: Date | null;

    @OneToMany(() => UserAuthority, (userAuthority) => userAuthority.user, {
        eager: true,
    })
    authorities?: any[];
}

/src/domain/user-authority.entity.ts를 다음과 같이 만듭니다.

import {
  Column,
  Entity,
  JoinColumn,
  ManyToOne,
  PrimaryGeneratedColumn,
} from 'typeorm';
import { User } from './user.entity';

@Entity('user_authority')
export class UserAuthority {
  @PrimaryGeneratedColumn()
  id: number;

  @Column('int', { name: 'user_id' })
  userId: number;

  @Column('varchar',{name: 'authority_name'})
  authorityName: string;

  @ManyToOne(() => User, (user) => user.authorities)
  @JoinColumn({ name: 'user_id', referencedColumnName: 'id' })
  user: User;
}

 

테이블 자동 생성

orm.config.ts 파일에서 syncronize를 true로 변경합니다.

SYNCRONIZE: true,

 

Application을 실행합니다.

yarn start

MySQL에 테이블이 생성된 것을 확인할 수 있습니다.

 

이상으로 TypeORM 설정이 완료되었습니다.

반응형
반응형

여러 테이블의 데이터를 한꺼번에 처리할 경우가 있습니다.

예를 들면 회원 탈퇴의 경우,

고객의 계정 정보와 다른 여러 테이블에 들어있는 정보들을 한꺼번에 삭제해줘야만 하죠.

이때 특정 데이터가 삭제되지 않고 남게 되면 문제가 발생할 수 있습니다.

이렇게 모든 데이터를 한꺼번에 지우고, 만약 하나라도 오류가 발생할 경우 모든 것을 원복하는 것을 트랜젝션이라 합니다.

 

Nestjs에서 typeorm을 사용할때 트랜젝션 처리 하는 샘플코드를 만들어봅니다.

 

총 3개의 테이블에 데이터가 들어 있습니다.

- user : 사용자

- user_authority : 사용자 권한

- survey : 설문 정보

 

각각의 테이블 정보를 삭제하는 코드는 다음과 같습니다.

- user(사용자) 삭제

async deleteUser(user: User): Promise<any>{
    return await this.userRepository.createQueryBuilder()
        .delete()
        .from(User, 'user')
        .where('id = :id', { id: user.id })
        .execute();
}

- user_authority(사용자 권한) 삭제

async deleteUserAuthorities(user: User): Promise<any>{
    return await this.userAuthorityRepository.createQueryBuilder()
        .delete()
        .from(UserAuthority, 'userAuthority')
        .where('userId = :userId', { userId: user.id })
        .execute();
}

- survey(설문 정보) 삭제

async deleteAllUserSurvey(user: User): Promise<any>{
    return await this.surveyRepository.createQueryBuilder()
        .delete()
        .from(Survey, 'survey')
        .where('userId = :userId', { userId: user.id})
        .execute();
}

마지막에는 commit을 해줍니다.

await queryRunner.commitTransaction()

이 3가지를 transaction으로 처리하는 코드는 다음과 같습니다.

import {DataSource, FindOneOptions, Repository} from 'typeorm';
...

// 회원 탈퇴
async cancelUser(user: User): Promise<any>{
    // transaction 처리
    const queryRunner = this.dataSource.createQueryRunner();
    await queryRunner.connect();
    await queryRunner.startTransaction();
    try{
        // survey 삭제
        await this.deleteAllUserSurvey(user);
        // 사용자 삭제
        await this.deleteUser(user);
        // 사용자 권한 삭제
        await this.deleteUserAuthorities(user);
        // commit
        await queryRunner.commitTransaction()
    } catch (err) {
    	// 실패시 rollback
        await queryRunner.rollbackTransaction();
    } finally {
    	// release
        await queryRunner.release();
    }
}

이렇게 작성하시면 3개가 모두 성공해야만 회원 탈퇴가 성공하게 되고, 하나라도 실패할 경우 Rollback이 됩니다.

이상으로 Nestjs에서 typeorm의 tranaction 처리에 대해 알아보았습니다.

반응형
반응형

다음은 이 글의 동영상 강의 입니다.

https://youtu.be/4mjd5P7cZIA

https://youtu.be/NCqCfyQoNz8

 

Nest로 로그인 기능을 구현하기 위해 우선적으로 회원 가입을 만들어봅니다.

 

이 예제의 소스는 아래 사이트에서 받으실 수 있습니다.

https://github.com/CodeGearGit/nest-register-sample

 

GitHub - CodeGearGit/nest-register-sample

Contribute to CodeGearGit/nest-register-sample development by creating an account on GitHub.

github.com

 

USER 테이블의 구조는 다음과 같습니다.

auth 모듈을 만듭니다.

nest g module auth

auth/entity/user.entity.ts 를 만듭니다.

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

@Entity('user')
export class User{
    @PrimaryGeneratedColumn()
    id: number;

    @Column()
    username: string;
    
    @Column()
    password: string;
}

auth/user.repository.ts 를 만듭니다.

import { EntityRepository, Repository } from "typeorm";
import { User } from "./entity/user.entity";

@EntityRepository(User)
export class UserRepository extends Repository<User>{}

auth/dto/user.dto.ts 를 만듭니다.

export class UserDTO {
    username: string;
    password: string;
}

auth/user.servict.ts 를만듭니다.

import { Injectable } from "@nestjs/common";
import { InjectRepository } from "@nestjs/typeorm";
import { FindOneOptions } from "typeorm";
import { UserDTO } from "./dto/user.dto";
import { UserRepository } from "./user.repository";

@Injectable()
export class UserService{
    constructor(@InjectRepository(UserRepository) private userRepository: UserRepository){}

    async findByFields(options: FindOneOptions<UserDTO>): Promise<UserDTO | undefined> {
        return await this.userRepository.findOne(options);
    }

    async save(userDTO: UserDTO): Promise<UserDTO | undefined> {
        return await this.userRepository.save(userDTO);
    }
}

auth/auth.service.ts 를 만듭니다.

(nest g service auth)

import { HttpException, HttpStatus, Injectable } from "@nestjs/common";
import { UserDTO } from "./dto/user.dto";
import { UserService } from "./user.service";

@Injectable()
export class AuthService {
    constructor(
        private userService: UserService
    ){}

    async registerNewUser(newUser: UserDTO): Promise<UserDTO> {
        let userFind: UserDTO = await this.userService.findByFields({ where: { username: newUser.username } });
        if(userFind){
            throw new HttpException('Username already used!', HttpStatus.BAD_REQUEST);
        }
        return this.userService.save(newUser);
    }
}

auth/auth.controller.ts를 만듭니다.

(nest g controller auth)

import { Body, Controller, Post, Req } from "@nestjs/common";
import { Response, Request } from 'express';
import { AuthService } from "./auth.service";
import { UserDTO } from "./dto/user.dto";

@Controller('api')
export class AuthController {
    constructor(private authService: AuthService){}

    @Post('/register')
    async registerAccount(@Req() req: Request, @Body() userDTO: UserDTO): Promise<any> {
        return await this.authService.registerNewUser(userDTO);
    }
}

auth/auth.module.ts를 아래와 같이 수정합니다.

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { AuthController } from './auth.controller';
import { AuthService } from './auth.service';
import { UserRepository } from './user.repository';
import { UserService } from './user.service';

@Module({
    imports: [TypeOrmModule.forFeature([UserRepository])],
    exports: [TypeOrmModule],
    controllers: [AuthController],
    providers: [AuthService, UserService]
  })
export class AuthModule {}

서버를 start 합니다.

npm run start:dev

postman에서 다음과 같이 테스트를 합니다.

POST http://localhost:3000/api/register
Body-raw-JSON
{
    "username": "codegear",
    "password": "1111"
}

실행 결과는 다음과 같습니다.

user 테이블에서도 다음과 같이 확인하실 수 있습니다.

 

반응형

+ Recent posts