Format files and fix http response

server/routers/org/createOrg.ts

@@ -6,59 +6,59 @@ 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 createOrgSchema = z.object({
-  name: z.string().min(1).max(255),
-  domain: z.string().min(1).max(255),
+    name: z.string().min(1).max(255),
+    domain: z.string().min(1).max(255),
 });
 
 const MAX_ORGS = 5;
 
 export async function createOrg(req: Request, res: Response, next: NextFunction): Promise<any> {
-  try {
-    const parsedBody = createOrgSchema.safeParse(req.body);
-    if (!parsedBody.success) {
-      return next(
-        createHttpError(
-          HttpCode.BAD_REQUEST,
-          parsedBody.error.errors.map(e => e.message).join(', ')
-        )
-      );
+    try {
+        const parsedBody = createOrgSchema.safeParse(req.body);
+        if (!parsedBody.success) {
+            return next(
+                createHttpError(
+                    HttpCode.BAD_REQUEST,
+                    parsedBody.error.errors.map(e => e.message).join(', ')
+                )
+            );
+        }
+
+        const userOrgIds = req.userOrgIds;
+        if (userOrgIds && userOrgIds.length > MAX_ORGS) {
+            return next(
+                createHttpError(
+                    HttpCode.FORBIDDEN,
+                    `Maximum number of organizations reached.`
+                )
+            );
+        }
+
+        // Check if the user has permission to list sites
+        const hasPermission = await checkUserActionPermission(ActionsEnum.createOrg, req);
+        if (!hasPermission) {
+            return next(createHttpError(HttpCode.FORBIDDEN, 'User does not have permission to list sites'));
+        }
+
+        const { name, domain } = parsedBody.data;
+
+        const newOrg = await db.insert(orgs).values({
+            name,
+            domain,
+        }).returning();
+
+        return response(res, {
+            data: newOrg[0],
+            success: true,
+            error: false,
+            message: "Organization created successfully",
+            status: HttpCode.CREATED,
+        });
+    } catch (error) {
+        logger.error(error);
+        return next(createHttpError(HttpCode.INTERNAL_SERVER_ERROR, "An error occurred..."));
     }
-
-    const userOrgIds = req.userOrgIds;
-    if (userOrgIds && userOrgIds.length > MAX_ORGS) {
-      return next(
-        createHttpError(
-          HttpCode.FORBIDDEN,
-          `Maximum number of organizations reached.`
-        )
-      );
-    }
-
-    // Check if the user has permission to list sites
-    const hasPermission = await checkUserActionPermission(ActionsEnum.createOrg, req);
-    if (!hasPermission) {
-      return next(createHttpError(HttpCode.FORBIDDEN, 'User does not have permission to list sites'));
-    }
-
-    const { name, domain } = parsedBody.data;
-
-    const newOrg = await db.insert(orgs).values({
-      name,
-      domain,
-    }).returning();
-
-    return res.status(HttpCode.CREATED).send(
-      response(res, {
-        data: newOrg[0],
-        success: true,
-        error: false,
-        message: "Organization created successfully",
-        status: HttpCode.CREATED,
-      })
-    );
-  } catch (error) {
-    next(error);
-  }
 }

server/routers/org/deleteOrg.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 deleteOrgSchema = z.object({
-  orgId: z.string().transform(Number).pipe(z.number().int().positive())
+    orgId: z.string().transform(Number).pipe(z.number().int().positive())
 });
 
 export async function deleteOrg(req: Request, res: Response, next: NextFunction): Promise<any> {
-  try {
-    const parsedParams = deleteOrgSchema.safeParse(req.params);
-    if (!parsedParams.success) {
-      return next(
-        createHttpError(
-          HttpCode.BAD_REQUEST,
-          parsedParams.error.errors.map(e => e.message).join(', ')
-        )
-      );
+    try {
+        const parsedParams = deleteOrgSchema.safeParse(req.params);
+        if (!parsedParams.success) {
+            return next(
+                createHttpError(
+                    HttpCode.BAD_REQUEST,
+                    parsedParams.error.errors.map(e => e.message).join(', ')
+                )
+            );
+        }
+
+        const { orgId } = parsedParams.data;
+
+        // Check if the user has permission to list sites
+        const hasPermission = await checkUserActionPermission(ActionsEnum.deleteOrg, req);
+        if (!hasPermission) {
+            return next(createHttpError(HttpCode.FORBIDDEN, 'User does not have permission to list sites'));
+        }
+
+        const deletedOrg = await db.delete(orgs)
+            .where(eq(orgs.orgId, orgId))
+            .returning();
+
+        if (deletedOrg.length === 0) {
+            return next(
+                createHttpError(
+                    HttpCode.NOT_FOUND,
+                    `Organization with ID ${orgId} not found`
+                )
+            );
+        }
+
+        return response(res, {
+            data: null,
+            success: true,
+            error: false,
+            message: "Organization deleted successfully",
+            status: HttpCode.OK,
+        });
+    } catch (error) {
+        logger.error(error);
+        return next(createHttpError(HttpCode.INTERNAL_SERVER_ERROR, "An error occurred..."));
     }
-
-    const { orgId } = parsedParams.data;
-
-    // Check if the user has permission to list sites
-    const hasPermission = await checkUserActionPermission(ActionsEnum.deleteOrg, req);
-    if (!hasPermission) {
-      return next(createHttpError(HttpCode.FORBIDDEN, 'User does not have permission to list sites'));
-    }
-
-    const deletedOrg = await db.delete(orgs)
-      .where(eq(orgs.orgId, orgId))
-      .returning();
-
-    if (deletedOrg.length === 0) {
-      return next(
-        createHttpError(
-          HttpCode.NOT_FOUND,
-          `Organization with ID ${orgId} not found`
-        )
-      );
-    }
-
-    return res.status(HttpCode.OK).send(
-      response(res, {
-        data: null,
-        success: true,
-        error: false,
-        message: "Organization deleted successfully",
-        status: HttpCode.OK,
-      })
-    );
-  } catch (error) {
-    next(error);
-  }
 }

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

server/routers/org/listOrgs.ts

@@ -7,88 +7,88 @@ import HttpCode from '@server/types/HttpCode';
 import createHttpError from 'http-errors';
 import { sql, inArray } from 'drizzle-orm';
 import { ActionsEnum, checkUserActionPermission } from '@server/auth/actions';
+import logger from '@server/logger';
 
 const listOrgsSchema = 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 listOrgs(req: Request, res: Response, next: NextFunction): Promise<any> {
-  try {
-    const parsedQuery = listOrgsSchema.safeParse(req.query);
-    if (!parsedQuery.success) {
-      return next(
-        createHttpError(
-          HttpCode.BAD_REQUEST,
-          parsedQuery.error.errors.map(e => e.message).join(', ')
-        )
-      );
-    }
+    try {
+        const parsedQuery = listOrgsSchema.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 { limit, offset } = parsedQuery.data;
 
-    // Check if the user has permission to list sites
-    const hasPermission = await checkUserActionPermission(ActionsEnum.listOrgs, req);
-    if (!hasPermission) {
-      return next(createHttpError(HttpCode.FORBIDDEN, 'User does not have permission to list sites'));
-    }
+        // Check if the user has permission to list sites
+        const hasPermission = await checkUserActionPermission(ActionsEnum.listOrgs, req);
+        if (!hasPermission) {
+            return next(createHttpError(HttpCode.FORBIDDEN, 'User does not have permission to list sites'));
+        }
 
-    // Use the userOrgs passed from the middleware
-    const userOrgIds = req.userOrgIds;
+        // Use the userOrgs passed from the middleware
+        const userOrgIds = req.userOrgIds;
 
-    if (!userOrgIds || userOrgIds.length === 0) {
-      return res.status(HttpCode.OK).send(
-        response(res, {
-          data: {
-            organizations: [],
-            pagination: {
-              total: 0,
-              limit,
-              offset,
+        if (!userOrgIds || userOrgIds.length === 0) {
+            return res.status(HttpCode.OK).send(
+                response(res, {
+                    data: {
+                        organizations: [],
+                        pagination: {
+                            total: 0,
+                            limit,
+                            offset,
+                        },
+                    },
+                    success: true,
+                    error: false,
+                    message: "No organizations found for the user",
+                    status: HttpCode.OK,
+                })
+            );
+        }
+
+        const organizations = await db.select()
+            .from(orgs)
+            .where(inArray(orgs.orgId, userOrgIds))
+            .limit(limit)
+            .offset(offset);
+
+        const totalCountResult = await db.select({ count: sql<number>`cast(count(*) as integer)` })
+            .from(orgs)
+            .where(inArray(orgs.orgId, userOrgIds));
+        const totalCount = totalCountResult[0].count;
+
+        // // Add the user's role for each organization
+        // const organizationsWithRoles = organizations.map(org => ({
+        //   ...org,
+        //   userRole: req.userOrgRoleIds[org.orgId],
+        // }));
+
+        return response(res, {
+            data: {
+                organizations,
+                pagination: {
+                    total: totalCount,
+                    limit,
+                    offset,
+                },
             },
-          },
-          success: true,
-          error: false,
-          message: "No organizations found for the user",
-          status: HttpCode.OK,
-        })
-      );
+            success: true,
+            error: false,
+            message: "Organizations retrieved successfully",
+            status: HttpCode.OK,
+        });
+    } catch (error) {
+        logger.error(error);
+        return next(createHttpError(HttpCode.INTERNAL_SERVER_ERROR, "An error occurred..."));
     }
-
-    const organizations = await db.select()
-      .from(orgs)
-      .where(inArray(orgs.orgId, userOrgIds))
-      .limit(limit)
-      .offset(offset);
-
-    const totalCountResult = await db.select({ count: sql<number>`cast(count(*) as integer)` })
-      .from(orgs)
-      .where(inArray(orgs.orgId, userOrgIds));
-    const totalCount = totalCountResult[0].count;
-
-    // // Add the user's role for each organization
-    // const organizationsWithRoles = organizations.map(org => ({
-    //   ...org,
-    //   userRole: req.userOrgRoleIds[org.orgId],
-    // }));
-
-    return res.status(HttpCode.OK).send(
-      response(res, {
-        data: {
-          organizations,
-          pagination: {
-            total: totalCount,
-            limit,
-            offset,
-          },
-        },
-        success: true,
-        error: false,
-        message: "Organizations retrieved successfully",
-        status: HttpCode.OK,
-      })
-    );
-  } catch (error) {
-    next(error);
-  }
 }

server/routers/org/updateOrg.ts

@@ -7,74 +7,74 @@ 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 updateOrgParamsSchema = z.object({
-  orgId: z.string().transform(Number).pipe(z.number().int().positive())
+    orgId: z.string().transform(Number).pipe(z.number().int().positive())
 });
 
 const updateOrgBodySchema = z.object({
-  name: z.string().min(1).max(255).optional(),
-  domain: z.string().min(1).max(255).optional(),
+    name: z.string().min(1).max(255).optional(),
+    domain: z.string().min(1).max(255).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 updateOrg(req: Request, res: Response, next: NextFunction): Promise<any> {
-  try {
-    const parsedParams = updateOrgParamsSchema.safeParse(req.params);
-    if (!parsedParams.success) {
-      return next(
-        createHttpError(
-          HttpCode.BAD_REQUEST,
-          parsedParams.error.errors.map(e => e.message).join(', ')
-        )
-      );
+    try {
+        const parsedParams = updateOrgParamsSchema.safeParse(req.params);
+        if (!parsedParams.success) {
+            return next(
+                createHttpError(
+                    HttpCode.BAD_REQUEST,
+                    parsedParams.error.errors.map(e => e.message).join(', ')
+                )
+            );
+        }
+
+        const parsedBody = updateOrgBodySchema.safeParse(req.body);
+        if (!parsedBody.success) {
+            return next(
+                createHttpError(
+                    HttpCode.BAD_REQUEST,
+                    parsedBody.error.errors.map(e => e.message).join(', ')
+                )
+            );
+        }
+
+        const { orgId } = parsedParams.data;
+        const updateData = parsedBody.data;
+
+
+        // Check if the user has permission to list sites
+        const hasPermission = await checkUserActionPermission(ActionsEnum.updateOrg, req);
+        if (!hasPermission) {
+            return next(createHttpError(HttpCode.FORBIDDEN, 'User does not have permission to list sites'));
+        }
+
+        const updatedOrg = await db.update(orgs)
+            .set(updateData)
+            .where(eq(orgs.orgId, orgId))
+            .returning();
+
+        if (updatedOrg.length === 0) {
+            return next(
+                createHttpError(
+                    HttpCode.NOT_FOUND,
+                    `Organization with ID ${orgId} not found`
+                )
+            );
+        }
+
+        return response(res, {
+            data: updatedOrg[0],
+            success: true,
+            error: false,
+            message: "Organization updated successfully",
+            status: HttpCode.OK,
+        });
+    } catch (error) {
+        logger.error(error);
+        return next(createHttpError(HttpCode.INTERNAL_SERVER_ERROR, "An error occurred..."));
     }
-
-    const parsedBody = updateOrgBodySchema.safeParse(req.body);
-    if (!parsedBody.success) {
-      return next(
-        createHttpError(
-          HttpCode.BAD_REQUEST,
-          parsedBody.error.errors.map(e => e.message).join(', ')
-        )
-      );
-    }
-
-    const { orgId } = parsedParams.data;
-    const updateData = parsedBody.data;
-
-
-    // Check if the user has permission to list sites
-    const hasPermission = await checkUserActionPermission(ActionsEnum.updateOrg, req);
-    if (!hasPermission) {
-      return next(createHttpError(HttpCode.FORBIDDEN, 'User does not have permission to list sites'));
-    }
-
-    const updatedOrg = await db.update(orgs)
-      .set(updateData)
-      .where(eq(orgs.orgId, orgId))
-      .returning();
-
-    if (updatedOrg.length === 0) {
-      return next(
-        createHttpError(
-          HttpCode.NOT_FOUND,
-          `Organization with ID ${orgId} not found`
-        )
-      );
-    }
-
-    return res.status(HttpCode.OK).send(
-      response(res, {
-        data: updatedOrg[0],
-        success: true,
-        error: false,
-        message: "Organization updated successfully",
-        status: HttpCode.OK,
-      })
-    );
-  } catch (error) {
-    next(error);
-  }
 }