Convert user service to TS

Author: guanquann

backend/user-service/.env.sample

@@ -3,3 +3,8 @@ PORT=3001
 
 # Secret for creating JWT signature
 JWT_SECRET=you-can-replace-this-with-your-own-secret
+
+# admin default credentials
+ADMIN_USERNAME=administrator
+ADMIN_EMAIL=[email protected]
+ADMIN_PASSWORD=Admin@123

backend/user-service/README.md

@@ -12,7 +12,13 @@ import {
   updateUserById as _updateUserById,
   updateUserPrivilegeById as _updateUserPrivilegeById,
 } from "../model/repository";
-import { validateEmail, validateUsername, validatePassword } from "../utils/validators";
+import {
+  validateEmail,
+  validateUsername,
+  validatePassword,
+  validateName,
+  validateBiography,
+} from "../utils/validators";
 import { IUser } from "../model/user-model";
 
 export async function createUser(req: Request, res: Response): Promise<Response> {
@@ -87,59 +93,102 @@ export async function getAllUsers(req: Request, res: Response): Promise<Response
 
 export async function updateUser(req: Request, res: Response): Promise<Response> {
   try {
-    const { username, email, password, profile_picture_url, first_name, last_name, biography } =
+    const { username, email, password, profilePictureUrl, firstName, lastName, biography } =
       req.body;
-    if (
-      username ||
-      email ||
-      password ||
-      profile_picture_url ||
-      first_name ||
-      last_name ||
-      biography
-    ) {
+    if (username || email || password || profilePictureUrl || firstName || lastName || biography) {
       const userId = req.params.id;
+
       if (!isValidObjectId(userId)) {
         return res.status(404).json({ message: `User ${userId} not found` });
       }
+
       const user = await _findUserById(userId);
       if (!user) {
         return res.status(404).json({ message: `User ${userId} not found` });
       }
-      if (username || email) {
-        let existingUser = await _findUserByUsername(username);
+
+      if (username) {
+        const { isValid: isValidUsername, message: usernameMessage } = validateUsername(username);
+        if (!isValidUsername) {
+          return res.status(400).json({ message: usernameMessage });
+        }
+
+        const existingUser = await _findUserByUsername(username);
         if (existingUser && existingUser.id !== userId) {
           return res.status(409).json({ message: "username already exists" });
         }
-        existingUser = await _findUserByEmail(email);
+      }
+
+      if (email) {
+        const { isValid: isValidEmail, message: emailMessage } = validateEmail(email);
+        if (!isValidEmail) {
+          return res.status(400).json({ message: emailMessage });
+        }
+
+        const existingUser = await _findUserByEmail(email);
         if (existingUser && existingUser.id !== userId) {
           return res.status(409).json({ message: "email already exists" });
         }
       }
 
       let hashedPassword: string | undefined;
       if (password) {
+        const { isValid: isValidPassword, message: passwordMessage } = validatePassword(password);
+        if (!isValidPassword) {
+          return res.status(400).json({ message: passwordMessage });
+        }
+
         const salt = bcrypt.genSaltSync(10);
         hashedPassword = bcrypt.hashSync(password, salt);
       }
+
+      if (firstName) {
+        const { isValid: isValidFirstName, message: firstNameMessage } = validateName(
+          firstName,
+          "first name"
+        );
+        if (!isValidFirstName) {
+          return res.status(400).json({ message: firstNameMessage });
+        }
+      }
+
+      if (lastName) {
+        const { isValid: isValidLastName, message: lastNameMessage } = validateName(
+          lastName,
+          "last name"
+        );
+        if (!isValidLastName) {
+          return res.status(400).json({ message: lastNameMessage });
+        }
+      }
+
+      if (biography) {
+        const { isValid: isValidBiography, message: biographyMessage } =
+          validateBiography(biography);
+        if (!isValidBiography) {
+          return res.status(400).json({ message: biographyMessage });
+        }
+      }
+
       const updatedUser = await _updateUserById(
         userId,
         username,
         email,
         hashedPassword,
-        profile_picture_url,
-        first_name,
-        last_name,
+        profilePictureUrl,
+        firstName,
+        lastName,
         biography
       );
       return res.status(200).json({
         message: `Updated data for user ${userId}`,
         data: formatUserResponse(updatedUser as IUser),
       });
     } else {
-      return res
-        .status(400)
-        .json({ message: "No field to update: username and email and password are all missing!" });
+      return res.status(400).json({
+        message:
+          "No field to update. Update one of the following fields: username, email, password, profilePictureUrl, firstName, lastName, biography",
+      });
     }
   } catch (err) {
     console.error(err);
@@ -203,9 +252,9 @@ export function formatUserResponse(user: IUser) {
     isAdmin: user.isAdmin,
     createdAt: user.createdAt,
 
-    profile_picture_url: user.profile_picture_url,
-    first_name: user.first_name,
-    last_name: user.last_name,
+    profilePictureUrl: user.profilePictureUrl,
+    firstName: user.firstName,
+    lastName: user.lastName,
     biography: user.biography,
   };
 }

backend/user-service/controller/user-controller.ts

@@ -16,14 +16,16 @@ export async function connectToDB() {
 export async function createUser(
   username: string,
   email: string,
-  password: string
+  password: string,
+  isAdmin: boolean = false
 ): Promise<IUser> {
   return new UserModel({
     username,
     email,
     password,
-    first_name: faker.person.firstName(),
-    last_name: faker.person.lastName(),
+    firstName: faker.person.firstName(),
+    lastName: faker.person.lastName(),
+    isAdmin,
   }).save();
 }
 
@@ -57,9 +59,9 @@ export async function updateUserById(
   username: string,
   email: string,
   password: string | undefined,
-  profile_picture_url: string,
-  first_name: string,
-  last_name: string,
+  profilePictureUrl: string,
+  firstName: string,
+  lastName: string,
   biography: string
 ): Promise<IUser | null> {
   return UserModel.findByIdAndUpdate(
@@ -69,9 +71,9 @@ export async function updateUserById(
         username,
         email,
         password,
-        profile_picture_url,
-        first_name,
-        last_name,
+        profilePictureUrl,
+        firstName,
+        lastName,
         biography,
       },
     },

backend/user-service/model/repository.ts

@@ -7,9 +7,9 @@ export interface IUser extends Document {
   createdAt?: Date;
   isAdmin: boolean;
 
-  profile_picture_url?: string;
-  first_name?: string;
-  last_name?: string;
+  profilePictureUrl?: string;
+  firstName?: string;
+  lastName?: string;
   biography?: string;
 }
 
@@ -37,15 +37,15 @@ const UserModelSchema: Schema<IUser> = new mongoose.Schema({
     required: true,
     default: false,
   },
-  profile_picture_url: {
+  profilePictureUrl: {
     type: String,
     required: false,
   },
-  first_name: {
+  firstName: {
     type: String,
     required: false,
   },
-  last_name: {
+  lastName: {
     type: String,
     required: false,
   },

backend/user-service/model/user-model.ts

@@ -5,7 +5,9 @@
   "main": "app.ts",
   "type": "module",
   "scripts": {
+    "seed": "tsx scripts/seed.ts",
     "start": "tsx server.ts",
+    "dev": "tsx watch server.ts",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "keywords": [],

backend/user-service/package.json

@@ -8,7 +8,11 @@ import {
   updateUser,
   updateUserPrivilege,
 } from "../controller/user-controller.js";
-import { verifyAccessToken, verifyIsAdmin, verifyIsOwnerOrAdmin } from "../middleware/basic-access-control.js";
+import {
+  verifyAccessToken,
+  verifyIsAdmin,
+  verifyIsOwnerOrAdmin,
+} from "../middleware/basic-access-control.js";
 
 const router = express.Router();
 
@@ -18,7 +22,7 @@ router.patch("/:id/privilege", verifyAccessToken, verifyIsAdmin, updateUserPrivi
 
 router.post("/", createUser);
 
-router.get("/:id", verifyAccessToken, verifyIsOwnerOrAdmin, getUser);
+router.get("/:id", verifyAccessToken, getUser);
 
 router.patch("/:id", verifyAccessToken, verifyIsOwnerOrAdmin, updateUser);
 

backend/user-service/routes/user-routes.ts

@@ -0,0 +1,37 @@
+import bcrypt from "bcrypt";
+import { connectToDB, createUser, findUserByEmail } from "../model/repository";
+
+export async function seedAdminAccount() {
+  await connectToDB();
+
+  const adminUsername = process.env.ADMIN_USERNAME || "administrator";
+  const adminEmail = process.env.ADMIN_EMAIL || "[email protected]";
+  const adminPassword = process.env.ADMIN_PASSWORD || "Admin@123";
+
+  if (!process.env.ADMIN_USERNAME || !process.env.ADMIN_EMAIL || !process.env.ADMIN_PASSWORD) {
+    console.error(
+      "Admin account not seeded in .env. Using default admin account credentials (username: administrator, email: [email protected], password: Admin@123)"
+    );
+  }
+
+  try {
+    const existingAdmin = await findUserByEmail(adminEmail);
+    if (existingAdmin) {
+      console.error("Admin account already exists in the database.");
+      process.exit(1);
+    }
+
+    const salt = bcrypt.genSaltSync(10);
+    const hashedPassword = bcrypt.hashSync(adminPassword, salt);
+
+    await createUser(adminUsername, adminEmail, hashedPassword, true);
+
+    console.log("Admin account created successfully.");
+    process.exit(0);
+  } catch (err) {
+    console.error("Error seeding admin account:", err);
+    process.exit(1);
+  }
+}
+
+seedAdminAccount();

backend/user-service/scripts/seed.ts

@@ -6,9 +6,9 @@ export interface AuthenticatedRequest extends Request {
     username: string;
     email: string;
     isAdmin: boolean;
-    profile_picture_url?: string;
-    first_name?: string;
-    last_name?: string;
+    profilePictureUrl?: string;
+    firstName?: string;
+    lastName?: string;
     biography?: string;
   };
 }