Merge pull request #161 from cuappdev/aayush/refactor

Aayush/refactor

Author: Aayush-Agnihotri

.env_template

@@ -1,19 +1,11 @@
-ADMIN_EMAILS=
 DB_HOST=
 DB_NAME=
 DB_PASSWORD=
 DB_PORT=
 DB_USERNAME=
-HOST=
-IMAGE_UPLOAD_URL=
 IS_PROD=
-LOGGING=
-NODE_TLS_REJECT_UNAUTHORIZED=
-OAUTH_ANDROID_CLIENT=
-OAUTH_BACKEND_ID=
-OAUTH_CLIENT_SECRET=
-OAUTH_IOS_ID=
+FIREBASE_SERVICE_ACCOUNT_PATH=
 PORT=
+IMAGE_UPLOAD_URL=
 UPLOAD_BUCKET_NAME=
 UPLOAD_SIZE_LIMIT=
-FIREBASE_SERVICE_ACCOUNT_PATH=

.envrctemplate

@@ -1,18 +1,7 @@
 module.exports = {
-  preset: 'ts-jest',
-  testEnvironment: 'node',
-  roots: [
-    'src'
-  ],
-  moduleNameMapper: {
-    '^firebase-admin/messaging$': 'firebase-admin',
-  },
-  maxWorkers: 1,
-  //verbose: true
+  preset: "ts-jest",
+  testEnvironment: "node",
+  roots: ["src"],
+  maxWorkers: 4,
+  verbose: true,
 };
-
-process.env = Object.assign(process.env, {
-  ADMIN_EMAILS: 'appdevresell@gmail.com, maw346@cornell.edu, sn685@cornell.edu',
-  FIREBASE_SERVICE_ACCOUNT_PATH: '/Users/hover/OneDrive/Desktop/AppDev/secrets/firebase-admin-service-account.json'
-  
-});

jest.config.js

@@ -1,48 +1,61 @@
 // necessary immediate imports
-import 'reflect-metadata';
-import 'dotenv/config';
-
-
-import dotenv from 'dotenv';
-import { createExpressServer, ForbiddenError, UnauthorizedError, useContainer as routingUseContainer, HttpError } from 'routing-controllers';
-
-import { EntityManager, getManager, useContainer } from 'typeorm';
-import { Container } from 'typeorm-typedi-extensions';
-import { Express } from 'express';
-import * as swaggerUi from 'swagger-ui-express';
-import * as path from 'path';
-import * as admin from 'firebase-admin';
+import "reflect-metadata";
+import "dotenv/config";
+
+import dotenv from "dotenv";
+import {
+  createExpressServer,
+  ForbiddenError,
+  UnauthorizedError,
+  useContainer as routingUseContainer,
+  HttpError,
+} from "routing-controllers";
+
+import { EntityManager, getManager, useContainer } from "typeorm";
+import { Container } from "typeorm-typedi-extensions";
+import { Express } from "express";
+import * as swaggerUi from "swagger-ui-express";
+import * as path from "path";
+import * as admin from "firebase-admin";
 
 dotenv.config();
 
+console.log(
+  "FIREBASE_SERVICE_ACCOUNT_PATH:",
+  process.env.FIREBASE_SERVICE_ACCOUNT_PATH,
+);
 var serviceAccountPath = process.env.FIREBASE_SERVICE_ACCOUNT_PATH!;
 const serviceAccount = require(serviceAccountPath);
 
 if (!serviceAccountPath) {
-  throw new Error('FIREBASE_SERVICE_ACCOUNT_PATH environment variable is not set.');
+  throw new Error(
+    "FIREBASE_SERVICE_ACCOUNT_PATH environment variable is not set.",
+  );
 }
 
 if (!admin.apps.length) {
   admin.initializeApp({
     credential: admin.credential.cert(serviceAccount),
-  
   });
 }
 
-
-export { admin };  // Export the admin instance
-
-import { controllers } from './api/controllers';
-import { middlewares } from './api/middlewares';
-import { UserModel } from './models/UserModel';
-import { ReportPostRequest, ReportProfileRequest, ReportMessageRequest } from './types';
-import { GetReportsResponse, Report } from './types/ApiResponses';
-import { ReportController } from './api/controllers/ReportController';
-import resellConnection from './utils/DB';
-import { ReportService } from './services/ReportService';
-import { ReportRepository } from './repositories/ReportRepository';
-import { reportToString } from './utils/Requests';
-import { CurrentUserChecker } from 'routing-controllers/types/CurrentUserChecker';
+export { admin }; // Export the admin instance
+
+import { controllers } from "./api/controllers";
+import { middlewares } from "./api/middlewares";
+import { UserModel } from "./models/UserModel";
+import {
+  ReportPostRequest,
+  ReportProfileRequest,
+  ReportMessageRequest,
+} from "./types";
+import { GetReportsResponse, Report } from "./types/ApiResponses";
+import { ReportController } from "./api/controllers/ReportController";
+import resellConnection from "./utils/DB";
+import { ReportService } from "./services/ReportService";
+import { ReportRepository } from "./repositories/ReportRepository";
+import { reportToString } from "./utils/Requests";
+import { CurrentUserChecker } from "routing-controllers/types/CurrentUserChecker";
 // import { getLoadedModel } from './utils/SentenceEncoder';
 
 dotenv.config();
@@ -61,16 +74,16 @@ async function main() {
 
   const app: Express = createExpressServer({
     cors: true,
-    routePrefix: '/api/',
+    routePrefix: "/api/",
     controllers: controllers,
     middlewares: middlewares,
     currentUserChecker: async (action: any) => {
-      console.log('AUTH MIDDLEWARE CALLED for path:', action.request.path);
+      console.log("AUTH MIDDLEWARE CALLED for path:", action.request.path);
       const authHeader = action.request.headers["authorization"];
       if (!authHeader) {
         throw new ForbiddenError("No authorization token provided");
       }
-      const token = authHeader.split(' ')[1];
+      const token = authHeader.split(" ")[1];
       if (!token) {
         throw new ForbiddenError("Invalid authorization token format");
       }
@@ -84,22 +97,30 @@ async function main() {
         console.log("uid");
         action.request.firebaseUid = userId;
         console.log("here");
-        if (!email || !email.endsWith('@cornell.edu')) {
-          throw new ForbiddenError('Only Cornell email addresses are allowed');
+        if (!email || !email.endsWith("@cornell.edu")) {
+          throw new ForbiddenError("Only Cornell email addresses are allowed");
         }
         // Find or create user in your database using Firebase UID
-        const manager = getManager(); 
-        let user = await manager.findOne(UserModel, { firebaseUid: userId }, 
-          { relations: ["posts", "saved", "feedbacks", "requests"] });
+        const manager = getManager();
+        let user = await manager.findOne(
+          UserModel,
+          { firebaseUid: userId },
+          { relations: ["posts", "saved", "feedbacks", "requests"] },
+        );
         if (!user) {
           // Check if this is the user creation route or authorization route
-          const isUserCreateRoute = action.request.path === '/api/user/create/' || 
-                                   action.request.path === '/api/user/create' || 
-                                   action.request.path === '/api/authorize' ||
-                                   action.request.path === 'api/authorize';
-          console.log(`User not found for path: ${action.request.path}, isUserCreateRoute: ${isUserCreateRoute}`);
+          const isUserCreateRoute =
+            action.request.path === "/api/user/create/" ||
+            action.request.path === "/api/user/create" ||
+            action.request.path === "/api/authorize" ||
+            action.request.path === "api/authorize";
+          console.log(
+            `User not found for path: ${action.request.path}, isUserCreateRoute: ${isUserCreateRoute}`,
+          );
           if (!isUserCreateRoute) {
-            throw new ForbiddenError('User not found. Please create an account first.');
+            throw new ForbiddenError(
+              "User not found. Please create an account first.",
+            );
           }
           // For user creation routes, return a minimal UserModel
           const tempUser = new UserModel();
@@ -109,24 +130,27 @@ async function main() {
           tempUser.username = `temp_${decodedToken.uid}`;
           tempUser.isActive = true;
           tempUser.admin = false;
-          tempUser.isNewUser = true; 
+          tempUser.isNewUser = true;
           return tempUser;
-        } 
+        }
         if (!user) {
-          throw new ForbiddenError('User authentication failed');
+          throw new ForbiddenError("User authentication failed");
         }
         return user;
       } catch (error) {
         if (error instanceof ForbiddenError) {
           throw error;
         }
-        if (error.code == 'auth/argument-error'){
-          throw new HttpError(408, 'Request timed out while waiting for response');
+        if (error.code == "auth/argument-error") {
+          throw new HttpError(
+            408,
+            "Request timed out while waiting for response",
+          );
         }
-        if (error.code === 'auth/id-token-expired') {
-          throw new UnauthorizedError('Token has expired');
+        if (error.code === "auth/id-token-expired") {
+          throw new UnauthorizedError("Token has expired");
         }
-        throw new UnauthorizedError('Invalid authorization token');
+        throw new UnauthorizedError("Invalid authorization token");
       }
     },
     defaults: {
@@ -142,26 +166,27 @@ async function main() {
     defaultErrorHandler: false,
   });
 
-  const host = process.env.HOST ?? 'localhost';
   const port = process.env.PORT ?? 3000;
 
-  const swaggerDocument = require(path.join(__dirname, '../swagger.json'));
-  app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerDocument));
-  console.log(`Swagger documentation available at http://${host}:${port}/api-docs`);
-  
+  const swaggerDocument = require(path.join(__dirname, "../swagger.json"));
+  app.use("/api-docs", swaggerUi.serve, swaggerUi.setup(swaggerDocument));
+  console.log(
+    `Swagger documentation available at http://localhost:${port}/api-docs`,
+  );
+
   const entityManager = getManager();
   const reportService = new ReportService(entityManager);
   const reportController = new ReportController(reportService);
 
-  app.set('view engine', 'pug')
+  app.set("view engine", "pug");
 
-  app.get('/api/reports/admin/', async (req: any, res: any) => {
+  app.get("/api/reports/admin/", async (req: any, res: any) => {
     const userCheck = async (action: any) => {
       const authHeader = req.headers["authorization"];
       if (!authHeader) {
         throw new ForbiddenError("No authorization token provided");
       }
-      const token = authHeader.split(' ')[1];
+      const token = authHeader.split(" ")[1];
       if (!token) {
         throw new ForbiddenError("Invalid authorization token format");
       }
@@ -174,25 +199,26 @@ async function main() {
         if (!user || !user.admin) throw new ForbiddenError("User unauthorized");
         return user;
       } catch (error) {
-        if (error.code === 'auth/id-token-expired') {
-          throw new UnauthorizedError('Token has expired');
+        if (error.code === "auth/id-token-expired") {
+          throw new UnauthorizedError("Token has expired");
         }
-        throw new UnauthorizedError('Invalid authorization token');
+        throw new UnauthorizedError("Invalid authorization token");
       }
-    }
+    };
     const user = await userCheck(req);
     user.admin = true;
     const postReports = await reportController.getAllPostReports(user);
     const profileReports = await reportController.getAllProfileReports(user);
     const messageReports = await reportController.getAllMessageReports(user);
-    res.render('admin', { 
-      postReports: reportToString(postReports), 
-      profileReports: reportToString(profileReports), 
-      messageReports: reportToString(messageReports) });
+    res.render("admin", {
+      postReports: reportToString(postReports),
+      profileReports: reportToString(profileReports),
+      messageReports: reportToString(messageReports),
+    });
   });
-  
+
   app.listen(port, () => {
-    console.log(`Resell backend bartering on ${host}:${port}`);
+    console.log(`Resell backend bartering on http://localhost:${port}`);
   });
 }
 

src/app.ts

@@ -1,27 +1,25 @@
-import { Connection, createConnection } from 'typeorm';
+import { Connection, createConnection } from "typeorm";
 // import { models } from '../models';
 
 export default async function resellConnection(): Promise<Connection> {
-  const entitiesPath = __dirname + '/../models/*Model.ts';
+  const entitiesPath = __dirname + "/../models/*Model.ts";
   return await createConnection({
-    database: process.env.DB_NAME || 'resell-test',
+    database: process.env.DB_NAME || "resell-test",
     entities: [entitiesPath],
     host: process.env.DB_HOST,
-    logging: (process.env.LOGGING?.toLowerCase() === "true"), //set to true to help with debugging
+    logging: true,
     password: process.env.DB_PASSWORD,
     port: +(process.env.DB_PORT || 5432),
     synchronize: true,
-    type: 'postgres',
-    username: process.env.DB_USERNAME || 'postgres',
+    type: "postgres",
+    username: process.env.DB_USERNAME || "postgres",
     extra: {
-      ssl: (process.env.IS_PROD?.toLowerCase() === "true"),
+      ssl: process.env.IS_PROD?.toLowerCase() === "true",
     },
-    migrations: [
-      'src/migrations/*.ts',
-    ],
+    migrations: ["src/migrations/*.ts"],
     cli: {
-      entitiesDir: 'src/models/',
-      migrationsDir: 'src/migrations',
+      entitiesDir: "src/models/",
+      migrationsDir: "src/migrations",
     },
   });
 }