Devops

backend/.babelrc

@@ -1,3 +1,3 @@
 {
   "presets": ["@babel/preset-env"]
-}
+}

backend/.env.sample

@@ -1,2 +1,2 @@
-MONGODB_URI="mongodb://127.0.0.1/wanderlust"
-REDIS_URL="127.0.0.1:6379"
+MONGODB_URI="mongodb://mongo/wanderlust"
+CORS_ORIGIN="http://3.136.26.144:5000"

backend/Dockerfile

@@ -0,0 +1,37 @@
+#------------- stage1------------
+FROM node:22 AS backend-builder
+
+# setup the working dir
+WORKDIR /app
+
+# code
+COPY . .
+
+
+# package install
+RUN npm i
+
+# Test
+#RUN npm run test
+
+#-------------- stage2-------------
+
+FROM node:22-slim
+
+#setup the working dir
+WORKDIR /app
+
+# copy the above stage as compressed
+COPY --from=backend-builder /app .
+
+COPY .env.sample .env
+
+#port
+EXPOSE 5000
+
+CMD ["npm", "start"]
+
+
+
+
+

backend/config/utils.js

@@ -4,5 +4,21 @@ dotenv.config();
 const PORT = process.env.PORT;
 const MONGODB_URI = process.env.MONGODB_URI;
 const REDIS_URL = process.env.REDIS_URL;
+const ACCESS_COOKIE_MAXAGE = process.env.ACCESS_COOKIE_MAXAGE;
+const ACCESS_TOKEN_EXPIRES_IN = process.env.ACCESS_TOKEN_EXPIRES_IN;
+const REFRESH_COOKIE_MAXAGE = process.env.REFRESH_COOKIE_MAXAGE;
+const REFRESH_TOKEN_EXPIRES_IN = process.env.REFRESH_TOKEN_EXPIRES_IN;
+const JWT_SECRET = process.env.JWT_SECRET;
+const FRONTEND_URL = process.env.FRONTEND_URL;
 
-export { MONGODB_URI, PORT, REDIS_URL };
+export {
+  MONGODB_URI,
+  PORT,
+  REDIS_URL,
+  ACCESS_COOKIE_MAXAGE,
+  ACCESS_TOKEN_EXPIRES_IN,
+  REFRESH_COOKIE_MAXAGE,
+  REFRESH_TOKEN_EXPIRES_IN,
+  JWT_SECRET,
+  FRONTEND_URL,
+};

backend/controllers/auth-controller.js

@@ -4,6 +4,7 @@ import jwt from 'jsonwebtoken';
 import axios from 'axios';
 import { HTTP_STATUS, RESPONSE_MESSAGES } from '../utils/constants.js';
 import { accessCookieOptions, refreshCookieOptions } from '../utils/cookie_options.js';
+import { ACCESS_TOKEN_EXPIRES_IN, JWT_SECRET, REFRESH_TOKEN_EXPIRES_IN } from '../config/utils.js';
 const { hash, compareSync } = bcrypt;
 const { sign } = jwt;
 
@@ -15,17 +16,23 @@ export const signUpWithEmail = async (req, res, next) => {
     if (!name || !email || !password) {
       throw new Error('All fields are required.');
     }
-    const isExisitsUser = await User.findOne({ email });
-    if (isExisitsUser) {
-      throw new Error('User already exists.');
+    const isExisitsUserName = await User.findOne({ name });
+
+    if (isExisitsUserName) {
+      throw new Error('Name already exists.');
+    } else {
+      const isExisitsUserEmail = await User.findOne({ email });
+      if (isExisitsUserEmail) {
+        throw new Error('Email already exists.');
+      }
     }
     const hashedPassword = await hash(password, 10);
     const newUser = await User.create({ name, email, password: hashedPassword });
-    const accessToken = sign({ name, _id: newUser._id }, process.env.JWT_SECRET, {
-      expiresIn: process.env.ACCESS_TOKEN_EXPIRES_IN,
+    const accessToken = sign({ name, _id: newUser._id, role: newUser.role }, JWT_SECRET, {
+      expiresIn: ACCESS_TOKEN_EXPIRES_IN,
     });
-    const refreshToken = sign({ name, _id: newUser._id }, process.env.JWT_SECRET, {
-      expiresIn: process.env.REFRESH_TOKEN_EXPIRES_IN,
+    const refreshToken = sign({ name, _id: newUser._id, role: newUser.role }, JWT_SECRET, {
+      expiresIn: REFRESH_TOKEN_EXPIRES_IN,
     });
     res.cookie('access_token', accessToken, accessCookieOptions);
     res.cookie('refresh_token', refreshToken, refreshCookieOptions);
@@ -60,19 +67,20 @@ export const signInWithEmail = async (req, res, next) => {
     }
     let accessToken;
     let refreshToken;
+
     if (isUserExists && compareSync(password, isUserExists.password)) {
       accessToken = sign(
-        { name: isUserExists.name, _id: isUserExists._id },
-        process.env.JWT_SECRET,
+        { name: isUserExists.name, _id: isUserExists._id, role: isUserExists.role },
+        JWT_SECRET,
         {
-          expiresIn: process.env.ACCESS_TOKEN_EXPIRES_IN,
+          expiresIn: ACCESS_TOKEN_EXPIRES_IN,
         }
       );
       refreshToken = sign(
-        { name: isUserExists.name, _id: isUserExists._id },
-        process.env.JWT_SECRET,
+        { name: isUserExists.name, _id: isUserExists._id, role: isUserExists.role },
+        JWT_SECRET,
         {
-          expiresIn: process.env.REFRESH_TOKEN_EXPIRES_IN,
+          expiresIn: REFRESH_TOKEN_EXPIRES_IN,
         }
       );
       res.cookie('access_token', accessToken, accessCookieOptions);
@@ -94,6 +102,7 @@ export const signInWithEmail = async (req, res, next) => {
     res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json({
       success: false,
       message: error.message,
+      error,
     });
   }
 };
@@ -377,8 +386,8 @@ export const signInWithGithub = async (req, res, next) => {
 //Sign Out
 export const signOutUser = async (req, res, next) => {
   try {
-    res.cookie('access_token', '', { maxAge: 1 });
-    res.cookie('refresh_token', '', { maxAge: 1 });
+    res.cookie('access_token', '', { maxAge: 0 });
+    res.cookie('refresh_token', '', { maxAge: 0 });
 
     res.status(200).json({ success: true, message: RESPONSE_MESSAGES.USERS.SIGNED_OUT });
   } catch (error) {

backend/controllers/posts-controller.js

@@ -1,4 +1,5 @@
 import Post from '../models/post.js';
+import User from '../models/user.js';
 import {
   deleteDataFromCache,
   retrieveDataFromCache,
@@ -16,6 +17,8 @@ export const createPostHandler = async (req, res) => {
       isFeaturedPost = false,
     } = req.body;
 
+    const userId = req.user._id;
+
     // Validation - check if all fields are filled
     if (!title || !authorName || !imageLink || !description || !categories) {
       return res
@@ -45,6 +48,7 @@ export const createPostHandler = async (req, res) => {
       description,
       categories,
       isFeaturedPost,
+      authorId: req.user._id,
     });
 
     const [savedPost] = await Promise.all([
@@ -54,6 +58,9 @@ export const createPostHandler = async (req, res) => {
       deleteDataFromCache(REDIS_KEYS.LATEST_POSTS), // Invalidate cache for latest posts
     ]);
 
+    // updating user doc to include the ObjectId of the created post
+    await User.findByIdAndUpdate(userId, { $push: { posts: savedPost._id } });
+
     res.status(HTTP_STATUS.OK).json(savedPost);
   } catch (err) {
     res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json({ message: err.message });
@@ -147,6 +154,7 @@ export const deletePostByIdHandler = async (req, res) => {
     if (!post) {
       return res.status(HTTP_STATUS.NOT_FOUND).json({ message: RESPONSE_MESSAGES.POSTS.NOT_FOUND });
     }
+    await User.findByIdAndUpdate(post.authorId, { $pull: { posts: req.params.id } });
 
     res.status(HTTP_STATUS.OK).json({ message: RESPONSE_MESSAGES.POSTS.DELETED });
   } catch (err) {

backend/controllers/user-controller.js

@@ -0,0 +1,52 @@
+import { HTTP_STATUS, RESPONSE_MESSAGES } from '../utils/constants.js';
+import User from '../models/user.js';
+
+export const getAllUserHandler = async (req, res) => {
+  try {
+    const users = await User.find().select('_id name email');
+    return res.status(HTTP_STATUS.OK).json({ users });
+  } catch (error) {
+    res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json({ message: err.message });
+  }
+};
+
+export const changeUserRoleHandler = async (req, res) => {
+  try {
+    const userId = req.params.userId;
+    const { role } = req.body;
+    if (role === 'user' || role === 'admin') {
+      const user = await User.findById(userId);
+      if (!user)
+        return res
+          .status(HTTP_STATUS.NOT_FOUND)
+          .json({ message: RESPONSE_MESSAGES.USERS.USER_NOT_EXISTS });
+      user.role = role;
+      user.save();
+    } else {
+      return res
+        .status(HTTP_STATUS.BAD_REQUEST)
+        .json({ message: RESPONSE_MESSAGES.COMMON.REQUIRED_FIELDS });
+    }
+    return res.status(HTTP_STATUS.OK).json({ message: RESPONSE_MESSAGES.USERS.UPDATE });
+  } catch (error) {
+    res
+      .status(HTTP_STATUS.INTERNAL_SERVER_ERROR)
+      .json({ message: RESPONSE_MESSAGES.COMMON.INTERNAL_SERVER_ERROR });
+  }
+};
+
+export const deleteUserHandler = async (req, res) => {
+  try {
+    const userId = req.params.userId;
+    const user = await User.findByIdAndDelete(userId);
+    if (!user)
+      return res
+        .status(HTTP_STATUS.NOT_FOUND)
+        .json({ message: RESPONSE_MESSAGES.USERS.USER_NOT_EXISTS });
+    res.status(HTTP_STATUS.NO_CONTENT).json({ message: RESPONSE_MESSAGES.USERS.DELETED });
+  } catch (error) {
+    res
+      .status(HTTP_STATUS.INTERNAL_SERVER_ERROR)
+      .json({ message: RESPONSE_MESSAGES.COMMON.INTERNAL_SERVER_ERROR });
+  }
+};

backend/middlewares/auth-middleware.js

@@ -0,0 +1,45 @@
+import { JWT_SECRET } from '../config/utils.js';
+import { HTTP_STATUS, RESPONSE_MESSAGES } from '../utils/constants.js';
+import jwt from 'jsonwebtoken';
+
+export const authMiddleware = async (req, res, next) => {
+  const authHeader = req.headers.access_token;
+
+  if (authHeader) {
+    const token = authHeader.split(' ')[1];
+
+    jwt.verify(token, JWT_SECRET, (error, payload) => {
+      if (error) {
+        return res.status(HTTP_STATUS.FORBIDDEN).json({
+          success: false,
+          message: RESPONSE_MESSAGES.USERS.INVALID_TOKEN,
+        });
+      }
+      req.user = payload;
+      next();
+    });
+  } else {
+    return res.status(HTTP_STATUS.UNAUTHORIZED).json({
+      success: false,
+      message: RESPONSE_MESSAGES.USERS.UNAUTHORIZED_USER,
+    });
+  }
+};
+
+export const isAdminMiddleware = async (req, res, next) => {
+  try {
+    const role = req.user.role;
+    if (role !== 'admin') {
+      return res.status(HTTP_STATUS.UNAUTHORIZED).json({
+        success: false,
+        message: RESPONSE_MESSAGES.USERS.UNAUTHORIZED_USER,
+      });
+    }
+    next();
+  } catch (error) {
+    return res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json({
+      success: 'fail',
+      message: error.message,
+    });
+  }
+};

backend/middlewares/post-middleware.js

@@ -0,0 +1,23 @@
+import Post from '../models/post.js';
+import { HTTP_STATUS, RESPONSE_MESSAGES } from '../utils/constants.js';
+
+export const isAuthorMiddleware = async (req, res, next) => {
+  try {
+    const userId = req.user._id;
+    const postId = req.params.id;
+    const post = await Post.findById(postId);
+    if (!post) {
+      return res.status(HTTP_STATUS.NOT_FOUND).json({ message: RESPONSE_MESSAGES.POSTS.NOT_FOUND });
+    }
+
+    console.log(post.authorId, userId);
+    if (post.authorId.toString() !== userId) {
+      return res
+        .status(HTTP_STATUS.FORBIDDEN)
+        .json({ message: RESPONSE_MESSAGES.POSTS.NOT_ALLOWED });
+    }
+    next();
+  } catch (error) {
+    res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json({ message: err.message });
+  }
+};

backend/models/post.js

@@ -1,4 +1,4 @@
-import { Schema, model } from 'mongoose';
+import mongoose, { Schema, model } from 'mongoose';
 
 const postSchema = new Schema({
   authorName: String,
@@ -8,6 +8,11 @@ const postSchema = new Schema({
   description: String,
   isFeaturedPost: Boolean,
   timeOfPost: { type: Date, default: Date.now },
+  authorId: {
+    type: Schema.Types.ObjectId,
+    ref: 'User',
+    required: true,
+  },
 });
 
 export default model('Post', postSchema);

backend/models/user.js

@@ -21,7 +21,7 @@ const userSchema = new Schema({
     type: String,
     default: 'user',
   },
-  createdPosts: [{ type: Schema.Types.ObjectId, ref: 'Post' }],
+  posts: [{ type: Schema.Types.ObjectId, ref: 'Post' }],
 });
 
 export default model('User', userSchema);