typescript-express-starter 9.2.0 → 10.0.1

package/lib/node-postgres/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "typescript-express-starter",
+  "version": "0.0.0",
+  "description": "TypeScript + PostgreSQL + Express API Server",
+  "author": "",
+  "license": "ISC",
+  "scripts": {
+    "start": "npm run build && cross-env NODE_ENV=production node dist/server.js",
+    "dev": "cross-env NODE_ENV=development nodemon",
+    "build": "swc src -d dist --source-maps --copy-files",
+    "build:tsc": "tsc && tsc-alias",
+    "test": "jest --forceExit --detectOpenHandles",
+    "lint": "eslint --ignore-path .gitignore --ext .ts src/",
+    "lint:fix": "npm run lint -- --fix",
+    "deploy:prod": "npm run build && pm2 start ecosystem.config.js --only prod",
+    "deploy:dev": "pm2 start ecosystem.config.js --only dev"
+  },
+  "dependencies": {
+    "bcrypt": "^5.0.1",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.13.2",
+    "compression": "^1.7.4",
+    "cookie-parser": "^1.4.6",
+    "cors": "^2.8.5",
+    "dotenv": "^16.0.1",
+    "envalid": "^7.3.1",
+    "express": "^4.18.1",
+    "helmet": "^5.1.1",
+    "hpp": "^0.2.3",
+    "jsonwebtoken": "^8.5.1",
+    "morgan": "^1.10.0",
+    "pg": "^8.8.0",
+    "swagger-jsdoc": "^6.2.1",
+    "swagger-ui-express": "^4.5.0",
+    "reflect-metadata": "^0.1.3",
+    "typedi": "^0.10.0",
+    "winston": "^3.8.1",
+    "winston-daily-rotate-file": "^4.7.1"
+  },
+  "devDependencies": {
+    "@swc/cli": "^0.1.57",
+    "@swc/core": "^1.2.220",
+    "@types/bcrypt": "^5.0.0",
+    "@types/compression": "^1.7.2",
+    "@types/cookie-parser": "^1.4.3",
+    "@types/cors": "^2.8.12",
+    "@types/express": "^4.17.13",
+    "@types/hpp": "^0.2.2",
+    "@types/jest": "^28.1.6",
+    "@types/jsonwebtoken": "^8.5.8",
+    "@types/morgan": "^1.9.3",
+    "@types/node": "^17.0.45",
+    "@types/pg": "^8.6.5",
+    "@types/supertest": "^2.0.12",
+    "@types/swagger-jsdoc": "^6.0.1",
+    "@types/swagger-ui-express": "^4.1.3",
+    "@typescript-eslint/eslint-plugin": "^5.29.0",
+    "@typescript-eslint/parser": "^5.29.0",
+    "cross-env": "^7.0.3",
+    "eslint": "^8.20.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-prettier": "^4.2.1",
+    "husky": "^8.0.1",
+    "jest": "^28.1.1",
+    "lint-staged": "^13.0.3",
+    "node-config": "^0.0.2",
+    "node-gyp": "^9.1.0",
+    "nodemon": "^2.0.19",
+    "pm2": "^5.2.0",
+    "prettier": "^2.7.1",
+    "supertest": "^6.2.4",
+    "ts-jest": "^28.0.7",
+    "ts-node": "^10.9.1",
+    "tsc-alias": "^1.7.0",
+    "tsconfig-paths": "^4.0.0",
+    "typescript": "^4.7.4"
+  }
+}

package/lib/node-postgres/src/app.ts

@@ -0,0 +1,87 @@
+import 'reflect-metadata';
+import compression from 'compression';
+import cookieParser from 'cookie-parser';
+import cors from 'cors';
+import express from 'express';
+import helmet from 'helmet';
+import hpp from 'hpp';
+import morgan from 'morgan';
+import swaggerJSDoc from 'swagger-jsdoc';
+import swaggerUi from 'swagger-ui-express';
+import { NODE_ENV, PORT, LOG_FORMAT, ORIGIN, CREDENTIALS } from '@config';
+import { client } from '@database';
+import { Routes } from '@interfaces/routes.interface';
+import { ErrorMiddleware } from '@middlewares/error.middleware';
+import { logger, stream } from '@utils/logger';
+
+export class App {
+  public app: express.Application;
+  public env: string;
+  public port: string | number;
+
+  constructor(routes: Routes[]) {
+    this.app = express();
+    this.env = NODE_ENV || 'development';
+    this.port = PORT || 3000;
+
+    this.connectToDatabase();
+    this.initializeMiddlewares();
+    this.initializeRoutes(routes);
+    this.initializeSwagger();
+    this.initializeErrorHandling();
+  }
+
+  public listen() {
+    this.app.listen(this.port, () => {
+      logger.info(`=================================`);
+      logger.info(`======= ENV: ${this.env} =======`);
+      logger.info(`🚀 App listening on the port ${this.port}`);
+      logger.info(`=================================`);
+    });
+  }
+
+  public getServer() {
+    return this.app;
+  }
+
+  private async connectToDatabase() {
+    await client.connect();
+  }
+
+  private initializeMiddlewares() {
+    this.app.use(morgan(LOG_FORMAT, { stream }));
+    this.app.use(cors({ origin: ORIGIN, credentials: CREDENTIALS }));
+    this.app.use(hpp());
+    this.app.use(helmet());
+    this.app.use(compression());
+    this.app.use(express.json());
+    this.app.use(express.urlencoded({ extended: true }));
+    this.app.use(cookieParser());
+  }
+
+  private initializeRoutes(routes: Routes[]) {
+    routes.forEach(route => {
+      this.app.use('/', route.router);
+    });
+  }
+
+  private initializeSwagger() {
+    const options = {
+      swaggerDefinition: {
+        info: {
+          title: 'REST API',
+          version: '1.0.0',
+          description: 'Example docs',
+        },
+      },
+      apis: ['swagger.yaml'],
+    };
+
+    const specs = swaggerJSDoc(options);
+    this.app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(specs));
+  }
+
+  private initializeErrorHandling() {
+    this.app.use(ErrorMiddleware);
+  }
+}

package/lib/node-postgres/src/config/index.ts

@@ -0,0 +1,6 @@
+import { config } from 'dotenv';
+config({ path: `.env.${process.env.NODE_ENV || 'development'}.local` });
+
+export const CREDENTIALS = process.env.CREDENTIALS === 'true';
+export const { NODE_ENV, PORT, SECRET_KEY, LOG_FORMAT, LOG_DIR, ORIGIN } = process.env;
+export const { DB_USER, DB_PASSWORD, DB_HOST, DB_PORT, DB_DATABASE } = process.env;

package/lib/node-postgres/src/controllers/auth.controller.ts

@@ -0,0 +1,44 @@
+import { NextFunction, Request, Response } from 'express';
+import { Container } from 'typedi';
+import { RequestWithUser } from '@interfaces/auth.interface';
+import { User } from '@interfaces/users.interface';
+import { AuthService } from '@services/auth.service';
+
+export class AuthController {
+  public auth = Container.get(AuthService);
+
+  public signUp = async (req: Request, res: Response, next: NextFunction): Promise<void> => {
+    try {
+      const userData: User = req.body;
+      const signUpUserData: User = await this.auth.signup(userData);
+
+      res.status(201).json({ data: signUpUserData, message: 'signup' });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  public logIn = async (req: Request, res: Response, next: NextFunction): Promise<void> => {
+    try {
+      const userData: User = req.body;
+      const { cookie, findUser } = await this.auth.login(userData);
+
+      res.setHeader('Set-Cookie', [cookie]);
+      res.status(200).json({ data: findUser, message: 'login' });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  public logOut = async (req: RequestWithUser, res: Response, next: NextFunction): Promise<void> => {
+    try {
+      const userData: User = req.user;
+      const logOutUserData: User = await this.auth.logout(userData);
+
+      res.setHeader('Set-Cookie', ['Authorization=; Max-age=0']);
+      res.status(200).json({ data: logOutUserData, message: 'logout' });
+    } catch (error) {
+      next(error);
+    }
+  };
+}

package/lib/node-postgres/src/controllers/users.controller.ts

@@ -0,0 +1,63 @@
+import { NextFunction, Request, Response } from 'express';
+import { Container } from 'typedi';
+import { User } from '@interfaces/users.interface';
+import { UserService } from '@services/users.service';
+
+export class UserController {
+  public user = Container.get(UserService);
+
+  public getUsers = async (req: Request, res: Response, next: NextFunction): Promise<void> => {
+    try {
+      const findAllUsersData: User[] = await this.user.findAllUser();
+
+      res.status(200).json({ data: findAllUsersData, message: 'findAll' });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  public getUserById = async (req: Request, res: Response, next: NextFunction): Promise<void> => {
+    try {
+      const userId = Number(req.params.id);
+      const findOneUserData: User = await this.user.findUserById(userId);
+
+      res.status(200).json({ data: findOneUserData, message: 'findOne' });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  public createUser = async (req: Request, res: Response, next: NextFunction): Promise<void> => {
+    try {
+      const userData: User = req.body;
+      const createUserData: User = await this.user.createUser(userData);
+
+      res.status(201).json({ data: createUserData, message: 'created' });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  public updateUser = async (req: Request, res: Response, next: NextFunction): Promise<void> => {
+    try {
+      const userId = Number(req.params.id);
+      const userData: User = req.body;
+      const updateUserData: User[] = await this.user.updateUser(userId, userData);
+
+      res.status(200).json({ data: updateUserData, message: 'updated' });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  public deleteUser = async (req: Request, res: Response, next: NextFunction): Promise<void> => {
+    try {
+      const userId = Number(req.params.id);
+      const deleteUserData: User[] = await this.user.deleteUser(userId);
+
+      res.status(200).json({ data: deleteUserData, message: 'deleted' });
+    } catch (error) {
+      next(error);
+    }
+  };
+}

package/lib/node-postgres/src/database/index.ts

@@ -0,0 +1,6 @@
+import { Client } from 'pg';
+import { DB_USER, DB_PASSWORD, DB_HOST, DB_PORT, DB_DATABASE } from '@config';
+
+export const client = new Client({
+  connectionString: `postgres://${DB_USER}:${DB_PASSWORD}@${DB_HOST}:${DB_PORT}/${DB_DATABASE}`,
+});

package/lib/node-postgres/src/database/init.sql

@@ -0,0 +1,110 @@
+-- TABLE 존재할 경우 삭제
+DROP TABLE IF EXISTS teachers cascade;
+DROP TABLE IF EXISTS classes cascade;
+DROP TABLE IF EXISTS students cascade;
+DROP TABLE IF EXISTS classes_category cascade;
+DROP TABLE IF EXISTS enrolment cascade;
+
+-- ============
+--   강사 테이블
+-- ============
+-- 강사 테이블 생성
+CREATE TABLE teachers(
+    "teacherId" SERIAL PRIMARY KEY,
+    -- 강사 ID
+    "teacherName" VARCHAR(32) NOT NULL,
+    -- 강사명
+    "teacherAbout" VARCHAR(48) -- 강사 정보
+);
+-- 강사 데이터 생성
+INSERT INTO teachers(
+        "teacherId",
+        "teacherName",
+        "teacherAbout"
+    )
+VALUES (1, '조현영', '웹 개발 강사'),
+    (2, '개복치개발자', '안드로이드 코틀린 강사'),
+    (3, '이고잉', '생활코딩 운영진 겸 강사'),
+    (4, '김태원', '파이썬 알고리즘 강사'),
+    (5, '윤재성', 'Kotiln 기반 안드로이드 강사'),
+    (6, '조훈', '쿠버네티스 강사'),
+    (7, 'Rookiss', '얼리언 엔진 전문 강사'),
+    (8, '유용한IT학습', 'SQLD 자격증 취득 강사'),
+    (9, '김태민', '쿠버네티스 강사'),
+    (10, '큰돌', '알고리즘 강사');
+SELECT SETVAL(
+        '"teachers_teacherId_seq"',
+        (
+            SELECT max("teacherId")
+            FROM teachers
+        )
+    );
+-- ===================
+--   강의 카테고리 테이블
+-- ===================
+-- 강의 카테고리 테이블 생성
+CREATE TABLE classes_category(
+    "categoryId" SERIAL PRIMARY KEY,
+    -- 카테고리 ID
+    "categoryName" VARCHAR(32) UNIQUE NOT NULL -- 카테고리 명
+);
+-- 강의 카테고리 데이터 생성
+INSERT INTO classes_category("categoryId", "categoryName")
+VALUES (1, '웹'),
+    (2, '앱'),
+    (3, '게임'),
+    (4, '알고리즘'),
+    (5, '인프라'),
+    (6, '데이터베이스');
+SELECT SETVAL(
+        '"classes_category_categoryId_seq"',
+        (
+            SELECT max("categoryId")
+            FROM classes_category
+        )
+    );
+-- ============
+--   강의 테이블
+-- ============
+-- 강의 테이블 생성
+CREATE TABLE classes(
+    "classId" SERIAL PRIMARY KEY,
+    -- 강의 ID
+    "className" VARCHAR(32) UNIQUE NOT NULL,
+    -- 강의명
+    "classPrice" INTEGER NOT NULL DEFAULT 0,
+    -- 가격
+    "introduce" TEXT,
+    -- 강의 소개
+    "active" BOOLEAN NOT NULL DEFAULT false,
+    -- 강의 활성화 (true: 공개, false, 비공개)
+    "createdAt" TIMESTAMP WITHOUT TIME ZONE DEFAULT(NOW() AT TIME ZONE 'utc'),
+    -- 강의 생성 일자
+    "updatedAt" TIMESTAMP WITHOUT TIME ZONE,
+    -- 강의 수정 일자
+    "teacherId" INTEGER REFERENCES teachers("teacherId") ON DELETE CASCADE,
+    -- 강사 ID
+    "categoryId" INTEGER REFERENCES classes_category("categoryId") ON DELETE CASCADE -- 강사 ID
+);
+-- ==============
+--   수강생 테이블
+-- ==============
+-- 수강생 테이블 생성
+CREATE TABLE students(
+    "studentId" SERIAL PRIMARY KEY,
+    -- 수강생 ID
+    "email" VARCHAR(48) UNIQUE NOT NULL,
+    -- 수강생 이메일
+    "nickname" VARCHAR(32) NOT NULL -- 수강생 닉네임
+);
+-- ===============
+--   수강신청 테이블
+-- ===============
+-- 수강신청 테이블 생성
+CREATE TABLE enrolment(
+    "classId" INTEGER REFERENCES classes("classId") ON DELETE CASCADE,
+    -- 강의 ID
+    "studentId" INTEGER REFERENCES students("studentId") ON DELETE CASCADE,
+    -- 수강생 ID
+    "applicationAt" TIMESTAMP WITHOUT TIME ZONE DEFAULT(NOW() AT TIME ZONE 'utc') -- 신청 일자
+);

package/lib/node-postgres/src/dtos/users.dto.ts

@@ -0,0 +1,20 @@
+import { IsEmail, IsString, IsNotEmpty, MinLength, MaxLength } from 'class-validator';
+
+export class CreateUserDto {
+  @IsEmail()
+  public email: string;
+
+  @IsString()
+  @IsNotEmpty()
+  @MinLength(9)
+  @MaxLength(32)
+  public password: string;
+}
+
+export class UpdateUserDto {
+  @IsString()
+  @IsNotEmpty()
+  @MinLength(9)
+  @MaxLength(32)
+  public password: string;
+}

package/lib/node-postgres/src/exceptions/httpException.ts

@@ -0,0 +1,10 @@
+export class HttpException extends Error {
+  public status: number;
+  public message: string;
+
+  constructor(status: number, message: string) {
+    super(message);
+    this.status = status;
+    this.message = message;
+  }
+}

package/lib/node-postgres/src/http/auth.http

@@ -0,0 +1,27 @@
+# baseURL
+@baseURL = http://localhost:3000
+
+###
+# User Signup
+POST {{ baseURL }}/signup
+Content-Type: application/json
+
+{
+    "email": "example@email.com",
+	"password": "password"
+}
+
+###
+# User Login
+POST {{ baseURL }}/login
+Content-Type: application/json
+
+{
+    "email": "example@email.com",
+	"password": "password"
+}
+
+###
+# User Logout
+POST {{ baseURL }}/logout
+Content-Type: application/json

package/lib/node-postgres/src/http/users.http

@@ -0,0 +1,34 @@
+# baseURL
+@baseURL = http://localhost:3000
+
+###
+# Find All Users
+GET {{ baseURL }}/users
+
+###
+# Find User By Id
+GET {{ baseURL }}/users/1
+
+###
+# Create User
+POST {{ baseURL }}/users
+Content-Type: application/json
+
+{
+    "email": "example@email.com",
+	"password": "password"
+}
+
+###
+# Modify User By Id
+PUT {{ baseURL }}/users/1
+Content-Type: application/json
+
+{
+    "email": "example@email.com",
+	"password": "password"
+}
+
+###
+# Delete User By Id
+DELETE {{ baseURL }}/users/1

package/lib/node-postgres/src/interfaces/auth.interface.ts

@@ -0,0 +1,15 @@
+import { Request } from 'express';
+import { User } from '@interfaces/users.interface';
+
+export interface DataStoredInToken {
+  id: number;
+}
+
+export interface TokenData {
+  token: string;
+  expiresIn: number;
+}
+
+export interface RequestWithUser extends Request {
+  user: User;
+}

package/lib/node-postgres/src/interfaces/routes.interface.ts

@@ -0,0 +1,6 @@
+import { Router } from 'express';
+
+export interface Routes {
+  path?: string;
+  router: Router;
+}

package/lib/node-postgres/src/interfaces/users.interface.ts

@@ -0,0 +1,5 @@
+export interface User {
+  id?: number;
+  email: string;
+  password: string;
+}

package/lib/node-postgres/src/middlewares/auth.middleware.ts

@@ -0,0 +1,38 @@
+import { NextFunction, Response } from 'express';
+import { verify } from 'jsonwebtoken';
+import { SECRET_KEY } from '@config';
+import { HttpException } from '@exceptions/httpException';
+import { DataStoredInToken, RequestWithUser } from '@interfaces/auth.interface';
+import { UserModel } from '@models/users.model';
+
+const getAuthorization = req => {
+  const coockie = req.cookies['Authorization'];
+  if (coockie) return coockie;
+
+  const header = req.header('Authorization');
+  if (header) return header.split('Bearer ')[1];
+
+  return null;
+};
+
+export const AuthMiddleware = async (req: RequestWithUser, res: Response, next: NextFunction) => {
+  try {
+    const Authorization = getAuthorization(req);
+
+    if (Authorization) {
+      const { id } = (await verify(Authorization, SECRET_KEY)) as DataStoredInToken;
+      const findUser = UserModel.find(user => user.id === id);
+
+      if (findUser) {
+        req.user = findUser;
+        next();
+      } else {
+        next(new HttpException(401, 'Wrong authentication token'));
+      }
+    } else {
+      next(new HttpException(404, 'Authentication token missing'));
+    }
+  } catch (error) {
+    next(new HttpException(401, 'Wrong authentication token'));
+  }
+};

package/lib/node-postgres/src/middlewares/error.middleware.ts

@@ -0,0 +1,15 @@
+import { NextFunction, Request, Response } from 'express';
+import { HttpException } from '@exceptions/httpException';
+import { logger } from '@utils/logger';
+
+export const ErrorMiddleware = (error: HttpException, req: Request, res: Response, next: NextFunction) => {
+  try {
+    const status: number = error.status || 500;
+    const message: string = error.message || 'Something went wrong';
+
+    logger.error(`[${req.method}] ${req.path} >> StatusCode:: ${status}, Message:: ${message}`);
+    res.status(status).json({ message });
+  } catch (error) {
+    next(error);
+  }
+};

package/lib/node-postgres/src/middlewares/validation.middleware.ts

@@ -0,0 +1,27 @@
+import { plainToInstance } from 'class-transformer';
+import { validateOrReject, ValidationError } from 'class-validator';
+import { NextFunction, Request, Response } from 'express';
+import { HttpException } from '@exceptions/httpException';
+
+/**
+ * @name ValidationMiddleware
+ * @description Allows use of decorator and non-decorator based validation
+ * @param type dto
+ * @param skipMissingProperties When skipping missing properties
+ * @param whitelist Even if your object is an instance of a validation class it can contain additional properties that are not defined
+ * @param forbidNonWhitelisted If you would rather to have an error thrown when any non-whitelisted properties are present
+ */
+export const ValidationMiddleware = (type: any, skipMissingProperties = false, whitelist = false, forbidNonWhitelisted = false) => {
+  return (req: Request, res: Response, next: NextFunction) => {
+    const dto = plainToInstance(type, req.body);
+    validateOrReject(dto, { skipMissingProperties, whitelist, forbidNonWhitelisted })
+      .then(() => {
+        req.body = dto;
+        next();
+      })
+      .catch((errors: ValidationError[]) => {
+        const message = errors.map((error: ValidationError) => Object.values(error.constraints)).join(', ');
+        next(new HttpException(400, message));
+      });
+  };
+};

package/lib/node-postgres/src/models/users.model.ts

@@ -0,0 +1,9 @@
+import { User } from '@interfaces/users.interface';
+
+// password: password
+export const UserModel: User[] = [
+  { id: 1, email: 'example1@email.com', password: '$2b$10$TBEfaCe1oo.2jfkBDWcj/usBj4oECsW2wOoDXpCa2IH9xqCpEK/hC' },
+  { id: 2, email: 'example2@email.com', password: '$2b$10$TBEfaCe1oo.2jfkBDWcj/usBj4oECsW2wOoDXpCa2IH9xqCpEK/hC' },
+  { id: 3, email: 'example3@email.com', password: '$2b$10$TBEfaCe1oo.2jfkBDWcj/usBj4oECsW2wOoDXpCa2IH9xqCpEK/hC' },
+  { id: 4, email: 'example4@email.com', password: '$2b$10$TBEfaCe1oo.2jfkBDWcj/usBj4oECsW2wOoDXpCa2IH9xqCpEK/hC' },
+];

package/lib/node-postgres/src/routes/auth.route.ts

@@ -0,0 +1,21 @@
+import { Router } from 'express';
+import { AuthController } from '@controllers/auth.controller';
+import { CreateUserDto } from '@dtos/users.dto';
+import { Routes } from '@interfaces/routes.interface';
+import { AuthMiddleware } from '@middlewares/auth.middleware';
+import { ValidationMiddleware } from '@middlewares/validation.middleware';
+
+export class AuthRoute implements Routes {
+  public router = Router();
+  public auth = new AuthController();
+
+  constructor() {
+    this.initializeRoutes();
+  }
+
+  private initializeRoutes() {
+    this.router.post('/signup', ValidationMiddleware(CreateUserDto, 'body'), this.auth.signUp);
+    this.router.post('/login', ValidationMiddleware(CreateUserDto, 'body'), this.auth.logIn);
+    this.router.post('/logout', AuthMiddleware, this.auth.logOut);
+  }
+}

package/lib/node-postgres/src/routes/users.route.ts

@@ -0,0 +1,23 @@
+import { Router } from 'express';
+import { UserController } from '@controllers/users.controller';
+import { CreateUserDto } from '@dtos/users.dto';
+import { Routes } from '@interfaces/routes.interface';
+import { ValidationMiddleware } from '@middlewares/validation.middleware';
+
+export class UserRoute implements Routes {
+  public path = '/users';
+  public router = Router();
+  public user = new UserController();
+
+  constructor() {
+    this.initializeRoutes();
+  }
+
+  private initializeRoutes() {
+    this.router.get(`${this.path}`, this.user.getUsers);
+    this.router.get(`${this.path}/:id(\\d+)`, this.user.getUserById);
+    this.router.post(`${this.path}`, ValidationMiddleware(CreateUserDto, 'body'), this.user.createUser);
+    this.router.put(`${this.path}/:id(\\d+)`, ValidationMiddleware(CreateUserDto, 'body', true), this.user.updateUser);
+    this.router.delete(`${this.path}/:id(\\d+)`, this.user.deleteUser);
+  }
+}

package/lib/node-postgres/src/server.ts

@@ -0,0 +1,10 @@
+import { App } from '@/app';
+import { AuthRoute } from '@routes/auth.route';
+import { UserRoute } from '@routes/users.route';
+import { ValidateEnv } from '@utils/validateEnv';
+
+ValidateEnv();
+
+const app = new App([new AuthRoute(), new UserRoute()]);
+
+app.listen();