Changed routers for all instances

Author: anika-4444

server/package.json

@@ -42,7 +42,7 @@
   "scripts": {
     "build": "tsc --project tsconfig.build.json",
     "start": "node build/app.js",
-    "dev": "nodemon --exec \"ts-node\" src/app.ts",
+    "dev": "nodemon --exec 'tsx' src/app.ts",
     "type-check": "tsc --project tsconfig.json --pretty --noEmit",
     "test": "cross-env NODE_ENV=test mocha -r ts-node/register \"tests/**/*.ts\" --exit --timeout 30000",
     "test:watch": "cross-env NODE_ENV=test nodemon --watch . --exec 'mocha -r ts-node/register \"tests/**/*.ts\" --timeout 10000' --ext ts"

server/src/db/prisma.ts

@@ -1,6 +1,6 @@
 import "dotenv/config";
 import { PrismaPg } from "@prisma/adapter-pg";
-import { PrismaClient } from "@prisma/client";
+import { PrismaClient } from "../../generated/prisma/client";
 
 const connectionString = `${process.env.DATABASE_URL}`;
 

server/src/router/admin.ts

@@ -1,26 +1,38 @@
 import express from 'express';
 import { v4 as uuid } from 'uuid';
-import * as db from './common';
-import { Admin } from '../models/admin';
+import { prisma } from '../db/prisma';
+import { AdminRole } from '../../generated/prisma/client';
 import { validateUser, checkNetIDExists, checkNetIDExistsForOtherEmployee } from '../util';
-import { UserType } from '../models/subscription';
 
 const router = express.Router();
-const tableName = 'Admins';
 
 // Get an admin
-router.get('/:id', validateUser('Admin'), (req, res) => {
-  const {
-    params: { id },
-  } = req;
-  db.getById(res, Admin, id, tableName);
+router.get('/:id', validateUser('Admin'), async (req, res) => {
+  try {
+    const { id } = req.params;
+    const admin = await prisma.admin.findUnique({ where: { id } });
+    if (!admin) {
+      return res.status(400).send({ err: 'id not found in Admins' });
+    }
+    res.status(200).json({ data: admin });
+  } catch (error) {
+    console.error('Error fetching admin:', error);
+    res.status(500).send({ err: 'Failed to fetch admin' });
+  }
 });
 
 // Get all admins
-router.get('/', validateUser('Admin'), (req, res) => {
-  db.getAll(res, Admin, tableName);
+router.get('/', validateUser('Admin'), async (req, res) => {
+  try {
+    const admins = await prisma.admin.findMany();
+    res.status(200).send({ data: admins });
+  } catch (error) {
+    console.error('Error fetching admins:', error);
+    res.status(500).send({ err: 'Failed to fetch admins' });
+  }
 });
 
+
 // Put a driver in Admins table
 router.post('/', validateUser('Admin'), async (req, res) => {
   try {
@@ -33,17 +45,27 @@ router.post('/', validateUser('Admin'), async (req, res) => {
       });
     }
 
-    const admin = new Admin({
-      id: !body.eid || body.eid === '' ? uuid() : body.eid,
-      firstName: body.firstName,
-      lastName: body.lastName,
-      type: body.type,
-      isDriver: body.isDriver,
-      phoneNumber: body.phoneNumber,
-      email: body.email,
+    const rolesInput = body.type || body.roles || [];
+    const roles = Array.isArray(rolesInput)
+      ? rolesInput
+          .map((r: string) => r.toUpperCase().replace(/\s+/g, '_'))
+          .filter((r: string) => r === 'SDS_ADMIN' || r === 'REDRUNNER_ADMIN')
+      : [];
+
+    const admin = await prisma.admin.create({
+      data: {
+        id: !body.eid || body.eid === '' ? uuid() : body.eid,
+        firstName: body.firstName,
+        lastName: body.lastName,
+        roles: roles as AdminRole[],
+        isDriver: body.isDriver || false,
+        phoneNumber: body.phoneNumber,
+        email: body.email,
+        photoLink: body.photoLink || null,
+      },
     });
 
-    db.create(res, admin);
+    res.status(200).send({ data: admin });
   } catch (error) {
     console.error('Error creating admin:', error);
     res.status(500).send({ err: 'Failed to create admin' });
@@ -53,12 +75,9 @@ router.post('/', validateUser('Admin'), async (req, res) => {
 // Update an existing admin
 router.put('/:id', validateUser('Admin'), async (req, res) => {
   try {
-    const {
-      params: { id },
-      body,
-    } = req;
+    const { id } = req.params;
+    const { body } = req;
 
-    // Check if email is being changed and if it conflicts with another employee
     if (body.email) {
       const emailExists = await checkNetIDExistsForOtherEmployee(body.email, id);
       if (emailExists) {
@@ -68,19 +87,40 @@ router.put('/:id', validateUser('Admin'), async (req, res) => {
       }
     }
 
-    db.update(res, Admin, { id }, body, tableName);
-  } catch (error) {
+    if (body.type || body.roles) {
+      const roles = body.type || body.roles;
+      body.roles = Array.isArray(roles) ? roles.map((r: string) => r.toUpperCase() as AdminRole) : roles;
+      delete body.type;
+    }
+
+    const admin = await prisma.admin.update({
+      where: { id },
+      data: body,
+    });
+
+    res.status(200).send({ data: admin });
+  } catch (error: any) {
+    if (error.code === 'P2025') {
+      return res.status(400).send({ err: 'id not found in Admins' });
+    }
     console.error('Error updating admin:', error);
     res.status(500).send({ err: 'Failed to update admin' });
   }
 });
 
 // Remove an admin
-router.delete('/:id', validateUser('Admin'), (req, res) => {
-  const {
-    params: { id },
-  } = req;
-  db.deleteById(res, Admin, id, tableName);
+router.delete('/:id', validateUser('Admin'), async (req, res) => {
+  try {
+    const { id } = req.params;
+    await prisma.admin.delete({ where: { id } });
+    res.status(200).send({ id });
+  } catch (error: any) {
+    if (error.code === 'P2025') {
+      return res.status(400).send({ err: 'id not found in Admins' });
+    }
+    console.error('Error deleting admin:', error);
+    res.status(500).send({ err: 'Failed to delete admin' });
+  }
 });
 
 export default router;

server/src/router/auth.ts

@@ -1,12 +1,8 @@
 import express from 'express';
 import * as jwt from 'jsonwebtoken';
-import { Rider } from '../models/rider';
-import { Admin } from '../models/admin';
-import { Driver } from '../models/driver';
+import { prisma } from '../db/prisma';
 import { OAuth2Client } from 'google-auth-library';
 import { oauthValues } from '../config';
-import { ModelType } from 'dynamoose/dist/General';
-import { Item } from 'dynamoose/dist/Item';
 import { UnregisteredUserType } from '@carriage-web/shared/types';
 
 const router = express.Router();
@@ -22,19 +18,6 @@ const audience = [
   '241748771473-7rfda2grc8f7p099bmf98en0q9bcvp18.apps.googleusercontent.com',
 ];
 
-/**
- * Returns the appropriate model (Rider, Driver, Admin) for a given table name.
- * @param table - The string name of the table (e.g., 'Riders', 'Drivers', 'Admins').
- */
-function getModel(table: string) {
-  const tableToModel: { [table: string]: ModelType<Item> } = {
-    Riders: Rider,
-    Drivers: Driver,
-    Admins: Admin,
-  };
-  return tableToModel[table];
-}
-
 /**
  * Derives the singular user type from the table name.
  * For example, 'Riders' becomes 'Rider'.
@@ -45,79 +28,48 @@ function getUserType(table: string) {
 }
 
 /**
- * Finds a user in the specified model by email and sends back a JWT token if found.
+ * Finds a user in Prisma by email and sends back a JWT token if found.
  * If logging in as an Admin and no match is found, the Driver table is checked as a fallback for admin-flagged users.
  * @param res - Express response object.
- * @param model - The model to query (Rider, Admin, or Driver).
  * @param table - Name of the user table (used to derive userType).
  * @param email - The email address to look up.
  * @param userInfo - Optional user info from Google OAuth (name, etc.).
  */
-function findUserAndSendToken(
+async function findUserAndSendToken(
   res: express.Response,
-  model: ModelType<Item>,
   table: string,
   email: string,
   userInfo?: Partial<UnregisteredUserType>
 ) {
-  model.scan({ email: { eq: email } }).exec((err, data) => {
-    if (err) {
-      res.status(err.statusCode || 500).send({ err: err.message });
-      return;
-    }
+  try {
+    let user: any = null;
 
-    if (data?.length) {
-      const { id, active } = data[0].toJSON();
-      if (table === 'Riders' && !active) {
+    if (table === 'Riders') {
+      user = await prisma.rider.findUnique({ where: { email } });
+      if (user && !user.active) {
         res.status(400).send({ err: 'User not active' });
         return;
       }
+    } else if (table === 'Drivers') {
+      user = await prisma.driver.findUnique({ where: { email } });
+    } else if (table === 'Admins') {
+      user = await prisma.admin.findUnique({ where: { email } });
+
+      // Fallback: Check drivers table for admins
+      if (!user) {
+        const driver = await prisma.driver.findUnique({ where: { email } });
+        if (driver) {
+          user = driver;
+        }
+      }
+    }
+
+    if (user) {
       const userPayload = {
-        id,
+        id: user.id,
         userType: getUserType(table),
       };
-      res
-        .status(200)
-        .send({ jwt: jwt.sign(userPayload, process.env.JWT_SECRET!) });
-    } else if (table === 'Admins') {
-      // Check drivers table for admins
-      // when the frontend page is made, this removed and we only use the first scan and change the error handling to check
-      // per table this is because we would have decoupled admins and drivers, so drivers wouldnt sign on admin page and vice versa
-      // but maybe we would allow admins to log onto the driver page?
-      Driver.scan({ email: { eq: email } }).exec((dErr, dData) => {
-        if (dErr) {
-          res.status(dErr.statusCode || 500).send({ err: dErr });
-        } else if (dData?.length) {
-          const { id, admin } = dData[0].toJSON();
-          if (admin) {
-            const userPayload = {
-              id,
-              userType: getUserType(table),
-            };
-            res
-              .status(200)
-              .send({ jwt: jwt.sign(userPayload, process.env.JWT_SECRET!) });
-          } else {
-            const unregisteredUser: UnregisteredUserType = {
-              email: email,
-              name: userInfo?.name || 'User',
-            };
-            res.status(400).send({
-              err: 'User not found',
-              user: unregisteredUser,
-            });
-          }
-        } else {
-          const unregisteredUser: UnregisteredUserType = {
-            email: email,
-            name: userInfo?.name || 'User',
-          };
-          res.status(400).send({
-            err: 'User not found',
-            user: unregisteredUser,
-          });
-        }
-      });
+      res.status(200).send({ jwt: jwt.sign(userPayload, process.env.JWT_SECRET!) });
     } else {
       const unregisteredUser: UnregisteredUserType = {
         email: email,
@@ -128,7 +80,10 @@ function findUserAndSendToken(
         user: unregisteredUser,
       });
     }
-  });
+  } catch (error) {
+    console.error('Error finding user:', error);
+    res.status(500).send({ err: 'Internal server error' });
+  }
 }
 
 /**
@@ -148,6 +103,12 @@ async function getIdToken(client: OAuth2Client, code: string) {
 router.post('/', async (req, res) => {
   const { code, table } = req.body;
   try {
+    const validTables = ['Riders', 'Drivers', 'Admins'];
+    if (!validTables.includes(table)) {
+      res.status(400).send({ err: 'Table not found' });
+      return;
+    }
+
     const client = new OAuth2Client({
       clientId: oauthValues.client_id,
       clientSecret: oauthValues.client_secret,
@@ -158,15 +119,11 @@ router.post('/', async (req, res) => {
     const payload = result.getPayload();
     const email = payload?.email;
     const name = payload?.name;
-    const model = getModel(table);
-    if (model && email) {
-      findUserAndSendToken(res, model, table, email, { name });
-    } else if (!model) {
-      res.status(400).send({ err: 'Table not found' });
-    } else if (!email) {
-      res.status(400).send({ err: 'Email not found' });
+
+    if (email) {
+      await findUserAndSendToken(res, table, email, { name });
     } else {
-      res.status(400).send({ err: 'Payload not found' });
+      res.status(400).send({ err: 'Email not found' });
     }
   } catch (err) {
     console.log(err);
@@ -178,15 +135,16 @@ if (process.env.NODE_ENV === 'test') {
   router.post('/dummy', async (req, res) => {
     const { email, table } = req.body;
     try {
-      const model = getModel(table);
-      if (model && email) {
-        findUserAndSendToken(res, model, table, email, { name: email });
-      } else if (!model) {
+      const validTables = ['Riders', 'Drivers', 'Admins'];
+      if (!validTables.includes(table)) {
         res.status(400).send({ err: 'Table not found' });
-      } else if (!email) {
-        res.status(400).send({ err: 'Email not found' });
+        return;
+      }
+
+      if (email) {
+        await findUserAndSendToken(res, table, email, { name: email });
       } else {
-        res.status(400).send({ err: 'Payload not found' });
+        res.status(400).send({ err: 'Email not found' });
       }
     } catch (err) {
       console.log(err);