Merge branch 'backend' into feature/STR-81-login-signup-for-users

rxmox · web-flow · commit 253cc20cefd3 · 2025-11-20T14:14:52.000-07:00
diff --git a/.github/workflows/backend.yml b/.github/workflows/backend.yml
diff --git a/.github/workflows/cd-backend.yml b/.github/workflows/cd-backend.yml
@@ -0,0 +1,57 @@
+name: CD - Deploy Backend
+
+on:
+  workflow_dispatch:
+    inputs:
+      build_number:
+        description: 'CI Build Number'
+        required: true
+        type: string
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Download build artifact from CI workflow
+        env:
+          GH_TOKEN: ${{ secrets.PAT_TOKEN }}
+        run: |
+          echo "Fetching artifact for build #${{ inputs.build_number }}"
+          
+          CI_RUN_ID=$(gh run list --workflow "CI - Build Backend" --json databaseId,number -q ".[] | select(.number == ${{ inputs.build_number }}) | .databaseId")
+          
+          if [ -z "$CI_RUN_ID" ]; then
+            echo "Could not find CI run with build number ${{ inputs.build_number }}"
+            exit 1
+          fi
+          
+          echo "Found CI run ID: $CI_RUN_ID"
+          gh run download $CI_RUN_ID --name node-backend-${{ inputs.build_number }}
+          ls -l
+
+      - name: Extract artifact
+        run: |
+          tar -xzf node-backend-${{ inputs.build_number }}.tar.gz
+          ls -la output
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+
+      - name: Install Vercel CLI
+        run: npm install -g vercel
+
+      - name: Deploy to Vercel
+        env:
+          VERCEL_TOKEN: ${{ secrets.VERCEL_TOKEN }}
+          VERCEL_ORG_ID: ${{ secrets.VERCEL_ORG_ID_BACKEND }}
+          VERCEL_PROJECT_ID: ${{ secrets.VERCEL_PROJECT_ID_BACKEND }}
+        run: |
+          cd output
+          vercel pull --yes --environment=production --token=$VERCEL_TOKEN
+          vercel deploy --prod --token=$VERCEL_TOKEN
diff --git a/.github/workflows/ci-backend.yml b/.github/workflows/ci-backend.yml
@@ -0,0 +1,49 @@
+name: CI - Build Backend
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'shatter-backend/**'
+
+  pull_request:
+    branches: [main]
+    paths:
+      - 'shatter-backend/**'
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+
+      - name: Install dependencies
+        run: |
+            cd shatter-backend
+            npm ci
+
+      - name: Build project
+        run: |
+            cd shatter-backend   
+            npm run build
+
+      - name: Package build artifacts
+        run: |
+            cd shatter-backend
+            mkdir output
+            cp -r dist package.json package-lock.json vercel.json output/
+            tar -czf node-backend-${{ github.run_number }}.tar.gz output
+            mv node-backend-${{ github.run_number }}.tar.gz $GITHUB_WORKSPACE/
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: node-backend-${{ github.run_number }}
+          path: node-backend-${{ github.run_number }}.tar.gz
diff --git a/shatter-backend/.gitignore b/shatter-backend/.gitignore
@@ -24,3 +24,4 @@ dist-ssr
 *.sw?
 
 .env
+.vercel
diff --git a/shatter-backend/api/index.ts b/shatter-backend/api/index.ts
@@ -0,0 +1,71 @@
+import 'dotenv/config';
+import mongoose from 'mongoose';
+import app from '../src/app';
+
+const MONGODB_URI = process.env.MONGO_URI;
+
+let connectionPromise: Promise<void> | null = null;
+
+async function connectDB() {
+  if (mongoose.connection.readyState === 1) {
+    return;
+  }
+
+  if (mongoose.connection.readyState !== 0) {
+    await mongoose.disconnect();
+    connectionPromise = null;
+  }
+
+  if (connectionPromise) {
+    return connectionPromise;
+  }
+
+  if (!MONGODB_URI) {
+    throw new Error('MONGO_URI is not set in environment variables');
+  }
+
+  connectionPromise = (async () => {
+    try {   
+      await mongoose.connect(MONGODB_URI, {
+        maxPoolSize: 10,
+        minPoolSize: 2,
+        maxIdleTimeMS: 30000,
+        serverSelectionTimeoutMS: 5000,
+        socketTimeoutMS: 45000,
+      });
+
+      mongoose.connection.on('error', (err) => {
+        console.error('MongoDB connection error:', err);
+        connectionPromise = null;
+      });
+
+      mongoose.connection.on('disconnected', () => {
+        console.log('MongoDB disconnected');
+        connectionPromise = null;
+      });
+
+    } catch (error) {
+      console.error('Failed to connect to MongoDB:', error);
+      connectionPromise = null;
+      throw error;
+    }
+  })();
+
+  return connectionPromise;
+}
+
+connectDB().catch(console.error);
+
+app.use(async (req, res, next) => {
+  try {
+    await connectDB();
+    next();
+  } catch (error: any) {
+    res.status(500).json({ 
+      error: 'Database connection failed',
+      message: error.message
+    });
+  }
+});
+
+export default app;
diff --git a/shatter-backend/src/app.ts b/shatter-backend/src/app.ts
@@ -1,29 +1,16 @@
-// Express framework gives us fucnctions to creeate web server, handle routes, process HTTP req and send responses
 import express from 'express';
-import userRoutes from './routes/user_route.ts'; // these routes define how to handel requests to /api/users
+import userRoutes from './routes/user_route'; // these routes define how to handle requests to /api/users
 import authRoutes from './routes/auth_routes';
 
-// Creating express application as a single "app" object, started in server.ts
-// This object represents entire web server and will be used to:
-// register Middleware, define routes ....
 const app = express();
 
-// Middleware setup
-// responsible for parsing incoming JSON request bodies, making req.body usable in controllers
 app.use(express.json());
 
-// Defining routes
-// a simple route that sends back plain text "Hello" when anyone visits the app in browser
 app.get('/', (_req, res) => {
   res.send('Hello');
 });
 
-// Mounts the user routes under the path 'api/users'
-// any routes defined in user_route.ts will be accessible with URLs starting with /api/users
 app.use('/api/users', userRoutes);
 app.use('/api/auth', authRoutes);
 
-
-// Export the configured Express app, so that server.ts can import it
-// Keeping app setup separate from server startup makes the code modular and testable
 export default app;
diff --git a/shatter-backend/src/controllers/user_controller.ts b/shatter-backend/src/controllers/user_controller.ts
@@ -1,50 +1,41 @@
-// import req and res types for type safety
-import { Request, Response } from 'express';
-import { User } from '../models/user_model.ts'; // imports user model created with mongoose
+import { Request, Response } from "express";
+import { User } from "../models/user_model";
 
 // controller: GET /api/users
 // This function handles GET reqs to /api/users
 // It fetches all users from MongoDB and sends them as json
 
 export const getUsers = async (_req: Request, res: Response) => {
-    try {
-	// retrieves all docs from "users" collection
-	const users = await User.find().lean(); // .lean() returns plain JS objects instead of Mongoose docs, may change incase we need extra model methods later
-	res.json(users); // sends list of users back as JSON response
-    } catch (err) { // log the error if something goes wrong
-	console.error('GET /api/users error:', err);
-	res.status(500).json({ error: 'Failed to fetch users' });
-    }
+  try {
+    const users = await User.find().lean();
+    res.json(users); 
+  } catch (err: any) {
+    console.error("GET /api/users error:", err);
+    res.status(500).json({
+      error: "Failed to fetch users",
+      message: err.message,
+    });
+  }
 };
 
-
 // controller: POST /api/users
 // reads data from req body, vailidates it and creates a new user
 export const createUser = async (req: Request, res: Response) => {
-    try {
-	// Destructure the req body sent by the client
-	// The ?? {} ensures we don't get error if req.body is undefined
-	const { name, email } = req.body ?? {};
+  try {
+    const { name, email } = req.body ?? {};
 
-	// Basic validation to ensure both name and email are provided
-	// if not respond with bad request and stop further processes
-	if (!name || !email) {
-	    return res.status(400).json({ error: 'name and email required' });
-	}
+    if (!name || !email) {
+      return res.status(400).json({ error: "name and email required" });
+    }
 
-	// create a new user doc in DB using Mongoose's .create()
-	const user = await User.create({ name, email });
-	// respond with "created" and send back created user as JSON
-	res.status(201).json(user);
-    } catch(err: any) {
-	// Handle duplicate email error
-	// Mongo DB rejects duplicat value since we have email marked as 'unique'
-	if (err?.code === 11000) {
-	    return res.status(409).json({ error: 'email already exists' });
-	}
-	
-	// for all other errors, log them and return generic 500 response
-	console.error('POST /api/users error:', err);
-	res.status(500).json({error: 'Failed to create user' });
+    const user = await User.create({ name, email });
+    res.status(201).json(user);
+  } catch (err: any) {
+    if (err?.code === 11000) {
+      return res.status(409).json({ error: "email already exists" });
     }
+
+    console.error("POST /api/users error:", err);
+    res.status(500).json({ error: "Failed to create user" });
+  }
 };
diff --git a/shatter-backend/src/routes/user_route.ts b/shatter-backend/src/routes/user_route.ts
@@ -1,16 +1,9 @@
-// router is like a mini-express app that allows grouping of related routes together
 import { Router } from 'express';
-import { getUsers, createUser } from '../controllers/user_controller.ts';
-// Importing controller functions that handle logic for each route
-// These function define what happens when a req is received
+import { getUsers, createUser } from '../controllers/user_controller';
 
-// creating new router instance
 const router = Router();
 
-// Defining routes for the /api/users path
-router.get('/', getUsers);    // when GET req is made, run getUsers func
-router.post('/', createUser); // when POST req is made, run creatUser func
+router.get('/', getUsers);    
+router.post('/', createUser); 
 
-// Export the router so it can be used in app.ts
-// app.ts imports router and mounts it under '/api/users'
 export default router;
diff --git a/shatter-backend/src/server.ts b/shatter-backend/src/server.ts
@@ -1,31 +1,26 @@
-// This is the main entry point that starts the application
-
-import 'dotenv/config';           // loads .env file and populates process.env (the node.js object)
-import mongoose from 'mongoose';  // mongoose is an Object Data Modelling (ODM) livrary for MongoDB
-import app from './app.ts';       // Import the express app
-
+import 'dotenv/config';        
+import mongoose from 'mongoose';  
+import app from './app';       
 
 // config
+const PORT = process.env.PORT ? Number(process.env.PORT) : 4000; 
+const MONGODB_URI = process.env.MONGO_URI;                       
 
-const PORT = process.env.PORT ? Number(process.env.PORT) : 4000; // use defined PORT in .env if present , otherwise default to 400
-const MONGODB_URI = process.env.MONGO_URI;                       // read the mongoDB connection from env variables
-
-// Start up function
 async function start() {
     try {
-	if (!MONGODB_URI) {                            // check that MOGO URI is provided in .env
+	if (!MONGODB_URI) {                           
 	    throw new Error('MONGODB_URI is not set'); 
 	}
-	await mongoose.connect(MONGODB_URI);  // this returns a promise, so we 'await' until it's successfully connected
+	await mongoose.connect(MONGODB_URI); 
 	console.log('Successfully connected to MongoDB');
 
 	// start listening for incoming HTTP requests on chosen port
 	app.listen(PORT, () => {
 	    console.log('Server running on http://localhost:${PORT}');
 	});
-    } catch (err) {           		             // if connection goes wrong, log the error
+    } catch (err) {           		           
 	console.error('Failed to start server:', err);
-	process.exit(1);    // code 1 indicates failure
+	process.exit(1);   
     }
 }
 
diff --git a/shatter-backend/tsconfig.json b/shatter-backend/tsconfig.json
diff --git a/shatter-backend/vercel.json b/shatter-backend/vercel.json

Original file line number	Diff line number	Diff line change
`@@ -24,3 +24,4 @@ dist-ssr`
`24`	`24`	`*.sw?`
`25`	`25`
`26`	`26`	`.env`
	`27`	`+.vercel`