lapeh 2.2.9 → 2.3.2

package/api-testing-enambelas/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);
-}

package/api-testing-enambelas/src/controllers/rbacController.ts

@@ -1,478 +0,0 @@
-import { Request, Response } from "express";
-import { prisma } from "@lapeh/core/database";
-import { sendError, sendFastSuccess } from "@lapeh/utils/response";
-import { Validator } from "@lapeh/utils/validator";
-import { z } from "zod";
-import { getSerializer, createResponseSchema } from "@lapeh/core/serializer";
-
-// --- Serializers ---
-
-const roleSchema = {
-  type: "object",
-  properties: {
-    id: { type: "string" },
-    name: { type: "string" },
-    slug: { type: "string" },
-    description: { type: "string", nullable: true },
-    created_at: { type: "string", format: "date-time", nullable: true },
-    updated_at: { type: "string", format: "date-time", nullable: true },
-  },
-};
-
-const permissionSchema = {
-  type: "object",
-  properties: {
-    id: { type: "string" },
-    name: { type: "string" },
-    slug: { type: "string" },
-    description: { type: "string", nullable: true },
-    created_at: { type: "string", format: "date-time", nullable: true },
-    updated_at: { type: "string", format: "date-time", nullable: true },
-  },
-};
-
-const roleSerializer = getSerializer("role", createResponseSchema(roleSchema));
-const roleListSerializer = getSerializer(
-  "role-list",
-  createResponseSchema({ type: "array", items: roleSchema })
-);
-
-const permissionSerializer = getSerializer(
-  "permission",
-  createResponseSchema(permissionSchema)
-);
-const permissionListSerializer = getSerializer(
-  "permission-list",
-  createResponseSchema({ type: "array", items: permissionSchema })
-);
-
-const voidSerializer = getSerializer(
-  "void",
-  createResponseSchema({ type: "null" })
-);
-
-// --- Controllers ---
-
-export async function createRole(req: Request, res: Response) {
-  const validator = Validator.make(req.body || {}, {
-    name: "required|string|min:1",
-    slug: "required|string|min:1|unique:roles,slug",
-    description: "string",
-  });
-
-  if (await validator.fails()) {
-    sendError(res, 422, "Validation error", validator.errors());
-    return;
-  }
-
-  const { name, slug, description } = await validator.validated();
-  // Manual unique check removed as it is handled by validator
-
-  const role = await prisma.roles.create({
-    data: {
-      name,
-      slug,
-      description: description || null,
-      created_at: new Date(),
-      updated_at: new Date(),
-    },
-  });
-  sendFastSuccess(res, 201, roleSerializer, {
-    status: "success",
-    message: "Role created",
-    data: { ...role, id: role.id.toString() },
-  });
-}
-
-export async function listRoles(_req: Request, res: Response) {
-  const roles = await prisma.roles.findMany({
-    orderBy: { id: "asc" },
-  });
-  const serialized = roles.map((r: any) => ({ ...r, id: r.id.toString() }));
-  sendFastSuccess(res, 200, roleListSerializer, {
-    status: "success",
-    message: "Roles list",
-    data: serialized,
-  });
-}
-
-export async function updateRole(req: Request, res: Response) {
-  const { id } = req.params;
-  const roleId = BigInt(id);
-
-  const validator = Validator.make(req.body || {}, {
-    name: "string",
-    slug: `string|unique:roles,slug,${id}`,
-    description: "string",
-  });
-
-  if (await validator.fails()) {
-    sendError(res, 422, "Validation error", validator.errors());
-    return;
-  }
-  const { name, slug, description } = await validator.validated();
-
-  const role = await prisma.roles.findUnique({ where: { id: roleId } });
-  if (!role) {
-    sendError(res, 404, "Role not found");
-    return;
-  }
-  // Manual unique check removed as it is handled by validator
-  const updated = await prisma.roles.update({
-    where: { id: roleId },
-    data: {
-      name: name ?? role.name,
-      slug: slug ?? role.slug,
-      description: description ?? role.description,
-      updated_at: new Date(),
-    },
-  });
-  sendFastSuccess(res, 200, roleSerializer, {
-    status: "success",
-    message: "Role updated",
-    data: { ...updated, id: updated.id.toString() },
-  });
-}
-
-export async function deleteRole(req: Request, res: Response) {
-  const { id } = req.params;
-  const roleId = BigInt(id);
-  const role = await prisma.roles.findUnique({ where: { id: roleId } });
-  if (!role) {
-    sendError(res, 404, "Role not found");
-    return;
-  }
-  await prisma.role_permissions.deleteMany({ where: { role_id: roleId } });
-  await prisma.user_roles.deleteMany({ where: { role_id: roleId } });
-  await prisma.roles.delete({ where: { id: roleId } });
-  sendFastSuccess(res, 200, voidSerializer, {
-    status: "success",
-    message: "Role deleted",
-    data: null,
-  });
-}
-
-export async function createPermission(req: Request, res: Response) {
-  const validator = Validator.make(req.body || {}, {
-    name: "required|string|min:1",
-    slug: "required|string|min:1|unique:permissions,slug",
-    description: "string",
-  });
-
-  if (await validator.fails()) {
-    sendError(res, 422, "Validation error", validator.errors());
-    return;
-  }
-  const { name, slug, description } = await validator.validated();
-  // Manual unique check removed as it is handled by validator
-
-  const permission = await prisma.permissions.create({
-    data: {
-      name,
-      slug,
-      description: description || null,
-      created_at: new Date(),
-      updated_at: new Date(),
-    },
-  });
-  sendFastSuccess(res, 201, permissionSerializer, {
-    status: "success",
-    message: "Permission created",
-    data: { ...permission, id: permission.id.toString() },
-  });
-}
-
-export async function listPermissions(_req: Request, res: Response) {
-  const permissions = await prisma.permissions.findMany({
-    orderBy: { id: "asc" },
-  });
-  const serialized = permissions.map((p: any) => ({
-    ...p,
-    id: p.id.toString(),
-  }));
-  sendFastSuccess(res, 200, permissionListSerializer, {
-    status: "success",
-    message: "Permissions list",
-    data: serialized,
-  });
-}
-
-export async function updatePermission(req: Request, res: Response) {
-  const { id } = req.params;
-  const permissionId = BigInt(id);
-
-  const validator = Validator.make(req.body || {}, {
-    name: "string",
-    slug: `string|unique:permissions,slug,${id}`,
-    description: "string",
-  });
-
-  if (await validator.fails()) {
-    sendError(res, 422, "Validation error", validator.errors());
-    return;
-  }
-  const { name, slug, description } = await validator.validated();
-
-  const permission = await prisma.permissions.findUnique({
-    where: { id: permissionId },
-  });
-  if (!permission) {
-    sendError(res, 404, "Permission not found");
-    return;
-  }
-  // Manual unique check removed as it is handled by validator
-  const updated = await prisma.permissions.update({
-    where: { id: permissionId },
-    data: {
-      name: name ?? permission.name,
-      slug: slug ?? permission.slug,
-      description: description ?? permission.description,
-      updated_at: new Date(),
-    },
-  });
-  sendFastSuccess(res, 200, permissionSerializer, {
-    status: "success",
-    message: "Permission updated",
-    data: { ...updated, id: updated.id.toString() },
-  });
-}
-
-export async function deletePermission(req: Request, res: Response) {
-  const { id } = req.params;
-  const permissionId = BigInt(id);
-  const permission = await prisma.permissions.findUnique({
-    where: { id: permissionId },
-  });
-  if (!permission) {
-    sendError(res, 404, "Permission not found");
-    return;
-  }
-  await prisma.role_permissions.deleteMany({
-    where: { permission_id: permissionId },
-  });
-  await prisma.user_permissions.deleteMany({
-    where: { permission_id: permissionId },
-  });
-  await prisma.permissions.delete({ where: { id: permissionId } });
-  sendFastSuccess(res, 200, voidSerializer, {
-    status: "success",
-    message: "Permission deleted",
-    data: null,
-  });
-}
-
-export async function assignRoleToUser(req: Request, res: Response) {
-  const validator = Validator.make(req.body || {}, {
-    userId: z.string().min(1, "userId wajib diisi"),
-    roleId: z.string().min(1, "roleId wajib diisi"),
-  });
-
-  if (await validator.fails()) {
-    sendError(res, 422, "Validation error", validator.errors());
-    return;
-  }
-  const { userId, roleId } = await validator.validated();
-
-  const user = await prisma.users.findUnique({
-    where: { id: BigInt(userId) },
-  });
-  if (!user) {
-    sendError(res, 404, "User not found");
-    return;
-  }
-  const role = await prisma.roles.findUnique({
-    where: { id: BigInt(roleId) },
-  });
-  if (!role) {
-    sendError(res, 404, "Role not found");
-    return;
-  }
-  await prisma.user_roles.upsert({
-    where: {
-      user_id_role_id: {
-        user_id: BigInt(userId),
-        role_id: BigInt(roleId),
-      },
-    },
-    create: {
-      user_id: BigInt(userId),
-      role_id: BigInt(roleId),
-      created_at: new Date(),
-    },
-    update: {},
-  });
-  sendFastSuccess(res, 200, voidSerializer, {
-    status: "success",
-    message: "Role assigned to user",
-    data: null,
-  });
-}
-
-export async function removeRoleFromUser(req: Request, res: Response) {
-  const validator = Validator.make(req.body || {}, {
-    userId: z.string().min(1, "userId wajib diisi"),
-    roleId: z.string().min(1, "roleId wajib diisi"),
-  });
-
-  if (await validator.fails()) {
-    sendError(res, 422, "Validation error", validator.errors());
-    return;
-  }
-  const { userId, roleId } = await validator.validated();
-
-  await prisma.user_roles.deleteMany({
-    where: {
-      user_id: BigInt(userId),
-      role_id: BigInt(roleId),
-    },
-  });
-  sendFastSuccess(res, 200, voidSerializer, {
-    status: "success",
-    message: "Role removed from user",
-    data: null,
-  });
-}
-
-export async function assignPermissionToRole(req: Request, res: Response) {
-  const validator = Validator.make(req.body || {}, {
-    roleId: z.string().min(1, "roleId wajib diisi"),
-    permissionId: z.string().min(1, "permissionId wajib diisi"),
-  });
-
-  if (await validator.fails()) {
-    sendError(res, 422, "Validation error", validator.errors());
-    return;
-  }
-  const { roleId, permissionId } = await validator.validated();
-
-  const role = await prisma.roles.findUnique({
-    where: { id: BigInt(roleId) },
-  });
-  if (!role) {
-    sendError(res, 404, "Role not found");
-    return;
-  }
-  const permission = await prisma.permissions.findUnique({
-    where: { id: BigInt(permissionId) },
-  });
-  if (!permission) {
-    sendError(res, 404, "Permission not found");
-    return;
-  }
-  await prisma.role_permissions.upsert({
-    where: {
-      role_id_permission_id: {
-        role_id: BigInt(roleId),
-        permission_id: BigInt(permissionId),
-      },
-    },
-    create: {
-      role_id: BigInt(roleId),
-      permission_id: BigInt(permissionId),
-      created_at: new Date(),
-    },
-    update: {},
-  });
-  sendFastSuccess(res, 200, voidSerializer, {
-    status: "success",
-    message: "Permission assigned to role",
-    data: null,
-  });
-}
-
-export async function removePermissionFromRole(req: Request, res: Response) {
-  const validator = Validator.make(req.body || {}, {
-    roleId: z.string().min(1, "roleId wajib diisi"),
-    permissionId: z.string().min(1, "permissionId wajib diisi"),
-  });
-
-  if (await validator.fails()) {
-    sendError(res, 422, "Validation error", validator.errors());
-    return;
-  }
-  const { roleId, permissionId } = await validator.validated();
-
-  await prisma.role_permissions.deleteMany({
-    where: {
-      role_id: BigInt(roleId),
-      permission_id: BigInt(permissionId),
-    },
-  });
-  sendFastSuccess(res, 200, voidSerializer, {
-    status: "success",
-    message: "Permission removed from role",
-    data: null,
-  });
-}
-
-export async function assignPermissionToUser(req: Request, res: Response) {
-  const validator = Validator.make(req.body || {}, {
-    userId: z.string().min(1, "userId wajib diisi"),
-    permissionId: z.string().min(1, "permissionId wajib diisi"),
-  });
-
-  if (await validator.fails()) {
-    sendError(res, 422, "Validation error", validator.errors());
-    return;
-  }
-  const { userId, permissionId } = await validator.validated();
-
-  const user = await prisma.users.findUnique({
-    where: { id: BigInt(userId) },
-  });
-  if (!user) {
-    sendError(res, 404, "User not found");
-    return;
-  }
-  const permission = await prisma.permissions.findUnique({
-    where: { id: BigInt(permissionId) },
-  });
-  if (!permission) {
-    sendError(res, 404, "Permission not found");
-    return;
-  }
-  await prisma.user_permissions.upsert({
-    where: {
-      user_id_permission_id: {
-        user_id: BigInt(userId),
-        permission_id: BigInt(permissionId),
-      },
-    },
-    create: {
-      user_id: BigInt(userId),
-      permission_id: BigInt(permissionId),
-      created_at: new Date(),
-    },
-    update: {},
-  });
-  sendFastSuccess(res, 200, voidSerializer, {
-    status: "success",
-    message: "Permission assigned to user",
-    data: null,
-  });
-}
-
-export async function removePermissionFromUser(req: Request, res: Response) {
-  const validator = Validator.make(req.body || {}, {
-    userId: z.string().min(1, "userId wajib diisi"),
-    permissionId: z.string().min(1, "permissionId wajib diisi"),
-  });
-
-  if (await validator.fails()) {
-    sendError(res, 422, "Validation error", validator.errors());
-    return;
-  }
-  const { userId, permissionId } = await validator.validated();
-
-  await prisma.user_permissions.deleteMany({
-    where: {
-      user_id: BigInt(userId),
-      permission_id: BigInt(permissionId),
-    },
-  });
-  sendFastSuccess(res, 200, voidSerializer, {
-    status: "success",
-    message: "Permission removed from user",
-    data: null,
-  });
-}