lapeh 1.0.1

package/scripts/make-module.js

@@ -0,0 +1,158 @@
+const fs = require('fs');
+const path = require('path');
+
+const moduleName = process.argv[2];
+
+if (!moduleName) {
+  console.error('❌ Please specify the module name.');
+  console.error('   Usage: npm run make:module <name>');
+  console.error('   Example: npm run make:module product');
+  process.exit(1);
+}
+
+// Convert "product" -> "Product" (PascalCase) for Class names
+const PascalCaseName = moduleName.charAt(0).toUpperCase() + moduleName.slice(1);
+// Convert "product" -> "product" (camelCase) for variables/files
+const camelCaseName = moduleName.toLowerCase();
+
+const srcDir = path.join(__dirname, '..', 'src');
+
+// 1. Create Controller
+const controllerContent = `import { Request, Response } from 'express';
+import { ${PascalCaseName}Service } from '../services/${camelCaseName}Service';
+import { successResponse, errorResponse } from '../utils/response';
+
+export const ${PascalCaseName}Controller = {
+  async getAll(req: Request, res: Response) {
+    try {
+      const data = await ${PascalCaseName}Service.getAll();
+      return successResponse(res, data, '${PascalCaseName}s retrieved successfully');
+    } catch (error) {
+      return errorResponse(res, error as Error);
+    }
+  },
+
+  async getById(req: Request, res: Response) {
+    try {
+      const { id } = req.params;
+      const data = await ${PascalCaseName}Service.getById(id);
+      if (!data) return errorResponse(res, new Error('${PascalCaseName} not found'), 404);
+      return successResponse(res, data, '${PascalCaseName} retrieved successfully');
+    } catch (error) {
+      return errorResponse(res, error as Error);
+    }
+  },
+
+  async create(req: Request, res: Response) {
+    try {
+      const data = await ${PascalCaseName}Service.create(req.body);
+      return successResponse(res, data, '${PascalCaseName} created successfully', 201);
+    } catch (error) {
+      return errorResponse(res, error as Error);
+    }
+  },
+
+  async update(req: Request, res: Response) {
+    try {
+      const { id } = req.params;
+      const data = await ${PascalCaseName}Service.update(id, req.body);
+      return successResponse(res, data, '${PascalCaseName} updated successfully');
+    } catch (error) {
+      return errorResponse(res, error as Error);
+    }
+  },
+
+  async delete(req: Request, res: Response) {
+    try {
+      const { id } = req.params;
+      await ${PascalCaseName}Service.delete(id);
+      return successResponse(res, null, '${PascalCaseName} deleted successfully');
+    } catch (error) {
+      return errorResponse(res, error as Error);
+    }
+  }
+};
+`;
+
+// 2. Create Service
+const serviceContent = `// import prisma from '../prisma'; // Uncomment this line if you use Prisma
+
+export const ${PascalCaseName}Service = {
+  async getAll() {
+    // return prisma.${camelCaseName}.findMany();
+    return [{ id: 1, name: 'Sample ${PascalCaseName}' }]; // Placeholder
+  },
+
+  async getById(id: string) {
+    // return prisma.${camelCaseName}.findUnique({ where: { id } });
+    return { id, name: 'Sample ${PascalCaseName}' }; // Placeholder
+  },
+
+  async create(data: any) {
+    // return prisma.${camelCaseName}.create({ data });
+    return { id: Date.now(), ...data }; // Placeholder
+  },
+
+  async update(id: string, data: any) {
+    // return prisma.${camelCaseName}.update({ where: { id }, data });
+    return { id, ...data }; // Placeholder
+  },
+
+  async delete(id: string) {
+    // return prisma.${camelCaseName}.delete({ where: { id } });
+    return true; // Placeholder
+  }
+};
+`;
+
+// 3. Create Route
+const routeContent = `import { Router } from 'express';
+import { ${PascalCaseName}Controller } from '../controllers/${camelCaseName}Controller';
+import { authenticateToken } from '../middleware/auth';
+
+const router = Router();
+
+router.get('/', authenticateToken, ${PascalCaseName}Controller.getAll);
+router.get('/:id', authenticateToken, ${PascalCaseName}Controller.getById);
+router.post('/', authenticateToken, ${PascalCaseName}Controller.create);
+router.put('/:id', authenticateToken, ${PascalCaseName}Controller.update);
+router.delete('/:id', authenticateToken, ${PascalCaseName}Controller.delete);
+
+export default router;
+`;
+
+const paths = {
+  controller: path.join(srcDir, 'controllers', `${camelCaseName}Controller.ts`),
+  service: path.join(srcDir, 'services', `${camelCaseName}Service.ts`),
+  route: path.join(srcDir, 'routes', `${camelCaseName}.ts`),
+};
+
+// Helper to create directory if not exists
+function ensureDir(filePath) {
+  const dirname = path.dirname(filePath);
+  if (!fs.existsSync(dirname)) {
+    fs.mkdirSync(dirname, { recursive: true });
+  }
+}
+
+try {
+  ensureDir(paths.controller);
+  fs.writeFileSync(paths.controller, controllerContent);
+  console.log(`✅ Created Controller: src/controllers/${camelCaseName}Controller.ts`);
+
+  ensureDir(paths.service);
+  fs.writeFileSync(paths.service, serviceContent);
+  console.log(`✅ Created Service: src/services/${camelCaseName}Service.ts`);
+
+  ensureDir(paths.route);
+  fs.writeFileSync(paths.route, routeContent);
+  console.log(`✅ Created Route: src/routes/${camelCaseName}.ts`);
+
+  console.log('\n⚠️  Don\'t forget to register the new route in src/index.ts or src/server.ts!');
+  console.log(`   import ${camelCaseName}Routes from './routes/${camelCaseName}';`);
+  console.log(`   app.use('/${camelCaseName}s', ${camelCaseName}Routes);`);
+
+} catch (error) {
+  console.error('❌ Error creating module:', error);
+  process.exit(1);
+}

package/src/controllers/authController.ts

@@ -0,0 +1,347 @@
+import { Request, Response } from "express";
+import { prisma } from "../prisma";
+import bcrypt from "bcryptjs";
+import jwt from "jsonwebtoken";
+import { v4 as uuidv4 } from "uuid";
+import { sendSuccess, sendError } from "../utils/response";
+import {
+  registerSchema,
+  loginSchema,
+  refreshSchema,
+  updatePasswordSchema,
+  updateProfileSchema,
+} from "../schema/auth-schema";
+
+export const ACCESS_TOKEN_EXPIRES_IN_SECONDS = 7 * 24 * 60 * 60;
+
+export async function register(req: Request, res: Response) {
+  const parsed = registerSchema.safeParse(req.body);
+  if (!parsed.success) {
+    const errors = parsed.error.flatten().fieldErrors;
+    sendError(res, 422, "Validation error", errors);
+    return;
+  }
+  const { email, name, password } = parsed.data;
+  const existing = await prisma.users.findUnique({ where: { email } });
+  if (existing) {
+    sendError(res, 409, "Email already used", {
+      field: "email",
+      message: "Email sudah terdaftar, silakan gunakan email lain",
+    });
+    return;
+  }
+  const hash = await bcrypt.hash(password, 10);
+  const user = await prisma.users.create({
+    data: {
+      email,
+      name,
+      password: hash,
+      uuid: uuidv4(),
+      created_at: new Date(),
+      updated_at: new Date(),
+    },
+  });
+
+  const defaultRole = await prisma.roles.findUnique({
+    where: { slug: "user" },
+  });
+  if (defaultRole) {
+    await prisma.user_roles.create({
+      data: {
+        user_id: user.id,
+        role_id: defaultRole.id,
+        created_at: new Date(),
+      },
+    });
+  }
+
+  sendSuccess(res, 200, "Registrasi berhasil", {
+    id: user.id.toString(),
+    email: user.email,
+    name: user.name,
+    role: defaultRole ? defaultRole.slug : "user",
+  });
+}
+
+export async function login(req: Request, res: Response) {
+  const parsed = loginSchema.safeParse(req.body);
+  if (!parsed.success) {
+    const errors = parsed.error.flatten().fieldErrors;
+    sendError(res, 422, "Validation error", errors);
+    return;
+  }
+  const { email, password } = parsed.data;
+  const user = await prisma.users.findUnique({
+    where: { email },
+    include: {
+      user_roles: {
+        include: {
+          roles: true,
+        },
+      },
+    },
+  });
+  if (!user) {
+    sendError(res, 401, "Email not registered", {
+      field: "email",
+      message: "Email belum terdaftar, silakan registrasi terlebih dahulu",
+    });
+    return;
+  }
+  const ok = await bcrypt.compare(password, user.password);
+  if (!ok) {
+    sendError(res, 401, "Invalid credentials", {
+      field: "password",
+      message: "Password yang Anda masukkan salah",
+    });
+    return;
+  }
+  const secret = process.env.JWT_SECRET;
+  if (!secret) {
+    sendError(res, 500, "Server misconfigured");
+    return;
+  }
+  const primaryUserRole =
+    user.user_roles && user.user_roles.length > 0 && user.user_roles[0].roles
+      ? user.user_roles[0].roles.slug
+      : "user";
+  const accessExpiresInSeconds = ACCESS_TOKEN_EXPIRES_IN_SECONDS;
+  const accessExpiresAt = new Date(
+    Date.now() + accessExpiresInSeconds * 1000
+  ).toISOString();
+  const token = jwt.sign(
+    { userId: user.id.toString(), role: primaryUserRole },
+    secret,
+    { expiresIn: accessExpiresInSeconds }
+  );
+  const refreshExpiresInSeconds = 30 * 24 * 60 * 60;
+  const refreshToken = jwt.sign(
+    {
+      userId: user.id.toString(),
+      role: primaryUserRole,
+      tokenType: "refresh",
+    },
+    secret,
+    { expiresIn: refreshExpiresInSeconds }
+  );
+  sendSuccess(res, 200, "Login berhasil", {
+    token,
+    refreshToken,
+    expiresIn: accessExpiresInSeconds,
+    expiresAt: accessExpiresAt,
+    name: user.name,
+    role: primaryUserRole,
+  });
+}
+
+export async function me(req: Request, res: Response) {
+  const payload = (req as any).user as { userId: string; role: string };
+  if (!payload || !payload.userId) {
+    sendError(res, 401, "Unauthorized");
+    return;
+  }
+  const user = await prisma.users.findUnique({
+    where: { id: BigInt(payload.userId) },
+    include: {
+      user_roles: {
+        include: {
+          roles: true,
+        },
+      },
+    },
+  });
+  if (!user) {
+    sendError(res, 404, "User not found");
+    return;
+  }
+  const { password, remember_token, ...rest } = user as any;
+  sendSuccess(res, 200, "User profile", {
+    ...rest,
+    id: user.id.toString(),
+    role:
+      user.user_roles && user.user_roles.length > 0 && user.user_roles[0].roles
+        ? user.user_roles[0].roles.slug
+        : "user",
+  });
+}
+
+export async function logout(req: Request, res: Response) {
+  sendSuccess(res, 200, "Logout berhasil", null);
+}
+
+export async function refreshToken(req: Request, res: Response) {
+  const parsed = refreshSchema.safeParse(req.body);
+  if (!parsed.success) {
+    const errors = parsed.error.flatten().fieldErrors;
+    sendError(res, 422, "Validation error", errors);
+    return;
+  }
+  const secret = process.env.JWT_SECRET;
+  if (!secret) {
+    sendError(res, 500, "Server misconfigured");
+    return;
+  }
+  try {
+    const decoded = jwt.verify(parsed.data.refreshToken, secret) as {
+      userId: string;
+      role: string;
+      tokenType?: string;
+      iat: number;
+      exp: number;
+    };
+    if (decoded.tokenType !== "refresh") {
+      sendError(res, 401, "Invalid refresh token");
+      return;
+    }
+    const user = await prisma.users.findUnique({
+      where: { id: BigInt(decoded.userId) },
+      include: {
+        user_roles: {
+          include: {
+            roles: true,
+          },
+        },
+      },
+    });
+    if (!user) {
+      sendError(res, 401, "Invalid refresh token");
+      return;
+    }
+    const primaryUserRole =
+      user.user_roles && user.user_roles.length > 0 && user.user_roles[0].roles
+        ? user.user_roles[0].roles.slug
+        : "user";
+    const accessExpiresInSeconds = ACCESS_TOKEN_EXPIRES_IN_SECONDS;
+    const accessExpiresAt = new Date(
+      Date.now() + accessExpiresInSeconds * 1000
+    ).toISOString();
+    const token = jwt.sign(
+      { userId: user.id.toString(), role: primaryUserRole },
+      secret,
+      { expiresIn: accessExpiresInSeconds }
+    );
+    sendSuccess(res, 200, "Token refreshed", {
+      token,
+      expiresIn: accessExpiresInSeconds,
+      expiresAt: accessExpiresAt,
+      name: user.name,
+      role: primaryUserRole,
+    });
+  } catch {
+    sendError(res, 401, "Invalid refresh token");
+  }
+}
+
+export async function updateAvatar(req: Request, res: Response) {
+  const payload = (req as any).user as { userId: string; role: string };
+  if (!payload || !payload.userId) {
+    sendError(res, 401, "Unauthorized");
+    return;
+  }
+  const file = (req as any).file as {
+    filename: string;
+    path: string;
+  } | null;
+  if (!file) {
+    sendError(res, 400, "Avatar file wajib diupload");
+    return;
+  }
+  const userId = BigInt(payload.userId);
+  const avatar = file.filename;
+  const avatar_url =
+    process.env.AVATAR_BASE_URL || `/uploads/avatars/${file.filename}`;
+  const updated = await prisma.users.update({
+    where: { id: userId },
+    data: {
+      avatar,
+      avatar_url,
+      updated_at: new Date(),
+    },
+  });
+  const { password, remember_token, ...rest } = updated as any;
+  sendSuccess(res, 200, "Avatar berhasil diperbarui", {
+    ...rest,
+    id: updated.id.toString(),
+  });
+}
+
+export async function updatePassword(req: Request, res: Response) {
+  const payload = (req as any).user as { userId: string; role: string };
+  if (!payload || !payload.userId) {
+    sendError(res, 401, "Unauthorized");
+    return;
+  }
+  const parsed = updatePasswordSchema.safeParse(req.body);
+  if (!parsed.success) {
+    const errors = parsed.error.flatten().fieldErrors;
+    sendError(res, 422, "Validation error", errors);
+    return;
+  }
+  const { currentPassword, newPassword } = parsed.data;
+  const user = await prisma.users.findUnique({
+    where: { id: BigInt(payload.userId) },
+  });
+  if (!user) {
+    sendError(res, 404, "User not found");
+    return;
+  }
+  const ok = await bcrypt.compare(currentPassword, user.password);
+  if (!ok) {
+    sendError(res, 401, "Invalid credentials", {
+      field: "currentPassword",
+      message: "Password saat ini tidak sesuai",
+    });
+    return;
+  }
+  const hash = await bcrypt.hash(newPassword, 10);
+  await prisma.users.update({
+    where: { id: user.id },
+    data: {
+      password: hash,
+      updated_at: new Date(),
+    },
+  });
+  sendSuccess(res, 200, "Password berhasil diperbarui", null);
+}
+
+export async function updateProfile(req: Request, res: Response) {
+  const payload = (req as any).user as { userId: string; role: string };
+  if (!payload || !payload.userId) {
+    sendError(res, 401, "Unauthorized");
+    return;
+  }
+  const parsed = updateProfileSchema.safeParse(req.body);
+  if (!parsed.success) {
+    const errors = parsed.error.flatten().fieldErrors;
+    sendError(res, 422, "Validation error", errors);
+    return;
+  }
+  const { name, email } = parsed.data;
+  const userId = BigInt(payload.userId);
+  const existing = await prisma.users.findFirst({
+    where: {
+      email,
+      NOT: { id: userId },
+    },
+  });
+  if (existing) {
+    sendError(res, 409, "Email already used", {
+      field: "email",
+      message: "Email sudah terdaftar, silakan gunakan email lain",
+    });
+    return;
+  }
+  const updated = await prisma.users.update({
+    where: { id: userId },
+    data: {
+      name,
+      email,
+      updated_at: new Date(),
+    },
+  });
+  const { password, remember_token, ...rest } = updated as any;
+  sendSuccess(res, 200, "Profil berhasil diperbarui", {
+    ...rest,
+    id: updated.id.toString(),
+  });
+}