요청 라이프사이클

Client
  |
  | HTTP Request
  v
Express App
  |
  |-- [1] CORS middleware
  |-- [2] bodyParser (JSON or multipart/form-data)
  |-- [3] jwtVerification(auth?)
  |-- [4] Custom middleware (middleware: [...] in IOptions)
  |-- [5] wrapWithEffect(handler)  ← Effect 기반 실행/트레이싱
  |-- [6] Wrapper(handler)
  |         |-- extract req.params  → path
  |         |-- extract req.body    → body
  |         |-- extract req.query   → query
  |         |-- extract req.user    → user  (set by jwtVerification)
  |         |-- parse ?page=&limit= → paging (PaginationQueryType)
  |         |-- call handler(args)
  |         |-- res.status(200).json(output)
  |         |-- on error: errorToResponse(err, res)
  |
  v
Client receives JSON response

@Post('/admin/action', {
  auth: true,
  middleware: [requireAdminRole, rateLimiter],
  body: AdminActionDto,
  response: ActionResultDto,
})
async adminAction({ body, user }: ExecuteArgs) {
  // requireAdminRole과 rateLimiter를 통과한 경우에만 도달
  return await this.adminService.performAction(user, body as AdminActionDto);
}

// packages/router/src/utils/wrapper.ts
import { errorToResponse } from '@asapjs/error';
import type { PaginationQueryType } from '@asapjs/sequelize';
 
export interface ExecuteArgs<P = {}, Q = {}, B = {}> {
  req: Request;
  res: Response;
  path?: P | { [key: string]: any };
  query: Q & { [key: string]: any };
  body: B & { [key: string]: any };
  files?: { [key: string]: any };
  user?: any;
  paging: PaginationQueryType;
}
 
export default function Wrapper(cb: (args: ExecuteArgs) => Promise<unknown>): Callback {
  return async function _Wrapper(req: Request, res: Response, next: NextFunction) {
    try {
      const user = req.user;
      const { page: pageProp = 0, limit: limitProp = 20 } = req.query;
      const page = parseInt(String(pageProp), 10);
      const limit = parseInt(String(limitProp), 10);
      const paging: PaginationQueryType = { page, limit };
      const args: ExecuteArgs = {
        req,
        res,
        query: req.query,
        path: req.params,
        body: req.body,
        user,
        paging,
      };
      const output = await cb(args);
      if (output) {
        res.status(200).json(output);
      }
    } catch (err) {
      const isServerError =
        err == null ||
        typeof err !== 'object' ||
        (err as { status?: number }).status === 500 ||
        (err as { status?: number }).status === undefined;
 
      if (isServerError) {
        logger.error('[SERVER ERROR]', err);
        if (getConfig().sentry !== undefined) {
          Sentry.captureException(err);
        }
      }
      errorToResponse(err, res);
    }
  };
}

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

// errors/UserErrors.ts
import { error } from '@asapjs/error';
import { TypeIs } from '@asapjs/schema';
 
export class UserErrors {
  static NOT_FOUND = error(404, 'USER_NOT_FOUND', '사용자를 찾을 수 없습니다. ID: {userId}', {
    userId: TypeIs.INT({ comment: '사용자 ID' }),
  });
}
 
// Application 레이어에서:
throw UserErrors.NOT_FOUND({ userId: 42 });
// → HTTP 404 { status: 404, errorCode: 'USER_NOT_FOUND', message: '사용자를 찾을 수 없습니다. ID: 42', data: { userId: 42 } }

import { HttpException } from '@asapjs/router';
 
throw new HttpException(400, 'Email already registered');
// → HTTP 400 { status: 400, message: 'Email already registered' }