typescript-express-starter 9.2.0 → 10.0.1

package/lib/graphql/.env.development.local

@@ -2,11 +2,11 @@
 PORT = 3000
 
 # DATABASE
-DB_HOST = localhost
-DB_PORT = 5432
-DB_USER = root
-DB_PASSWORD = password
-DB_DATABASE = dev
+POSTGRES_USER = root
+POSTGRES_PASSWORD = password
+POSTGRES_HOST = localhost
+POSTGRES_PORT = 5432
+POSTGRES_DB = dev
 
 # TOKEN
 SECRET_KEY = secretKey
@@ -16,5 +16,5 @@ LOG_FORMAT = dev
 LOG_DIR = ../logs
 
 # CORS
-ORIGIN = true
+ORIGIN = *
 CREDENTIALS = true

package/lib/graphql/.env.production.local

@@ -2,11 +2,11 @@
 PORT = 3000
 
 # DATABASE
-DB_HOST = localhost
-DB_PORT = 5432
-DB_USER = root
-DB_PASSWORD = password
-DB_DATABASE = prod
+POSTGRES_USER = root
+POSTGRES_PASSWORD = password
+POSTGRES_HOST = localhost
+POSTGRES_PORT = 5432
+POSTGRES_DB = dev
 
 # TOKEN
 SECRET_KEY = secretKey
@@ -16,5 +16,5 @@ LOG_FORMAT = combined
 LOG_DIR = ../logs
 
 # CORS
-ORIGIN = false
+ORIGIN = your.domain.com
 CREDENTIALS = true

package/lib/graphql/.env.test.local

@@ -2,11 +2,11 @@
 PORT = 3000
 
 # DATABASE
-DB_HOST = localhost
-DB_PORT = 5432
-DB_USER = root
-DB_PASSWORD = password
-DB_DATABASE = test
+POSTGRES_USER = root
+POSTGRES_PASSWORD = password
+POSTGRES_HOST = localhost
+POSTGRES_PORT = 5432
+POSTGRES_DB = dev
 
 # TOKEN
 SECRET_KEY = secretKey
@@ -16,5 +16,5 @@ LOG_FORMAT = dev
 LOG_DIR = ../logs
 
 # CORS
-ORIGIN = true
+ORIGIN = *
 CREDENTIALS = true

package/lib/graphql/.swcrc

@@ -22,7 +22,7 @@
     "paths": {
       "@/*": ["*"],
       "@config": ["config"],
-      "@databases": ["databases"],
+      "@database": ["database"],
       "@dtos/*": ["dtos/*"],
       "@entities/*": ["entities/*"],
       "@exceptions/*": ["exceptions/*"],

package/lib/graphql/Dockerfile.dev

@@ -0,0 +1,19 @@
+# NodeJS Version 16
+FROM node:16.18-buster-slim
+
+# Copy Dir
+COPY . ./app
+
+# Work to Dir
+WORKDIR /app
+
+# Install Node Package
+RUN npm install --legacy-peer-deps
+
+# Set Env
+ENV NODE_ENV development
+
+EXPOSE 3000
+
+# Cmd script
+CMD ["npm", "run", "dev"]

package/lib/graphql/Dockerfile.prod

@@ -0,0 +1,19 @@
+# NodeJS Version 16
+FROM node:16.18-buster-slim
+
+# Copy Dir
+COPY . ./app
+
+# Work to Dir
+WORKDIR /app
+
+# Install Node Package
+RUN npm install --legacy-peer-deps
+
+# Set Env
+ENV NODE_ENV production
+
+EXPOSE 3000
+
+# Cmd script
+CMD ["npm", "run", "start"]

package/lib/graphql/Makefile

@@ -2,28 +2,45 @@
 # ex) production-stage: make build APP_NAME=<APP_NAME>
 # ex) development-stage: make build-dev APP_NAME=<APP_NAME>
 
+SHELL := /bin/bash
+
 APP_NAME = typescript-express
 APP_NAME := $(APP_NAME)
 
-.PHONY: build
-# Build the container image - Dvelopment
-build-dev:
+.PHONY: help start clean db test
+
+help:
+	@grep -E '^[1-9a-zA-Z_-]+:.*?## .*$$|(^#--)' $(MAKEFILE_LIST) \
+	| awk 'BEGIN {FS = ":.*?## "}; {printf "\033[32m %-43s\033[0m %s\n", $$1, $$2}' \
+	| sed -e 's/\[32m #-- /[33m/'
+
+#-- Docker
+up: ## Up the container images
+	docker-compose up -d
+
+down: ## Down the container images
+	docker-compose down
+
+build: ## Build the container image - Production
 	docker build -t ${APP_NAME}\
-		--target development-build-stage\
-		-f Dockerfile .
+		-f Dockerfile.prod .
 
-# Build the container image - Production
-build:
+build-dev: ## Build the container image - Development
 	docker build -t ${APP_NAME}\
-		--target production-build-stage\
-		-f Dockerfile .
+		-f Dockerfile.dev .
 
-# Clean the container image
-clean:
+run: ## Run the container image
+	docker run -d -it -p 3000:3000 ${APP_NAME}
+
+pause: ## Pause the containers
+	docker container rm -f ${APP_NAME}
+
+clean: ## Clean the images
 	docker rmi -f ${APP_NAME}
 
-# Run the container image
-run:
-	docker run -d -it -p 3000:3000 ${APP_NAME}
+remove: ## Remove the volumes
+	docker volume rm -f ${APP_NAME}
 
-all: build
+#-- Database
+db: ## Start the local database PostgreSQL
+	docker-compose up -d pg

package/lib/graphql/docker-compose.yml

@@ -1,43 +1,51 @@
-version: '3.7'
+version: "3.9"
 
 services:
   proxy:
-    image: nginx:alpine
     container_name: proxy
+    image: nginx:alpine
     ports:
-      - '80:80'
+      - "80:80"
     volumes:
       - ./nginx.conf:/etc/nginx/nginx.conf
-    restart: 'unless-stopped'
+    restart: "unless-stopped"
     networks:
       - backend
+
   server:
+    container_name: server
     build:
       context: ./
-      target: development-build-stage
-      dockerfile: Dockerfile
-    container_name: server
+      dockerfile: Dockerfile.dev
     ports:
-      - '3000:3000'
+      - "3000:3000"
+    environment:
+      POSTGRES_USER: root
+      POSTGRES_PASSWORD: password
+      POSTGRES_HOST: pg
+      POSTGRES_PORT: 5432
+      POSTGRES_DB: dev
     volumes:
       - ./:/app
       - /app/node_modules
-    restart: 'unless-stopped'
+    restart: "unless-stopped"
     networks:
       - backend
     links:
       - pg
     depends_on:
       - pg
+
   pg:
-    image: bitnami/postgresql:11-debian-9
     container_name: pg
-    environment:
-      POSTGRESQL_USERNAME: root
-      POSTGRESQL_PASSWORD: password
-      POSTGRESQL_DATABASE: test
+    image: postgres:14.5-alpine
     ports:
-      - '5432:5432'
+      - "5432:5432"
+    environment:
+      POSTGRES_USER: root
+      POSTGRES_PASSWORD: password
+      POSTGRES_DB: dev
+    restart: "always"
     networks:
       - backend
 

package/lib/graphql/package.json

@@ -26,13 +26,14 @@
     "dotenv": "^16.0.1",
     "envalid": "^7.3.1",
     "express": "^4.18.1",
-    "graphql": "^16.5.0",
+    "graphql": "^15.8.0",
     "helmet": "^5.1.1",
     "hpp": "^0.2.3",
     "jsonwebtoken": "^8.5.1",
     "pg": "^8.7.3",
     "reflect-metadata": "^0.1.13",
     "type-graphql": "^1.1.1",
+    "typedi": "^0.10.0",
     "typeorm": "^0.2.45",
     "winston": "^3.8.1",
     "winston-daily-rotate-file": "^4.7.1"

package/lib/graphql/src/app.ts

@@ -8,14 +8,13 @@ import express from 'express';
 import helmet from 'helmet';
 import hpp from 'hpp';
 import { buildSchema } from 'type-graphql';
-import { createConnection } from 'typeorm';
 import { NODE_ENV, PORT, ORIGIN, CREDENTIALS } from '@config';
-import { dbConnection } from '@databases';
-import { authMiddleware, authChecker } from '@middlewares/auth.middleware';
-import errorMiddleware from '@middlewares/error.middleware';
+import { dbConnection } from '@database';
+import { AuthMiddleware, AuthCheckerMiddleware } from '@middlewares/auth.middleware';
+import { ErrorMiddleware } from '@middlewares/error.middleware';
 import { logger, responseLogger, errorLogger } from '@utils/logger';
 
-class App {
+export class App {
   public app: express.Application;
   public env: string;
   public port: string | number;
@@ -45,8 +44,8 @@ class App {
     return this.app;
   }
 
-  private connectToDatabase() {
-    createConnection(dbConnection);
+  private async connectToDatabase() {
+    await dbConnection();
   }
 
   private initializeMiddlewares() {
@@ -65,7 +64,7 @@ class App {
   private async initApolloServer(resolvers) {
     const schema = await buildSchema({
       resolvers: resolvers,
-      authChecker: authChecker,
+      authChecker: AuthCheckerMiddleware,
     });
 
     const apolloServer = new ApolloServer({
@@ -77,7 +76,7 @@ class App {
       ],
       context: async ({ req }) => {
         try {
-          const user = await authMiddleware(req);
+          const user = await AuthMiddleware(req);
           return { user };
         } catch (error) {
           throw new Error(error);
@@ -89,19 +88,20 @@ class App {
         return response;
       },
       formatError: error => {
-        errorLogger(error);
-
-        return error;
+        try {
+          errorLogger(error);
+          return error;
+        } catch (err) {
+          return new Error(err);
+        }
       },
     });
 
     await apolloServer.start();
-    apolloServer.applyMiddleware({ app: this.app, cors: ORIGIN, path: '/graphql' });
+    apolloServer.applyMiddleware({ app: this.app, cors: false, path: '/graphql' });
   }
 
   private initializeErrorHandling() {
-    this.app.use(errorMiddleware);
+    this.app.use(ErrorMiddleware);
   }
 }
-
-export default App;

package/lib/graphql/src/config/index.ts

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

package/lib/graphql/src/database/index.ts

@@ -0,0 +1,26 @@
+import { join } from 'path';
+import { createConnection, ConnectionOptions } from 'typeorm';
+import { POSTGRES_USER, POSTGRES_PASSWORD, POSTGRES_HOST, POSTGRES_PORT, POSTGRES_DB } from '@config';
+
+export const dbConnection = async () => {
+  const dbConfig: ConnectionOptions = {
+    type: 'postgres',
+    username: POSTGRES_USER,
+    password: POSTGRES_PASSWORD,
+    host: POSTGRES_HOST,
+    port: Number(POSTGRES_PORT),
+    database: POSTGRES_DB,
+    synchronize: true,
+    logging: false,
+    entities: [join(__dirname, '../**/*.entity{.ts,.js}')],
+    migrations: [join(__dirname, '../**/*.migration{.ts,.js}')],
+    subscribers: [join(__dirname, '../**/*.subscriber{.ts,.js}')],
+    cli: {
+      entitiesDir: 'src/entities',
+      migrationsDir: 'src/migration',
+      subscribersDir: 'src/subscriber',
+    },
+  };
+
+  await createConnection(dbConfig);
+}

package/lib/graphql/src/dtos/users.dto.ts

@@ -1,4 +1,4 @@
-import { IsEmail, IsString } from 'class-validator';
+import { IsEmail, IsString, IsNotEmpty, MinLength, MaxLength } from 'class-validator';
 import { InputType, Field } from 'type-graphql';
 import { User } from '@typedefs/users.type';
 
@@ -10,5 +10,18 @@ export class CreateUserDto implements Partial<User> {
 
   @Field()
   @IsString()
+  @IsNotEmpty()
+  @MinLength(9)
+  @MaxLength(32)
+  password: string;
+}
+
+@InputType()
+export class UpdateUserDto implements Partial<User> {
+  @Field()
+  @IsString()
+  @IsNotEmpty()
+  @MinLength(9)
+  @MaxLength(32)
   password: string;
 }

package/lib/graphql/src/interfaces/users.interface.ts

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

package/lib/graphql/src/middlewares/auth.middleware.ts

@@ -3,15 +3,25 @@ import { AuthChecker } from 'type-graphql';
 import { getRepository } from 'typeorm';
 import { SECRET_KEY } from '@config';
 import { UserEntity } from '@entities/users.entity';
-import { HttpException } from '@exceptions/HttpException';
+import { HttpException } from '@exceptions/httpException';
 import { RequestWithUser, DataStoredInToken } from '@interfaces/auth.interface';
 
-export const authMiddleware = async req => {
+const getAuthorization = req => {
+  const cookie = req.cookies['Authorization'];
+  if (cookie) return cookie;
+
+  const header = req.header('Authorization');
+  if (header) return header.split('Bearer ')[1];
+
+  return null;
+};
+
+export const AuthMiddleware = async req => {
   try {
-    const Authorization = req.cookies['Authorization'] || (req.header('Authorization') ? req.header('Authorization').split('Bearer ')[1] : null);
+    const Authorization = getAuthorization(req);
+
     if (Authorization) {
-      const secretKey: string = SECRET_KEY;
-      const { id } = (await verify(Authorization, secretKey)) as DataStoredInToken;
+      const { id } = verify(Authorization, SECRET_KEY) as DataStoredInToken;
       const userRepository = getRepository(UserEntity);
       const findUser = await userRepository.findOne(id, { select: ['id', 'email', 'password'] });
       return findUser;
@@ -23,7 +33,7 @@ export const authMiddleware = async req => {
   }
 };
 
-export const authChecker: AuthChecker<RequestWithUser> = async ({ context: { user } }) => {
+export const AuthCheckerMiddleware: AuthChecker<RequestWithUser> = async ({ context: { user } }) => {
   if (!user) {
     throw new HttpException(404, 'Authentication token missing');
   }

package/lib/graphql/src/middlewares/error.middleware.ts

@@ -1,8 +1,8 @@
 import { NextFunction, Request, Response } from 'express';
-import { HttpException } from '@exceptions/HttpException';
+import { HttpException } from '@exceptions/httpException';
 import { logger } from '@utils/logger';
 
-const errorMiddleware = (error: HttpException, req: Request, res: Response, next: NextFunction) => {
+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';
@@ -13,5 +13,3 @@ const errorMiddleware = (error: HttpException, req: Request, res: Response, next
     next(error);
   }
 };
-
-export default errorMiddleware;

package/lib/graphql/src/repositories/auth.repository.ts

@@ -4,16 +4,24 @@ import { EntityRepository } from 'typeorm';
 import { SECRET_KEY } from '@config';
 import { CreateUserDto } from '@dtos/users.dto';
 import { UserEntity } from '@entities/users.entity';
-import { HttpException } from '@exceptions/HttpException';
+import { HttpException } from '@exceptions/httpException';
 import { DataStoredInToken, TokenData } from '@interfaces/auth.interface';
 import { User } from '@interfaces/users.interface';
-import { isEmpty } from '@utils/util';
+
+const createToken = (user: User): TokenData => {
+  const dataStoredInToken: DataStoredInToken = { id: user.id };
+  const expiresIn: number = 60 * 60;
+
+  return { expiresIn, token: sign(dataStoredInToken, SECRET_KEY, { expiresIn }) };
+};
+
+const createCookie = (tokenData: TokenData): string => {
+  return `Authorization=${tokenData.token}; HttpOnly; Max-Age=${tokenData.expiresIn};`;
+};
 
 @EntityRepository(UserEntity)
-export default class AuthRepository {
+export class AuthRepository {
   public async userSignUp(userData: CreateUserDto): Promise<User> {
-    if (isEmpty(userData)) throw new HttpException(400, "userData is empty");
-
     const findUser: User = await UserEntity.findOne({ where: { email: userData.email } });
     if (findUser) throw new HttpException(409, `This email ${userData.email} already exists`);
 
@@ -24,38 +32,22 @@ export default class AuthRepository {
   }
 
   public async userLogIn(userData: CreateUserDto): Promise<{ cookie: string; findUser: User }> {
-    if (isEmpty(userData)) throw new HttpException(400, "userData is empty");
-
     const findUser: User = await UserEntity.findOne({ where: { email: userData.email } });
     if (!findUser) throw new HttpException(409, `This email ${userData.email} was not found`);
 
     const isPasswordMatching: boolean = await compare(userData.password, findUser.password);
-    if (!isPasswordMatching) throw new HttpException(409, "Password is not matching");
+    if (!isPasswordMatching) throw new HttpException(409, 'Password is not matching');
 
-    const tokenData = this.createToken(findUser);
-    const cookie = this.createCookie(tokenData);
+    const tokenData = createToken(findUser);
+    const cookie = createCookie(tokenData);
 
     return { cookie, findUser };
   }
 
   public async userLogOut(userId: number): Promise<User> {
-    if (isEmpty(userId)) throw new HttpException(400, "userId is empty");
-
     const findUser: User = await UserEntity.findOne({ where: { id: userId } });
     if (!findUser) throw new HttpException(409, "User doesn't exist");
 
     return findUser;
   }
-
-  public createToken(user: User): TokenData {
-    const dataStoredInToken: DataStoredInToken = { id: user.id };
-    const secretKey: string = SECRET_KEY;
-    const expiresIn: number = 60 * 60;
-
-    return { expiresIn, token: sign(dataStoredInToken, secretKey, { expiresIn }) };
-  }
-
-  public createCookie(tokenData: TokenData): string {
-    return `Authorization=${tokenData.token}; HttpOnly; Max-Age=${tokenData.expiresIn};`;
-  }
 }

package/lib/graphql/src/repositories/users.repository.ts

@@ -1,13 +1,12 @@
 import { hash } from 'bcrypt';
 import { EntityRepository } from 'typeorm';
-import { CreateUserDto } from '@dtos/users.dto';
+import { CreateUserDto, UpdateUserDto } from '@dtos/users.dto';
 import { UserEntity } from '@entities/users.entity';
-import { HttpException } from '@exceptions/HttpException';
+import { HttpException } from '@exceptions/httpException';
 import { User } from '@interfaces/users.interface';
-import { isEmpty } from '@utils/util';
 
-@EntityRepository()
-export default class UserRepository {
+@EntityRepository(UserEntity)
+export class UserRepository {
   public async userFindAll(): Promise<User[]> {
     const users: User[] = await UserEntity.find();
 
@@ -15,8 +14,6 @@ export default class UserRepository {
   }
 
   public async userFindById(userId: number): Promise<User> {
-    if (isEmpty(userId)) throw new HttpException(400, "UserId is empty");
-
     const user: User = await UserEntity.findOne({ where: { id: userId } });
     if (!user) throw new HttpException(409, "User doesn't exist");
 
@@ -24,8 +21,6 @@ export default class UserRepository {
   }
 
   public async userCreate(userData: CreateUserDto): Promise<User> {
-    if (isEmpty(userData)) throw new HttpException(400, "userData is empty");
-
     const findUser: User = await UserEntity.findOne({ where: { email: userData.email } });
     if (findUser) throw new HttpException(409, `This email ${userData.email} already exists`);
 
@@ -35,9 +30,7 @@ export default class UserRepository {
     return createUserData;
   }
 
-  public async userUpdate(userId: number, userData: CreateUserDto): Promise<User> {
-    if (isEmpty(userData)) throw new HttpException(400, "userData is empty");
-
+  public async userUpdate(userId: number, userData: UpdateUserDto): Promise<User> {
     const findUser: User = await UserEntity.findOne({ where: { id: userId } });
     if (!findUser) throw new HttpException(409, "User doesn't exist");
 
@@ -49,8 +42,6 @@ export default class UserRepository {
   }
 
   public async userDelete(userId: number): Promise<User> {
-    if (isEmpty(userId)) throw new HttpException(400, "User doesn't existId");
-
     const findUser: User = await UserEntity.findOne({ where: { id: userId } });
     if (!findUser) throw new HttpException(409, "User doesn't exist");
 

package/lib/graphql/src/resolvers/auth.resolver.ts

@@ -1,10 +1,10 @@
 import { Authorized, Arg, Ctx, Mutation, Resolver } from 'type-graphql';
 import { CreateUserDto } from '@dtos/users.dto';
-import AuthRepository from '@repositories/auth.repository';
+import { AuthRepository } from '@repositories/auth.repository';
 import { User } from '@typedefs/users.type';
 
 @Resolver()
-export class authResolver extends AuthRepository {
+export class AuthResolver extends AuthRepository {
   @Mutation(() => User, {
     description: 'User signup',
   })

package/lib/graphql/src/resolvers/users.resolver.ts

@@ -1,10 +1,10 @@
 import { Arg, Mutation, Query, Resolver } from 'type-graphql';
-import { CreateUserDto } from '@dtos/users.dto';
-import UserRepository from '@repositories/users.repository';
+import { CreateUserDto, UpdateUserDto } from '@dtos/users.dto';
+import { UserRepository } from '@repositories/users.repository';
 import { User } from '@typedefs/users.type';
 
 @Resolver()
-export class userResolver extends UserRepository {
+export class UserResolver extends UserRepository {
   @Query(() => [User], {
     description: 'User find list',
   })
@@ -32,7 +32,7 @@ export class userResolver extends UserRepository {
   @Mutation(() => User, {
     description: 'User update',
   })
-  async updateUser(@Arg('userId') userId: number, @Arg('userData') userData: CreateUserDto): Promise<User> {
+  async updateUser(@Arg('userId') userId: number, @Arg('userData') userData: UpdateUserDto): Promise<User> {
     const user: User = await this.userUpdate(userId, userData);
     return user;
   }

package/lib/graphql/src/server.ts

@@ -1,11 +1,10 @@
-import App from '@/app';
-import validateEnv from '@utils/validateEnv';
+import { App } from '@/app';
+import { AuthResolver } from '@resolvers/auth.resolver';
+import { UserResolver } from '@resolvers/users.resolver';
+import { ValidateEnv } from '@utils/validateEnv';
 
-import { authResolver } from '@resolvers/auth.resolver';
-import { userResolver } from '@resolvers/users.resolver';
+ValidateEnv();
 
-validateEnv();
-
-const app = new App([authResolver, userResolver]);
+const app = new App([AuthResolver, UserResolver]);
 
 app.listen();

package/lib/graphql/src/test/auth.test.ts

@@ -0,0 +1,10 @@
+import request from 'supertest';
+import { App } from '@/app';
+import { CreateUserDto } from '@dtos/users.dto';
+
+afterAll(async () => {
+  await new Promise<void>(resolve => setTimeout(() => resolve(), 500));
+});
+
+describe('Testing Auth', () => {
+});