feat(all): refactor code for readability and simplicity

The controllers, services, routes, and others have been updated to reduce code complexity and improve readability. Changes include removing unnecessary lines, replacing long function signatures with simpler versions, and streamlining condition checks and logger statements.

Signed-off-by: Mathis <yidhra@tuta.io>

biome.json

@@ -28,6 +28,6 @@
   "formatter": {
     "indentStyle": "tab",
     "indentWidth": 2,
-    "lineWidth": 64
+    "lineWidth": 80
   }
 }

src/controllers/auth.controller.ts

@@ -22,10 +22,7 @@ const logger = new Logger({
  *                   - error: "exist" if the user already exists
  *                   - Otherwise, the registered user data
  */
-async function registerUser(
+async function registerUser(req: Request, res: Response): Promise<unknown> {
-	req: Request,
-	res: Response,
-): Promise<unknown> {
 	const body = req.body;
 	if (!body) {
 		logger.warn(`Invalid input data (${req.ip})`);
@@ -59,8 +56,7 @@ async function registerUser(
 		lastName: `${body.lastName}`,
 	};
 
-	const RegisterServiceResult =
+	const RegisterServiceResult = await UserService.register(sanitizeData);
-		await UserService.register(sanitizeData);
 
 	if (RegisterServiceResult.error === "gdprNotApproved") {
 		logger.warn(`GDPR not approved (${req.ip})`);
@@ -79,10 +75,7 @@ async function registerUser(
 
 	// SUCCESS
 	logger.info(`User registered successfully (${req.ip})`);
-	return res
+	return res.type("application/json").status(201).json(RegisterServiceResult);
-		.type("application/json")
-		.status(201)
-		.json(RegisterServiceResult);
 }
 
 /**
@@ -93,10 +86,7 @@ async function registerUser(
  *
  * @return {Promise<void>} A promise that resolves when the user is logged in or rejects with an error.
  */
-async function loginUser(
+async function loginUser(req: Request, res: Response): Promise<void> {
-	req: Request,
-	res: Response,
-): Promise<void> {
 	const body = req.body;
 	if (!body) {
 		res.type("application/json").status(400).json({
@@ -131,10 +121,7 @@ async function loginUser(
 			message: "Invalid password.",
 		});
 	}
-	res
+	res.type("application/json").status(200).json(LoginServiceResult);
-		.type("application/json")
-		.status(200)
-		.json(LoginServiceResult);
 }
 
 async function getAllUsers(req: Request, res: Response) {
@@ -170,10 +157,7 @@ async function getAllUsers(req: Request, res: Response) {
 			error: "Internal server error",
 		});
 	}
-	return res
+	return res.type("application/json").status(200).json(AllUserResponse);
-		.type("application/json")
-		.status(200)
-		.json(AllUserResponse);
 }
 
 async function getUser(req: Request, res: Response) {
@@ -267,14 +251,11 @@ async function editUser(req: Request, res: Response) {
 		//TODO Interface
 		const modifiedData = {};
 		//@ts-ignore
-		if (body.firstName)
+		if (body.firstName) modifiedData.firstName = `${body.firstName}`;
-			modifiedData.firstName = `${body.firstName}`;
 		//@ts-ignore
-		if (body.lastName)
+		if (body.lastName) modifiedData.lastName = `${body.lastName}`;
-			modifiedData.lastName = `${body.lastName}`;
 		//@ts-ignore
-		if (body.displayName)
+		if (body.displayName) modifiedData.displayName = `${body.displayName}`;
-			modifiedData.displayName = `${body.displayName}`;
 		//TODO Case handled with hashing by the service.
 		//if (body.password) modifiedData.password = `${body.password}`;
 
@@ -290,31 +271,21 @@ async function editUser(req: Request, res: Response) {
 			});
 		}
 		if (EditUserServiceResult.error !== "none") {
-			logger.error(
+			logger.error(`Error occurred during user edit (${req.ip})`);
-				`Error occurred during user edit (${req.ip})`,
-			);
 			return res.type("application/json").status(500).json({
 				error: "Internal server error",
 			});
 		}
-		return res
+		return res.type("application/json").status(200).json(EditUserServiceResult);
-			.type("application/json")
-			.status(200)
-			.json(EditUserServiceResult);
 	}
 	//Not itself or
-	logger.warn(
+	logger.warn(`Unauthorized access attempt, not self or admin (${req.ip})`);
-		`Unauthorized access attempt, not self or admin (${req.ip})`,
-	);
 	return res.type("application/json").status(403).json({
 		error: "Unauthorized",
 	});
 }
 
-async function deleteUser(
+async function deleteUser(req: Request, res: Response): Promise<Response> {
-	req: Request,
-	res: Response,
-): Promise<Response> {
 	const authHeader = req.headers.authorization;
 	const bearerToken = authHeader?.split(" ")[1];
 	if (!bearerToken) {
@@ -340,13 +311,9 @@ async function deleteUser(
 		});
 	}
 	if (sourceUser.is_admin || sourceUser.id === payload.sub) {
-		const deleteUserServiceResult = await UserService.delete(
+		const deleteUserServiceResult = await UserService.delete(`${targetUserId}`);
-			`${targetUserId}`,
-		);
 		if (!deleteUserServiceResult) {
-			logger.error(
+			logger.error(`Error occurred during user delete (${req.ip})`);
-				`Error occurred during user delete (${req.ip})`,
-			);
 			return res.type("application/json").status(500).json({
 				error: "Internal server error",
 			});

src/controllers/brand.controller.ts

@@ -17,14 +17,9 @@ const logger = new Logger({
  *
  * @returns A Promise that resolves to the response object with a status code and a JSON message indicating the success or failure of brand creation.
  */
-async function createBrand(
+async function createBrand(req: Request, res: Response): Promise<Response> {
-	req: Request,
-	res: Response,
-): Promise<Response> {
 	const body: IDbBrand = req.body;
-	const doesExist = await BrandService.getBySlug(
+	const doesExist = await BrandService.getBySlug(`${body.slug_name}`);
-		`${body.slug_name}`,
-	);
 	if (doesExist) {
 		logger.error("Brand already exists");
 		return res.status(400).json({
@@ -42,9 +37,7 @@ async function createBrand(
 			error: "Failed to create brand",
 		});
 	}
-	logger.info(
+	logger.info(`Brand created successfully ! (${body.slug_name})`);
-		`Brand created successfully ! (${body.slug_name})`,
-	);
 	return res.status(201).json({
 		message: "Brand created successfully",
 	});
@@ -57,10 +50,7 @@ async function createBrand(
  * @param {Response} res - The HTTP response object.
  * @return {Promise<Response>} A promise that resolves with the HTTP response.
  */
-async function updateBrand(
+async function updateBrand(req: Request, res: Response): Promise<Response> {
-	req: Request,
-	res: Response,
-): Promise<Response> {
 	const body: IDbBrand = req.body;
 	const brandSlug = req.params["brandSlug"];
 	if (!brandSlug) {
@@ -100,10 +90,7 @@ async function updateBrand(
  * @param {Response} res - The response object to send the result.
  * @returns {Promise<Response>} - A promise that resolves to the response with the retrieved brand.
  */
-async function getBySlugBrand(
+async function getBySlugBrand(req: Request, res: Response): Promise<Response> {
-	req: Request,
-	res: Response,
-): Promise<Response> {
 	const brandSlug = req.params["brandSlug"];
 	if (!brandSlug) {
 		logger.error("Brand slug is missing");
@@ -129,10 +116,7 @@ async function getBySlugBrand(
  * @param {Response} res - The response object.
  * @returns {Promise<Response>} - A promise with the response object.
  */
-async function getAllBrand(
+async function getAllBrand(_req: Request, res: Response): Promise<Response> {
-	_req: Request,
-	res: Response,
-): Promise<Response> {
 	const brands = await BrandService.getAll();
 	if (!brands) {
 		logger.error("Failed to retrieve brands");
@@ -156,10 +140,7 @@ async function getAllBrand(
  * @param {Response} res - The response object.
  * @returns {Promise<Response>} - The response object indicating the success or failure of the delete operation.
  */
-async function deleteBrand(
+async function deleteBrand(req: Request, res: Response): Promise<Response> {
-	req: Request,
-	res: Response,
-): Promise<Response> {
 	const brandSlug = req.params["brandSlug"];
 	if (!brandSlug) {
 		logger.error("Brand slug is missing");

src/controllers/category.controller.ts

@@ -15,14 +15,9 @@ const logger = new Logger({
  * @param {Response} res - The response object to send back to the client.
  * @returns {Promise<Response>} The response object indicating the outcome of the category creation.
  */
-async function createCategory(
+async function createCategory(req: Request, res: Response): Promise<Response> {
-	req: Request,
-	res: Response,
-): Promise<Response> {
 	const body: IDbCategory = req.body;
-	const doesExist = await CategoryService.getBySlug(
+	const doesExist = await CategoryService.getBySlug(`${body.slug_name}`);
-		`${body.slug_name}`,
-	);
 	if (doesExist) {
 		logger.error("Category already exists");
 		return res.status(400).json({
@@ -39,9 +34,7 @@ async function createCategory(
 			error: "Failed to create category",
 		});
 	}
-	logger.info(
+	logger.info(`Category created successfully ! (${body.slug_name})`);
-		`Category created successfully ! (${body.slug_name})`,
-	);
 	return res.status(201).json({
 		message: "Category created successfully",
 	});
@@ -55,10 +48,7 @@ async function createCategory(
  *
  * @return {Promise<Response>} - A promise that will be resolved with the result of the update operation.
  */
-async function updateCategory(
+async function updateCategory(req: Request, res: Response): Promise<Response> {
-	req: Request,
-	res: Response,
-): Promise<Response> {
 	const body: IDbCategory = req.body;
 	const categoryId = req.params["categorySlug"];
 	if (!categoryId) {
@@ -67,9 +57,7 @@ async function updateCategory(
 			error: "Category slug is missing",
 		});
 	}
-	const doesExist = await CategoryService.getById(
+	const doesExist = await CategoryService.getById(`${categoryId}`);
-		`${categoryId}`,
-	);
 	if (!doesExist || !doesExist.id) {
 		logger.error("Category not found");
 		return res.status(404).json({
@@ -100,10 +88,7 @@ async function updateCategory(
  * @param {Response} res - The response object to send the result.
  * @returns {Promise<Response>} A Promise that resolves to the response object.
  */
-async function deleteCategory(
+async function deleteCategory(req: Request, res: Response): Promise<Response> {
-	req: Request,
-	res: Response,
-): Promise<Response> {
 	const categorySlug = req.params["categorySlug"];
 	if (!categorySlug) {
 		logger.error("Category slug is missing");
@@ -111,27 +96,21 @@ async function deleteCategory(
 			error: "Category slug is missing",
 		});
 	}
-	const doesExist = await CategoryService.getBySlug(
+	const doesExist = await CategoryService.getBySlug(`${categorySlug}`);
-		`${categorySlug}`,
-	);
 	if (!doesExist || !doesExist.id) {
 		logger.error("Category not found");
 		return res.status(404).json({
 			error: "Category not found",
 		});
 	}
-	const deleteResult = await CategoryService.delete(
+	const deleteResult = await CategoryService.delete(`${doesExist.id}`);
-		`${doesExist.id}`,
-	);
 	if (!deleteResult) {
 		logger.error("Failed to delete category");
 		return res.status(500).json({
 			error: "Failed to delete category",
 		});
 	}
-	logger.info(
+	logger.info(`Category deleted successfully! (${categorySlug})`);
-		`Category deleted successfully! (${categorySlug})`,
-	);
 	return res.status(200).json({
 		message: "Category deleted successfully",
 	});
@@ -144,10 +123,7 @@ async function deleteCategory(
  * @param {Response} res - The response object.
  * @return {Promise<Response>} - A promise that resolves to the response object.
  */
-async function getAllCategory(
+async function getAllCategory(_req: Request, res: Response): Promise<Response> {
-	_req: Request,
-	res: Response,
-): Promise<Response> {
 	const categories = await CategoryService.getAll();
 	if (!categories) {
 		logger.error("Failed to get categories");
@@ -186,18 +162,14 @@ async function getBySlugCategory(
 			error: "Category slug is missing",
 		});
 	}
-	const category = await CategoryService.getBySlug(
+	const category = await CategoryService.getBySlug(`${categorySlug}`);
-		`${categorySlug}`,
-	);
 	if (!category || !category.id) {
 		logger.error("Category not found");
 		return res.status(404).json({
 			error: "Category not found",
 		});
 	}
-	logger.info(
+	logger.info(`Category retrieved successfully! (${categorySlug})`);
-		`Category retrieved successfully! (${categorySlug})`,
-	);
 	return res.status(200).json({
 		id: category.id,
 		display_name: category.display_name,

src/controllers/model.controller.ts

@@ -9,14 +9,9 @@ const logger = new Logger({
 	name: "ModelController",
 });
 
-async function createModel(
+async function createModel(req: Request, res: Response): Promise<Response> {
-	req: Request,
-	res: Response,
-): Promise<Response> {
 	const body: IDbModel = req.body;
-	const doesExist = await CategoryService.getBySlug(
+	const doesExist = await CategoryService.getBySlug(`${body.slug_name}`);
-		`${body.slug_name}`,
-	);
 	if (doesExist) {
 		logger.error("Category already exists");
 		return res.status(400).json({
@@ -38,22 +33,15 @@ async function createModel(
 			error: "Failed to create category",
 		});
 	}
-	logger.info(
+	logger.info(`Category created successfully ! (${body.slug_name})`);
-		`Category created successfully ! (${body.slug_name})`,
-	);
 	return res.status(201).json({
 		message: "Category created successfully",
 	});
 }
 
-async function updateModel(
+async function updateModel(req: Request, res: Response): Promise<Response> {
-	req: Request,
-	res: Response,
-): Promise<Response> {
 	const body: IDbModel = req.body;
-	const doesExist = await ModelService.getBySlug(
+	const doesExist = await ModelService.getBySlug(`${body.slug_name}`);
-		`${body.slug_name}`,
-	);
 	if (!doesExist) {
 		logger.error("Model does not exist");
 		return res.status(404).json({
@@ -76,9 +64,7 @@ async function updateModel(
 			error: "Failed to update model",
 		});
 	}
-	logger.info(
+	logger.info(`Model updated successfully! (${body.slug_name})`);
-		`Model updated successfully! (${body.slug_name})`,
-	);
 	return res.status(200).json({
 		message: "Model updated successfully",
 	});
@@ -99,10 +85,7 @@ async function getAllModel(res: Response): Promise<Response> {
 	});
 }
 
-async function getModelBySlug(
+async function getModelBySlug(req: Request, res: Response): Promise<Response> {
-	req: Request,
-	res: Response,
-): Promise<Response> {
 	const slug = req.params["modelSlug"];
 	if (!slug) {
 		logger.error("Invalid slug");
@@ -122,10 +105,7 @@ async function getModelBySlug(
 	});
 }
 
-async function deleteModel(
+async function deleteModel(req: Request, res: Response): Promise<Response> {
-	req: Request,
-	res: Response,
-): Promise<Response> {
 	const modelSlug = req.params["modelSlug"];
 	if (!modelSlug) {
 		logger.error("Invalid model slug");
@@ -141,9 +121,7 @@ async function deleteModel(
 			error: "Failed to delete model",
 		});
 	}
-	logger.info(
+	logger.info(`Model deleted successfully! (SLUG: ${modelSlug})`);
-		`Model deleted successfully! (SLUG: ${modelSlug})`,
-	);
 	return res.status(200).json({
 		message: "Model deleted successfully",
 	});

src/routes/auth/authRouter.ts

@@ -10,25 +10,16 @@ AuthRouter.route("/register").post(AuthController.register);
 
 // PATCH
 //TODO - To test
-AuthRouter.route("/me").patch(
+AuthRouter.route("/me").patch(UserGuard, AuthController.editUser);
-	UserGuard,
-	AuthController.editUser,
-);
 
 // GET
 AuthRouter.route("/me").get(UserGuard, AuthController.getSelf);
 
 // DELETE
-AuthRouter.route("/me").delete(
+AuthRouter.route("/me").delete(UserGuard, AuthController.deleteSelf);
-	UserGuard,
-	AuthController.deleteSelf,
-);
 
 // GET
-AuthRouter.route("/all").get(
+AuthRouter.route("/all").get(AdminGuard, AuthController.getAllUsers);
-	AdminGuard,
-	AuthController.getAllUsers,
-);
 
 // GET
 AuthRouter.route("/user/:targetId")

src/routes/catalog/catalogRouter.ts

@@ -9,10 +9,7 @@ const CatalogRouter: Router = express.Router();
 
 //-- MODELS >>
 
-CatalogRouter.route("/model/new").get(
+CatalogRouter.route("/model/new").get(AdminGuard, ModelController.create);
-	AdminGuard,
-	ModelController.create,
-);
 
 CatalogRouter.route("/model/all").get(ModelController.getAll);
 
@@ -23,14 +20,9 @@ CatalogRouter.route("/model/:modelSlug")
 
 //-- CATEGORY >>
 
-CatalogRouter.route("/category/new").get(
+CatalogRouter.route("/category/new").get(AdminGuard, CategoryController.create);
-	AdminGuard,
-	CategoryController.create,
-);
 
-CatalogRouter.route("/category/all").get(
+CatalogRouter.route("/category/all").get(CategoryController.getAll);
-	CategoryController.getAll,
-);
 
 CatalogRouter.route("/category/:categorySlug")
 	.get(UserGuard, CategoryController.getBySlug)
@@ -39,10 +31,7 @@ CatalogRouter.route("/category/:categorySlug")
 
 //-- BRAND >>
 
-CatalogRouter.route("/brand/new").post(
+CatalogRouter.route("/brand/new").post(AdminGuard, BrandController.create);
-	AdminGuard,
-	BrandController.create,
-);
 CatalogRouter.route("/brand/all").get(BrandController.getAll);
 CatalogRouter.route("/brand/:brandSlug")
 	.get(UserGuard, BrandController.getBySlug)

src/services/brand.service.ts

@@ -27,19 +27,14 @@ async function createBrand(data: IDbBrand): Promise<unknown> {
 		};
 	}
 	const brandId = uuidv4();
-	const createdBrand = await MysqlService.Brand.insert(
+	const createdBrand = await MysqlService.Brand.insert(DbHandler, {
-		DbHandler,
-		{
 		id: brandId,
 		slug_name: `${data.slug_name}`,
 		display_name: `${data.display_name}`,
 		image_blob: data.image_blob,
-		},
+	});
-	);
 	if (createdBrand) {
-		logger.info(
+		logger.info(`Brand created successfully (${data.slug_name})`);
-			`Brand created successfully (${data.slug_name})`,
-		);
 		return {
 			success: true,
 			brand: createdBrand,
@@ -71,19 +66,14 @@ async function updateBrand(data: IDbBrand): Promise<boolean> {
 		logger.error(`Brand already exists (${data.slug_name})`);
 		return false;
 	}
-	const updatedBrand = await MysqlService.Brand.update(
+	const updatedBrand = await MysqlService.Brand.update(DbHandler, {
-		DbHandler,
-		{
 		id: data.id,
 		slug_name: `${data.slug_name}`,
 		display_name: `${data.display_name}`,
 		image_blob: data.image_blob,
-		},
+	});
-	);
 	if (updatedBrand) {
-		logger.info(
+		logger.info(`Brand updated successfully (${data.slug_name})`);
-			`Brand updated successfully (${data.slug_name})`,
-		);
 		return true;
 	}
 	logger.error(`Failed to update brand (${data.slug_name})`);
@@ -100,9 +90,7 @@ async function getAllBrand(): Promise<Array<IDbBrand> | false> {
 		logger.error("Failed to retrieve brands");
 		return false;
 	}
-	logger.info(
+	logger.info(`Retrieved all brands successfully (${brands.length})`);
-		`Retrieved all brands successfully (${brands.length})`,
-	);
 	return brands;
 }
 
@@ -112,24 +100,17 @@ async function getAllBrand(): Promise<Array<IDbBrand> | false> {
  * @param {string} brandSlug - The slug of the brand.
  * @returns {Promise<IDbBrand|false>} - A promise that resolves to the retrieved brand object or false if the brand is not found.
  */
-async function getBySlugBrand(
+async function getBySlugBrand(brandSlug: string): Promise<IDbBrand | false> {
-	brandSlug: string,
-): Promise<IDbBrand | false> {
 	if (!brandSlug) {
 		logger.error("Brand slug is missing");
 		return false;
 	}
-	const brand = await MysqlService.Brand.getBySlug(
+	const brand = await MysqlService.Brand.getBySlug(DbHandler, brandSlug);
-		DbHandler,
-		brandSlug,
-	);
 	if (!brand) {
 		logger.error(`Brand not found (${brandSlug})`);
 		return false;
 	}
-	logger.info(
+	logger.info(`Retrieved brand by slug successfully (${brandSlug})`);
-		`Retrieved brand by slug successfully (${brandSlug})`,
-	);
 	return brand;
 }
 
@@ -140,9 +121,7 @@ async function getBySlugBrand(
  *
  * @returns {Promise<IDbBrand | false>} A promise that resolves to the retrieved brand object, or false if the brand is not found or the ID is invalid.
  */
-async function getByIdBrand(
+async function getByIdBrand(brandId: string): Promise<IDbBrand | false> {
-	brandId: string,
-): Promise<IDbBrand | false> {
 	if (!brandId) {
 		logger.error("Brand ID is missing");
 		return false;
@@ -151,17 +130,12 @@ async function getByIdBrand(
 		logger.error("Invalid brand ID");
 		return false;
 	}
-	const brand = await MysqlService.Brand.getById(
+	const brand = await MysqlService.Brand.getById(DbHandler, brandId);
-		DbHandler,
-		brandId,
-	);
 	if (!brand) {
 		logger.error(`Brand not found (${brandId})`);
 		return false;
 	}
-	logger.info(
+	logger.info(`Retrieved brand by ID successfully (${brandId})`);
-		`Retrieved brand by ID successfully (${brandId})`,
-	);
 	return brand;
 }
 
@@ -185,10 +159,7 @@ async function deleteBrand(brandId: string): Promise<boolean> {
 		return false;
 	}
 	//TODO verify if as models linked
-	const deletedBrand = await MysqlService.Brand.delete(
+	const deletedBrand = await MysqlService.Brand.delete(DbHandler, brandId);
-		DbHandler,
-		brandId,
-	);
 	if (!deletedBrand) {
 		logger.error(`Failed to delete brand (${brandId})`);
 		return false;

src/services/category.service.ts

@@ -15,12 +15,8 @@ const logger = new Logger({
  * @returns {Promise<boolean>} A promise that resolves with the created category.
  *                            If an error occurs, the promise will reject with the error.
  */
-async function createCategory(
+async function createCategory(data: IDbCategory): Promise<boolean> {
-	data: IDbCategory,
+	logger.info(`Creating a new category... (${data.display_name})`);
-): Promise<boolean> {
-	logger.info(
-		`Creating a new category... (${data.display_name})`,
-	);
 	try {
 		await MysqlService.Category.insert(DbHandler, {
 			id: uuidv4(),
@@ -69,9 +65,7 @@ async function updateCategory(data: IDbCategory) {
  *
  * @returns {Promise<Array<IDbCategory>> | null} Promise that resolves to an array of IDbCategory objects or null if an error occurred.
  */
-async function getAll(): Promise<Promise<
+async function getAll(): Promise<Promise<Array<IDbCategory>> | null> {
-	Array<IDbCategory>
-> | null> {
 	try {
 		logger.info("Getting all categories...");
 		return await MysqlService.Category.getAll(DbHandler);
@@ -87,15 +81,10 @@ async function getAll(): Promise<Promise<
  * @param {string} slug - The slug of the category
  * @return {Promise<IDbCategory|null>} - A promise that resolves to the category object or null if not found
  */
-async function getBySlug(
+async function getBySlug(slug: string): Promise<IDbCategory | null> {
-	slug: string,
-): Promise<IDbCategory | null> {
 	try {
 		logger.info(`Getting category by slug... (${slug})`);
-		return await MysqlService.Category.getBySlug(
+		return await MysqlService.Category.getBySlug(DbHandler, slug);
-			DbHandler,
-			slug,
-		);
 	} catch (error) {
 		logger.error(`Error getting category by slug: ${error}`);
 		return null;
@@ -108,9 +97,7 @@ async function getBySlug(
  * @param {string} id - The id of the category to retrieve.
  * @returns {Promise<IDbCategory | null>} - A Promise that resolves with the retrieved category object or null if not found.
  */
-async function getById(
+async function getById(id: string): Promise<IDbCategory | null> {
-	id: string,
-): Promise<IDbCategory | null> {
 	try {
 		logger.info(`Getting category by id... (${id})`);
 		return await MysqlService.Category.getById(DbHandler, id);

src/services/credential.service.ts

@@ -9,10 +9,7 @@ export async function getHashFromPassword(password: string) {
 }
 
 //ToTest
-export async function comparePassword(
+export async function comparePassword(password: string, hash: string) {
-	password: string,
-	hash: string,
-) {
 	return await Argon2id.verify(hash, password, {
 		secret: Buffer.from(`${process.env["HASH_SECRET"]}`),
 		algorithm: 2,

src/services/jwt.service.ts

@@ -61,9 +61,7 @@ async function JwtSignService(
 		.setIssuer(`${process.env["JWT_SECRET"]} - Mathis HERRIOT`)
 		.setAudience(audience)
 		.setExpirationTime(expTime)
-		.sign(
+		.sign(new TextEncoder().encode(`${process.env["JWT_SECRET"]}`));
-			new TextEncoder().encode(`${process.env["JWT_SECRET"]}`),
-		);
 }
 
 const JwtService = {

src/services/model.service.ts

@@ -72,18 +72,13 @@ async function updateModel(data: IDbModel): Promise<boolean> {
  * @param {string} modelSlug - The slug of the model to be deleted.
  * @return {Promise<boolean>} - A promise that resolves to true if the deletion is successful, else false.
  */
-async function deleteModel(
+async function deleteModel(modelSlug: string): Promise<boolean> {
-	modelSlug: string,
-): Promise<boolean> {
 	if (!modelSlug) {
 		logger.error("Model slug is missing");
 		return false;
 	}
 	logger.info(`Deleting model with ID: ${modelSlug}`);
-	const doesExist = await MysqlService.Model.getBySlug(
+	const doesExist = await MysqlService.Model.getBySlug(DbHandler, modelSlug);
-		DbHandler,
-		modelSlug,
-	);
 	if (!doesExist || !doesExist.id) {
 		logger.warn(`Model with slug ${modelSlug} not found`);
 		return false;
@@ -104,15 +99,10 @@ async function deleteModel(
  * @param {string} modelSlug - The slug of the model to be fetched.
  * @return {Promise<IDbModel | null>} - A promise that resolves to the model if found, else null.
  */
-async function getBySlugModel(
+async function getBySlugModel(modelSlug: string): Promise<IDbModel | null> {
-	modelSlug: string,
-): Promise<IDbModel | null> {
 	logger.info(`Fetching model with slug: ${modelSlug}`);
 	try {
-		const model = await MysqlService.Model.getBySlug(
+		const model = await MysqlService.Model.getBySlug(DbHandler, modelSlug);
-			DbHandler,
-			modelSlug,
-		);
 		if (!model) {
 			logger.warn(`Model with slug ${modelSlug} not found`);
 			return null;

src/validators/AdminGuard.ts

@@ -13,14 +13,9 @@ const UNAUTHORIZED = 401;
 const FORBIDDEN = 403;
 const UNAUTH_MESSAGE = "Missing Authorization Header";
 const INVALID_TOKEN_MESSAGE = "Invalid or expired token.";
-const PERMISSON_NOT_VALID =
+const PERMISSON_NOT_VALID = "You are missing the required permission.";
-	"You are missing the required permission.";
 
-async function AdminGuard(
+async function AdminGuard(req: Request, res: Response, next: NextFunction) {
-	req: Request,
-	res: Response,
-	next: NextFunction,
-) {
 	const authHeader = req.headers.authorization;
 	if (!authHeader) {
 		logger.warn(`Invalid header (${req.ip})`);
@@ -40,8 +35,7 @@ async function AdminGuard(
 
 	if (token) {
 		// @ts-ignore
-		const isSourceAdmin =
+		const isSourceAdmin = await MysqlService.User.getAdminStateForId(
-			await MysqlService.User.getAdminStateForId(
 			DbHandler,
 			token.sub,
 		);

src/validators/UserGuard.ts

@@ -14,11 +14,7 @@ const UNAUTH_MESSAGE = "Missing Authorization Header";
 const INVALID_TOKEN_MESSAGE = "Invalid or expired token.";
 const USER_NOT_EXIST = "You dont exist anymore";
 
-async function UserGuard(
+async function UserGuard(req: Request, res: Response, next: NextFunction) {
-	req: Request,
-	res: Response,
-	next: NextFunction,
-) {
 	const authHeader = req.headers.authorization;
 	if (!authHeader) {
 		return res.status(UNAUTHORIZED).json({
@@ -44,10 +40,7 @@ async function UserGuard(
 				message: USER_NOT_EXIST,
 			});
 		}
-		const user = await MySqlService.User.getById(
+		const user = await MySqlService.User.getById(DbHandler, userId);
-			DbHandler,
-			userId,
-		);
 		if (user) {
 			logger.info(`An user do a request. (${user?.username})`);
 			next();