lapeh 2.3.6 → 2.3.8

package/prisma.config.ts

@@ -1,15 +0,0 @@
-// This file was generated by Prisma, and assumes you have installed the following:
-// npm install --save-dev prisma dotenv
-import "dotenv/config";
-import { defineConfig, env } from "prisma/config";
-
-export default defineConfig({
-  schema: "prisma/schema.prisma",
-  migrations: {
-    path: "prisma/migrations",
-    seed: "ts-node -r tsconfig-paths/register prisma/seed.ts",
-  },
-  datasource: {
-    url: env("DATABASE_URL"),
-  },
-});

package/src/controllers/authController.ts

@@ -1,469 +0,0 @@
-import { Request, Response } from "express";
-import bcrypt from "bcryptjs";
-import jwt from "jsonwebtoken";
-import { v4 as uuidv4 } from "uuid";
-import { prisma } from "@lapeh/core/database";
-import { sendError, sendFastSuccess } from "@lapeh/utils/response";
-import { Validator } from "@lapeh/utils/validator";
-import { getSerializer, createResponseSchema } from "@lapeh/core/serializer";
-
-export const ACCESS_TOKEN_EXPIRES_IN_SECONDS = 7 * 24 * 60 * 60;
-
-// --- Serializers ---
-
-const registerSchema = {
-  type: "object",
-  properties: {
-    id: { type: "string" },
-    email: { type: "string" },
-    name: { type: "string" },
-    role: { type: "string" },
-  },
-};
-
-const loginSchema = {
-  type: "object",
-  properties: {
-    token: { type: "string" },
-    refreshToken: { type: "string" },
-    expiresIn: { type: "integer" },
-    expiresAt: { type: "string" },
-    name: { type: "string" },
-    role: { type: "string" },
-  },
-};
-
-const userProfileSchema = {
-  type: "object",
-  properties: {
-    id: { type: "string" },
-    name: { type: "string" },
-    email: { type: "string" },
-    role: { type: "string" },
-    avatar: { type: "string", nullable: true },
-    avatar_url: { type: "string", nullable: true },
-    email_verified_at: { type: "string", format: "date-time", nullable: true },
-    created_at: { type: "string", format: "date-time", nullable: true },
-    updated_at: { type: "string", format: "date-time", nullable: true },
-  },
-};
-
-const refreshTokenSchema = {
-  type: "object",
-  properties: {
-    token: { type: "string" },
-    expiresIn: { type: "integer" },
-    expiresAt: { type: "string" },
-    name: { type: "string" },
-    role: { type: "string" },
-  },
-};
-
-const registerSerializer = getSerializer(
-  "auth-register",
-  createResponseSchema(registerSchema)
-);
-const loginSerializer = getSerializer(
-  "auth-login",
-  createResponseSchema(loginSchema)
-);
-const userProfileSerializer = getSerializer(
-  "auth-profile",
-  createResponseSchema(userProfileSchema)
-);
-const refreshTokenSerializer = getSerializer(
-  "auth-refresh",
-  createResponseSchema(refreshTokenSchema)
-);
-
-const voidSerializer = getSerializer(
-  "void",
-  createResponseSchema({ type: "null" })
-);
-
-// --- Controllers ---
-
-export async function register(req: Request, res: Response) {
-  const validator = Validator.make(req.body || {}, {
-    email: "required|email|unique:users,email",
-    name: "required|min:1",
-    password: "required|min:4",
-    confirmPassword: "required|min:4|same:password",
-  });
-
-  if (await validator.fails()) {
-    sendError(res, 422, "Validation error", validator.errors());
-    return;
-  }
-  const { email, name, password } = await validator.validated();
-  // Manual unique check removed as it is handled by validator
-  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(),
-      },
-    });
-  }
-
-  sendFastSuccess(res, 200, registerSerializer, {
-    status: "success",
-    message: "Registration successful",
-    data: {
-      id: user.id.toString(),
-      email: user.email,
-      name: user.name,
-      role: defaultRole ? defaultRole.slug : "user",
-    },
-  });
-}
-
-export async function login(req: Request, res: Response) {
-  const validator = Validator.make(req.body || {}, {
-    email: "required|email",
-    password: "required|min:4",
-  });
-
-  if (await validator.fails()) {
-    sendError(res, 422, "Validation error", validator.errors());
-    return;
-  }
-  const { email, password } = await validator.validated();
-  const user = await prisma.users.findUnique({
-    where: { email },
-    include: {
-      user_roles: {
-        include: {
-          role: true,
-        },
-      },
-    },
-  });
-  if (!user) {
-    sendError(res, 401, "Email not registered", {
-      field: "email",
-      message: "Email is not registered, please register first",
-    });
-    return;
-  }
-  const ok = await bcrypt.compare(password, user.password);
-  if (!ok) {
-    sendError(res, 401, "Invalid credentials", {
-      field: "password",
-      message: "The password you entered is incorrect",
-    });
-    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].role
-      ? user.user_roles[0].role.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 }
-  );
-  sendFastSuccess(res, 200, loginSerializer, {
-    status: "success",
-    message: "Login successful",
-    data: {
-      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: {
-          role: true,
-        },
-      },
-    },
-  });
-  if (!user) {
-    sendError(res, 404, "User not found");
-    return;
-  }
-  const { password, remember_token, ...rest } = user as any;
-  sendFastSuccess(res, 200, userProfileSerializer, {
-    status: "success",
-    message: "User profile",
-    data: {
-      ...rest,
-      id: user.id.toString(),
-      role:
-        user.user_roles && user.user_roles.length > 0 && user.user_roles[0].role
-          ? user.user_roles[0].role.slug
-          : "user",
-    },
-  });
-}
-
-export async function logout(_req: Request, res: Response) {
-  // In a stateless JWT setup, logout is client-side (delete token).
-  // If using a whitelist/blacklist in Redis, invalidate the token here.
-  // For now, just return success.
-  sendFastSuccess(res, 200, voidSerializer, {
-    status: "success",
-    message: "Logout successful",
-    data: null,
-  });
-}
-
-export async function refreshToken(req: Request, res: Response) {
-  const validator = Validator.make(req.body || {}, {
-    refreshToken: "required|min:1",
-  });
-  if (await validator.fails()) {
-    sendError(res, 422, "Validation error", validator.errors());
-    return;
-  }
-  const secret = process.env.JWT_SECRET;
-  if (!secret) {
-    sendError(res, 500, "Server misconfigured");
-    return;
-  }
-  try {
-    const validatedData = await validator.validated();
-    const decoded = jwt.verify(validatedData.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: {
-            role: true,
-          },
-        },
-      },
-    });
-    if (!user) {
-      sendError(res, 401, "Invalid refresh token");
-      return;
-    }
-    const primaryUserRole =
-      user.user_roles && user.user_roles.length > 0 && user.user_roles[0].role
-        ? user.user_roles[0].role.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 }
-    );
-    sendFastSuccess(res, 200, refreshTokenSerializer, {
-      status: "success",
-      message: "Token refreshed",
-      data: {
-        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 data = {
-    avatar: (req as any).file,
-  };
-
-  const validator = Validator.make(data, {
-    avatar: "nullable|image|mimes:jpeg,png,jpg,gif|max:2048",
-  });
-
-  if (await validator.fails()) {
-    sendError(res, 422, "Validation error", validator.errors());
-    return;
-  }
-
-  const { avatar: file } = await validator.validated();
-
-  if (!file) {
-    sendError(res, 400, "Avatar file is required");
-    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;
-  // Note: user_roles might not be fetched in update, so role defaults to "user" or fetched if needed.
-  // Ideally we should refetch or pass existing role.
-  // For now assuming role is preserved or handled by frontend state, but API should return it.
-  // Let's rely on nullable role or simple "user" fallback if not present in `updated`.
-  // Actually `update` returns what was updated. Relations are not included unless specified.
-  // For now we will return it compatible with userProfileSchema.
-
-  sendFastSuccess(res, 200, userProfileSerializer, {
-    status: "success",
-    message: "Avatar updated successfully",
-    data: {
-      ...rest,
-      id: updated.id.toString(),
-      role: payload.role, // Use role from JWT payload as it shouldn't change here
-    },
-  });
-}
-
-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 validator = Validator.make(req.body || {}, {
-    currentPassword: "required|min:4",
-    newPassword: "required|min:4",
-    confirmPassword: "required|min:4|same:newPassword",
-  });
-  if (await validator.fails()) {
-    sendError(res, 422, "Validation error", validator.errors());
-    return;
-  }
-  const { currentPassword, newPassword } = await validator.validated();
-  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: "Current password is incorrect",
-    });
-    return;
-  }
-  const hash = await bcrypt.hash(newPassword, 10);
-  await prisma.users.update({
-    where: { id: user.id },
-    data: {
-      password: hash,
-      updated_at: new Date(),
-    },
-  });
-  sendFastSuccess(res, 200, voidSerializer, {
-    status: "success",
-    message: "Password updated successfully",
-    data: 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 validator = Validator.make(req.body || {}, {
-    name: "required|min:1",
-    email: `required|email|unique:users,email,${payload.userId}`,
-  });
-  if (await validator.fails()) {
-    sendError(res, 422, "Validation error", validator.errors());
-    return;
-  }
-  const { name, email } = await validator.validated();
-  const userId = BigInt(payload.userId);
-  // Manual unique check removed as it is handled by validator
-
-  const updated = await prisma.users.update({
-    where: { id: userId },
-    data: {
-      name,
-      email,
-      updated_at: new Date(),
-    },
-  });
-  const { password, remember_token, ...rest } = updated as any;
-  sendFastSuccess(res, 200, userProfileSerializer, {
-    status: "success",
-    message: "Profile updated successfully",
-    data: {
-      ...rest,
-      id: updated.id.toString(),
-      role: payload.role, // Use role from JWT payload
-    },
-  });
-}

package/src/controllers/petController.ts

@@ -1,194 +0,0 @@
-import { Request, Response } from "express";
-import { prisma } from "@lapeh/core/database";
-import { sendSuccess, sendError, sendFastSuccess } from "@lapeh/utils/response";
-import { getPagination, buildPaginationMeta } from "@lapeh/utils/pagination";
-import { Validator } from "@lapeh/utils/validator";
-import {
-  getSerializer,
-  createResponseSchema,
-  createPaginatedResponseSchema,
-} from "@lapeh/core/serializer";
-
-// 1. Definisikan Schema Output untuk performa tinggi
-const petSchema = {
-  type: "object",
-  properties: {
-    id: { type: "string" }, // BigInt dikonversi ke string
-    name: { type: "string" },
-    species: { type: "string" },
-    age: { type: "integer" },
-    created_at: { type: "string", format: "date-time" },
-    updated_at: { type: "string", format: "date-time" },
-  },
-};
-
-// 2. Compile Serializer
-// Untuk Single Item
-const petSerializer = getSerializer(
-  "pet-single",
-  createResponseSchema(petSchema)
-);
-
-// Untuk List Item (Paginated)
-const petListSerializer = getSerializer(
-  "pet-list",
-  createPaginatedResponseSchema(petSchema)
-);
-
-export async function index(req: Request, res: Response) {
-  const { page, perPage, skip, take } = getPagination(req.query);
-  const search = req.query.search as string;
-
-  const where: any = {};
-  if (search) {
-    where.OR = [
-      { name: { contains: search, mode: "insensitive" } },
-      { species: { contains: search, mode: "insensitive" } },
-    ];
-  }
-
-  const [data, total] = await Promise.all([
-    prisma.pets.findMany({
-      where,
-      skip,
-      take,
-      orderBy: { created_at: "desc" },
-    }),
-    prisma.pets.count({ where }),
-  ]);
-
-  // Kita perlu convert BigInt ke string sebelum masuk serializer
-  // Karena fast-json-stringify mengharapkan tipe data yang sesuai dengan schema
-  const serialized = data.map((item: any) => ({
-    ...item,
-    id: item.id.toString(),
-  }));
-
-  const meta = buildPaginationMeta(page, perPage, total);
-
-  // Gunakan sendFastSuccess untuk performa maksimal
-  // Struktur data disesuaikan dengan createPaginatedResponseSchema: { data: [], meta: {} }
-  sendFastSuccess(res, 200, petListSerializer, {
-    status: "success",
-    message: "Pets retrieved successfully",
-    data: {
-      data: serialized,
-      meta,
-    },
-  });
-}
-
-export async function show(req: Request, res: Response) {
-  const { id } = req.params;
-  const pet = await prisma.pets.findUnique({
-    where: { id: BigInt(id) },
-  });
-
-  if (!pet) {
-    sendError(res, 404, "Pet not found");
-    return;
-  }
-
-  // Gunakan sendFastSuccess
-  sendFastSuccess(res, 200, petSerializer, {
-    status: "success",
-    message: "Pet retrieved successfully",
-    data: {
-      ...pet,
-      id: pet.id.toString(),
-    },
-  });
-}
-
-export async function store(req: Request, res: Response) {
-  const validator = Validator.make(req.body || {}, {
-    name: "required|string",
-    species: "required|string",
-    age: "required|integer|min:1",
-  });
-
-  if (await validator.fails()) {
-    sendError(res, 422, "Validation error", validator.errors());
-    return;
-  }
-
-  const validatedData = await validator.validated();
-  const pet = await prisma.pets.create({
-    data: {
-      ...validatedData,
-      created_at: new Date(),
-      updated_at: new Date(),
-    },
-  });
-
-  // Gunakan sendFastSuccess
-  sendFastSuccess(res, 201, petSerializer, {
-    status: "success",
-    message: "Pet created successfully",
-    data: {
-      ...pet,
-      id: pet.id.toString(),
-    },
-  });
-}
-
-export async function update(req: Request, res: Response) {
-  const { id } = req.params;
-  const validator = Validator.make(req.body || {}, {
-    name: "string",
-    species: "string",
-    age: "integer|min:1",
-  });
-
-  if (await validator.fails()) {
-    sendError(res, 422, "Validation error", validator.errors());
-    return;
-  }
-
-  const existing = await prisma.pets.findUnique({
-    where: { id: BigInt(id) },
-  });
-
-  if (!existing) {
-    sendError(res, 404, "Pet not found");
-    return;
-  }
-
-  const validatedData = await validator.validated();
-  const updated = await prisma.pets.update({
-    where: { id: BigInt(id) },
-    data: {
-      ...validatedData,
-      updated_at: new Date(),
-    },
-  });
-
-  // Gunakan sendFastSuccess
-  sendFastSuccess(res, 200, petSerializer, {
-    status: "success",
-    message: "Pet updated successfully",
-    data: {
-      ...updated,
-      id: updated.id.toString(),
-    },
-  });
-}
-
-export async function destroy(req: Request, res: Response) {
-  const { id } = req.params;
-
-  const existing = await prisma.pets.findUnique({
-    where: { id: BigInt(id) },
-  });
-
-  if (!existing) {
-    sendError(res, 404, "Pet not found");
-    return;
-  }
-
-  await prisma.pets.delete({
-    where: { id: BigInt(id) },
-  });
-
-  sendSuccess(res, 200, "Pet deleted successfully", null);
-}