사용자 CRUD

src/user/
├── controller/
│   └── UserController.ts    # HTTP 경계 — 라우트 데코레이터
├── application/
│   └── UserApplication.ts   # 비즈니스 로직 — 검증, 해싱, 토큰 발급
├── domain/
│   └── entity/
│       └── UsersTable.ts     # 데이터 경계 — @Table 모델
└── dto/
    ├── CreateUserDto.ts      # 회원가입 요청 형태
    ├── LoginRequestDto.ts    # 로그인 요청 형태
    ├── LoginResponseDto.ts   # 로그인 응답 형태
    └── UserInfoDto.ts        # 사용자 정보 응답 형태

// example/src/user/domain/entity/UsersTable.ts
import { Model } from 'sequelize-typescript';
import { Table, TypeIs } from '@asapjs/sequelize';
 
@Table({
  tableName: 'users',
  timestamps: true,
})
export default class UsersTable extends Model {
  @TypeIs.INT({ primaryKey: true, autoIncrement: true, comment: '사용자 ID' })
  id: number;
 
  @TypeIs.STRING({ unique: true, comment: '이메일 (고유)' })
  email: string;
 
  @TypeIs.PASSWORD({ comment: '비밀번호 (bcrypt)' })
  password: string;
 
  @TypeIs.STRING({ comment: '사용자 이름' })
  name: string;
 
  @TypeIs.DATETIME({ comment: '생성 일시' })
  created_at: Date;
 
  @TypeIs.DATETIME({ comment: '수정 일시' })
  updated_at: Date;
}

// example/src/user/dto/CreateUserDto.ts
import { ExtendableDto, Dto, TypeIs } from '@asapjs/sequelize';
import UsersTable from '../domain/entity/UsersTable';
 
@Dto({ name: 'create_user_dto', defineTable: UsersTable, timestamps: false })
export default class CreateUserDto extends ExtendableDto {
  @TypeIs.STRING({ comment: '이메일' })
  email: string;
 
  @TypeIs.PASSWORD({ comment: '비밀번호' })
  password: string;
 
  @TypeIs.STRING({ comment: '사용자 이름' })
  name: string;
}

// example/src/user/dto/UserInfoDto.ts
import { ExtendableDto, Dto, TypeIs } from '@asapjs/sequelize';
import UsersTable from '../domain/entity/UsersTable';
 
@Dto({ name: 'user_info_dto', defineTable: UsersTable, timestamps: false })
export default class UserInfoDto extends ExtendableDto {
  @TypeIs.INT({ comment: '사용자 ID' })
  id: number;
 
  @TypeIs.STRING({ comment: '이메일' })
  email: string;
 
  @TypeIs.STRING({ comment: '사용자 이름' })
  name: string;
}

// example/src/user/application/UserApplication.ts
import bcrypt from 'bcrypt';
import UsersTable from '../domain/entity/UsersTable';
import CreateUserDto from '../dto/CreateUserDto';
import LoginRequestDto from '../dto/LoginRequestDto';
import { jwtSign } from '../../utils/jwt';
 
export default class UserApplication {
  private users: typeof UsersTable;
 
  constructor() {
    this.users = UsersTable;
  }
 
  async register(dto: CreateUserDto) {
    // 중복 체크
    const existingUser = await this.users.findOne({ where: { email: dto.email } });
    if (existingUser) {
      throw new Error('Email already exists');
    }
 
    // 비밀번호 해싱
    const hashedPassword = await bcrypt.hash(dto.password, 10);
 
    // 사용자 생성
    const user = await this.users.create({
      email: dto.email,
      password: hashedPassword,
      name: dto.name,
    } as any);
 
    return {
      id: user.id,
      email: user.email,
      name: user.name,
    };
  }
 
  async login(dto: LoginRequestDto) {
    // 사용자 조회
    const user = await this.users.findOne({ where: { email: dto.email } });
    if (!user) {
      throw new Error('Invalid email or password');
    }
 
    // 비밀번호 검증
    const isPasswordValid = await bcrypt.compare(dto.password, user.password);
    if (!isPasswordValid) {
      throw new Error('Invalid email or password');
    }
 
    // JWT 토큰 생성
    const payload = { userId: user.id, email: user.email };
    const accessToken = jwtSign(payload, '1d');
    const refreshToken = jwtSign(payload, '7d');
 
    return {
      accessToken,
      refreshToken,
    };
  }
 
  async getUserInfo(user: any) {
    if (!user || !user.userId) {
      throw new Error('Unauthorized');
    }
 
    const userRecord = await this.users.findByPk(user.userId);
    if (!userRecord) {
      throw new Error('User not found');
    }
 
    return {
      id: userRecord.id,
      email: userRecord.email,
      name: userRecord.name,
    };
  }
}

// example/src/user/controller/UserController.ts
import { RouterController, Get, Post, ExecuteArgs } from '@asapjs/router';
import UserApplication from '../application/UserApplication';
import CreateUserDto from '../dto/CreateUserDto';
import LoginRequestDto from '../dto/LoginRequestDto';
import LoginResponseDto from '../dto/LoginResponseDto';
import UserInfoDto from '../dto/UserInfoDto';
 
export default class UserController extends RouterController {
  public tag = 'User';
  public basePath = '/users';
 
  private userService: UserApplication;
 
  constructor() {
    super();
    this.registerRoutes();
    this.userService = new UserApplication();
  }
 
  @Post('/register', {
    title: '회원 가입',
    description: '새로운 사용자를 등록합니다',
    body: CreateUserDto,
    response: UserInfoDto,
  })
  async register({ body }: ExecuteArgs) {
    const dto = body as CreateUserDto;
    return await this.userService.register(dto);
  }
 
  @Post('/login', {
    title: '로그인',
    description: '이메일과 비밀번호로 로그인합니다',
    body: LoginRequestDto,
    response: LoginResponseDto,
  })
  async login({ body }: ExecuteArgs) {
    const dto = body as LoginRequestDto;
    return await this.userService.login(dto);
  }
 
  @Get('/me', {
    title: '내 정보 조회',
    description: '현재 로그인한 사용자의 정보를 조회합니다',
    auth: true,
    response: UserInfoDto,
  })
  async getMe({ user }: ExecuteArgs) {
    return await this.userService.getUserInfo(user);
  }
}

// example/src/route.ts
import UserController from './user/controller/UserController';
 
export default [new UserController()];

POST /api/users/register
  Content-Type: application/json
  { "email": "alice@example.com", "password": "secret123", "name": "Alice" }

async register({ body }: ExecuteArgs) {
  const dto = body as CreateUserDto;
  return await this.userService.register(dto);
}

{
  "id": 1,
  "email": "alice@example.com",
  "name": "Alice"
}