fix: revise register

apps/backend/src/routes/register/route.ts

@@ -3,19 +3,19 @@ import { HTTPException } from "hono/http-exception";
 import db from "../../drizzle";
 import { respondents } from "../../drizzle/schema/respondents";
 import { users } from "../../drizzle/schema/users";
+import { rolesSchema } from "../../drizzle/schema/roles";
 import { rolesToUsers } from "../../drizzle/schema/rolesToUsers";
 import { hashPassword } from "../../utils/passwordUtils";
 import requestValidator from "../../utils/requestValidator";
 import authInfo from "../../middlewares/authInfo";
-import checkPermission from "../../middlewares/checkPermission";
+import { or, eq } from "drizzle-orm";
-import { and, eq, or } from "drizzle-orm";
 import { z } from "zod";
 import HonoEnv from "../../types/HonoEnv";
 
 const registerFormSchema = z.object({
     name: z.string().min(1).max(255),
     username: z.string().min(1).max(255),
-    email: z.string().email().optional(),
+    email: z.string().email(),
     password: z.string().min(6),
     companyName: z.string().min(1).max(255),
     position: z.string().min(1).max(255),
@@ -23,36 +23,15 @@ const registerFormSchema = z.object({
     address: z.string().min(1),
     phoneNumber: z.string().min(1).max(13),
     isEnabled: z.string().default("false"),
-    roles: z
-    .string()
-    .refine(
-        (data) => {
-            try {
-                const parsed = JSON.parse(data);
-                return Array.isArray(parsed);
-            } catch {
-                return false;
-            }
-        },
-        {
-            message: "Roles must be an array",
-        }
-    )
-    .optional(),
 });
 
 const respondentsRoute = new Hono<HonoEnv>()
     .use(authInfo)
-    .post(
+    //post user
-        "/",
+    .post("/", requestValidator("json", registerFormSchema), async (c) => {
-        checkPermission("register.create"),
-        requestValidator("json", registerFormSchema),
-        async (c) => {
         const formData = c.req.valid("json");
 
-            console.log("Form Data:", formData);
+        // Check if the provided email or username is already exists in database
-    
-            // Build conditions based on available formData
         const conditions = [];
         if (formData.email) {
             conditions.push(eq(users.email, formData.email));
@@ -62,36 +41,34 @@ const respondentsRoute = new Hono<HonoEnv>()
         const existingUser = await db
             .select()
             .from(users)
-                .where(or(...conditions));
+            .where(
-    
+                or(
-            console.log("Existing Users:", existingUser);
+                    eq(users.email, formData.email),
+                    eq(users.username, formData.username)
+                )
+            );
 
         const existingRespondent = await db
             .select()
             .from(respondents)
             .where(eq(respondents.phoneNumber, formData.phoneNumber));
 
-            console.log("Existing Respondents:", existingRespondent);
-    
         if (existingUser.length > 0) {
             throw new HTTPException(400, {
-                    message: "Email atau username sudah terdaftar",
+                message: "Email or username has been registered",
             });
         }
 
         if (existingRespondent.length > 0) {
             throw new HTTPException(400, {
-                    message: "Nomor HP sudah terdaftar",
+                message: "Phone number has been registered",
             });
         }
 
         // Hash the password
         const hashedPassword = await hashPassword(formData.password);
 
-            console.log("Hashed Password:", hashedPassword);
-    
         // Start a transaction
-            try {
         const result = await db.transaction(async (trx) => {
             // Create user
             const [newUser] = await trx
@@ -103,55 +80,53 @@ const respondentsRoute = new Hono<HonoEnv>()
                     password: hashedPassword,
                     isEnabled: formData.isEnabled?.toLowerCase() === "true" || true,
                 })
-                        .returning();
+                .returning()
-    
+                .catch(() => {
-                    console.log("New User:", newUser);
+                    throw new HTTPException(500, { message: "Error creating user" });
+                });
 
             // Create respondent
-                    await trx.insert(respondents).values({
+            await trx
+                .insert(respondents)
+                .values({
                     companyName: formData.companyName,
                     position: formData.position,
                     workExperience: formData.workExperience,
                     address: formData.address,
                     phoneNumber: formData.phoneNumber,
                     userId: newUser.id,
+                })
+                .catch(() => {
+                    throw new HTTPException(500, {
+                        message: "Error creating respondent",
+                    });
                 });
 
-                    console.log("Respondent Created for User ID:", newUser.id);
+            // Automatically assign "user" role to the new user
+            const [role] = await trx
+                .select()
+                .from(rolesSchema)
+                .where(eq(rolesSchema.code, "user"))
+                .limit(1);
 
-                    // If roles are included in the request, add to rolesToUsers
+            if (!role) {
-                    if (formData.roles) {
+                throw new HTTPException(500, { message: "Role 'user' not found" });
-                        try {
+            }
-                            const roles = JSON.parse(formData.roles) as string[];
+
-                            if (roles.length) {
+            await trx.insert(rolesToUsers).values({
-                                await trx.insert(rolesToUsers).values(
-                                    roles.map((role) => ({
                 userId: newUser.id,
-                                        roleId: role,
+                roleId: role.id,
-                                    }))
-                                );
-                            }
-                        } catch (error) {
-                            console.error("Error parsing roles:", error);
-                            throw new HTTPException(400, {
-                                message: "Invalid roles format",
             });
-                        }
-                    }
 
             return newUser;
         });
 
-                return c.json({
+        return c.json(
-                    message: "User and respondent created successfully",
+            {
-                }, 201);
+                message: "User created successfully",
-            } catch (error) {
+            },
-                console.error("Error creating user and respondent:", error);
+            201
-                throw new HTTPException(500, {
-                    message: "Error creating user and respondent",
-                });
-            }
-        }
         );
+    });
 
 export default respondentsRoute;