Format files and fix http response

server/routers/auth/getUserOrgs.ts

@@ -6,28 +6,28 @@ import createHttpError from 'http-errors';
 import HttpCode from '@server/types/HttpCode';
 
 export async function getUserOrgs(req: Request, res: Response, next: NextFunction) {
-  const userId = req.user?.id; // Assuming you have user information in the request
+    const userId = req.user?.id; // Assuming you have user information in the request
 
-  if (!userId) {
-    return next(createHttpError(HttpCode.UNAUTHORIZED, 'User not authenticated'));
-  }
+    if (!userId) {
+        return next(createHttpError(HttpCode.UNAUTHORIZED, 'User not authenticated'));
+    }
 
-  try {
-    const userOrganizations = await db.select({
-      orgId: userOrgs.orgId,
-      role: userOrgs.role,
-    })
-      .from(userOrgs)
-      .where(eq(userOrgs.userId, userId));
+    try {
+        const userOrganizations = await db.select({
+            orgId: userOrgs.orgId,
+            roleId: userOrgs.roleId,
+        })
+            .from(userOrgs)
+            .where(eq(userOrgs.userId, userId));
 
-    req.userOrgs = userOrganizations.map(org => org.orgId);
-    // req.userOrgRoleIds = userOrganizations.reduce((acc, org) => {
-    //   acc[org.orgId] = org.role;
-    //   return acc;
-    // }, {} as Record<number, string>);
+        req.userOrgIds = userOrganizations.map(org => org.orgId);
+        // req.userOrgRoleIds = userOrganizations.reduce((acc, org) => {
+        //   acc[org.orgId] = org.role;
+        //   return acc;
+        // }, {} as Record<number, string>);
 
-    next();
-  } catch (error) {
-    next(createHttpError(HttpCode.INTERNAL_SERVER_ERROR, 'Error retrieving user organizations'));
-  }
+        next();
+    } catch (error) {
+        next(createHttpError(HttpCode.INTERNAL_SERVER_ERROR, 'Error retrieving user organizations'));
+    }
 }

server/routers/auth/verifyOrgAccess.ts

@@ -7,31 +7,31 @@ import HttpCode from '@server/types/HttpCode';
 import { AuthenticatedRequest } from '@server/types/Auth';
 
 export function verifyOrgAccess(req: Request, res: Response, next: NextFunction) {
-  const userId = req.user!.id; // Assuming you have user information in the request
-  const orgId = parseInt(req.params.orgId);
+    const userId = req.user!.id; // Assuming you have user information in the request
+    const orgId = parseInt(req.params.orgId);
 
-  if (!userId) {
-    return next(createHttpError(HttpCode.UNAUTHORIZED, 'User not authenticated'));
-  }
+    if (!userId) {
+        return next(createHttpError(HttpCode.UNAUTHORIZED, 'User not authenticated'));
+    }
 
-  if (isNaN(orgId)) {
-    return next(createHttpError(HttpCode.BAD_REQUEST, 'Invalid organization ID'));
-  }
+    if (isNaN(orgId)) {
+        return next(createHttpError(HttpCode.BAD_REQUEST, 'Invalid organization ID'));
+    }
 
-  db.select()
-    .from(userOrgs)
-    .where(and(eq(userOrgs.userId, userId), eq(userOrgs.orgId, orgId)))
-    .then((result) => {
-      if (result.length === 0) {
-        next(createHttpError(HttpCode.FORBIDDEN, 'User does not have access to this organization'));
-      } else {
-        // User has access, attach the user's role to the request for potential future use
-        req.userOrgRoleId = result[0].roleId;
-        req.userOrgId = orgId;
-        next();
-      }
-    })
-    .catch((error) => {
-      next(createHttpError(HttpCode.INTERNAL_SERVER_ERROR, 'Error verifying organization access'));
-    });
+    db.select()
+        .from(userOrgs)
+        .where(and(eq(userOrgs.userId, userId), eq(userOrgs.orgId, orgId)))
+        .then((result) => {
+            if (result.length === 0) {
+                next(createHttpError(HttpCode.FORBIDDEN, 'User does not have access to this organization'));
+            } else {
+                // User has access, attach the user's role to the request for potential future use
+                req.userOrgRoleId = result[0].roleId;
+                req.userOrgId = orgId;
+                next();
+            }
+        })
+        .catch((error) => {
+            next(createHttpError(HttpCode.INTERNAL_SERVER_ERROR, 'Error verifying organization access'));
+        });
 }

server/routers/auth/verifyResourceAccess.ts

@@ -6,73 +6,73 @@ import createHttpError from 'http-errors';
 import HttpCode from '@server/types/HttpCode';
 
 export async function verifyResourceAccess(req: Request, res: Response, next: NextFunction) {
-  const userId = req.user!.id; // Assuming you have user information in the request
-  const resourceId = req.params.resourceId;
+    const userId = req.user!.id; // Assuming you have user information in the request
+    const resourceId = req.params.resourceId;
 
-  if (!userId) {
-    return next(createHttpError(HttpCode.UNAUTHORIZED, 'User not authenticated'));
-  }
-
-  try {
-    // Get the resource
-    const resource = await db.select()
-      .from(resources)
-      .where(eq(resources.resourceId, resourceId))
-      .limit(1);
-
-    if (resource.length === 0) {
-      return next(createHttpError(HttpCode.NOT_FOUND, `Resource with ID ${resourceId} not found`));
+    if (!userId) {
+        return next(createHttpError(HttpCode.UNAUTHORIZED, 'User not authenticated'));
     }
 
-    if (!resource[0].orgId) {
-      return next(createHttpError(HttpCode.INTERNAL_SERVER_ERROR, `Resource with ID ${resourceId} does not have an organization ID`));
+    try {
+        // Get the resource
+        const resource = await db.select()
+            .from(resources)
+            .where(eq(resources.resourceId, resourceId))
+            .limit(1);
+
+        if (resource.length === 0) {
+            return next(createHttpError(HttpCode.NOT_FOUND, `Resource with ID ${resourceId} not found`));
+        }
+
+        if (!resource[0].orgId) {
+            return next(createHttpError(HttpCode.INTERNAL_SERVER_ERROR, `Resource with ID ${resourceId} does not have an organization ID`));
+        }
+
+        // Get user's role ID in the organization
+        const userOrgRole = await db.select()
+            .from(userOrgs)
+            .where(and(eq(userOrgs.userId, userId), eq(userOrgs.orgId, resource[0].orgId)))
+            .limit(1);
+
+        if (userOrgRole.length === 0) {
+            return next(createHttpError(HttpCode.FORBIDDEN, 'User does not have access to this organization'));
+        }
+
+        const userOrgRoleId = userOrgRole[0].roleId;
+        req.userOrgRoleId = userOrgRoleId;
+        req.userOrgId = resource[0].orgId;
+
+        // Check role-based resource access first
+        const roleResourceAccess = await db.select()
+            .from(roleResources)
+            .where(
+                and(
+                    eq(roleResources.resourceId, resourceId),
+                    eq(roleResources.roleId, userOrgRoleId)
+                )
+            )
+            .limit(1);
+
+        if (roleResourceAccess.length > 0) {
+            // User's role has access to the resource
+            return next();
+        }
+
+        // If role doesn't have access, check user-specific resource access
+        const userResourceAccess = await db.select()
+            .from(userResources)
+            .where(and(eq(userResources.userId, userId), eq(userResources.resourceId, resourceId)))
+            .limit(1);
+
+        if (userResourceAccess.length > 0) {
+            // User has direct access to the resource
+            return next();
+        }
+
+        // If we reach here, the user doesn't have access to the resource
+        return next(createHttpError(HttpCode.FORBIDDEN, 'User does not have access to this resource'));
+
+    } catch (error) {
+        return next(createHttpError(HttpCode.INTERNAL_SERVER_ERROR, 'Error verifying resource access'));
     }
-
-    // Get user's role ID in the organization
-    const userOrgRole = await db.select()
-      .from(userOrgs)
-      .where(and(eq(userOrgs.userId, userId), eq(userOrgs.orgId, resource[0].orgId)))
-      .limit(1);
-
-    if (userOrgRole.length === 0) {
-      return next(createHttpError(HttpCode.FORBIDDEN, 'User does not have access to this organization'));
-    }
-
-    const userOrgRoleId = userOrgRole[0].roleId;
-    req.userOrgRoleId = userOrgRoleId;
-    req.userOrgId = resource[0].orgId;
-
-    // Check role-based resource access first
-    const roleResourceAccess = await db.select()
-      .from(roleResources)
-      .where(
-        and(
-          eq(roleResources.resourceId, resourceId),
-          eq(roleResources.roleId, userOrgRoleId)
-        )
-      )
-      .limit(1);
-
-    if (roleResourceAccess.length > 0) {
-      // User's role has access to the resource
-      return next();
-    }
-
-    // If role doesn't have access, check user-specific resource access
-    const userResourceAccess = await db.select()
-      .from(userResources)
-      .where(and(eq(userResources.userId, userId), eq(userResources.resourceId, resourceId)))
-      .limit(1);
-
-    if (userResourceAccess.length > 0) {
-      // User has direct access to the resource
-      return next();
-    }
-
-    // If we reach here, the user doesn't have access to the resource
-    return next(createHttpError(HttpCode.FORBIDDEN, 'User does not have access to this resource'));
-
-  } catch (error) {
-    return next(createHttpError(HttpCode.INTERNAL_SERVER_ERROR, 'Error verifying resource access'));
-  }
 }

server/routers/auth/verifySiteAccess.ts

@@ -6,74 +6,74 @@ import createHttpError from 'http-errors';
 import HttpCode from '@server/types/HttpCode';
 
 export async function verifySiteAccess(req: Request, res: Response, next: NextFunction) {
-  const userId = req.user!.id; // Assuming you have user information in the request
-  const siteId = parseInt(req.params.siteId);
+    const userId = req.user!.id; // Assuming you have user information in the request
+    const siteId = parseInt(req.params.siteId);
 
-  if (!userId) {
-    return next(createHttpError(HttpCode.UNAUTHORIZED, 'User not authenticated'));
-  }
-
-  if (isNaN(siteId)) {
-    return next(createHttpError(HttpCode.BAD_REQUEST, 'Invalid site ID'));
-  }
-
-  try {
-    // Get the site
-    const site = await db.select().from(sites).where(eq(sites.siteId, siteId)).limit(1);
-
-    if (site.length === 0) {
-      return next(createHttpError(HttpCode.NOT_FOUND, `Site with ID ${siteId} not found`));
+    if (!userId) {
+        return next(createHttpError(HttpCode.UNAUTHORIZED, 'User not authenticated'));
     }
 
-    if (!site[0].orgId) {
-      return next(createHttpError(HttpCode.INTERNAL_SERVER_ERROR, `Site with ID ${siteId} does not have an organization ID`));
+    if (isNaN(siteId)) {
+        return next(createHttpError(HttpCode.BAD_REQUEST, 'Invalid site ID'));
     }
 
-    // Get user's role ID in the organization
-    const userOrgRole = await db.select()
-      .from(userOrgs)
-      .where(and(eq(userOrgs.userId, userId), eq(userOrgs.orgId, site[0].orgId)))
-      .limit(1);
+    try {
+        // Get the site
+        const site = await db.select().from(sites).where(eq(sites.siteId, siteId)).limit(1);
 
-    if (userOrgRole.length === 0) {
-      return next(createHttpError(HttpCode.FORBIDDEN, 'User does not have access to this organization'));
+        if (site.length === 0) {
+            return next(createHttpError(HttpCode.NOT_FOUND, `Site with ID ${siteId} not found`));
+        }
+
+        if (!site[0].orgId) {
+            return next(createHttpError(HttpCode.INTERNAL_SERVER_ERROR, `Site with ID ${siteId} does not have an organization ID`));
+        }
+
+        // Get user's role ID in the organization
+        const userOrgRole = await db.select()
+            .from(userOrgs)
+            .where(and(eq(userOrgs.userId, userId), eq(userOrgs.orgId, site[0].orgId)))
+            .limit(1);
+
+        if (userOrgRole.length === 0) {
+            return next(createHttpError(HttpCode.FORBIDDEN, 'User does not have access to this organization'));
+        }
+
+        const userOrgRoleId = userOrgRole[0].roleId;
+        req.userOrgRoleId = userOrgRoleId;
+        req.userOrgId = site[0].orgId;
+
+        // Check role-based site access first
+        const roleSiteAccess = await db.select()
+            .from(roleSites)
+            .where(
+                and(
+                    eq(roleSites.siteId, siteId),
+                    eq(roleSites.roleId, userOrgRoleId)
+                )
+            )
+            .limit(1);
+
+        if (roleSiteAccess.length > 0) {
+            // User's role has access to the site
+            return next();
+        }
+
+        // If role doesn't have access, check user-specific site access
+        const userSiteAccess = await db.select()
+            .from(userSites)
+            .where(and(eq(userSites.userId, userId), eq(userSites.siteId, siteId)))
+            .limit(1);
+
+        if (userSiteAccess.length > 0) {
+            // User has direct access to the site
+            return next();
+        }
+
+        // If we reach here, the user doesn't have access to the site
+        return next(createHttpError(HttpCode.FORBIDDEN, 'User does not have access to this site'));
+
+    } catch (error) {
+        return next(createHttpError(HttpCode.INTERNAL_SERVER_ERROR, 'Error verifying site access'));
     }
-
-    const userOrgRoleId = userOrgRole[0].roleId;
-    req.userOrgRoleId = userOrgRoleId;
-    req.userOrgId = site[0].orgId;
-
-    // Check role-based site access first
-    const roleSiteAccess = await db.select()
-      .from(roleSites)
-      .where(
-        and(
-          eq(roleSites.siteId, siteId),
-          eq(roleSites.roleId, userOrgRoleId)
-        )
-      )
-      .limit(1);
-
-    if (roleSiteAccess.length > 0) {
-      // User's role has access to the site
-      return next();
-    }
-
-    // If role doesn't have access, check user-specific site access
-    const userSiteAccess = await db.select()
-      .from(userSites)
-      .where(and(eq(userSites.userId, userId), eq(userSites.siteId, siteId)))
-      .limit(1);
-
-    if (userSiteAccess.length > 0) {
-      // User has direct access to the site
-      return next();
-    }
-
-    // If we reach here, the user doesn't have access to the site
-    return next(createHttpError(HttpCode.FORBIDDEN, 'User does not have access to this site'));
-
-  } catch (error) {
-    return next(createHttpError(HttpCode.INTERNAL_SERVER_ERROR, 'Error verifying site access'));
-  }
 }

server/routers/auth/verifyTargetAccess.ts

@@ -6,79 +6,79 @@ import createHttpError from 'http-errors';
 import HttpCode from '@server/types/HttpCode';
 
 export async function verifyTargetAccess(req: Request, res: Response, next: NextFunction) {
-  const userId = req.user!.id; // Assuming you have user information in the request
-  const targetId = parseInt(req.params.targetId);
+    const userId = req.user!.id; // Assuming you have user information in the request
+    const targetId = parseInt(req.params.targetId);
 
-  if (!userId) {
-    return next(createHttpError(HttpCode.UNAUTHORIZED, 'User not authenticated'));
-  }
+    if (!userId) {
+        return next(createHttpError(HttpCode.UNAUTHORIZED, 'User not authenticated'));
+    }
 
-  if (isNaN(targetId)) {
-    return next(createHttpError(HttpCode.BAD_REQUEST, 'Invalid organization ID'));
-  }
+    if (isNaN(targetId)) {
+        return next(createHttpError(HttpCode.BAD_REQUEST, 'Invalid organization ID'));
+    }
 
-  const target = await db.select()
-    .from(targets)
-    .where(eq(targets.targetId, targetId))
-    .limit(1);
+    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`
-      )
-    );
-  }
+    if (target.length === 0) {
+        return next(
+            createHttpError(
+                HttpCode.NOT_FOUND,
+                `target with ID ${targetId} not found`
+            )
+        );
+    }
 
-  const resourceId = target[0].resourceId;
+    const resourceId = target[0].resourceId;
 
-  if (resourceId) {
-    return next(
-      createHttpError(
-        HttpCode.INTERNAL_SERVER_ERROR,
-        `target with ID ${targetId} does not have a resource ID`
-      )
-    );
-  }
+    if (resourceId) {
+        return next(
+            createHttpError(
+                HttpCode.INTERNAL_SERVER_ERROR,
+                `target with ID ${targetId} does not have a resource ID`
+            )
+        );
+    }
 
-  const resource = await db.select()
-    .from(resources)
-    .where(eq(resources.resourceId, resourceId!))
-    .limit(1);
+    const resource = await db.select()
+        .from(resources)
+        .where(eq(resources.resourceId, resourceId!))
+        .limit(1);
 
-  if (resource.length === 0) {
-    return next(
-      createHttpError(
-        HttpCode.NOT_FOUND,
-        `resource with ID ${resourceId} not found`
-      )
-    );
-  }
+    if (resource.length === 0) {
+        return next(
+            createHttpError(
+                HttpCode.NOT_FOUND,
+                `resource with ID ${resourceId} not found`
+            )
+        );
+    }
 
-  if (!resource[0].orgId) {
-    return next(
-      createHttpError(
-        HttpCode.INTERNAL_SERVER_ERROR,
-        `resource with ID ${resourceId} does not have an organization ID`
-      )
-    );
-  }
+    if (!resource[0].orgId) {
+        return next(
+            createHttpError(
+                HttpCode.INTERNAL_SERVER_ERROR,
+                `resource with ID ${resourceId} does not have an organization ID`
+            )
+        );
+    }
 
-  db.select()
-    .from(userOrgs)
-    .where(and(eq(userOrgs.userId, userId), eq(userOrgs.orgId, resource[0].orgId)))
-    .then((result) => {
-      if (result.length === 0) {
-        next(createHttpError(HttpCode.FORBIDDEN, 'User does not have access to this organization'));
-      } else {
-        // User has access, attach the user's role to the request for potential future use
-        req.userOrgRoleId = result[0].roleId;
-        req.userOrgId = resource[0].orgId!;
-        next();
-      }
-    })
-    .catch((error) => {
-      next(createHttpError(HttpCode.INTERNAL_SERVER_ERROR, 'Error verifying organization access'));
-    });
+    db.select()
+        .from(userOrgs)
+        .where(and(eq(userOrgs.userId, userId), eq(userOrgs.orgId, resource[0].orgId)))
+        .then((result) => {
+            if (result.length === 0) {
+                next(createHttpError(HttpCode.FORBIDDEN, 'User does not have access to this organization'));
+            } else {
+                // User has access, attach the user's role to the request for potential future use
+                req.userOrgRoleId = result[0].roleId;
+                req.userOrgId = resource[0].orgId!;
+                next();
+            }
+        })
+        .catch((error) => {
+            next(createHttpError(HttpCode.INTERNAL_SERVER_ERROR, 'Error verifying organization access'));
+        });
 }