typescript-express-starter 9.2.0 → 10.0.0

package/lib/routing-controllers/src/controllers/auth.controller.ts

@@ -1,38 +1,39 @@
 import { Response } from 'express';
 import { Controller, Req, Body, Post, UseBefore, HttpCode, Res } from 'routing-controllers';
+import { Container } from 'typedi';
 import { CreateUserDto } from '@dtos/users.dto';
 import { RequestWithUser } from '@interfaces/auth.interface';
 import { User } from '@interfaces/users.interface';
-import authMiddleware from '@middlewares/auth.middleware';
-import { validationMiddleware } from '@middlewares/validation.middleware';
-import AuthService from '@services/auth.service';
+import { AuthMiddleware } from '@middlewares/auth.middleware';
+import { ValidationMiddleware } from '@middlewares/validation.middleware';
+import { AuthService } from '@services/auth.service';
 
 @Controller()
 export class AuthController {
-  public authService = new AuthService();
+  public auth = Container.get(AuthService);
 
   @Post('/signup')
-  @UseBefore(validationMiddleware(CreateUserDto, 'body'))
+  @UseBefore(ValidationMiddleware(CreateUserDto, 'body'))
   @HttpCode(201)
-  async signUp(@Body() userData: CreateUserDto) {
-    const signUpUserData: User = await this.authService.signup(userData);
+  async signUp(@Body() userData: User) {
+    const signUpUserData: User = await this.auth.signup(userData);
     return { data: signUpUserData, message: 'signup' };
   }
 
   @Post('/login')
-  @UseBefore(validationMiddleware(CreateUserDto, 'body'))
-  async logIn(@Res() res: Response, @Body() userData: CreateUserDto) {
-    const { cookie, findUser } = await this.authService.login(userData);
+  @UseBefore(ValidationMiddleware(CreateUserDto, 'body'))
+  async logIn(@Res() res: Response, @Body() userData: User) {
+    const { cookie, findUser } = await this.auth.login(userData);
 
     res.setHeader('Set-Cookie', [cookie]);
     return { data: findUser, message: 'login' };
   }
 
   @Post('/logout')
-  @UseBefore(authMiddleware)
+  @UseBefore(AuthMiddleware)
   async logOut(@Req() req: RequestWithUser, @Res() res: Response) {
     const userData: User = req.user;
-    const logOutUserData: User = await this.authService.logout(userData);
+    const logOutUserData: User = await this.auth.logout(userData);
 
     res.setHeader('Set-Cookie', ['Authorization=; Max-age=0']);
     return { data: logOutUserData, message: 'logout' };

package/lib/routing-controllers/src/controllers/users.controller.ts

@@ -1,49 +1,51 @@
 import { Controller, Param, Body, Get, Post, Put, Delete, HttpCode, UseBefore } from 'routing-controllers';
 import { OpenAPI } from 'routing-controllers-openapi';
+import { Container } from 'typedi';
 import { CreateUserDto } from '@dtos/users.dto';
 import { User } from '@interfaces/users.interface';
-import userService from '@services/users.service';
-import { validationMiddleware } from '@middlewares/validation.middleware';
+import { ValidationMiddleware } from '@middlewares/validation.middleware';
+import { UserService } from '@services/users.service';
 
 @Controller()
-export class UsersController {
-  public userService = new userService();
+export class UserController {
+  public path = '/users'
+  public user = Container.get(UserService);
 
   @Get('/users')
   @OpenAPI({ summary: 'Return a list of users' })
   async getUsers() {
-    const findAllUsersData: User[] = await this.userService.findAllUser();
+    const findAllUsersData: User[] = await this.user.findAllUser();
     return { data: findAllUsersData, message: 'findAll' };
   }
 
   @Get('/users/:id')
   @OpenAPI({ summary: 'Return find a user' })
   async getUserById(@Param('id') userId: number) {
-    const findOneUserData: User = await this.userService.findUserById(userId);
+    const findOneUserData: User = await this.user.findUserById(userId);
     return { data: findOneUserData, message: 'findOne' };
   }
 
   @Post('/users')
   @HttpCode(201)
-  @UseBefore(validationMiddleware(CreateUserDto, 'body'))
+  @UseBefore(ValidationMiddleware(CreateUserDto, 'body'))
   @OpenAPI({ summary: 'Create a new user' })
-  async createUser(@Body() userData: CreateUserDto) {
-    const createUserData: User = await this.userService.createUser(userData);
+  async createUser(@Body() userData: User) {
+    const createUserData: User = await this.user.createUser(userData);
     return { data: createUserData, message: 'created' };
   }
 
   @Put('/users/:id')
-  @UseBefore(validationMiddleware(CreateUserDto, 'body', true))
+  @UseBefore(ValidationMiddleware(CreateUserDto, 'body', true))
   @OpenAPI({ summary: 'Update a user' })
-  async updateUser(@Param('id') userId: number, @Body() userData: CreateUserDto) {
-    const updateUserData: User[] = await this.userService.updateUser(userId, userData);
+  async updateUser(@Param('id') userId: number, @Body() userData: User) {
+    const updateUserData: User[] = await this.user.updateUser(userId, userData);
     return { data: updateUserData, message: 'updated' };
   }
 
   @Delete('/users/:id')
   @OpenAPI({ summary: 'Delete a user' })
   async deleteUser(@Param('id') userId: number) {
-    const deleteUserData: User[] = await this.userService.deleteUser(userId);
+    const deleteUserData: User[] = await this.user.deleteUser(userId);
     return { data: deleteUserData, message: 'deleted' };
   }
 }

package/lib/routing-controllers/src/dtos/users.dto.ts

@@ -1,9 +1,20 @@
-import { IsEmail, IsString } from 'class-validator';
+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/routing-controllers/src/interfaces/users.interface.ts

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

package/lib/routing-controllers/src/middlewares/auth.middleware.ts

@@ -1,19 +1,27 @@
 import { NextFunction, Response } from 'express';
 import { verify } from 'jsonwebtoken';
 import { SECRET_KEY } from '@config';
-import { HttpException } from '@exceptions/HttpException';
+import { HttpException } from '@exceptions/httpException';
 import { DataStoredInToken, RequestWithUser } from '@interfaces/auth.interface';
-import userModel from '@models/users.model';
+import { UserModel } from '@models/users.model';
 
-const authMiddleware = async (req: RequestWithUser, res: Response, next: NextFunction) => {
+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 = 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 verificationResponse = (await verify(Authorization, secretKey)) as DataStoredInToken;
-      const userId = verificationResponse.id;
-      const findUser = userModel.find(user => user.id === userId);
+      const { id } = (await verify(Authorization, SECRET_KEY)) as DataStoredInToken;
+      const findUser = UserModel.find(user => user.id === id);
 
       if (findUser) {
         req.user = findUser;
@@ -28,5 +36,3 @@ const authMiddleware = async (req: RequestWithUser, res: Response, next: NextFun
     next(new HttpException(401, 'Wrong authentication token'));
   }
 };
-
-export default authMiddleware;

package/lib/routing-controllers/src/middlewares/error.middleware.ts

@@ -1,18 +1,15 @@
 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';
 
-    console.error(`[${req.method}] ${req.path} >> StatusCode:: ${status}, Message:: ${message}`);
     logger.error(`[${req.method}] ${req.path} >> StatusCode:: ${status}, Message:: ${message}`);
     res.status(status).json({ message });
   } catch (error) {
     next(error);
   }
 };
-
-export default errorMiddleware;

package/lib/routing-controllers/src/middlewares/validation.middleware.ts

@@ -1,31 +1,27 @@
-import { plainToClass } from 'class-transformer';
-import { validate, ValidationError } from 'class-validator';
-import { RequestHandler } from 'express';
-import { HttpException } from '@exceptions/HttpException';
+import { plainToInstance } from 'class-transformer';
+import { validateOrReject, ValidationError } from 'class-validator';
+import { NextFunction, Request, Response } from 'express';
+import { HttpException } from '@exceptions/httpException';
 
-const getAllNestedErrors = (error: ValidationError) => {
-  if(error.constraints){
-    return Object.values(error.constraints)
-  }
-  return error.children.map(getAllNestedErrors).join(',')
-}
-
-export const validationMiddleware = (
-  type: any,
-  value: string | 'body' | 'query' | 'params' = 'body',
-  skipMissingProperties = false,
-  whitelist = true,
-  forbidNonWhitelisted = true,
-): RequestHandler => {
-  return (req, res, next) => {
-    const obj = plainToClass(type, req[value]);
-    validate(obj, { skipMissingProperties, whitelist, forbidNonWhitelisted }).then((errors: ValidationError[]) => {
-      if (errors.length > 0) {
-        const message = errors.map(getAllNestedErrors).join(', ');
-        next(new HttpException(400, message));
-      } else {
+/**
+ * @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/routing-controllers/src/models/users.model.ts

@@ -1,11 +1,9 @@
 import { User } from '@interfaces/users.interface';
 
 // password: password
-const userModel: User[] = [
+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' },
 ];
-
-export default userModel;

package/lib/routing-controllers/src/server.ts

@@ -1,10 +1,9 @@
-import App from '@/app';
+import { App } from '@/app';
 import { AuthController } from '@controllers/auth.controller';
-import { IndexController } from '@controllers/index.controller';
-import { UsersController } from '@controllers/users.controller';
-import validateEnv from '@utils/validateEnv';
+import { UserController } from '@controllers/users.controller';
+import { ValidateEnv } from '@utils/validateEnv';
 
-validateEnv();
+ValidateEnv();
 
-const app = new App([AuthController, IndexController, UsersController]);
+const app = new App([AuthController, UserController]);
 app.listen();

package/lib/routing-controllers/src/services/auth.service.ts

@@ -1,63 +1,53 @@
 import { compare, hash } from 'bcrypt';
 import { sign } from 'jsonwebtoken';
+import { Service } from 'typedi';
 import { SECRET_KEY } from '@config';
 import { CreateUserDto } from '@dtos/users.dto';
-import { HttpException } from '@exceptions/HttpException';
+import { HttpException } from '@exceptions/httpException';
 import { DataStoredInToken, TokenData } from '@interfaces/auth.interface';
 import { User } from '@interfaces/users.interface';
-import userModel from '@models/users.model';
-import { isEmpty } from '@utils/util';
+import { UserModel } from '@models/users.model';
 
-class AuthService {
-  public users = userModel;
+const createToken = (user: User): TokenData => {
+  const dataStoredInToken: DataStoredInToken = { id: user.id };
+  const expiresIn: number = 60 * 60;
 
-  public async signup(userData: CreateUserDto): Promise<User> {
-    if (isEmpty(userData)) throw new HttpException(400, "userData is empty");
+  return { expiresIn, token: sign(dataStoredInToken, SECRET_KEY, { expiresIn }) };
+}
+
+const createCookie = (tokenData: TokenData): string => {
+  return `Authorization=${tokenData.token}; HttpOnly; Max-Age=${tokenData.expiresIn};`;
+}
 
-    const findUser: User = this.users.find(user => user.email === userData.email);
+@Service()
+export class AuthService {
+  public async signup(userData: CreateUserDto): 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 hashedPassword = await hash(userData.password, 10);
-    const createUserData: User = { id: this.users.length + 1, ...userData, password: hashedPassword };
+    const createUserData: User = { id: UserModel.length + 1, ...userData, password: hashedPassword };
 
     return createUserData;
   }
 
   public async login(userData: CreateUserDto): Promise<{ cookie: string; findUser: User }> {
-    if (isEmpty(userData)) throw new HttpException(400, "userData is empty");
-
-    const findUser: User = this.users.find(user => user.email === userData.email);
+    const findUser: User = UserModel.find(user => user.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");
 
-    const tokenData = this.createToken(findUser);
-    const cookie = this.createCookie(tokenData);
+    const tokenData = createToken(findUser);
+    const cookie = createCookie(tokenData);
 
     return { cookie, findUser };
   }
 
   public async logout(userData: User): Promise<User> {
-    if (isEmpty(userData)) throw new HttpException(400, "userData is empty");
-
-    const findUser: User = this.users.find(user => user.email === userData.email && user.password === userData.password);
+    const findUser: User = UserModel.find(user => user.email === userData.email && user.password === userData.password);
     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};`;
-  }
 }
-
-export default AuthService;

package/lib/routing-controllers/src/services/users.service.ts

@@ -1,46 +1,40 @@
 import { hash } from 'bcrypt';
+import { Service } from 'typedi';
 import { CreateUserDto } from '@dtos/users.dto';
-import { HttpException } from '@exceptions/HttpException';
+import { HttpException } from '@exceptions/httpException';
 import { User } from '@interfaces/users.interface';
-import userModel from '@models/users.model';
-import { isEmpty } from '@utils/util';
-
-class UserService {
-  public users = userModel;
+import { UserModel } from '@models/users.model';
 
+@Service()
+export class UserService {
   public async findAllUser(): Promise<User[]> {
-    const users: User[] = this.users;
+    const users: User[] = UserModel;
     return users;
   }
 
   public async findUserById(userId: number): Promise<User> {
-    const findUser: User = this.users.find(user => user.id === userId);
+    const findUser: User = UserModel.find(user => user.id === userId);
     if (!findUser) throw new HttpException(409, "User doesn't exist");
 
     return findUser;
   }
 
   public async createUser(userData: CreateUserDto): Promise<User> {
-    if (isEmpty(userData)) throw new HttpException(400, "userData is empty");
-
-    const findUser: User = this.users.find(user => user.email === userData.email);
+    const findUser: User = UserModel.find(user => user.email === userData.email);
     if (findUser) throw new HttpException(409, `This email ${userData.email} already exists`);
 
     const hashedPassword = await hash(userData.password, 10);
-    const createUserData: User = { id: this.users.length + 1, ...userData, password: hashedPassword };
-    this.users = [...this.users, createUserData];
+    const createUserData: User = { id: UserModel.length + 1, ...userData, password: hashedPassword };
 
     return createUserData;
   }
 
   public async updateUser(userId: number, userData: CreateUserDto): Promise<User[]> {
-    if (isEmpty(userData)) throw new HttpException(400, "userData is empty");
-
-    const findUser: User = this.users.find(user => user.id === userId);
+    const findUser: User = UserModel.find(user => user.id === userId);
     if (!findUser) throw new HttpException(409, "User doesn't exist");
 
     const hashedPassword = await hash(userData.password, 10);
-    const updateUserData: User[] = this.users.map((user: User) => {
+    const updateUserData: User[] = UserModel.map((user: User) => {
       if (user.id === findUser.id) user = { id: userId, ...userData, password: hashedPassword };
       return user;
     });
@@ -49,12 +43,10 @@ class UserService {
   }
 
   public async deleteUser(userId: number): Promise<User[]> {
-    const findUser: User = this.users.find(user => user.id === userId);
+    const findUser: User = UserModel.find(user => user.id === userId);
     if (!findUser) throw new HttpException(409, "User doesn't exist");
 
-    const deleteUserData: User[] = this.users.filter(user => user.id !== findUser.id);
+    const deleteUserData: User[] = UserModel.filter(user => user.id !== findUser.id);
     return deleteUserData;
   }
 }
-
-export default UserService;

package/lib/routing-controllers/src/{tests → test}/auth.test.ts

@@ -1,5 +1,5 @@
 import request from 'supertest';
-import App from '@/app';
+import { App } from '@/app';
 import { AuthController } from '@controllers/auth.controller';
 import { CreateUserDto } from '@dtos/users.dto';
 

package/lib/routing-controllers/src/{tests → test}/users.test.ts

@@ -1,9 +1,9 @@
 import request from 'supertest';
-import App from '@/app';
-import { UsersController } from '@controllers/users.controller';
+import { App } from '@/app';
+import { UserController } from '@controllers/users.controller';
 import { CreateUserDto } from '@dtos/users.dto';
 import { User } from '@interfaces/users.interface';
-import userModel from '@models/users.model';
+import { UserModel } from '@models/users.model';
 
 afterAll(async () => {
   await new Promise<void>(resolve => setTimeout(() => resolve(), 500));
@@ -12,9 +12,9 @@ afterAll(async () => {
 describe('Testing Users', () => {
   describe('[GET] /users', () => {
     it('response statusCode 200 / findAll', () => {
-      const findUser: User[] = userModel;
+      const findUser: User[] = UserModel;
 
-      const app = new App([UsersController]);
+      const app = new App([UserController]);
       return request(app.getServer()).get('/users').expect(200, { data: findUser, message: 'findAll' });
     });
   });
@@ -22,9 +22,9 @@ describe('Testing Users', () => {
   describe('[GET] /users/:id', () => {
     it('response statusCode 200 / findOne', () => {
       const userId = 1;
-      const findUser: User = userModel.find(user => user.id === userId);
+      const findUser: User = UserModel.find(user => user.id === userId);
 
-      const app = new App([UsersController]);
+      const app = new App([UserController]);
       return request(app.getServer()).get(`/users/${userId}`).expect(200, { data: findUser, message: 'findOne' });
     });
   });
@@ -36,7 +36,7 @@ describe('Testing Users', () => {
         password: 'q1w2e3r4',
       };
 
-      const app = new App([UsersController]);
+      const app = new App([UserController]);
       return request(app.getServer()).post('/users').send(userData).expect(201);
     });
   });
@@ -49,7 +49,7 @@ describe('Testing Users', () => {
         password: 'q1w2e3r4',
       };
 
-      const app = new App([UsersController]);
+      const app = new App([UserController]);
       return request(app.getServer()).put(`/users/${userId}`).send(userData).expect(200);
     });
   });
@@ -58,7 +58,7 @@ describe('Testing Users', () => {
     it('response statusCode 200 / deleted', () => {
       const userId = 1;
 
-      const app = new App([UsersController]);
+      const app = new App([UserController]);
       return request(app.getServer()).delete(`/users/${userId}`).expect(200);
     });
   });

package/lib/routing-controllers/src/utils/validateEnv.ts

@@ -1,10 +1,8 @@
 import { cleanEnv, port, str } from 'envalid';
 
-const validateEnv = () => {
+export const ValidateEnv = () => {
   cleanEnv(process.env, {
     NODE_ENV: str(),
     PORT: port(),
   });
 };
-
-export default validateEnv;

package/lib/routing-controllers/tsconfig.json

@@ -34,5 +34,5 @@
     }
   },
   "include": ["src/**/*.ts", "src/**/*.json", ".env"],
-  "exclude": ["node_modules", "src/http", "src/logs", "src/tests"]
+  "exclude": ["node_modules", "src/http", "src/logs"]
 }

package/lib/sequelize/.env.development.local

@@ -2,10 +2,10 @@
 PORT = 3000
 
 # DATABASE
-DB_HOST = localhost
-DB_PORT = 3306
 DB_USER = root
 DB_PASSWORD = password
+DB_HOST = localhost
+DB_PORT = 3306
 DB_DATABASE = dev
 
 # TOKEN

package/lib/sequelize/.env.production.local

@@ -2,11 +2,11 @@
 PORT = 3000
 
 # DATABASE
-DB_HOST = localhost
-DB_PORT = 3306
 DB_USER = root
 DB_PASSWORD = password
-DB_DATABASE = prod
+DB_HOST = localhost
+DB_PORT = 3306
+DB_DATABASE = dev
 
 # TOKEN
 SECRET_KEY = secretKey

package/lib/sequelize/.env.test.local

@@ -2,11 +2,11 @@
 PORT = 3000
 
 # DATABASE
-DB_HOST = localhost
-DB_PORT = 3306
 DB_USER = root
 DB_PASSWORD = password
-DB_DATABASE = test
+DB_HOST = localhost
+DB_PORT = 3306
+DB_DATABASE = dev
 
 # TOKEN
 SECRET_KEY = secretKey

package/lib/sequelize/.swcrc

@@ -23,7 +23,7 @@
       "@/*": ["*"],
       "@config": ["config"],
       "@controllers/*": ["controllers/*"],
-      "@databases": ["databases"],
+      "@database": ["database"],
       "@dtos/*": ["dtos/*"],
       "@exceptions/*": ["exceptions/*"],
       "@interfaces/*": ["interfaces/*"],

package/lib/sequelize/Dockerfile.dev

@@ -0,0 +1,23 @@
+# 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
+
+RUN chmod +x /app/docker-entrypoint.sh
+
+ENTRYPOINT [ "docker-entrypoint.sh" ]
+
+# Set Env
+ENV NODE_ENV development
+
+EXPOSE 3000
+
+# Cmd script
+CMD ["npm", "run", "dev"]