ability to remove user from org

server/routers/auth/index.ts

@@ -11,7 +11,7 @@ export * from "./verifyResourceAccess";
 export * from "./verifyTargetAccess";
 export * from "./verifyRoleAccess";
 export * from "./verifyUserAccess";
-export * from "./verifySuperuser";
+export * from "./verifySuperUser";
 export * from "./verifyEmail";
 export * from "./requestEmailVerificationCode";
 export * from "./changePassword";

server/routers/auth/sendEmailVerificationCode.ts

@@ -4,7 +4,7 @@ import db from "@server/db";
 import { users, emailVerificationCodes } from "@server/db/schema";
 import { eq } from "drizzle-orm";
 import { sendEmail } from "@server/emails";
-import VerifyEmail from "@server/emails/templates/verifyEmailCode";
+import VerifyEmail from "@server/emails/templates/VerifyEmailCode";
 import config from "@server/config";
 
 export async function sendEmailVerificationCode(

server/routers/auth/verifyOrgAccess.ts

@@ -1,21 +1,29 @@
-import { Request, Response, NextFunction } from 'express';
-import { db } from '@server/db';
-import { userOrgs } from '@server/db/schema';
-import { and, eq } from 'drizzle-orm';
-import createHttpError from 'http-errors';
-import HttpCode from '@server/types/HttpCode';
-import { AuthenticatedRequest } from '@server/types/Auth';
+import { Request, Response, NextFunction } from "express";
+import { db } from "@server/db";
+import { userOrgs } from "@server/db/schema";
+import { and, eq } from "drizzle-orm";
+import createHttpError from "http-errors";
+import HttpCode from "@server/types/HttpCode";
+import { AuthenticatedRequest } from "@server/types/Auth";
 
-export function verifyOrgAccess(req: Request, res: Response, next: NextFunction) {
+export function verifyOrgAccess(
+    req: Request,
+    res: Response,
+    next: NextFunction
+) {
     const userId = req.user!.userId; // Assuming you have user information in the request
     const orgId = req.params.orgId;
 
     if (!userId) {
-        return next(createHttpError(HttpCode.UNAUTHORIZED, 'User not authenticated'));
+        return next(
+            createHttpError(HttpCode.UNAUTHORIZED, "User not authenticated")
+        );
     }
 
     if (!orgId) {
-        return next(createHttpError(HttpCode.BAD_REQUEST, 'Invalid organization ID'));
+        return next(
+            createHttpError(HttpCode.BAD_REQUEST, "Invalid organization ID")
+        );
     }
 
     db.select()
@@ -23,7 +31,12 @@ export function verifyOrgAccess(req: Request, res: Response, next: NextFunction)
         .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'));
+                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;
@@ -32,6 +45,11 @@ export function verifyOrgAccess(req: Request, res: Response, next: NextFunction)
             }
         })
         .catch((error) => {
-            next(createHttpError(HttpCode.INTERNAL_SERVER_ERROR, 'Error verifying organization access'));
+            next(
+                createHttpError(
+                    HttpCode.INTERNAL_SERVER_ERROR,
+                    "Error verifying organization access"
+                )
+            );
         });
 }

server/routers/auth/verifySuperuser.ts

@@ -6,7 +6,7 @@ import createHttpError from 'http-errors';
 import HttpCode from '@server/types/HttpCode';
 import logger from '@server/logger';
 
-export async function verifySuperuser(req: Request, res: Response, next: NextFunction) {
+export async function verifySuperUser(req: Request, res: Response, next: NextFunction) {
     const userId = req.user?.userId; // Assuming you have user information in the request
     const orgId = req.userOrgId;
 
@@ -30,14 +30,14 @@ export async function verifySuperuser(req: Request, res: Response, next: NextFun
         }
 
         // get userOrgRole[0].roleId
-        // Check if the user's role in the organization is a superuser role
+        // Check if the user's role in the organization is a Super User role
         const userRole = await db.select()
             .from(roles)
             .where(eq(roles.roleId, userOrgRole[0].roleId))
             .limit(1);
 
-        if (userRole.length === 0 || !userRole[0].isSuperuserRole) {
-            return next(createHttpError(HttpCode.FORBIDDEN, 'User does not have superuser access'));
+        if (userRole.length === 0 || !userRole[0].isSuperUserRole) {
+            return next(createHttpError(HttpCode.FORBIDDEN, 'User does not have Super User access'));
         }
 
         return next();

server/routers/auth/verifyUserAccess.ts

@@ -1,37 +1,62 @@
-import { Request, Response, NextFunction } from 'express';
-import { db } from '@server/db';
-import { sites, userOrgs, userSites, roleSites, roles } from '@server/db/schema';
-import { and, eq, or } from 'drizzle-orm';
-import createHttpError from 'http-errors';
-import HttpCode from '@server/types/HttpCode';
+import { Request, Response, NextFunction } from "express";
+import { db } from "@server/db";
+import {
+    sites,
+    userOrgs,
+    userSites,
+    roleSites,
+    roles,
+} from "@server/db/schema";
+import { and, eq, or } from "drizzle-orm";
+import createHttpError from "http-errors";
+import HttpCode from "@server/types/HttpCode";
 
-export async function verifyUserAccess(req: Request, res: Response, next: NextFunction) {
+export async function verifyUserAccess(
+    req: Request,
+    res: Response,
+    next: NextFunction
+) {
     const userId = req.user!.userId; // Assuming you have user information in the request
     const reqUserId = req.params.userId || req.body.userId || req.query.userId;
 
     if (!userId) {
-        return next(createHttpError(HttpCode.UNAUTHORIZED, 'User not authenticated'));
+        return next(
+            createHttpError(HttpCode.UNAUTHORIZED, "User not authenticated")
+        );
     }
 
     if (!reqUserId) {
-        return next(createHttpError(HttpCode.BAD_REQUEST, 'Invalid user ID'));
+        return next(createHttpError(HttpCode.BAD_REQUEST, "Invalid user ID"));
     }
 
     try {
-
-        const userOrg = await db.select()
+        const userOrg = await db
+            .select()
             .from(userOrgs)
-            .where(and(eq(userOrgs.userId, userId), eq(userOrgs.orgId, req.userOrgId!)))
+            .where(
+                and(
+                    eq(userOrgs.userId, reqUserId),
+                    eq(userOrgs.orgId, req.userOrgId!)
+                )
+            )
             .limit(1);
 
         if (userOrg.length === 0) {
-            return next(createHttpError(HttpCode.FORBIDDEN, 'User does not have access to this user'));
+            return next(
+                createHttpError(
+                    HttpCode.FORBIDDEN,
+                    "User does not have access to this user"
+                )
+            );
         }
 
-        // 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'));
-
+        return next();
     } catch (error) {
-        return next(createHttpError(HttpCode.INTERNAL_SERVER_ERROR, 'Error verifying site access'));
+        return next(
+            createHttpError(
+                HttpCode.INTERNAL_SERVER_ERROR,
+                "Error checking if user has access to this user"
+            )
+        );
     }
 }