lapeh 2.2.9 → 2.3.1

package/api-testing-duapuluh/api-testing-enambelas/src/controllers/petController.ts

@@ -0,0 +1,194 @@
+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-duapuluh/api-testing-enambelas/src/controllers/rbacController.ts

@@ -0,0 +1,478 @@
+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,
+  });
+}