create-craftjs 1.0.0

package/template/src/config/database.ts

@@ -0,0 +1,90 @@
+import { PrismaClient } from "@prisma/client";
+import { logger } from "./logger";
+import { DateTime } from "luxon";
+import { dbLogger } from "./logger";
+import { env } from "./env";
+
+export const prismaClient = new PrismaClient({
+  log: [
+    {
+      emit: "event",
+      level: "query",
+    },
+    {
+      emit: "event",
+      level: "error",
+    },
+    {
+      emit: "event",
+      level: "info",
+    },
+    {
+      emit: "event",
+      level: "warn",
+    },
+  ],
+});
+
+prismaClient.$use(async (params, next) => {
+  const result = await next(params);
+
+  const convertToYourTimeZone = (date: unknown): string => {
+    if (!(date instanceof Date) || isNaN(date.getTime())) {
+      return "";
+    }
+
+    return DateTime.fromJSDate(date)
+      .setZone(env.TZ || "UTC")
+      .toFormat(env.DATETIME_FORMAT);
+  };
+
+  const transformDates = (item: any): any => {
+    if (!item) return item;
+
+    if (Array.isArray(item)) {
+      return item.map(transformDates);
+    }
+
+    if (typeof item === "object") {
+      const newItem: any = { ...item };
+      for (const key in newItem) {
+        const value = newItem[key];
+        if (
+          ["created_at", "updated_at", "deleted_at"].includes(key) &&
+          value instanceof Date
+        ) {
+          newItem[key] = convertToYourTimeZone(value);
+        } else if (typeof value === "object" && value !== null) {
+          newItem[key] = transformDates(value);
+        }
+      }
+      return newItem;
+    }
+
+    return item;
+  };
+
+  return transformDates(result);
+});
+
+prismaClient.$on("query", (e) => {
+  dbLogger.info(`${e.query} - ${e.params}`);
+});
+prismaClient.$on("warn", (e) => {
+  logger.warn(e);
+});
+prismaClient.$on("info", (e) => {
+  logger.info(e);
+});
+prismaClient.$on("error", (e) => {
+  logger.error(e);
+});
+export const connectDatabase = async () => {
+  try {
+    await prismaClient.$connect();
+    logger.info("✅ Connected Database");
+  } catch (error) {
+    logger.error("❌ Failed Connect To Database", error);
+    throw error;
+  }
+};

package/template/src/config/env.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import "dotenv/config";
+
+const envSchema = z.object({
+  APP_NAME: z.string().default("Craft JS"),
+  APP_SECRET: z.string(),
+  NODE_ENV: z
+    .enum(["development", "production", "test"])
+    .default("development"),
+  TZ: z.string().default("Asia/Jakarta"),
+  DATETIME_FORMAT: z.string().default("dd-MM-yyyy HH:mm:ss"),
+  DATABASE_URL: z
+    .string()
+    .url({ message: "DATABASE_URL harus URL yang valid" }),
+  BASE_URL: z.string().url(),
+  BASE_API_URL: z.string().url(),
+  CLIENT_URL: z.string().url().optional(),
+  PORT: z.coerce.number().default(3000),
+  JWT_SECRET: z.string(),
+});
+
+const _env = envSchema.safeParse(process.env);
+
+if (!_env.success) {
+  console.error("❌ ENV ERROR:", _env.error.format());
+  process.exit(1);
+}
+
+export const env = _env.data;

package/template/src/config/logger.ts

@@ -0,0 +1,116 @@
+import winston from "winston";
+import chalk from "chalk";
+import DailyRotateFile from "winston-daily-rotate-file";
+import path from "path";
+import fs from "fs";
+
+const customFormat = winston.format.printf(({ level, message, timestamp }) => {
+  const formattedMessage =
+    typeof message === "object" ? JSON.stringify(message, null, 2) : message;
+
+  let coloredLevel = level.toUpperCase();
+
+  switch (level) {
+    case "error":
+      coloredLevel = chalk.redBright.bold(level.toUpperCase());
+      break;
+    case "warn":
+      coloredLevel = chalk.yellowBright.bold(level.toUpperCase());
+      break;
+    case "info":
+      coloredLevel = chalk.greenBright.bold(level.toUpperCase());
+      break;
+    case "debug":
+      coloredLevel = chalk.bgBlueBright.bold(level.toUpperCase());
+      break;
+    default:
+      coloredLevel = chalk.bgBlueBright.bold(level.toUpperCase());
+      break;
+  }
+
+  return `[${chalk.gray(timestamp)}] ${coloredLevel} - ${formattedMessage}`;
+});
+
+export const logger = winston.createLogger({
+  level: "debug",
+  format: winston.format.combine(
+    winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
+    customFormat
+  ),
+  transports: [new winston.transports.Console()],
+});
+
+const logDir = path.join(__dirname, "../../logs");
+if (!fs.existsSync(logDir)) {
+  fs.mkdirSync(logDir);
+}
+
+export const dbLogger = winston.createLogger({
+  level: "debug",
+  format: winston.format.combine(
+    winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
+    winston.format.printf(
+      ({ timestamp, level, message }) =>
+        `[${timestamp}] ${level.toUpperCase()}: ${message}`
+    )
+  ),
+  transports: [
+    new DailyRotateFile({
+      filename: path.join(logDir, "database-log-%DATE%.log"),
+      datePattern: "YYYY-MM-DD",
+      zippedArchive: false,
+      maxFiles: "30d",
+      maxSize: "10m",
+    }),
+  ],
+});
+
+// Format untuk FILE logs — tanpa warna
+const plainFormat = winston.format.printf(({ timestamp, level, message }) => {
+  return `[${timestamp}] ${level.toUpperCase()}: ${message}`;
+});
+
+// Format untuk CONSOLE logs — dengan warna
+const coloredHttpFormat = winston.format.printf(
+  ({ timestamp, level, message }) => {
+    let coloredLevel = level.toUpperCase();
+    switch (level) {
+      case "error":
+        coloredLevel = chalk.red.bold(level.toUpperCase());
+        break;
+      case "warn":
+        coloredLevel = chalk.yellow.bold(level.toUpperCase());
+        break;
+      case "info":
+        coloredLevel = chalk.blue.bold(level.toUpperCase());
+        break;
+      default:
+        coloredLevel = chalk.white(level.toUpperCase());
+        break;
+    }
+    return `[${chalk.gray(timestamp)}] ${coloredLevel}: ${message}`;
+  }
+);
+
+export const httpAccessLogger = winston.createLogger({
+  level: "debug",
+  transports: [
+    new DailyRotateFile({
+      filename: path.join(logDir, "access-log-%DATE%.log"),
+      datePattern: "YYYY-MM-DD",
+      zippedArchive: false,
+      maxFiles: "30d",
+      maxSize: "10m",
+      format: winston.format.combine(
+        winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
+        plainFormat
+      ),
+    }),
+    new winston.transports.Console({
+      format: winston.format.combine(
+        winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
+        coloredHttpFormat
+      ),
+    }),
+  ],
+});

package/template/src/config/web.ts

@@ -0,0 +1,40 @@
+import express from "express";
+import cors from "cors";
+import cookieParser from "cookie-parser";
+import { env } from "./env";
+// import expressLayouts from "express-ejs-layouts";
+// import path from "path";
+
+import { errorMiddleware } from "../middleware/error-middleware";
+import { httpLogger } from "../middleware/http-logger-middleware";
+import { errorResponse } from "../utils/response";
+import { setupSwagger } from "../utils/swagger";
+import { mainRouter } from "../routes/main-route";
+
+export const web = express();
+// EJS View Engine Setup
+// web.set("view engine", "ejs");
+// web.set("views", path.join(__dirname, "..", "views"));
+// web.use(expressLayouts);
+// web.set("layout", "layouts/main");
+
+// Middleware
+web.use(express.json());
+web.use(cookieParser());
+web.use(cors({ credentials: true, origin: `${env.CLIENT_URL}` }));
+web.use(express.static("public"));
+web.use(httpLogger);
+
+// Swagger Setup
+setupSwagger(web);
+
+// Routes
+web.use(mainRouter);
+
+// 404 Handler
+web.use((req, res) => {
+  res.status(404).json(errorResponse("Request Tidak Ada", 404));
+});
+
+// Global Error Handler
+web.use(errorMiddleware);

package/template/src/controllers/auth-controller.ts

@@ -0,0 +1,88 @@
+import { NextFunction, Request, Response } from "express";
+import {
+  loginRequest,
+  CreateUserRequest,
+  UpdateUserRequest,
+} from "../dtos/user-dto";
+import { successResponse, successUpdateResponse } from "../utils/response";
+import { AuthService } from "../services/auth-service";
+import { UserRequest } from "../types/type-request";
+import { env } from "../config/env";
+
+export class AuthController {
+  static async register(req: Request, res: Response, next: NextFunction) {
+    try {
+      const request: CreateUserRequest = req.body as CreateUserRequest;
+      const response = await AuthService.register(request);
+      res.status(201).json(successResponse("Register Berhasil", 201, response));
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  static async login(req: Request, res: Response, next: NextFunction) {
+    try {
+      const request: loginRequest = req.body as loginRequest;
+      const response = await AuthService.login(request);
+      res.cookie("refresh_token", response.refreshToken, {
+        httpOnly: true,
+        maxAge: 24 * 60 * 60 * 1000,
+        secure: env.NODE_ENV === "production",
+        sameSite: "lax",
+        path: "/",
+      });
+      res.status(200).json(
+        successResponse("Login Berhasil", 200, {
+          user: response.user,
+          accessToken: response.accessToken,
+        })
+      );
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  static async me(req: UserRequest, res: Response, next: NextFunction) {
+    try {
+      const response = await AuthService.me(req.user!);
+      res
+        .status(200)
+        .json(successResponse("Get Detail User Berhasil", 200, response));
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  static async updateProfile(
+    req: UserRequest,
+    res: Response,
+    next: NextFunction
+  ) {
+    try {
+      const request: UpdateUserRequest = req.body as UpdateUserRequest;
+      const response = await AuthService.updateProfile(req.user!, request);
+      res.status(200).json(successUpdateResponse(response));
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  static async logout(req: UserRequest, res: Response, next: NextFunction) {
+    await AuthService.logout(req);
+    res.clearCookie("refresh_token");
+    res.status(200).json(successResponse("Logout berhasil", 200));
+  }
+  static async refreshToken(req: Request, res: Response, next: NextFunction) {
+    try {
+      const response = await AuthService.refreshToken(req);
+      res.status(200).json(
+        successResponse("Get Access Token Berhasil", 200, {
+          user: response.user,
+          accessToken: response.accessToken,
+        })
+      );
+    } catch (error) {
+      next(error);
+    }
+  }
+}

package/template/src/controllers/user-controller.ts

@@ -0,0 +1,79 @@
+import { NextFunction, Request, Response } from "express";
+import {
+  CreateUserRequest,
+  ListUserRequest,
+  UpdateUserRequest,
+} from "../dtos/user-dto";
+import { UserService } from "../services/user-service";
+import {
+  successCreateResponse,
+  successDeleteResponse,
+  successResponse,
+  successUpdateResponse,
+} from "../utils/response";
+import { UserRequest } from "../types/type-request";
+
+export class UserController {
+  static async create(req: Request, res: Response, next: NextFunction) {
+    try {
+      const request: CreateUserRequest = req.body as CreateUserRequest;
+      console.log(request);
+      const response = await UserService.create(request);
+      res.status(201).json(successCreateResponse(response));
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  static async getAll(req: Request, res: Response, next: NextFunction) {
+    try {
+      const page = Number(req.query.page) || 1;
+      const take = Number(req.query.take) || 10;
+      const request: ListUserRequest = {
+        page: page,
+        take: take,
+        skip: (page - 1) * take,
+        name: req.query.name as string,
+      };
+      const response = await UserService.getAll(request);
+      res
+        .status(200)
+        .json(successResponse("Berhasil Get All Data", 200, response));
+    } catch (e) {
+      next(e);
+    }
+  }
+
+  static async getOne(req: Request, res: Response, next: NextFunction) {
+    try {
+      const id = req.params.id;
+      const response = await UserService.getOne(id);
+      res
+        .status(200)
+        .json(successResponse("Berhasil Get Detail Data", 200, response));
+    } catch (e) {
+      next(e);
+    }
+  }
+
+  static async update(req: UserRequest, res: Response, next: NextFunction) {
+    try {
+      const id = req.params.id;
+      const request: UpdateUserRequest = req.body as UpdateUserRequest;
+      const response = await UserService.update(id, request);
+      res.status(200).json(successUpdateResponse(response));
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  static async delete(req: Request, res: Response, next: NextFunction) {
+    try {
+      const id = req.params.id;
+      await UserService.delete(id);
+      res.status(200).json(successDeleteResponse());
+    } catch (e) {
+      next(e);
+    }
+  }
+}

package/template/src/dtos/list-dto.ts

@@ -0,0 +1,12 @@
+export type listResponse = {
+  data: any;
+  total_data: number;
+  paging: any;
+};
+export function tolistResponse(data: any): listResponse {
+  return {
+    data: data.data,
+    total_data: data.total_data,
+    paging: data.paging,
+  };
+}

package/template/src/dtos/user-dto.ts

@@ -0,0 +1,57 @@
+import { User } from "@prisma/client";
+export type loginRequest = {
+  email: string;
+  password: string;
+};
+export type CreateUserRequest = {
+  fullName: string;
+  email: string;
+  password: string;
+};
+
+export type UpdateUserRequest = {
+  fullName?: string;
+  email?: string;
+  password?: string;
+};
+
+export type ListUserRequest = {
+  page: number;
+  take: number;
+  skip: number;
+  name?: string;
+};
+export type UserDetailResponse = {
+  id: string;
+  fullName: string;
+  email: string;
+  image_id?: string;
+  image_url?: string;
+  created_at: Date;
+  updated_at: Date;
+  deleted_at?: Date;
+};
+
+export type UserResponse = {
+  id: string;
+  fullName: string;
+  email: string;
+};
+
+export function toUserDetailResponse(user: User): UserDetailResponse {
+  return {
+    id: user.id,
+    fullName: user.fullName,
+    email: user.email,
+    created_at: user.created_at,
+    updated_at: user.updated_at,
+    deleted_at: user.deleted_at!,
+  };
+}
+export function toUserResponse(user: User): UserResponse {
+  return {
+    id: user.id,
+    fullName: user.fullName,
+    email: user.email,
+  };
+}

package/template/src/main.ts

@@ -0,0 +1,28 @@
+import { web } from "./config/web";
+import { connectDatabase } from "./config/database";
+import { env } from "./config/env";
+import { logger } from "./config/logger";
+
+async function startServer() {
+  try {
+    if (
+      !env.APP_SECRET ||
+      env.APP_SECRET.trim() === "" ||
+      !env.JWT_SECRET ||
+      env.JWT_SECRET.trim() === ""
+    ) {
+      logger.error("❌ APP_SECRET or JWT_SECRET is missing in your .env file.");
+      logger.error("👉 Please run `node craft key:generate` to create them.");
+      process.exit(0);
+    }
+    await connectDatabase();
+    web.listen(env.PORT, () => {
+      logger.info(`🚀 Server is listening on: ${env.BASE_URL}`);
+      logger.info(`🔗 API Docs available at: ${env.BASE_API_URL}/docs`);
+    });
+  } catch (error) {
+    process.exit(0);
+  }
+}
+
+startServer();

package/template/src/middleware/auth-middleware.ts

@@ -0,0 +1,44 @@
+import { NextFunction, Response } from "express";
+import { errorResponse } from "../utils/response";
+import { prismaClient } from "../config/database";
+import jwt from "jsonwebtoken";
+import { UserRequest } from "../types/type-request";
+import { ResponseError } from "../utils/response-error";
+import { env } from "../config/env";
+
+export const authMiddleware = async (
+  req: UserRequest,
+  res: Response,
+  next: NextFunction
+) => {
+  const refreshToken = req.cookies.refresh_token;
+  if (!refreshToken) {
+    throw new ResponseError(401, "Unauthorized: Anda Belum Login.");
+  }
+  const token = req.get("Authorization")?.split(" ")[1];
+  if (!token) {
+    return res
+      .status(401)
+      .json(errorResponse("Unauthorized: Access Token Tidak Valid.", 401));
+  }
+  let payload;
+  try {
+    payload = jwt.verify(token, env.JWT_SECRET as string) as {
+      user_id: string;
+      user_email: string;
+      user_fullName: string;
+    };
+  } catch (err) {
+    throw new ResponseError(401, "Unauthorized: Access Token Tidak Valid.");
+  }
+  const user = await prismaClient.user.findUnique({
+    where: { id: payload.user_id },
+  });
+  if (!user) {
+    return res
+      .status(401)
+      .json(errorResponse("Unauthorized: Anda belum login", 401));
+  }
+  req.user = user;
+  next();
+};

package/template/src/middleware/error-middleware.ts

@@ -0,0 +1,27 @@
+import { NextFunction, Request, Response } from "express";
+import { ZodError } from "zod";
+import { errorResponse } from "../utils/response";
+import { ResponseError } from "../utils/response-error";
+
+export const errorMiddleware = async (
+  error: Error,
+  req: Request,
+  res: Response,
+  next: NextFunction
+) => {
+  if (error instanceof ZodError) {
+    let formattedErrors = error.errors.map((err) => ({
+      field: err.path.join("."),
+      message: err.message,
+    }));
+    res
+      .status(400)
+      .json(errorResponse("Validation Error", 400, formattedErrors));
+  } else if (error instanceof ResponseError) {
+    res
+      .status(error.status_code)
+      .json(errorResponse(error.message, error.status_code));
+  } else {
+    res.status(500).json(errorResponse(error.message, 500));
+  }
+};

package/template/src/middleware/http-logger-middleware.ts

@@ -0,0 +1,31 @@
+import { Request, Response, NextFunction } from "express";
+import { httpAccessLogger } from "../config/logger";
+
+export const httpLogger = async (
+  req: Request,
+  res: Response,
+  next: NextFunction
+) => {
+  const start = process.hrtime();
+
+  res.on("finish", () => {
+    const diff = process.hrtime(start);
+    const timeInMs = (diff[0] * 1e3 + diff[1] / 1e6).toFixed(3);
+
+    const logMessage = `${req.method} ${req.originalUrl} ${res.statusCode} ${timeInMs} ms - ${res.get("Content-Length") || 0}`;
+
+    if (res.statusCode >= 200 && res.statusCode < 300) {
+      httpAccessLogger.info(logMessage);
+    } else if (res.statusCode >= 300 && res.statusCode < 400) {
+      httpAccessLogger.info(logMessage);
+    } else if (res.statusCode >= 400 && res.statusCode < 500) {
+      httpAccessLogger.warn(logMessage);
+    } else if (res.statusCode >= 500) {
+      httpAccessLogger.error(logMessage);
+    } else {
+      httpAccessLogger.debug(logMessage);
+    }
+  });
+
+  next();
+};