Format files and fix http response

server/routers/target/createTarget.ts

@@ -6,66 +6,66 @@ import response from "@server/utils/response";
 import HttpCode from '@server/types/HttpCode';
 import createHttpError from 'http-errors';
 import { ActionsEnum, checkUserActionPermission } from '@server/auth/actions';
+import logger from '@server/logger';
 
 const createTargetParamsSchema = z.object({
-  resourceId: z.string().uuid(),
+    resourceId: z.string().uuid(),
 });
 
 const createTargetSchema = z.object({
-  ip: z.string().ip(),
-  method: z.string().min(1).max(10),
-  port: z.number().int().min(1).max(65535),
-  protocol: z.string().optional(),
-  enabled: z.boolean().default(true),
+    ip: z.string().ip(),
+    method: z.string().min(1).max(10),
+    port: z.number().int().min(1).max(65535),
+    protocol: z.string().optional(),
+    enabled: z.boolean().default(true),
 });
 
 export async function createTarget(req: Request, res: Response, next: NextFunction): Promise<any> {
-  try {
-    const parsedBody = createTargetSchema.safeParse(req.body);
-    if (!parsedBody.success) {
-      return next(
-        createHttpError(
-          HttpCode.BAD_REQUEST,
-          parsedBody.error.errors.map(e => e.message).join(', ')
-        )
-      );
+    try {
+        const parsedBody = createTargetSchema.safeParse(req.body);
+        if (!parsedBody.success) {
+            return next(
+                createHttpError(
+                    HttpCode.BAD_REQUEST,
+                    parsedBody.error.errors.map(e => e.message).join(', ')
+                )
+            );
+        }
+
+        const targetData = parsedBody.data;
+
+        const parsedParams = createTargetParamsSchema.safeParse(req.params);
+        if (!parsedParams.success) {
+            return next(
+                createHttpError(
+                    HttpCode.BAD_REQUEST,
+                    parsedParams.error.errors.map(e => e.message).join(', ')
+                )
+            );
+        }
+
+        const { resourceId } = parsedParams.data;
+
+        // Check if the user has permission to list sites
+        const hasPermission = await checkUserActionPermission(ActionsEnum.createTarget, req);
+        if (!hasPermission) {
+            return next(createHttpError(HttpCode.FORBIDDEN, 'User does not have permission to list sites'));
+        }
+
+        const newTarget = await db.insert(targets).values({
+            resourceId,
+            ...targetData
+        }).returning();
+
+        return response(res, {
+            data: newTarget[0],
+            success: true,
+            error: false,
+            message: "Target created successfully",
+            status: HttpCode.CREATED,
+        });
+    } catch (error) {
+        logger.error(error);
+        return next(createHttpError(HttpCode.INTERNAL_SERVER_ERROR, "An error occurred..."));
     }
-
-    const targetData = parsedBody.data;
-
-    const parsedParams = createTargetParamsSchema.safeParse(req.params);
-    if (!parsedParams.success) {
-      return next(
-        createHttpError(
-          HttpCode.BAD_REQUEST,
-          parsedParams.error.errors.map(e => e.message).join(', ')
-        )
-      );
-    }
-
-    const { resourceId } = parsedParams.data;
-
-    // Check if the user has permission to list sites
-    const hasPermission = await checkUserActionPermission(ActionsEnum.createTarget, req);
-    if (!hasPermission) {
-      return next(createHttpError(HttpCode.FORBIDDEN, 'User does not have permission to list sites'));
-    }
-
-    const newTarget = await db.insert(targets).values({
-      resourceId,
-      ...targetData
-    }).returning();
-
-    return res.status(HttpCode.CREATED).send(
-      response(res, {
-        data: newTarget[0],
-        success: true,
-        error: false,
-        message: "Target created successfully",
-        status: HttpCode.CREATED,
-      })
-    );
-  } catch (error) {
-    next(error);
-  }
 }

server/routers/target/deleteTarget.ts

@@ -7,54 +7,54 @@ import response from "@server/utils/response";
 import HttpCode from '@server/types/HttpCode';
 import createHttpError from 'http-errors';
 import { ActionsEnum, checkUserActionPermission } from '@server/auth/actions';
+import logger from '@server/logger';
 
 const deleteTargetSchema = z.object({
-  targetId: z.string().transform(Number).pipe(z.number().int().positive())
+    targetId: z.string().transform(Number).pipe(z.number().int().positive())
 });
 
 export async function deleteTarget(req: Request, res: Response, next: NextFunction): Promise<any> {
-  try {
-    const parsedParams = deleteTargetSchema.safeParse(req.params);
-    if (!parsedParams.success) {
-      return next(
-        createHttpError(
-          HttpCode.BAD_REQUEST,
-          parsedParams.error.errors.map(e => e.message).join(', ')
-        )
-      );
+    try {
+        const parsedParams = deleteTargetSchema.safeParse(req.params);
+        if (!parsedParams.success) {
+            return next(
+                createHttpError(
+                    HttpCode.BAD_REQUEST,
+                    parsedParams.error.errors.map(e => e.message).join(', ')
+                )
+            );
+        }
+
+        const { targetId } = parsedParams.data;
+
+        // Check if the user has permission to list sites
+        const hasPermission = await checkUserActionPermission(ActionsEnum.deleteTarget, req);
+        if (!hasPermission) {
+            return next(createHttpError(HttpCode.FORBIDDEN, 'User does not have permission to list sites'));
+        }
+
+        const deletedTarget = await db.delete(targets)
+            .where(eq(targets.targetId, targetId))
+            .returning();
+
+        if (deletedTarget.length === 0) {
+            return next(
+                createHttpError(
+                    HttpCode.NOT_FOUND,
+                    `Target with ID ${targetId} not found`
+                )
+            );
+        }
+
+        return response(res, {
+            data: null,
+            success: true,
+            error: false,
+            message: "Target deleted successfully",
+            status: HttpCode.OK,
+        });
+    } catch (error) {
+        logger.error(error);
+        return next(createHttpError(HttpCode.INTERNAL_SERVER_ERROR, "An error occurred..."));
     }
-
-    const { targetId } = parsedParams.data;
-
-    // Check if the user has permission to list sites
-    const hasPermission = await checkUserActionPermission(ActionsEnum.deleteTarget, req);
-    if (!hasPermission) {
-      return next(createHttpError(HttpCode.FORBIDDEN, 'User does not have permission to list sites'));
-    }
-
-    const deletedTarget = await db.delete(targets)
-      .where(eq(targets.targetId, targetId))
-      .returning();
-
-    if (deletedTarget.length === 0) {
-      return next(
-        createHttpError(
-          HttpCode.NOT_FOUND,
-          `Target with ID ${targetId} not found`
-        )
-      );
-    }
-
-    return res.status(HttpCode.OK).send(
-      response(res, {
-        data: null,
-        success: true,
-        error: false,
-        message: "Target deleted successfully",
-        status: HttpCode.OK,
-      })
-    );
-  } catch (error) {
-    next(error);
-  }
 }

server/routers/target/getTarget.ts

@@ -7,55 +7,55 @@ import response from "@server/utils/response";
 import HttpCode from '@server/types/HttpCode';
 import createHttpError from 'http-errors';
 import { ActionsEnum, checkUserActionPermission } from '@server/auth/actions';
+import logger from '@server/logger';
 
 const getTargetSchema = z.object({
-  targetId: z.string().transform(Number).pipe(z.number().int().positive())
+    targetId: z.string().transform(Number).pipe(z.number().int().positive())
 });
 
 export async function getTarget(req: Request, res: Response, next: NextFunction): Promise<any> {
-  try {
-    const parsedParams = getTargetSchema.safeParse(req.params);
-    if (!parsedParams.success) {
-      return next(
-        createHttpError(
-          HttpCode.BAD_REQUEST,
-          parsedParams.error.errors.map(e => e.message).join(', ')
-        )
-      );
+    try {
+        const parsedParams = getTargetSchema.safeParse(req.params);
+        if (!parsedParams.success) {
+            return next(
+                createHttpError(
+                    HttpCode.BAD_REQUEST,
+                    parsedParams.error.errors.map(e => e.message).join(', ')
+                )
+            );
+        }
+
+        const { targetId } = parsedParams.data;
+
+        // Check if the user has permission to list sites
+        const hasPermission = await checkUserActionPermission(ActionsEnum.getTarget, req);
+        if (!hasPermission) {
+            return next(createHttpError(HttpCode.FORBIDDEN, 'User does not have permission to list sites'));
+        }
+
+        const target = await db.select()
+            .from(targets)
+            .where(eq(targets.targetId, targetId))
+            .limit(1);
+
+        if (target.length === 0) {
+            return next(
+                createHttpError(
+                    HttpCode.NOT_FOUND,
+                    `Target with ID ${targetId} not found`
+                )
+            );
+        }
+
+        return response(res, {
+            data: target[0],
+            success: true,
+            error: false,
+            message: "Target retrieved successfully",
+            status: HttpCode.OK,
+        });
+    } catch (error) {
+        logger.error(error);
+        return next(createHttpError(HttpCode.INTERNAL_SERVER_ERROR, "An error occurred..."));
     }
-
-    const { targetId } = parsedParams.data;
-
-    // Check if the user has permission to list sites
-    const hasPermission = await checkUserActionPermission(ActionsEnum.getTarget, req);
-    if (!hasPermission) {
-      return next(createHttpError(HttpCode.FORBIDDEN, 'User does not have permission to list sites'));
-    }
-
-    const target = await db.select()
-      .from(targets)
-      .where(eq(targets.targetId, targetId))
-      .limit(1);
-
-    if (target.length === 0) {
-      return next(
-        createHttpError(
-          HttpCode.NOT_FOUND,
-          `Target with ID ${targetId} not found`
-        )
-      );
-    }
-
-    return res.status(HttpCode.OK).send(
-      response(res, {
-        data: target[0],
-        success: true,
-        error: false,
-        message: "Target retrieved successfully",
-        status: HttpCode.OK,
-      })
-    );
-  } catch (error) {
-    next(error);
-  }
 }

server/routers/target/listTargets.ts

@@ -7,89 +7,89 @@ import HttpCode from '@server/types/HttpCode';
 import createHttpError from 'http-errors';
 import { sql, eq } from 'drizzle-orm';
 import { ActionsEnum, checkUserActionPermission } from '@server/auth/actions';
+import logger from '@server/logger';
 
 const listTargetsParamsSchema = z.object({
     resourceId: z.string().optional()
 });
 
 const listTargetsSchema = z.object({
-  limit: z.string().optional().transform(Number).pipe(z.number().int().positive().default(10)),
-  offset: z.string().optional().transform(Number).pipe(z.number().int().nonnegative().default(0)),
+    limit: z.string().optional().transform(Number).pipe(z.number().int().positive().default(10)),
+    offset: z.string().optional().transform(Number).pipe(z.number().int().nonnegative().default(0)),
 });
 
 export async function listTargets(req: Request, res: Response, next: NextFunction): Promise<any> {
-  try {
-    const parsedQuery = listTargetsSchema.safeParse(req.query);
-    if (!parsedQuery.success) {
-      return next(
-        createHttpError(
-          HttpCode.BAD_REQUEST,
-          parsedQuery.error.errors.map(e => e.message).join(', ')
-        )
-      );
+    try {
+        const parsedQuery = listTargetsSchema.safeParse(req.query);
+        if (!parsedQuery.success) {
+            return next(
+                createHttpError(
+                    HttpCode.BAD_REQUEST,
+                    parsedQuery.error.errors.map(e => e.message).join(', ')
+                )
+            );
+        }
+
+        const { limit, offset } = parsedQuery.data;
+
+        const parsedParams = listTargetsParamsSchema.safeParse(req.params);
+        if (!parsedParams.success) {
+            return next(
+                createHttpError(
+                    HttpCode.BAD_REQUEST,
+                    parsedParams.error.errors.map(e => e.message).join(', ')
+                )
+            );
+        }
+
+        const { resourceId } = parsedParams.data;
+
+        // Check if the user has permission to list sites
+        const hasPermission = await checkUserActionPermission(ActionsEnum.listTargets, req);
+        if (!hasPermission) {
+            return next(createHttpError(HttpCode.FORBIDDEN, 'User does not have permission to list sites'));
+        }
+
+        let baseQuery: any = db
+            .select({
+                targetId: targets.targetId,
+                ip: targets.ip,
+                method: targets.method,
+                port: targets.port,
+                protocol: targets.protocol,
+                enabled: targets.enabled,
+                resourceName: resources.name,
+            })
+            .from(targets)
+            .leftJoin(resources, eq(targets.resourceId, resources.resourceId));
+
+        let countQuery: any = db.select({ count: sql<number>`cast(count(*) as integer)` }).from(targets);
+
+        if (resourceId) {
+            baseQuery = baseQuery.where(eq(targets.resourceId, resourceId));
+            countQuery = countQuery.where(eq(targets.resourceId, resourceId));
+        }
+
+        const targetsList = await baseQuery.limit(limit).offset(offset);
+        const totalCountResult = await countQuery;
+        const totalCount = totalCountResult[0].count;
+
+        return response(res, {
+            data: {
+                targets: targetsList,
+                pagination: {
+                    total: totalCount,
+                    limit,
+                    offset,
+                },
+            },
+            success: true,
+            error: false,
+            message: "Targets retrieved successfully",
+            status: HttpCode.OK,
+        });
+    } catch (error) {
+        logger.error(error);
+        return next(createHttpError(HttpCode.INTERNAL_SERVER_ERROR, "An error occurred..."));
     }
-
-    const { limit, offset } = parsedQuery.data;
-
-    const parsedParams = listTargetsParamsSchema.safeParse(req.params);
-    if (!parsedParams.success) {
-      return next(
-        createHttpError(
-          HttpCode.BAD_REQUEST,
-          parsedParams.error.errors.map(e => e.message).join(', ')
-        )
-      );
-    }
-
-    const { resourceId } = parsedParams.data;
-    
-    // Check if the user has permission to list sites
-    const hasPermission = await checkUserActionPermission(ActionsEnum.listTargets, req);
-    if (!hasPermission) {
-      return next(createHttpError(HttpCode.FORBIDDEN, 'User does not have permission to list sites'));
-    }
-
-    let baseQuery: any = db
-      .select({
-        targetId: targets.targetId,
-        ip: targets.ip,
-        method: targets.method,
-        port: targets.port,
-        protocol: targets.protocol,
-        enabled: targets.enabled,
-        resourceName: resources.name,
-      })
-      .from(targets)
-      .leftJoin(resources, eq(targets.resourceId, resources.resourceId));
-
-    let countQuery: any = db.select({ count: sql<number>`cast(count(*) as integer)` }).from(targets);
-
-    if (resourceId) {
-      baseQuery = baseQuery.where(eq(targets.resourceId, resourceId));
-      countQuery = countQuery.where(eq(targets.resourceId, resourceId));
-    }
-
-    const targetsList = await baseQuery.limit(limit).offset(offset);
-    const totalCountResult = await countQuery;
-    const totalCount = totalCountResult[0].count;
-
-    return response(res, {
-        data: {
-          targets: targetsList,
-          pagination: {
-            total: totalCount,
-            limit,
-            offset,
-          },
-        },
-        success: true,
-        error: false,
-        message: "Targets retrieved successfully",
-        status: HttpCode.OK,
-      })
-  } catch (error) {
-    console.log(error);
-    
-    return next(createHttpError(HttpCode.INTERNAL_SERVER_ERROR, "sadfdf"));
-  }
 }

server/routers/target/updateTarget.ts

@@ -7,76 +7,76 @@ import response from "@server/utils/response";
 import HttpCode from '@server/types/HttpCode';
 import createHttpError from 'http-errors';
 import { ActionsEnum, checkUserActionPermission } from '@server/auth/actions';
+import logger from '@server/logger';
 
 const updateTargetParamsSchema = z.object({
-  targetId: z.string().transform(Number).pipe(z.number().int().positive())
+    targetId: z.string().transform(Number).pipe(z.number().int().positive())
 });
 
 const updateTargetBodySchema = z.object({
-  ip: z.string().ip().optional(),
-  method: z.string().min(1).max(10).optional(),
-  port: z.number().int().min(1).max(65535).optional(),
-  protocol: z.string().optional(),
-  enabled: z.boolean().optional(),
+    ip: z.string().ip().optional(),
+    method: z.string().min(1).max(10).optional(),
+    port: z.number().int().min(1).max(65535).optional(),
+    protocol: z.string().optional(),
+    enabled: z.boolean().optional(),
 }).refine(data => Object.keys(data).length > 0, {
-  message: "At least one field must be provided for update"
+    message: "At least one field must be provided for update"
 });
 
 export async function updateTarget(req: Request, res: Response, next: NextFunction): Promise<any> {
-  try {
-    const parsedParams = updateTargetParamsSchema.safeParse(req.params);
-    if (!parsedParams.success) {
-      return next(
-        createHttpError(
-          HttpCode.BAD_REQUEST,
-          parsedParams.error.errors.map(e => e.message).join(', ')
-        )
-      );
+    try {
+        const parsedParams = updateTargetParamsSchema.safeParse(req.params);
+        if (!parsedParams.success) {
+            return next(
+                createHttpError(
+                    HttpCode.BAD_REQUEST,
+                    parsedParams.error.errors.map(e => e.message).join(', ')
+                )
+            );
+        }
+
+        const parsedBody = updateTargetBodySchema.safeParse(req.body);
+        if (!parsedBody.success) {
+            return next(
+                createHttpError(
+                    HttpCode.BAD_REQUEST,
+                    parsedBody.error.errors.map(e => e.message).join(', ')
+                )
+            );
+        }
+
+        const { targetId } = parsedParams.data;
+        const updateData = parsedBody.data;
+
+        // Check if the user has permission to list sites
+        const hasPermission = await checkUserActionPermission(ActionsEnum.updateTarget, req);
+        if (!hasPermission) {
+            return next(createHttpError(HttpCode.FORBIDDEN, 'User does not have permission to list sites'));
+        }
+
+        const updatedTarget = await db.update(targets)
+            .set(updateData)
+            .where(eq(targets.targetId, targetId))
+            .returning();
+
+        if (updatedTarget.length === 0) {
+            return next(
+                createHttpError(
+                    HttpCode.NOT_FOUND,
+                    `Target with ID ${targetId} not found`
+                )
+            );
+        }
+
+        return response(res, {
+            data: updatedTarget[0],
+            success: true,
+            error: false,
+            message: "Target updated successfully",
+            status: HttpCode.OK,
+        });
+    } catch (error) {
+        logger.error(error);
+        return next(createHttpError(HttpCode.INTERNAL_SERVER_ERROR, "An error occurred..."));
     }
-
-    const parsedBody = updateTargetBodySchema.safeParse(req.body);
-    if (!parsedBody.success) {
-      return next(
-        createHttpError(
-          HttpCode.BAD_REQUEST,
-          parsedBody.error.errors.map(e => e.message).join(', ')
-        )
-      );
-    }
-
-    const { targetId } = parsedParams.data;
-    const updateData = parsedBody.data;
-
-    // Check if the user has permission to list sites
-    const hasPermission = await checkUserActionPermission(ActionsEnum.updateTarget, req);
-    if (!hasPermission) {
-      return next(createHttpError(HttpCode.FORBIDDEN, 'User does not have permission to list sites'));
-    }
-
-    const updatedTarget = await db.update(targets)
-      .set(updateData)
-      .where(eq(targets.targetId, targetId))
-      .returning();
-
-    if (updatedTarget.length === 0) {
-      return next(
-        createHttpError(
-          HttpCode.NOT_FOUND,
-          `Target with ID ${targetId} not found`
-        )
-      );
-    }
-
-    return res.status(HttpCode.OK).send(
-      response(res, {
-        data: updatedTarget[0],
-        success: true,
-        error: false,
-        message: "Target updated successfully",
-        status: HttpCode.OK,
-      })
-    );
-  } catch (error) {
-    next(error);
-  }
 }