Trpc

api/package.json

@@ -1,14 +1,15 @@
 {
   "name": "peterportal-core-api",
   "version": "1.0.0",
-  "main": "dist/app.js",
+  "main": "src/app.ts",
+  "type": "module",
   "scripts": {
-    "start": "node dist/app.js",
-    "dev": "tsc-watch --onSuccess \"pnpm start\"",
+    "dev": "nodemon --exec tsx ./src/app.ts",
     "build": "tsc",
     "lint": "eslint . --ext ts,tsx --report-unused-disable-directives --max-warnings 0 && tsc --noEmit"
   },
   "dependencies": {
+    "@trpc/server": "^10.45.1",
     "@vendia/serverless-express": "^4.12.6",
     "axios": "^1.6.8",
     "connect-mongodb-session": "^5.0.0",
@@ -20,9 +21,10 @@
     "morgan": "^1.10.0",
     "passport": "^0.7.0",
     "passport-google-oauth": "^2.0.0",
-    "typescript": "^5.4.5"
+    "zod": "^3.23.8"
   },
   "devDependencies": {
+    "@peterportal/types": "workspace:*",
     "@types/connect-mongodb-session": "^2.4.7",
     "@types/cookie-parser": "^1.4.7",
     "@types/dotenv-flow": "^3.3.3",
@@ -35,6 +37,8 @@
     "@typescript-eslint/parser": "^7.8.0",
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",
-    "tsc-watch": "^6.2.0"
+    "nodemon": "^3.1.7",
+    "tsx": "^4.19.1",
+    "typescript": "^5.4.2"
   }
 }

api/src/app.ts

@@ -11,6 +11,7 @@ import session from 'express-session';
 import MongoDBStore from 'connect-mongodb-session';
 import dotenv from 'dotenv-flow';
 import serverlessExpress from '@vendia/serverless-express';
+import * as trpcExpress from '@trpc/server/adapters/express';
 import mongoose, { Mongoose } from 'mongoose';
 // load env
 dotenv.config();
@@ -19,15 +20,12 @@ dotenv.config();
 import { DB_NAME, COLLECTION_NAMES } from './helpers/mongo';
 
 // Custom Routes
-import coursesRouter from './controllers/courses';
-import professorsRouter from './controllers/professors';
-import scheduleRouter from './controllers/schedule';
-import reviewsRouter from './controllers/reviews';
-import usersRouter from './controllers/users';
-import roadmapRouter from './controllers/roadmap';
-import reportsRouter from './controllers/reports';
+import authRouter from './controllers/auth';
 
 import { SESSION_LENGTH } from './config/constants';
+import { createContext } from './helpers/trpc';
+import { appRouter } from './controllers';
+import passportInit from './config/passport';
 
 // instantiate app
 const app = express();
@@ -69,7 +67,7 @@ app.use(
 if (process.env.GOOGLE_CLIENT && process.env.GOOGLE_SECRET) {
   app.use(passport.initialize());
   app.use(passport.session());
-  require('./config/passport');
+  passportInit();
 } else {
   console.log('GOOGLE_CLIENT and/or GOOGLE_SECRET env var(s) not defined! Google login will not be available.');
 }
@@ -100,15 +98,17 @@ app.use(function (req, res, next) {
  */
 
 // Enable custom routes
-const router = express.Router();
-router.use('/courses', coursesRouter);
-router.use('/professors', professorsRouter);
-router.use('/schedule', scheduleRouter);
-router.use('/reviews', reviewsRouter);
-router.use('/users', usersRouter);
-router.use('/roadmap', roadmapRouter);
-router.use('/reports', reportsRouter);
-app.use('/api', router);
+const expressRouter = express.Router();
+expressRouter.use('/users/auth', authRouter);
+expressRouter.use(
+  '/trpc',
+  trpcExpress.createExpressMiddleware({
+    router: appRouter,
+    createContext,
+  }),
+);
+
+app.use('/api', expressRouter);
 
 /**
  * Error Handler

api/src/config/passport.ts

@@ -2,41 +2,43 @@
  @module PassportConfig
 */
 
-import { User } from 'express-session';
+import { User } from '@peterportal/types';
 import passport from 'passport';
 import { OAuth2Strategy as GoogleStrategy } from 'passport-google-oauth';
 
-passport.serializeUser(function (user, done) {
-  done(null, user);
-});
+export default function passportInit() {
+  passport.serializeUser(function (user, done) {
+    done(null, user);
+  });
 
-passport.deserializeUser(function (user: false | User | null | undefined, done) {
-  done(null, user);
-});
+  passport.deserializeUser(function (user: false | User | null | undefined, done) {
+    done(null, user);
+  });
 
-/**
- * Configuration for Google Strategy
- */
-passport.use(
-  new GoogleStrategy(
-    {
-      clientID: process.env.GOOGLE_CLIENT,
-      clientSecret: process.env.GOOGLE_SECRET,
-      callbackURL: process.env.PRODUCTION_DOMAIN + '/api/users/auth/google/callback',
-    },
-    function (accessToken, refreshToken, profile, done) {
-      let email = '';
-      // get the first registered email
-      if (profile.emails && profile.emails.length! > 0) {
-        email = profile.emails[0].value;
-      }
-      const userData = {
-        id: profile.id,
-        email: email,
-        name: profile.displayName,
-        picture: profile._json.picture,
-      };
-      done(null, userData);
-    },
-  ),
-);
+  /**
+   * Configuration for Google Strategy
+   */
+  passport.use(
+    new GoogleStrategy(
+      {
+        clientID: process.env.GOOGLE_CLIENT,
+        clientSecret: process.env.GOOGLE_SECRET,
+        callbackURL: process.env.PRODUCTION_DOMAIN + '/api/users/auth/google/callback',
+      },
+      function (accessToken, refreshToken, profile, done) {
+        let email = '';
+        // get the first registered email
+        if (profile.emails && profile.emails.length! > 0) {
+          email = profile.emails[0].value;
+        }
+        const userData = {
+          id: profile.id,
+          email: email,
+          name: profile.displayName,
+          picture: profile._json.picture,
+        };
+        done(null, userData);
+      },
+    ),
+  );
+}

api/src/controllers/auth.ts

@@ -0,0 +1,84 @@
+import express, { Request, Response } from 'express';
+import passport from 'passport';
+import { SESSION_LENGTH } from '../config/constants';
+import { User } from '@peterportal/types';
+
+const router = express.Router();
+
+/**
+ * Called after successful authentication
+ * @param req Express Request Object
+ * @param res Express Response Object
+ */
+function successLogin(req: Request, res: Response) {
+  // set the user cookie
+  res.cookie('user', req.user, {
+    maxAge: SESSION_LENGTH,
+  });
+  // redirect browser to the page they came from
+  const returnTo = req.session.returnTo ?? '/';
+  delete req.session.returnTo;
+  res.redirect(returnTo!);
+}
+
+/**
+ * Initiate authentication with Google
+ */
+router.get('/google', function (req, res) {
+  req.session.returnTo = req.headers.referer;
+  passport.authenticate('google', {
+    scope: ['https://www.googleapis.com/auth/userinfo.profile', 'https://www.googleapis.com/auth/userinfo.email'],
+    state: req.headers.host,
+  })(req, res);
+});
+
+/**
+ * Callback for Google authentication
+ */
+router.get('/google/callback', function (req, res) {
+  const returnTo = req.session.returnTo;
+  const host: string = req.query.state as string;
+  // all staging auths will redirect their callback to prod since all callback URLs must be registered
+  // with google cloud for security reasons and it isn't feasible to register the callback URLs for all
+  // staging instances
+  // if we are not on a staging instance (on prod or local) but original host is a staging instance, redirect back to host
+  if (host.startsWith('staging-') && !req.headers.host?.startsWith('staging')) {
+    // req.url doesn't include /api/users part, only /auth/google/callback? and whatever params after that
+    res.redirect(`https://${host}/api/users${req.url}`);
+    return;
+  }
+  passport.authenticate(
+    'google',
+    { failureRedirect: '/', session: true },
+    // provides user information to determine whether or not to authenticate
+    function (err: Error, user: User | false | null) {
+      if (err) return console.error(err);
+      if (!user) return console.error('Invalid login data');
+      // manually login
+      req.login(user, function (err) {
+        if (err) return console.error(err);
+        // check if user is an admin
+        const allowedUsers = JSON.parse(process.env.ADMIN_EMAILS ?? '[]');
+        if (allowedUsers.includes(user.email)) {
+          req.session.passport!.isAdmin = true;
+        }
+        req.session.returnTo = returnTo;
+        successLogin(req, res);
+      });
+    },
+  )(req, res);
+});
+
+/**
+ * Endpoint to logout
+ */
+router.get('/logout', function (req, res) {
+  req.session.destroy(function (err) {
+    if (err) console.error(err);
+    // clear the user cookie
+    res.clearCookie('user');
+    res.redirect('back');
+  });
+});
+
+export default router;

api/src/controllers/courses.ts

@@ -2,69 +2,71 @@
  @module CoursesRoute
 */
 
-import express, { Request } from 'express';
+import { z } from 'zod';
 import { getCourseQuery } from '../helpers/gql';
-const router = express.Router();
+import { publicProcedure, router } from '../helpers/trpc';
+import { CourseAAPIResponse, CourseBatchAAPIResponse, GradesRaw } from '@peterportal/types';
 
-/**
- * PPAPI proxy for course data
- */
-router.get('/api', (req: Request<never, unknown, never, { courseID: string }, never>, res) => {
-  const r = fetch(process.env.PUBLIC_API_URL + 'courses/' + encodeURIComponent(req.query.courseID), {
-    headers: {
-      'Content-Type': 'application/json',
-      Accept: 'application/json',
-    },
-  });
-  console.log(req.query.courseID);
-
-  r.then((response) => response.json()).then((data) => res.send(data.payload));
-});
-
-/**
- * PPAPI proxy for course data
- */
-router.post('/api/batch', (req: Request<never, unknown, { courses: string[] }, never>, res) => {
-  if (req.body.courses.length == 0) {
-    res.json({});
-  } else {
-    const r = fetch(process.env.PUBLIC_API_GRAPHQL_URL, {
-      method: 'POST',
+const coursesRouter = router({
+  /**
+   * PPAPI proxy for getting course data
+   */
+  get: publicProcedure.input(z.object({ courseID: z.string() })).query(async ({ input }) => {
+    const r = fetch(process.env.PUBLIC_API_URL + 'courses/' + encodeURIComponent(input.courseID), {
       headers: {
         'Content-Type': 'application/json',
+        Accept: 'application/json',
       },
-      body: JSON.stringify({
-        query: getCourseQuery(req.body.courses),
-      }),
     });
 
-    r.then((response) => response.json()).then((data) =>
-      res.json(
-        Object.fromEntries(
-          Object.values(data.data)
-            .filter((x) => x !== null)
-            .map((x) => [(x as { id: string }).id, x]),
-        ),
-      ),
-    );
-  }
-});
+    return r.then((response) => response.json()).then((data) => data.payload as CourseAAPIResponse);
+  }),
 
-/**
- * PPAPI proxy for grade distribution
- */
-router.get('/api/grades', (req: Request<never, unknown, never, { department: string; number: string }>, res) => {
-  const r = fetch(
-    process.env.PUBLIC_API_URL +
-      'grades/raw?department=' +
-      encodeURIComponent(req.query.department) +
-      '&courseNumber=' +
-      req.query.number,
-  );
+  /**
+   * PPAPI proxy for batch course data
+   */
+  batch: publicProcedure.input(z.object({ courses: z.string().array() })).mutation(async ({ input }) => {
+    if (input.courses.length == 0) {
+      return {};
+    } else {
+      const r = fetch(process.env.PUBLIC_API_GRAPHQL_URL!, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          query: getCourseQuery(input.courses),
+        }),
+      });
+
+      // change keys from _0,...,_x to course IDs
+      return r
+        .then((response) => response.json())
+        .then(
+          (data: CourseBatchAAPIResponse) =>
+            Object.fromEntries(
+              (Object.values(data.data) as CourseAAPIResponse[])
+                .filter((course) => course !== null)
+                .map((course) => [course.id, course]),
+            ) as CourseBatchAAPIResponse,
+        );
+    }
+  }),
+
+  /**
+   * PPAPI proxy for grade distribution
+   */
+  grades: publicProcedure.input(z.object({ department: z.string(), number: z.string() })).query(async ({ input }) => {
+    const r = fetch(
+      process.env.PUBLIC_API_URL +
+        'grades/raw?department=' +
+        encodeURIComponent(input.department) +
+        '&courseNumber=' +
+        input.number,
+    );
 
-  r.then((response) => response.json()).then((data) => {
-    res.send(data.payload);
-  });
+    return r.then((response) => response.json()).then((data) => data.payload as GradesRaw);
+  }),
 });
 
-export default router;
+export default coursesRouter;