typescript-express-starter 6.3.0 → 7.0.0

package/lib/graphql/src/app.ts

@@ -0,0 +1,105 @@
+import 'reflect-metadata';
+import '@/index';
+import { ApolloServerPluginLandingPageProductionDefault, ApolloServerPluginLandingPageLocalDefault } from 'apollo-server-core';
+import { ApolloServer } from 'apollo-server-express';
+import compression from 'compression';
+import cookieParser from 'cookie-parser';
+import cors from 'cors';
+import config from 'config';
+import express from 'express';
+import helmet from 'helmet';
+import hpp from 'hpp';
+import { buildSchema } from 'type-graphql';
+import { createConnection } from 'typeorm';
+import { dbConnection } from '@databases';
+import { authMiddleware, authChecker } from '@middlewares/auth.middleware';
+import errorMiddleware from '@middlewares/error.middleware';
+import { logger, responseLogger, errorLogger } from '@utils/logger';
+
+class App {
+  public app: express.Application;
+  public port: string | number;
+  public env: string;
+
+  constructor(resolvers) {
+    this.app = express();
+    this.port = process.env.PORT || 3000;
+    this.env = process.env.NODE_ENV || 'development';
+
+    this.connectToDatabase();
+    this.initializeMiddlewares();
+    this.initApolloServer(resolvers);
+    this.initializeErrorHandling();
+  }
+
+  public async listen() {
+    this.app.listen(this.port, () => {
+      logger.info(`=================================`);
+      logger.info(`======= ENV: ${this.env} =======`);
+      logger.info(`🚀 App listening on the port ${this.port}`);
+      logger.info(`🎮 http://localhost:${this.port}/graphql`);
+      logger.info(`=================================`);
+    });
+  }
+
+  public getServer() {
+    return this.app;
+  }
+
+  private connectToDatabase() {
+    createConnection(dbConnection);
+  }
+
+  private initializeMiddlewares() {
+    this.app.use(cors({ origin: config.get('cors.origin'), credentials: config.get('cors.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 async initApolloServer(resolvers) {
+    const schema = await buildSchema({
+      resolvers: resolvers,
+      authChecker: authChecker,
+    });
+
+    const apolloServer = new ApolloServer({
+      schema: schema,
+      plugins: [
+        process.env.NODE_ENV === 'production'
+          ? ApolloServerPluginLandingPageProductionDefault({ footer: false })
+          : ApolloServerPluginLandingPageLocalDefault({ footer: false }),
+      ],
+      context: async ({ req }) => {
+        try {
+          const user = await authMiddleware(req);
+          return { user };
+        } catch (error) {
+          throw new Error(error);
+        }
+      },
+      formatResponse: (response, request) => {
+        responseLogger(request);
+
+        return response;
+      },
+      formatError: error => {
+        errorLogger(error);
+
+        return error;
+      },
+    });
+
+    await apolloServer.start();
+    apolloServer.applyMiddleware({ app: this.app, cors: true, path: '/graphql' });
+  }
+
+  private initializeErrorHandling() {
+    this.app.use(errorMiddleware);
+  }
+}
+
+export default App;

package/lib/graphql/src/configs/development.json

@@ -0,0 +1,19 @@
+{
+    "env": "development",
+    "dbConfig": {
+        "host": "localhost",
+        "user": "root",
+        "port": 5432,
+        "password": "password",
+        "database": "test"
+    },
+    "secretKey": "secretKey",
+    "log": {
+        "format": "dev",
+        "dir": "../logs"
+    },
+    "cors": {
+        "origin": true,
+        "credentials": true
+    }
+}

package/lib/graphql/src/configs/production.json

@@ -0,0 +1,19 @@
+{
+    "env": "production",
+    "dbConfig": {
+        "host": "localhost",
+        "user": "root",
+        "port": 5432,
+        "password": "password",
+        "database": "test"
+    },
+    "secretKey": "secretKey",
+    "log": {
+        "format": "combined",
+        "dir": "../logs"
+    },
+    "cors": {
+        "origin": "your.domain.com",
+        "credentials": true
+    }
+}

package/lib/graphql/src/configs/test.json

@@ -0,0 +1,19 @@
+{
+    "env": "test",
+    "dbConfig": {
+        "host": "localhost",
+        "user": "root",
+        "port": 5432,
+        "password": "password",
+        "database": "test"
+    },
+    "secretKey": "secretKey",
+    "log": {
+        "format": "dev",
+        "dir": "../logs"
+    },
+    "cors": {
+        "origin": true,
+        "credentials": true
+    }
+}

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

@@ -0,0 +1,24 @@
+import config from 'config';
+import { join } from 'path';
+import { ConnectionOptions } from 'typeorm';
+import { dbConfig } from '@interfaces/db.interface';
+
+const { host, port, user, password, database }: dbConfig = config.get('dbConfig');
+export const dbConnection: ConnectionOptions = {
+  type: 'postgres',
+  host: host,
+  port: port,
+  username: user,
+  password: password,
+  database: database,
+  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',
+  },
+};

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

@@ -0,0 +1,14 @@
+import { IsEmail, IsString } from 'class-validator';
+import { InputType, Field } from 'type-graphql';
+import { User } from '@typedefs/users.type';
+
+@InputType()
+export class CreateUserDto implements Partial<User> {
+  @Field()
+  @IsEmail()
+  email: string;
+
+  @Field()
+  @IsString()
+  password: string;
+}

package/lib/graphql/src/entities/users.entity.ts

@@ -0,0 +1,26 @@
+import { IsNotEmpty } from 'class-validator';
+import { BaseEntity, Entity, PrimaryGeneratedColumn, Column, Unique, CreateDateColumn, UpdateDateColumn } from 'typeorm';
+import { User } from '@interfaces/users.interface';
+
+@Entity()
+export class UserEntity extends BaseEntity implements User {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column()
+  @IsNotEmpty()
+  @Unique()
+  email: string;
+
+  @Column()
+  @IsNotEmpty()
+  password: string;
+
+  @Column()
+  @CreateDateColumn()
+  createdAt: Date;
+
+  @Column()
+  @UpdateDateColumn()
+  updatedAt: Date;
+}

package/lib/graphql/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/graphql/src/http/auth.http

@@ -0,0 +1,49 @@
+# baseURL
+@baseURL = http://localhost:3000/graphql
+
+###
+# User Signup
+POST {{ baseURL }}
+Content-Type: application/json
+X-REQUEST-TYPE: GraphQL
+
+mutation {
+    signup (userData: {
+        email: "example@email.com",
+        password: "password"
+    }) {
+        id,
+        email,
+        password
+    }
+}
+
+###
+# User Login
+POST {{ baseURL }}
+Content-Type: application/json
+X-REQUEST-TYPE: GraphQL
+
+mutation {
+    login (userData: {
+        email: "example@email.com",
+        password: "password"
+    }) {
+        email,
+        password
+    }
+}
+
+###
+# User Logout
+POST {{ baseURL }}
+Content-Type: application/json
+X-REQUEST-TYPE: GraphQL
+Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6MiwiaWF0IjoxNjM5MDQ3MjM3LCJleHAiOjE2MzkwNTA4Mzd9.HD0AvZl1s-mycKxo0IJ1QT-oSKhjeArXrlNBffZUanY;
+
+mutation {
+    logout {
+        email,
+        password
+    }
+}

package/lib/graphql/src/http/users.http

@@ -0,0 +1,78 @@
+# baseURL
+@baseURL = http://localhost:3000/graphql
+
+###
+# Find All Users
+POST {{ baseURL }}
+Content-Type: application/json
+X-REQUEST-TYPE: GraphQL
+
+query {
+    getUsers {
+        id,
+        email,
+        password
+    }
+}
+
+###
+# Find User By Id
+POST {{ baseURL }}
+Content-Type: application/json
+X-REQUEST-TYPE: GraphQL
+
+query {
+    getUserById(userId: 1) {
+        id,
+        email,
+        password
+    }
+}
+
+###
+# Create User
+POST {{ baseURL }}
+Content-Type: application/json
+X-REQUEST-TYPE: GraphQL
+
+mutation {
+    createUser (userData: {
+        email: "example@email.com",
+        password: "password"
+    }) {
+        id,
+        email,
+        password
+    }
+}
+
+###
+# Modify User By Id
+POST {{ baseURL }}
+Content-Type: application/json
+X-REQUEST-TYPE: GraphQL
+
+mutation {
+    updateUser (userId: 1, userData: {
+        email: "example@email.com",
+        password: "password"
+    }) {
+        id,
+        email,
+        password
+    }
+}
+
+###
+# Delete User By Id
+POST {{ baseURL }}
+Content-Type: application/json
+X-REQUEST-TYPE: GraphQL
+
+mutation {
+    deleteUser (userId: 1) {
+        id,
+        email,
+        password
+    }
+}

package/lib/graphql/src/index.ts

@@ -0,0 +1 @@
+process.env['NODE_CONFIG_DIR'] = __dirname + '/configs';

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

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

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

@@ -0,0 +1,7 @@
+export interface dbConfig {
+  host: string;
+  user: string;
+  port: number;
+  password: string;
+  database: string;
+}

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

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

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

@@ -0,0 +1,32 @@
+import config from 'config';
+import { verify } from 'jsonwebtoken';
+import { AuthChecker } from 'type-graphql';
+import { getRepository } from 'typeorm';
+import { UserEntity } from '@entities/users.entity';
+import { HttpException } from '@exceptions/HttpException';
+import { RequestWithUser, DataStoredInToken } from '@interfaces/auth.interface';
+
+export const authMiddleware = async req => {
+  try {
+    const Authorization = req.cookies['Authorization'] || (req.header('Authorization') ? req.header('Authorization').split('Bearer ')[1] : null);
+    if (Authorization) {
+      const secretKey: string = config.get('secretKey');
+      const { id } = (await verify(Authorization, secretKey)) as DataStoredInToken;
+      const userRepository = getRepository(UserEntity);
+      const findUser = await userRepository.findOne(id, { select: ['id', 'email', 'password'] });
+      return findUser;
+    }
+
+    return null;
+  } catch (error) {
+    throw new HttpException(401, 'Wrong authentication token');
+  }
+};
+
+export const authChecker: AuthChecker<RequestWithUser> = async ({ context: { user } }) => {
+  if (!user) {
+    throw new HttpException(404, 'Authentication token missing');
+  }
+
+  return true;
+};

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

@@ -0,0 +1,17 @@
+import { NextFunction, Request, Response } from 'express';
+import { HttpException } from '@exceptions/HttpException';
+import { logger } from '@utils/logger';
+
+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);
+  }
+};
+
+export default errorMiddleware;

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

@@ -0,0 +1,61 @@
+import { hash, compare } from 'bcrypt';
+import config from 'config';
+import { sign } from 'jsonwebtoken';
+import { EntityRepository } from 'typeorm';
+import { CreateUserDto } from '@dtos/users.dto';
+import { UserEntity } from '@entities/users.entity';
+import { HttpException } from '@exceptions/HttpException';
+import { DataStoredInToken, TokenData } from '@interfaces/auth.interface';
+import { User } from '@interfaces/users.interface';
+import { isEmpty } from '@utils/util';
+
+@EntityRepository(UserEntity)
+export default class AuthRepository {
+  public async userSignUp(userData: CreateUserDto): Promise<User> {
+    if (isEmpty(userData)) throw new HttpException(400, "You're not userData");
+
+    const findUser: User = await UserEntity.findOne({ where: { email: userData.email } });
+    if (findUser) throw new HttpException(409, `You're email ${userData.email} already exists`);
+
+    const hashedPassword = await hash(userData.password, 10);
+    const createUserData: User = await UserEntity.save({ ...userData, password: hashedPassword });
+
+    return createUserData;
+  }
+
+  public async userLogIn(userData: CreateUserDto): Promise<{ cookie: string; findUser: User }> {
+    if (isEmpty(userData)) throw new HttpException(400, "You're not userData");
+
+    const findUser: User = await UserEntity.findOne({ where: { email: userData.email } });
+    if (!findUser) throw new HttpException(409, `You're email ${userData.email} not found`);
+
+    const isPasswordMatching: boolean = await compare(userData.password, findUser.password);
+    if (!isPasswordMatching) throw new HttpException(409, "You're password not matching");
+
+    const tokenData = this.createToken(findUser);
+    const cookie = this.createCookie(tokenData);
+
+    return { cookie, findUser };
+  }
+
+  public async userLogOut(userId: number): Promise<User> {
+    if (isEmpty(userId)) throw new HttpException(400, "You're not userId");
+
+    const findUser: User = await UserEntity.findOne({ where: { id: userId } });
+    if (!findUser) throw new HttpException(409, "You're not user");
+
+    return findUser;
+  }
+
+  public createToken(user: User): TokenData {
+    const dataStoredInToken: DataStoredInToken = { id: user.id };
+    const secretKey: string = config.get('secretKey');
+    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

@@ -0,0 +1,60 @@
+import { hash } from 'bcrypt';
+import { EntityRepository } from 'typeorm';
+import { CreateUserDto } from '@dtos/users.dto';
+import { UserEntity } from '@entities/users.entity';
+import { HttpException } from '@exceptions/HttpException';
+import { User } from '@interfaces/users.interface';
+import { isEmpty } from '@utils/util';
+
+@EntityRepository()
+export default class UserRepository {
+  public async userFindAll(): Promise<User[]> {
+    const users: User[] = await UserEntity.find();
+
+    return users;
+  }
+
+  public async userFindById(userId: number): Promise<User> {
+    if (isEmpty(userId)) throw new HttpException(400, "You're not userId");
+
+    const user: User = await UserEntity.findOne({ where: { id: userId } });
+    if (!user) throw new HttpException(409, "You're not user");
+
+    return user;
+  }
+
+  public async userCreate(userData: CreateUserDto): Promise<User> {
+    if (isEmpty(userData)) throw new HttpException(400, "You're not userData");
+
+    const findUser: User = await UserEntity.findOne({ where: { email: userData.email } });
+    if (findUser) throw new HttpException(409, `You're email ${userData.email} already exists`);
+
+    const hashedPassword = await hash(userData.password, 10);
+    const createUserData: User = await UserEntity.save({ ...userData, password: hashedPassword });
+
+    return createUserData;
+  }
+
+  public async userUpdate(userId: number, userData: CreateUserDto): Promise<User> {
+    if (isEmpty(userData)) throw new HttpException(400, "You're not userData");
+
+    const findUser: User = await UserEntity.findOne({ where: { id: userId } });
+    if (!findUser) throw new HttpException(409, "You're not user");
+
+    const hashedPassword = await hash(userData.password, 10);
+    await UserEntity.update(userId, { ...userData, password: hashedPassword });
+
+    const updateUser: User = await UserEntity.findOne({ where: { id: userId } });
+    return updateUser;
+  }
+
+  public async userDelete(userId: number): Promise<User> {
+    if (isEmpty(userId)) throw new HttpException(400, "You're not userId");
+
+    const findUser: User = await UserEntity.findOne({ where: { id: userId } });
+    if (!findUser) throw new HttpException(409, "You're not user");
+
+    await UserEntity.delete({ id: userId });
+    return findUser;
+  }
+}

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

@@ -0,0 +1,32 @@
+import { Authorized, Arg, Ctx, Mutation, Resolver } from 'type-graphql';
+import { CreateUserDto } from '@dtos/users.dto';
+import AuthRepository from '@repositories/auth.repository';
+import { User } from '@typedefs/users.type';
+
+@Resolver()
+export class authResolver extends AuthRepository {
+  @Mutation(() => User, {
+    description: 'User signup',
+  })
+  async signup(@Arg('userData') userData: CreateUserDto): Promise<User> {
+    const user: User = await this.userSignUp(userData);
+    return user;
+  }
+
+  @Mutation(() => User, {
+    description: 'User login',
+  })
+  async login(@Arg('userData') userData: CreateUserDto): Promise<User> {
+    const { findUser } = await this.userLogIn(userData);
+    return findUser;
+  }
+
+  @Authorized()
+  @Mutation(() => User, {
+    description: 'User logout',
+  })
+  async logout(@Ctx('user') userData: any): Promise<User> {
+    const user = await this.userLogOut(userData);
+    return user;
+  }
+}

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

@@ -0,0 +1,47 @@
+import { Arg, Mutation, Query, Resolver } from 'type-graphql';
+import { CreateUserDto } from '@dtos/users.dto';
+import UserRepository from '@repositories/users.repository';
+import { User } from '@typedefs/users.type';
+
+@Resolver()
+export class userResolver extends UserRepository {
+  @Query(() => [User], {
+    description: 'User find list',
+  })
+  async getUsers(): Promise<User[]> {
+    const users: User[] = await this.userFindAll();
+    return users;
+  }
+
+  @Query(() => User, {
+    description: 'User find by id',
+  })
+  async getUserById(@Arg('userId') userId: number): Promise<User> {
+    const user: User = await this.userFindById(userId);
+    return user;
+  }
+
+  @Mutation(() => User, {
+    description: 'User create',
+  })
+  async createUser(@Arg('userData') userData: CreateUserDto): Promise<User> {
+    const user: User = await this.userCreate(userData);
+    return user;
+  }
+
+  @Mutation(() => User, {
+    description: 'User update',
+  })
+  async updateUser(@Arg('userId') userId: number, @Arg('userData') userData: CreateUserDto): Promise<User> {
+    const user: User = await this.userUpdate(userId, userData);
+    return user;
+  }
+
+  @Mutation(() => User, {
+    description: 'User delete',
+  })
+  async deleteUser(@Arg('userId') userId: number): Promise<User> {
+    const user: User = await this.userDelete(userId);
+    return user;
+  }
+}

package/lib/graphql/src/server.ts

@@ -0,0 +1,14 @@
+import 'reflect-metadata';
+import 'dotenv/config';
+import '@/index';
+import App from '@/app';
+import validateEnv from '@utils/validateEnv';
+
+import { authResolver } from '@resolvers/auth.resolver';
+import { userResolver } from '@resolvers/users.resolver';
+
+validateEnv();
+
+const app = new App([authResolver, userResolver]);
+
+app.listen();