WorkSimplon/brief-05-back
2
0
Fork 0
Code Issues Pull Requests Packages Projects 1 Releases Wiki Activity

feat(all): refactor code for readability and simplicity

Browse Source 
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>
This commit is contained in:
Mathis H (Avnyr) 2024-04-30 11:03:28 +02:00
parent 28671146d1
commit a6593cb76f
Signed by: Mathis
GPG Key ID: DD9E0666A747D126
14 changed files with 94 additions and 286 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
biome.json
View File

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

63
src/controllers/auth.controller.ts
View File

@ -22,10 +22,7 @@ const logger = new Logger({
* - error: "exist" if the user already exists
* - Otherwise, the registered user data
*/
async function registerUser(
req: Request,
res: Response,
): Promise<unknown> {
async function registerUser(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 =
await UserService.register(sanitizeData);
const RegisterServiceResult = 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
.type("application/json")
.status(201)
.json(RegisterServiceResult);
return res.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(
req: Request,
res: Response,
): Promise<void> {
async function loginUser(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
.type("application/json")
.status(200)
.json(LoginServiceResult);
res.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
.type("application/json")
.status(200)
.json(AllUserResponse);
return res.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)
modifiedData.firstName = `${body.firstName}`;
if (body.firstName) modifiedData.firstName = `${body.firstName}`;
//@ts-ignore
if (body.lastName)
modifiedData.lastName = `${body.lastName}`;
if (body.lastName) modifiedData.lastName = `${body.lastName}`;
//@ts-ignore
if (body.displayName)
modifiedData.displayName = `${body.displayName}`;
if (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(
`Error occurred during user edit (${req.ip})`,
);
logger.error(`Error occurred during user edit (${req.ip})`);
return res.type("application/json").status(500).json({
error: "Internal server error",
});
}
return res
.type("application/json")
.status(200)
.json(EditUserServiceResult);
return res.type("application/json").status(200).json(EditUserServiceResult);
}
//Not itself or
logger.warn(
`Unauthorized access attempt, not self or admin (${req.ip})`,
);
logger.warn(`Unauthorized access attempt, not self or admin (${req.ip})`);
return res.type("application/json").status(403).json({
error: "Unauthorized",
});
}
async function deleteUser(
req: Request,
res: Response,
): Promise<Response> {
async function deleteUser(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(
`${targetUserId}`,
);
const deleteUserServiceResult = await UserService.delete(`${targetUserId}`);
if (!deleteUserServiceResult) {
logger.error(
`Error occurred during user delete (${req.ip})`,
);
logger.error(`Error occurred during user delete (${req.ip})`);
return res.type("application/json").status(500).json({
error: "Internal server error",
});

33
src/controllers/brand.controller.ts
View File

@ -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(
req: Request,
res: Response,
): Promise<Response> {
async function createBrand(req: Request, res: Response): Promise<Response> {
const body: IDbBrand = req.body;
const doesExist = await BrandService.getBySlug(
`${body.slug_name}`,
);
const doesExist = await BrandService.getBySlug(`${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(
`Brand created successfully ! (${body.slug_name})`,
);
logger.info(`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(
req: Request,
res: Response,
): Promise<Response> {
async function updateBrand(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(
req: Request,
res: Response,
): Promise<Response> {
async function getBySlugBrand(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(
_req: Request,
res: Response,
): Promise<Response> {
async function getAllBrand(_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(
req: Request,
res: Response,
): Promise<Response> {
async function deleteBrand(req: Request, res: Response): Promise<Response> {
const brandSlug = req.params["brandSlug"];
if (!brandSlug) {
logger.error("Brand slug is missing");

52
src/controllers/category.controller.ts
View File

@ -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(
req: Request,
res: Response,
): Promise<Response> {
async function createCategory(req: Request, res: Response): Promise<Response> {
const body: IDbCategory = req.body;
const doesExist = await CategoryService.getBySlug(
`${body.slug_name}`,
);
const doesExist = await CategoryService.getBySlug(`${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(
`Category created successfully ! (${body.slug_name})`,
);
logger.info(`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(
req: Request,
res: Response,
): Promise<Response> {
async function updateCategory(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(
`${categoryId}`,
);
const doesExist = await CategoryService.getById(`${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(
req: Request,
res: Response,
): Promise<Response> {
async function deleteCategory(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(
`${categorySlug}`,
);
const doesExist = await CategoryService.getBySlug(`${categorySlug}`);
if (!doesExist || !doesExist.id) {
logger.error("Category not found");
return res.status(404).json({
error: "Category not found",
});
}
const deleteResult = await CategoryService.delete(
`${doesExist.id}`,
);
const deleteResult = await CategoryService.delete(`${doesExist.id}`);
if (!deleteResult) {
logger.error("Failed to delete category");
return res.status(500).json({
error: "Failed to delete category",
});
}
logger.info(
`Category deleted successfully! (${categorySlug})`,
);
logger.info(`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(
_req: Request,
res: Response,
): Promise<Response> {
async function getAllCategory(_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(
`${categorySlug}`,
);
const category = await CategoryService.getBySlug(`${categorySlug}`);
if (!category || !category.id) {
logger.error("Category not found");
return res.status(404).json({
error: "Category not found",
});
}
logger.info(
`Category retrieved successfully! (${categorySlug})`,
);
logger.info(`Category retrieved successfully! (${categorySlug})`);
return res.status(200).json({
id: category.id,
display_name: category.display_name,

40
src/controllers/model.controller.ts
View File

@ -9,14 +9,9 @@ const logger = new Logger({
name: "ModelController",
});
async function createModel(
req: Request,
res: Response,
): Promise<Response> {
async function createModel(req: Request, res: Response): Promise<Response> {
const body: IDbModel = req.body;
const doesExist = await CategoryService.getBySlug(
`${body.slug_name}`,
);
const doesExist = await CategoryService.getBySlug(`${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(
`Category created successfully ! (${body.slug_name})`,
);
logger.info(`Category created successfully ! (${body.slug_name})`);
return res.status(201).json({
message: "Category created successfully",
});
}
async function updateModel(
req: Request,
res: Response,
): Promise<Response> {
async function updateModel(req: Request, res: Response): Promise<Response> {
const body: IDbModel = req.body;
const doesExist = await ModelService.getBySlug(
`${body.slug_name}`,
);
const doesExist = await ModelService.getBySlug(`${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(
`Model updated successfully! (${body.slug_name})`,
);
logger.info(`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(
req: Request,
res: Response,
): Promise<Response> {
async function getModelBySlug(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(
req: Request,
res: Response,
): Promise<Response> {
async function deleteModel(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(
`Model deleted successfully! (SLUG: ${modelSlug})`,
);
logger.info(`Model deleted successfully! (SLUG: ${modelSlug})`);
return res.status(200).json({
message: "Model deleted successfully",
});

15
src/routes/auth/authRouter.ts
View File

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

19
src/routes/catalog/catalogRouter.ts
View File

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

73
src/services/brand.service.ts
View File

@ -27,19 +27,14 @@ async function createBrand(data: IDbBrand): Promise<unknown> {
};
}
const brandId = uuidv4();
const createdBrand = await MysqlService.Brand.insert(
DbHandler,
{
id: brandId,
slug_name: `${data.slug_name}`,
display_name: `${data.display_name}`,
image_blob: data.image_blob,
},
);
const createdBrand = await MysqlService.Brand.insert(DbHandler, {
id: brandId,
slug_name: `${data.slug_name}`,
display_name: `${data.display_name}`,
image_blob: data.image_blob,
});
if (createdBrand) {
logger.info(
`Brand created successfully (${data.slug_name})`,
);
logger.info(`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(
DbHandler,
{
id: data.id,
slug_name: `${data.slug_name}`,
display_name: `${data.display_name}`,
image_blob: data.image_blob,
},
);
const updatedBrand = await MysqlService.Brand.update(DbHandler, {
id: data.id,
slug_name: `${data.slug_name}`,
display_name: `${data.display_name}`,
image_blob: data.image_blob,
});
if (updatedBrand) {
logger.info(
`Brand updated successfully (${data.slug_name})`,
);
logger.info(`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(
`Retrieved all brands successfully (${brands.length})`,
);
logger.info(`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(
brandSlug: string,
): Promise<IDbBrand | false> {
async function getBySlugBrand(brandSlug: string): Promise<IDbBrand | false> {
if (!brandSlug) {
logger.error("Brand slug is missing");
return false;
}
const brand = await MysqlService.Brand.getBySlug(
DbHandler,
brandSlug,
);
const brand = await MysqlService.Brand.getBySlug(DbHandler, brandSlug);
if (!brand) {
logger.error(`Brand not found (${brandSlug})`);
return false;
}
logger.info(
`Retrieved brand by slug successfully (${brandSlug})`,
);
logger.info(`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(
brandId: string,
): Promise<IDbBrand | false> {
async function getByIdBrand(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(
DbHandler,
brandId,
);
const brand = await MysqlService.Brand.getById(DbHandler, brandId);
if (!brand) {
logger.error(`Brand not found (${brandId})`);
return false;
}
logger.info(
`Retrieved brand by ID successfully (${brandId})`,
);
logger.info(`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(
DbHandler,
brandId,
);
const deletedBrand = await MysqlService.Brand.delete(DbHandler, brandId);
if (!deletedBrand) {
logger.error(`Failed to delete brand (${brandId})`);
return false;

25
src/services/category.service.ts
View File

@ -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(
data: IDbCategory,
): Promise<boolean> {
logger.info(
`Creating a new category... (${data.display_name})`,
);
async function createCategory(data: IDbCategory): 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<
Array<IDbCategory>
> | null> {
async function getAll(): Promise<Promise<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(
slug: string,
): Promise<IDbCategory | null> {
async function getBySlug(slug: string): Promise<IDbCategory | null> {
try {
logger.info(`Getting category by slug... (${slug})`);
return await MysqlService.Category.getBySlug(
DbHandler,
slug,
);
return await MysqlService.Category.getBySlug(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(
id: string,
): Promise<IDbCategory | null> {
async function getById(id: string): Promise<IDbCategory | null> {
try {
logger.info(`Getting category by id... (${id})`);
return await MysqlService.Category.getById(DbHandler, id);

5
src/services/credential.service.ts
View File

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

4
src/services/jwt.service.ts
View File

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

18
src/services/model.service.ts
View File

@ -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(
modelSlug: string,
): Promise<boolean> {
async function deleteModel(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(
DbHandler,
modelSlug,
);
const doesExist = await MysqlService.Model.getBySlug(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(
modelSlug: string,
): Promise<IDbModel | null> {
async function getBySlugModel(modelSlug: string): Promise<IDbModel | null> {
logger.info(`Fetching model with slug: ${modelSlug}`);
try {
const model = await MysqlService.Model.getBySlug(
DbHandler,
modelSlug,
);
const model = await MysqlService.Model.getBySlug(DbHandler, modelSlug);
if (!model) {
logger.warn(`Model with slug ${modelSlug} not found`);
return null;

18
src/validators/AdminGuard.ts
View File

@ -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 =
"You are missing the required permission.";
const PERMISSON_NOT_VALID = "You are missing the required permission.";
async function AdminGuard(
req: Request,
res: Response,
next: NextFunction,
) {
async function AdminGuard(req: Request, res: Response, next: NextFunction) {
const authHeader = req.headers.authorization;
if (!authHeader) {
logger.warn(`Invalid header (${req.ip})`);
@ -40,11 +35,10 @@ async function AdminGuard(
if (token) {
// @ts-ignore
const isSourceAdmin =
await MysqlService.User.getAdminStateForId(
DbHandler,
token.sub,
);
const isSourceAdmin = await MysqlService.User.getAdminStateForId(
DbHandler,
token.sub,
);
if (isSourceAdmin === true) next();
return res.status(FORBIDDEN).json({
message: PERMISSON_NOT_VALID,

11
src/validators/UserGuard.ts
View File

@ -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(
req: Request,
res: Response,
next: NextFunction,
) {
async function UserGuard(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(
DbHandler,
userId,
);
const user = await MySqlService.User.getById(DbHandler, userId);
if (user) {
logger.info(`An user do a request. (${user?.username})`);
next();