Node.js 계층 구조 설계 및 환경 변수 관리

controllers
├─ PostController.ts
dtos
├─ PostDto.ts
entities
├─ Post.ts
services
├─ PostService.ts
repositories
├─ PostRepository.ts
middlewares
├─ AuthMiddleware.ts
utils
├─ ... 생략

import { PostService } from "../services/PostService";
import {
  JsonController,
  Get,
  Param,
  Body,
  Post,
  Put,
  UseBefore,
  Res,
  Delete,
  HttpCode,
  QueryParams,
} from "routing-controllers";
// JWT 인증을 위한 미들웨어를 선언한다.
import { checkAccessToken } from "../middlewares/AuthMiddleware";
import { Response } from "express";
// routing-controllers에서 SwaggerUI를 사용하는 방법이다.
import { OpenAPI, ResponseSchema } from "routing-controllers-openapi";
import { CreatePostDto, UpdatePostDto, PageablePostDto } from "../dtos/PostDto";

@JsonController("/posts")
export class PostController {
  // 생성자 주입을 사용해서 의존성 주입을 한다.
  constructor(private postService: PostService) {}

  @HttpCode(201)
  @Post()
  // OpenAPI를 정의해서 SwaggerUI를 정의할 수 있다.
  @OpenAPI({
    summary: "Post 작성",
    statusCode: "201",
    security: [{ bearerAuth: [] }],
  })
  // AccessToken의 유효성을 검증한다.
  @UseBefore(checkAccessToken)
  public async create(
    @Body() createPostDto: CreatePostDto,
    @Res() res: Response,
  ) {
    // AccessToken으로 userId를 추출한다.
    const { userId } = res.locals.jwtPayload;
    // userId와 요청된 Dto로 게시글을 생성한다.
    const newPost = await this.postService.createPost(createPostDto, userId);

    return newPost;
  }
}

import { Service } from "typedi";
import { InjectRepository } from "typeorm-typedi-extensions";
import { Post } from "../entities/Post";
import { PostRepository } from "../repositories/PostRepository";
import { CreatePostDto, UpdatePostDto } from "../dtos/PostDto";

// PostService를 어느 곳에서나 주입할 수 있도록 해준다.
@Service()
export class PostService {
  // Repository를 생성자 주입에 사용하기 위해 typeorm-typedi-extensions를 사용한다.
  // https://github.com/typeorm/typeorm-typedi-extensions
  constructor(@InjectRepository() private postRepository: PostRepository) {}

  public async createPost(
    createPostDto: CreatePostDto,
    userId: string,
  ): Promise<Post> {
    const post = createPostDto.toEntity();
    post.userId = userId;
    post.previewContent = post.content.substring(0, 100);

    const newPost = await this.postRepository.save(post);
    return newPost;
  }
}

import { EntityRepository, Repository } from "typeorm";
import { Post } from "../entities/Post";

@EntityRepository(Post)
export class PostRepository extends Repository<Post> {
}

import {
  useContainer as routingUseContainer,
  useExpressServer,
} from "routing-controllers";
import { routingControllerOptions } from "./utils/RoutingConfig";

export class App {
  public app: express.Application;

  constructor() {
    this.app = express();
    // ... 생략
  }

  // ... 생략

  public async createExpressServer(port: number) {
    try {
      // routing-controllers, TypeORM과 함께 TypeDI를 사용하는 방법이다. (routingUseContainer)
      routingUseContainer(Container);
      useExpressServer(this.app, routingControllerOptions);
      useSwagger(this.app);
      useSentry(this.app);

      this.app.listen(port, () => {
        logger.info(`Server is running on http://localhost:${port}`);
      });
    } catch (error) {
      logger.error(error);
    }
  }
}

config
├─ .env.test
├─ .env.development
├─ .env.production

/**
 * NODE_ENV에 따른 .env 파일 로드
 */
require("dotenv").config({
  path: `config/.env.${process.env.NODE_ENV || "development"}`,
});

/**
 * 환경 변수
 */
export const env = {
  isDevelopment: process.env.NODE_ENV === "development",
  isProduction: process.env.NODE_ENV === "production",
  isTest: process.env.NODE_ENV === "test",
  app: {
    port: Number(process.env.PORT) || 3000,
    jwtAccessSecret: process.env.JWT_SECRET_ACCESS_KEY,
    jwtRefreshSecret: process.env.JWT_SECRET_REFRESH_KEY,
    // ... 생략
  },
  database: {
    host: process.env.DATABASE_HOST,
    // ... 생략
  },
  // ... 생략
};

// env.ts에서 환경 변수들이 정의된 env를 가져온다.
import { env } from "./env";

export async function createDatabaseConnection() {
  try {
    const connectionOpts: ConnectionOptions = {
      type: "mysql",
      host: env.database.host,
      // ... 생략
    };

    // ... 생략
  } catch (error) {
    throw error;
  }
}