create-craftjs 1.0.0

package/template/src/repositories/user-repository.ts

@@ -0,0 +1,75 @@
+import { prismaClient } from "../config/database";
+
+export class UserRepository {
+  static async countByEmail(email: string): Promise<number> {
+    return prismaClient.user.count({ where: { email } });
+  }
+
+  static async create(data: any) {
+    return prismaClient.user.create({ data });
+  }
+
+  static async findMany(filters: any, skip: number, take: number) {
+    return prismaClient.user.findMany({
+      where: {
+        AND: filters,
+        deleted_at: null,
+      },
+      skip,
+      take,
+      orderBy: { updated_at: "desc" },
+    });
+  }
+
+  static async count(filters: any) {
+    return prismaClient.user.count({
+      where: {
+        AND: filters,
+        deleted_at: null,
+      },
+    });
+  }
+
+  static async findById(id: string) {
+    return prismaClient.user.findUnique({
+      where: { id },
+    });
+  }
+
+  static async update(id: string, data: any) {
+    return prismaClient.user.update({
+      where: { id },
+      data,
+    });
+  }
+
+  static async delete(id: string) {
+    return prismaClient.user.delete({ where: { id } });
+  }
+
+  static async findUserByEmail(login: string) {
+    return prismaClient.user.findFirst({
+      where: {
+        email: login,
+      },
+    });
+  }
+
+  static async updateUser(data: any, id: string) {
+    return prismaClient.user.update({
+      where: { id },
+      data,
+    });
+  }
+
+  static async findemailExistsNotUserLoggedIn(email: string, idUser: string) {
+    return prismaClient.user.count({
+      where: {
+        email: email,
+        NOT: {
+          id: idUser,
+        },
+      },
+    });
+  }
+}

package/template/src/routes/auth-route.ts

@@ -0,0 +1,20 @@
+import express from "express";
+import { asyncHandler } from "../utils/async-handler";
+import { authMiddleware } from "../middleware/auth-middleware";
+
+import { AuthController } from "../controllers/auth-controller";
+export const authRouter = express.Router();
+authRouter.post("/api/auth/register", AuthController.register);
+authRouter.post("/api/auth/login", AuthController.login);
+authRouter.get("/api/auth/me", asyncHandler(authMiddleware), AuthController.me);
+authRouter.post(
+  "/api/auth/logout",
+  asyncHandler(authMiddleware),
+  AuthController.logout
+);
+authRouter.get("/api/auth/refresh-token", AuthController.refreshToken);
+authRouter.put(
+  "/api/auth/update-profile",
+  asyncHandler(authMiddleware),
+  AuthController.updateProfile
+);

package/template/src/routes/main-route.ts

@@ -0,0 +1,25 @@
+import express from "express";
+import { successResponse } from "../utils/response";
+import { authRouter } from "./auth-route";
+import { userRouter } from "./user-route";
+
+export const mainRouter = express.Router();
+
+// mainRouter.get("/", (req, res) => {
+//   res.render("index", { title: "Home Page" });
+// });
+
+mainRouter.get("/", (req, res) => {
+  res
+    .status(200)
+    .json(successResponse(`${process.env.APP_NAME}  is running`, 200))
+    .end();
+});
+mainRouter.get("/api", (req, res) => {
+  res
+    .status(200)
+    .json(successResponse(`${process.env.APP_NAME} api is running`, 200))
+    .end();
+});
+mainRouter.use(authRouter);
+mainRouter.use(userRouter);

package/template/src/routes/user-route.ts

@@ -0,0 +1,35 @@
+import express from "express";
+import { UserController } from "../controllers/user-controller";
+import { asyncHandler } from "../utils/async-handler";
+import { authMiddleware } from "../middleware/auth-middleware";
+
+export const userRouter = express.Router();
+
+userRouter.post(
+  "/api/users",
+  asyncHandler(authMiddleware),
+  UserController.create
+);
+
+userRouter.get(
+  "/api/users",
+  asyncHandler(authMiddleware),
+  UserController.getAll
+);
+userRouter.get(
+  "/api/users/:id",
+  asyncHandler(authMiddleware),
+  UserController.getOne
+);
+
+userRouter.put(
+  "/api/users/:id",
+  asyncHandler(authMiddleware),
+  UserController.update
+);
+
+userRouter.delete(
+  "/api/users/:id",
+  asyncHandler(authMiddleware),
+  UserController.delete
+);

package/template/src/services/auth-service.ts

@@ -0,0 +1,162 @@
+import {
+  toUserDetailResponse,
+  toUserResponse,
+  UserDetailResponse,
+  UserResponse,
+  loginRequest,
+  CreateUserRequest,
+  UpdateUserRequest,
+} from "../dtos/user-dto";
+import { ResponseError } from "../utils/response-error";
+import { UserValidation } from "../validations/user-validation";
+import { Validation } from "../utils/validation";
+import * as argon2 from "argon2";
+import { User } from "@prisma/client";
+import jwt from "jsonwebtoken";
+import { Request } from "express";
+import { UserRepository } from "../repositories/user-repository";
+import { UserRequest } from "../types/type-request";
+import { prismaClient } from "../config/database";
+import { env } from "../config/env";
+
+export class AuthService {
+  static async register(request: CreateUserRequest): Promise<UserResponse> {
+    const data = Validation.validate(UserValidation.REGISTER, request);
+    const emailExits = await UserRepository.countByEmail(data.email);
+
+    if (emailExits != 0) {
+      throw new ResponseError(409, "Akun Sudah Terdaftar!");
+    }
+
+    data.password = await argon2.hash(data.password);
+
+    const response = await UserRepository.create({
+      fullName: data.fullName,
+      email: data.email,
+      password: data.password,
+    });
+    return toUserResponse(response);
+  }
+
+  static async login(request: loginRequest) {
+    const data = Validation.validate(UserValidation.LOGIN, request);
+    const userExits = await UserRepository.findUserByEmail(data.email);
+
+    if (!userExits) {
+      throw new ResponseError(401, "Gagal Login! Detail login salah");
+    }
+
+    const isPasswordValid = await argon2.verify(
+      userExits.password,
+      data.password
+    );
+    if (!isPasswordValid) {
+      throw new ResponseError(401, "Gagal Login! Detail login salah");
+    }
+
+    const refreshToken = jwt.sign(
+      {
+        user_id: userExits.id,
+        user_fullName: userExits.fullName,
+        user_email: userExits.email,
+      },
+      env.JWT_SECRET as string,
+      {
+        expiresIn: "1d",
+      }
+    );
+
+    const accessToken = jwt.sign(
+      {
+        user_id: userExits.id,
+        user_fullName: userExits.fullName,
+        user_email: userExits.email,
+      },
+      env.JWT_SECRET as string,
+      {
+        expiresIn: "5m",
+      }
+    );
+
+    const user = toUserResponse(userExits);
+    return { user, refreshToken, accessToken };
+  }
+
+  static async me(user: User): Promise<UserDetailResponse> {
+    return toUserDetailResponse(user);
+  }
+
+  static async updateProfile(
+    user: User,
+    request: UpdateUserRequest
+  ): Promise<UserResponse> {
+    const data = Validation.validate(UserValidation.UPDATE, request);
+    if (data.fullName) {
+      user.fullName = data.fullName;
+    }
+    if (data.password) {
+      user.password = await argon2.hash(data.password);
+    }
+
+    if (data.email && data.email !== user.email) {
+      const emailExists = await UserRepository.findemailExistsNotUserLoggedIn(
+        data.email,
+        user.id
+      );
+      if (emailExists != 0) {
+        throw new ResponseError(409, "Email Sudah Ada");
+      }
+      user.email = data.email;
+    }
+    const result = await UserRepository.updateUser(
+      {
+        fullName: user.fullName,
+        password: user.password,
+        email: user.email,
+      },
+      user.id
+    );
+    return toUserResponse(result);
+  }
+
+  static async logout(req: UserRequest) {
+    const refreshToken = req.cookies.refresh_token;
+    if (!req.user) {
+      throw new ResponseError(401, "Unauthorized: Anda Belum Login.");
+    }
+    if (!refreshToken) {
+      throw new ResponseError(401, "Unauthorized: Anda Belum Login.");
+    }
+    return refreshToken;
+  }
+
+  static async refreshToken(req: Request) {
+    const refreshToken = req.cookies.refresh_token;
+    if (!refreshToken) {
+      throw new ResponseError(401, "Unauthorized, Anda Belum Login");
+    }
+
+    try {
+      const decoded = jwt.verify(refreshToken, env.JWT_SECRET as string) as any;
+
+      const user = await prismaClient.user.findUnique({
+        where: { id: decoded.user_id },
+      });
+
+      if (!user) {
+        throw new ResponseError(401, "Unauthorized, Anda Belum Login.");
+      }
+      const payload = {
+        user_id: user.id,
+        user_fullName: user.fullName,
+        user_email: user.email,
+      };
+      const accessToken = jwt.sign(payload, env.JWT_SECRET as string, {
+        expiresIn: "6m",
+      });
+      return { accessToken, user: payload };
+    } catch (err) {
+      throw new ResponseError(401, "Token Tidak Valid Atau Kadaluarsa");
+    }
+  }
+}

package/template/src/services/user-service.ts

@@ -0,0 +1,102 @@
+import {
+  CreateUserRequest,
+  ListUserRequest,
+  UpdateUserRequest,
+  toUserResponse,
+  UserResponse,
+} from "../dtos/user-dto";
+import { ResponseError } from "../utils/response-error";
+import { UserValidation } from "../validations/user-validation";
+import { Validation } from "../utils/validation";
+import * as argon2 from "argon2";
+import { listResponse, tolistResponse } from "../dtos/list-dto";
+import { UserRepository } from "../repositories/user-repository";
+import { env } from "../config/env";
+export class UserService {
+  static async create(request: CreateUserRequest): Promise<UserResponse> {
+    const data = Validation.validate(UserValidation.CREATE, request);
+    const emailExits = await UserRepository.countByEmail(data.email);
+    if (emailExits != 0) {
+      throw new ResponseError(409, "Email Sudah Terdaftar");
+    }
+    data.password = await argon2.hash(data.password);
+
+    const response = await UserRepository.create({
+      fullName: data.fullName,
+      email: data.email,
+      password: data.password,
+    });
+    return toUserResponse(response);
+  }
+  static async getAll(request: ListUserRequest): Promise<listResponse> {
+    const requestList = Validation.validate(UserValidation.LIST, request);
+    const filters = [];
+    if (requestList.name) {
+      filters.push({
+        fullName: {
+          contains: requestList.name,
+        },
+      });
+    }
+    const data = await UserRepository.findMany(
+      filters,
+      requestList.skip,
+      requestList.take
+    );
+    const totalData = await UserRepository.count(filters);
+    const result = {
+      data,
+      total_data: totalData,
+      paging: {
+        current_page: requestList.page,
+        total_page: Math.ceil(totalData / requestList.take),
+      },
+    };
+    return tolistResponse(result);
+  }
+
+  static async getOne(id: string): Promise<UserResponse> {
+    const data = await UserRepository.findById(id);
+    if (!data) {
+      throw new ResponseError(404, "Data Tidak Ditemukan");
+    }
+    return toUserResponse(data);
+  }
+  static async update(
+    id: string,
+    request: UpdateUserRequest
+  ): Promise<UserResponse> {
+    const data = Validation.validate(UserValidation.UPDATE, request);
+    const user = await UserRepository.findById(id);
+    if (!user) {
+      throw new ResponseError(404, "Data Tidak Ditemukan");
+    }
+    if (data.fullName) {
+      user.fullName = data.fullName;
+    }
+    if (data.password) {
+      user.password = await argon2.hash(data.password);
+    }
+    if (data.email && data.email !== user.email) {
+      const emailExists = await UserRepository.countByEmail(data.email);
+      if (emailExists != 0) {
+        throw new ResponseError(409, "Email Sudah Ada");
+      }
+      user.email = data.email;
+    }
+    const result = await UserRepository.update(id, {
+      fullName: user.fullName,
+      password: user.password,
+      email: user.email,
+    });
+    return toUserResponse(result);
+  }
+
+  static async delete(id: string) {
+    const data = await UserRepository.findById(id);
+    if (!data) {
+      throw new ResponseError(404, "Data Tidak Ditemukan");
+    }
+    await UserRepository.delete(id);
+  }
+}

package/template/src/types/type-request.ts

@@ -0,0 +1,6 @@
+import { User } from "@prisma/client";
+import { Request } from "express";
+
+export interface UserRequest extends Request {
+  user?: User;
+}

package/template/src/utils/async-handler.ts

@@ -0,0 +1,9 @@
+import { NextFunction, Request, Response } from "express";
+
+export const asyncHandler = (
+  fn: (req: Request, res: Response, next: NextFunction) => Promise<any>
+) => {
+  return (req: Request, res: Response, next: NextFunction) => {
+    fn(req, res, next).catch(next);
+  };
+};

package/template/src/utils/response-error.ts

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

package/template/src/utils/response.ts

@@ -0,0 +1,60 @@
+export function successResponse(
+  message: string,
+  statusCode: number = 200,
+  data?: any
+) {
+  return {
+    status: true,
+    status_code: statusCode,
+    message,
+    ...(data !== undefined && { data }),
+  };
+}
+
+export function successCreateResponse(data?: any) {
+  return {
+    status: true,
+    status_code: 201,
+    message: "Data Berhasil Ditambahkan",
+    ...(data !== undefined && { data }),
+  };
+}
+
+export function successUpdateResponse(data?: any) {
+  return {
+    status: true,
+    status_code: 200,
+    message: "Data Berhasil Diupdate",
+    ...(data !== undefined && { data }),
+  };
+}
+
+export function successDeleteResponse() {
+  return {
+    status: true,
+    status_code: 200,
+    message: "Data Berhasil Dihapus",
+    data: null,
+  };
+}
+export function successRestoreResponse() {
+  return {
+    status: true,
+    status_code: 200,
+    message: "Data Berhasil Direstore",
+    data: null,
+  };
+}
+
+export function errorResponse(
+  message: string,
+  statusCode: number = 400,
+  errors?: any
+) {
+  return {
+    status: false,
+    status_code: statusCode,
+    message,
+    ...(errors !== undefined && { errors }),
+  };
+}

package/template/src/utils/swagger.ts

@@ -0,0 +1,135 @@
+import swaggerJSDoc from "swagger-jsdoc";
+import swaggerUi from "swagger-ui-express";
+import { Express } from "express";
+import { SwaggerTheme } from "swagger-themes";
+import { env } from "../config/env";
+
+const swaggerOptions: swaggerJSDoc.Options = {
+  definition: {
+    openapi: "3.0.0",
+    info: {
+      title: `${env.APP_NAME} Api Documentation`,
+      version: "1.0.0",
+    },
+    servers: [
+      {
+        url: `${env.BASE_URL}`,
+        description: "Local server",
+      },
+    ],
+    components: {
+      securitySchemes: {
+        bearerAuth: {
+          type: "http",
+          scheme: "bearer",
+          bearerFormat: "JWT",
+        },
+      },
+      schemas: {
+        User: {
+          type: "object",
+          properties: {
+            id: {
+              type: "string",
+              format: "uuid",
+            },
+            fullName: {
+              type: "string",
+            },
+            email: {
+              type: "string",
+              format: "email",
+            },
+            password: {
+              type: "string",
+            },
+            created_at: {
+              type: "string",
+              format: "date-time",
+            },
+            updated_at: {
+              type: "string",
+              format: "date-time",
+            },
+            deleted_at: {
+              type: "string",
+              format: "date-time",
+            },
+          },
+          required: ["fullName", "email", "password"],
+        },
+      },
+      responses: {
+        UnauthorizedATError: {
+          description: "Unauthorized – token tidak valid atau tidak ada",
+          content: {
+            "application/json": {
+              example: {
+                status: false,
+                status_code: 401,
+                message: "Unauthorized: Access Token Tidak Valid.",
+              },
+            },
+          },
+        },
+        UnauthorizedNotLoginError: {
+          description: "Unauthorized - Belum Login.",
+          content: {
+            "application/json": {
+              example: {
+                status: false,
+                status_code: 401,
+                message: "Unauthorized: Anda Belum Login.",
+              },
+            },
+          },
+        },
+        ValidationError: {
+          description: "Validation Error",
+          content: {
+            "application/json": {
+              example: {
+                status: false,
+                status_code: 400,
+                message: "Validation Error",
+                errors: {
+                  field: "string",
+                  message: "string",
+                },
+              },
+            },
+          },
+        },
+        NotFoundError: {
+          description: "Data tidak ditemukan",
+          content: {
+            "application/json": {
+              example: {
+                status: false,
+                status_code: 404,
+                message: "Data Tidak Ditemukan",
+              },
+            },
+          },
+        },
+      },
+    },
+    security: [{ bearerAuth: [] }],
+  },
+  // apis: ["./src/route/**/*.ts"],
+  apis: ["./src/apidocs/**/*.ts"],
+};
+
+const swaggerSpec = swaggerJSDoc(swaggerOptions);
+const theme = new SwaggerTheme();
+const themeCss = theme.getBuffer("dark-monokai" as any);
+export function setupSwagger(app: Express) {
+  app.use(
+    "/api/docs",
+    swaggerUi.serve,
+    swaggerUi.setup(swaggerSpec, {
+      customCss: themeCss,
+      customSiteTitle: `${env.APP_NAME}  Api Documentation`,
+    })
+  );
+}

package/template/src/utils/validation.ts

@@ -0,0 +1,7 @@
+import { ZodType } from "zod";
+
+export class Validation {
+  static validate<T>(schema: ZodType, data: T): T {
+    return schema.parse(data);
+  }
+}