레이어드 아키텍처

HTTP Request
     |
     v
[ Controller ]   — HTTP 경계: 데코레이터, ExecuteArgs, 반환값
     |
     v
[ Application ]  — 비즈니스 로직: 유효성 검사, 오케스트레이션, 규칙
     |
     v
[ Repository ]   — 데이터 접근: 쿼리 추상화, 페이지네이션, DTO 매핑
     |
     v
[   Entity    ]  — 데이터 경계: @Table 모델, TypeIs 컬럼, Sequelize

// packages/example/src/user/controller/UserController.ts
import { ExecuteArgs, Get, Post, RouterController } from '@asapjs/router';
import { UserApplication } from '../application/UserApplication';
import CreateUserDto from '../dto/CreateUserDto';
import GetUserListQueryDto from '../dto/GetUserListQueryDto';
import UserDto from '../dto/UserDto';
import { UserErrors } from '../errors/UserErrors';
 
export default class UserController extends RouterController {
  public basePath = '/users';
  public tag = 'users';
 
  private userService: UserApplication;
 
  constructor() {
    super();
    this.registerRoutes();
    this.userService = new UserApplication();
  }
 
  @Get('/', {
    title: '사용자 목록 조회',
    description: '페이지네이션을 지원하는 사용자 목록을 조회합니다.',
    query: GetUserListQueryDto,
    response: UserDto,
  })
  public getUserList = async ({ paging, user }: ExecuteArgs<{}, GetUserListQueryDto, {}>) => {
    const result = await this.userService.list(paging, user);
    return { result };
  };
 
  @Get('/:userId', {
    title: '사용자 상세 조회',
    description: '특정 사용자의 상세 정보를 조회합니다.',
    response: UserDto,
    errors: [UserErrors.NOT_FOUND],
  })
  public getUserById = async ({ path }: ExecuteArgs<{ userId: string }, {}, {}>) => {
    const result = await this.userService.info(path?.userId);
    return { result };
  };
 
  @Post('/', {
    title: '사용자 생성',
    description: '새로운 사용자를 생성합니다.',
    body: CreateUserDto,
    response: UserDto,
    errors: [UserErrors.EMAIL_DUPLICATE, UserErrors.INVALID_DATA],
  })
  public createUser = async ({ body, user }: ExecuteArgs<{}, {}, CreateUserDto>) => {
    const result = await this.userService.create(body, user);
    return { result };
  };
}

// packages/example/src/user/application/UserApplication.ts
import type { PaginationQueryType } from '@asapjs/sequelize';
import UsersTable from '../domain/entity/UsersTable';
import UserDto from '../dto/UserDto';
import UserTableRepository from '../infra/UserTableRepository';
import { UserErrors } from '../errors/UserErrors';
import CreateUserDto from '../dto/CreateUserDto';
 
export class UserApplication {
  private users: typeof UsersTable;
  private usersRepository: UserTableRepository;
 
  constructor() {
    this.users = UsersTable;
    this.usersRepository = new UserTableRepository();
  }
 
  public list = async (paging: PaginationQueryType, user: UserDto) => {
    const raws = await this.usersRepository.list(paging, user);
    return raws;
  };
 
  public info = async (userId: number) => {
    const raw = await this.usersRepository.info(userId);
    if (!raw) throw UserErrors.NOT_FOUND({ userId: userId });
    return raw;
  };
 
  public create = async (body: CreateUserDto, user: UserDto) => {
    const data = new CreateUserDto().map(body);
    const raw = await this.users.create(data);
    return new UserDto().map(raw);
  };
}

// packages/example/src/user/infra/UserTableRepository.ts
import { Repository } from '@asapjs/sequelize';
import type { PaginationQueryType } from '@asapjs/sequelize';
import UsersTable from '../domain/entity/UsersTable';
import UserDto from '../dto/UserDto';
 
export default class UserTableRepository extends Repository {
  private users: typeof UsersTable;
 
  constructor() {
    super();
    this.users = UsersTable;
  }
 
  public list = async (paging: PaginationQueryType, user: UserDto) => {
    const users = await this.repository.findAll(this.users, {
      exportTo: UserDto,
      user,
      paging,
    });
    return new UserDto().pagingMap(users);
  };
 
  public info = async (userId: number) => {
    const user = await this.repository.findOne(this.users, {
      exportTo: UserDto,
      where: { id: userId },
    });
    if (!user) return null;
    return new UserDto().map(user);
  };
}

// packages/example/src/user/domain/entity/UsersTable.ts
import { Model } from 'sequelize-typescript';
import { Table, TypeIs } from '@asapjs/sequelize';
 
export enum UserTypeEnum {
  ADMIN = 'ADMIN',
  USER = 'USER',
}
 
@Table({ tableName: 'users' })
export default class UsersTable extends Model {
  @TypeIs.ENUM({ values: Object.keys(UserTypeEnum), comment: '유저 유형', defaultValue: UserTypeEnum.USER })
  type!: UserTypeEnum;
 
  @TypeIs.STRING({ comment: '이메일', unique: true })
  email!: string;
 
  @TypeIs.PASSWORD({ comment: '비밀번호' })
  password!: string;
 
  @TypeIs.STRING({ comment: '이름' })
  name!: string;
 
  @TypeIs.STRING({ comment: '전화번호', allowNull: true })
  phone!: string;
 
  @TypeIs.BOOLEAN({ comment: '활성 상태', defaultValue: true })
  is_active!: boolean;
 
  @TypeIs.DATETIME({ comment: '생성일' })
  created_at!: Date;
 
  @TypeIs.DATETIME({ comment: '수정일' })
  updated_at!: Date;
}

POST /users
  Content-Type: application/json
  { "type": "USER", "email": "alice@example.com", "password": "secret", "name": "Alice", "phone": "010-1234-5678" }

public createUser = async ({ body, user }: ExecuteArgs<{}, {}, CreateUserDto>) => {
  const result = await this.userService.create(body, user);
  return { result };
};