🌼 Update Version - v10.1.1

### 🌼 Update Version - v10.1.1

#### 🐞 Fix Bug
- Fix database import bug
- Correct variable name in users.route.ts

#### 🛠 Refactoring Code 
- Fix Database Connection

lib/node-postgres/.env.development.local

@@ -11,3 +11,10 @@ LOG_DIR = ../logs
 # CORS
 ORIGIN = *
 CREDENTIALS = true
+
+# DATABASE
+POSTGRES_USER = root
+POSTGRES_PASSWORD = password
+POSTGRES_HOST = localhost
+POSTGRES_PORT = 5432
+POSTGRES_DB = dev

lib/node-postgres/.env.production.local

@@ -11,3 +11,10 @@ LOG_DIR = ../logs
 # CORS
 ORIGIN = your.domain.com
 CREDENTIALS = true
+
+# DATABASE
+POSTGRES_USER = root
+POSTGRES_PASSWORD = password
+POSTGRES_HOST = pg
+POSTGRES_PORT = 5432
+POSTGRES_DB = dev

lib/node-postgres/.env.test.local

@@ -11,3 +11,10 @@ LOG_DIR = ../logs
 # CORS
 ORIGIN = *
 CREDENTIALS = true
+
+# DATABASE
+POSTGRES_USER = root
+POSTGRES_PASSWORD = password
+POSTGRES_HOST = pg
+POSTGRES_PORT = 5432
+POSTGRES_DB = dev

lib/node-postgres/.swcrc

@@ -28,7 +28,6 @@
         "@exceptions/*": ["exceptions/*"],
         "@interfaces/*": ["interfaces/*"],
         "@middlewares/*": ["middlewares/*"],
-        "@models/*": ["models/*"],
         "@services/*": ["services/*"],
         "@utils/*": ["utils/*"]
       }

lib/node-postgres/src/app.ts

@@ -9,7 +9,6 @@ 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';
@@ -24,7 +23,6 @@ export class App {
     this.env = NODE_ENV || 'development';
     this.port = PORT || 3000;
 
-    this.connectToDatabase();
     this.initializeMiddlewares();
     this.initializeRoutes(routes);
     this.initializeSwagger();
@@ -44,10 +42,6 @@ export class App {
     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 }));

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

@@ -3,4 +3,4 @@ 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;
+export const { POSTGRES_USER, POSTGRES_PASSWORD, POSTGRES_HOST, POSTGRES_PORT, POSTGRES_DB } = process.env;

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

@@ -1,6 +1,10 @@
 import { Client } from 'pg';
-import { DB_USER, DB_PASSWORD, DB_HOST, DB_PORT, DB_DATABASE } from '@config';
+import { POSTGRES_USER, POSTGRES_PASSWORD, POSTGRES_HOST, POSTGRES_PORT, POSTGRES_DB } from '@config';
 
 export const client = new Client({
-  connectionString: `postgres://${DB_USER}:${DB_PASSWORD}@${DB_HOST}:${DB_PORT}/${DB_DATABASE}`,
+  connectionString: `postgres://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${POSTGRES_HOST}:${POSTGRES_PORT}/${POSTGRES_DB}`,
 });
+
+client.connect();
+
+export default client;

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

@@ -1,110 +1,13 @@
--- 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, 비공개)
+-- If Exists Table Drop
+DROP TABLE IF EXISTS users cascade;
+-- ================
+--   TABLE [users]
+-- ================
+-- create users table
+CREATE TABLE users(
+    "id" SERIAL PRIMARY KEY,
+    "email" VARCHAR(32) UNIQUE NOT NULL,
+    "password" VARCHAR(48) NOT NULL,
     "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') -- 신청 일자
+    "updatedAt" TIMESTAMP WITHOUT TIME ZONE
 );

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

@@ -1,9 +1,9 @@
 import { NextFunction, Response } from 'express';
 import { verify } from 'jsonwebtoken';
 import { SECRET_KEY } from '@config';
+import pg from '@database';
 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'];
@@ -21,10 +21,18 @@ export const AuthMiddleware = async (req: RequestWithUser, res: Response, next:
 
     if (Authorization) {
       const { id } = (await verify(Authorization, SECRET_KEY)) as DataStoredInToken;
-      const findUser = UserModel.find(user => user.id === id);
+      const { rows, rowCount } = await pg.query(`
+        SELECT
+          "email",
+          "password"
+        FROM
+          users
+        WHERE
+          "id" = $1
+      `, id);
 
-      if (findUser) {
-        req.user = findUser;
+      if (rowCount) {
+        req.user = rows[0];
         next();
       } else {
         next(new HttpException(401, 'Wrong authentication token'));

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

@@ -14,8 +14,8 @@ export class AuthRoute implements Routes {
   }
 
   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('/signup', ValidationMiddleware(CreateUserDto), this.auth.signUp);
+    this.router.post('/login', ValidationMiddleware(CreateUserDto), this.auth.logIn);
     this.router.post('/logout', AuthMiddleware, this.auth.logOut);
   }
 }

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

@@ -16,8 +16,8 @@ export class UserRoute implements Routes {
   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.post(`${this.path}`, ValidationMiddleware(CreateUserDto), this.user.createUser);
+    this.router.put(`${this.path}/:id(\\d+)`, ValidationMiddleware(CreateUserDto, true), this.user.updateUser);
     this.router.delete(`${this.path}/:id(\\d+)`, this.user.deleteUser);
   }
 }

lib/node-postgres/src/services/auth.service.ts

@@ -2,10 +2,10 @@ import { hash, compare } from 'bcrypt';
 import { sign } from 'jsonwebtoken';
 import { Service } from 'typedi';
 import { SECRET_KEY } from '@config';
+import pg from '@database';
 import { HttpException } from '@exceptions/httpException';
 import { DataStoredInToken, TokenData } from '@interfaces/auth.interface';
 import { User } from '@interfaces/users.interface';
-import { UserModel } from '@models/users.model';
 
 const createToken = (user: User): TokenData => {
   const dataStoredInToken: DataStoredInToken = { id: user.id };
@@ -21,32 +21,83 @@ const createCookie = (tokenData: TokenData): string => {
 @Service()
 export class AuthService {
   public async signup(userData: User): Promise<User> {
-    const findUser: User = UserModel.find(user => user.email === userData.email);
-    if (findUser) throw new HttpException(409, `This email ${userData.email} already exists`);
+    const { email, password } = userData;
 
-    const hashedPassword = await hash(userData.password, 10);
-    const createUserData: User = { id: UserModel.length + 1, ...userData, password: hashedPassword };
+    const { rows: findUser } = await pg.query(
+      `
+    SELECT EXISTS(
+      SELECT
+        "email"
+      FROM
+        users
+      WHERE
+        "email" = $1
+    )`,
+      [email],
+    );
+    if (findUser[0].exists) throw new HttpException(409, `This email ${userData.email} already exists`);
 
-    return createUserData;
+    const hashedPassword = await hash(password, 10);
+    const { rows: signUpUserData } = await pg.query(
+      `
+      INSERT INTO
+        users(
+          "email",
+          "password"
+        )
+      VALUES ($1, $2)
+      RETURNING "email", "password"
+      `,
+      [email, hashedPassword],
+    );
+
+    return signUpUserData[0];
   }
 
   public async login(userData: User): Promise<{ cookie: string; findUser: User }> {
-    const findUser: User = UserModel.find(user => user.email === userData.email);
-    if (!findUser) throw new HttpException(409, `This email ${userData.email} was not found`);
+    const { email, password } = userData;
+
+    const { rows, rowCount } = await pg.query(
+      `
+      SELECT
+        "email",
+        "password"
+      FROM
+        users
+      WHERE
+        "email" = $1
+    `,
+      [email],
+    );
+    if (!rowCount) throw new HttpException(409, `This email ${email} was not found`);
 
-    const isPasswordMatching: boolean = await compare(userData.password, findUser.password);
+    const isPasswordMatching: boolean = await compare(password, rows[0].password);
     if (!isPasswordMatching) throw new HttpException(409, "You're password not matching");
 
-    const tokenData = createToken(findUser);
+    const tokenData = createToken(rows[0]);
     const cookie = createCookie(tokenData);
-
-    return { cookie, findUser };
+    return { cookie, findUser: rows[0] };
   }
 
   public async logout(userData: User): Promise<User> {
-    const findUser: User = UserModel.find(user => user.email === userData.email && user.password === userData.password);
-    if (!findUser) throw new HttpException(409, "User doesn't exist");
+    const { email, password } = userData;
+
+    const { rows, rowCount } = await pg.query(
+      `
+    SELECT
+        "email",
+        "password"
+      FROM
+        users
+      WHERE
+        "email" = $1
+      AND
+        "password" = $2
+    `,
+      [email, password],
+    );
+    if (!rowCount) throw new HttpException(409, "User doesn't exist");
 
-    return findUser;
+    return rows[0];
   }
 }