d

Author: harshxraj

.gitignore

@@ -0,0 +1,4 @@
+frontend/.env
+backend/.env
+frontend/node_modules/
+backend/node_modules/

backend/controllers/auth.controller.js

@@ -0,0 +1,99 @@
+import bcrypt from "bcrypt";
+import jwt from "jsonwebtoken";
+import User from "../models/User.model.js";
+
+let emailRegex = /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/;
+
+export const signup = async (req, res) => {
+  const { fullname, email, password } = req.body;
+
+  if (fullname.length < 3) {
+    return res
+      .status(403)
+      .json({ error: "Fullname must be at least 3 letters or more;" });
+  }
+
+  if (!email.length) {
+    return res.status(403).json({ error: "Enter Email" });
+  }
+
+  if (!emailRegex.test(email)) {
+    return res.status(403).json({ error: "Email is invalid!" });
+  }
+
+  if (password.length < 6) {
+    return res
+      .status(403)
+      .json({ error: "Password must be at least 6 letters or more" });
+  }
+
+  try {
+    const existingUser = await User.findOne({ email: email });
+
+    if (existingUser) {
+      return res.status(500).json({ error: "Email already Exists" });
+    }
+
+    const hashedPassword = await bcrypt.hash(password, 5);
+
+    const newUser = new User({ fullname, email, password: hashedPassword });
+
+    const user = await newUser.save();
+
+    const access_token = jwt.sign({ id: user._id }, process.env.JWT_SECRET);
+
+    return res.status(201).json({
+      user: {
+        fullname: user.fullname,
+        email: user.email,
+      },
+      access_token,
+    });
+  } catch (error) {
+    res
+      .status(400)
+      .json({ error: "User creation failed", message: error.message });
+  }
+};
+
+export const signin = async (req, res) => {
+  try {
+    const { email, password } = req.body;
+
+    // Find the user by email
+    const existingUser = await User.findOne({ email: email });
+
+    if (!existingUser) {
+      return res.status(404).json({ error: "User not found!" });
+    }
+
+    // Compare passwords
+    bcrypt.compare(password, existingUser.password, (err, result) => {
+      if (err) {
+        return res
+          .status(500)
+          .json({ error: "Error occured while login, Please try again!" });
+      }
+      if (!result) {
+        return res.status(403).json({ error: "Incorrect password!" });
+      }
+
+      const access_token = jwt.sign(
+        { id: existingUser._id },
+        process.env.JWT_SECRET
+      );
+
+      return res.status(201).json({
+        user: {
+          fullname: existingUser.fullname,
+          email: existingUser.email,
+        },
+        access_token,
+      });
+    });
+  } catch (error) {
+    res
+      .status(500)
+      .json({ error: "Internal server error", message: error.message });
+  }
+};

backend/controllers/todo.controller.js

@@ -0,0 +1,38 @@
+import Todo from "../models/Todo.model.js";
+import User from "../models/User.model.js";
+
+export const getAllTodos = async (req, res) => {
+  try {
+    const user = await User.findOne({ _id: req.id }).populate("todos");
+
+    if (!user) {
+      return res.status(404).json({ message: "User not found" });
+    }
+
+    const simplifiedTodos = user.todos.map((todo) => ({
+      id: todo._id,
+      title: todo.title,
+      column: todo.column,
+    }));
+
+    return res.status(200).json(simplifiedTodos);
+  } catch (err) {
+    return res.status(500).json({ error: err.message });
+  }
+};
+
+export const createTodo = async (req, res) => {
+  try {
+    const { title, column } = req.body;
+    const newTodo = await Todo.create({ title, userId: req.id, column });
+    await newTodo.save();
+
+    const currentUser = await User.findById(req.id);
+    currentUser.todos.push(newTodo._id);
+    await currentUser.save();
+    res.status(201).json({ msg: "todo created", newTodo });
+  } catch (err) {
+    console.log(err);
+    return res.status(500).json({ error: err });
+  }
+};

backend/db/connection.js

@@ -0,0 +1,14 @@
+import mongoose from "mongoose";
+import "dotenv/config";
+
+const connection = async () => {
+  try {
+    mongoose.connect(process.env.MONGO_DB_URI, {
+      autoIndex: true,
+    });
+  } catch (err) {
+    console.log(err);
+  }
+};
+
+export default connection;

backend/index.js

@@ -0,0 +1,21 @@
+import express from "express";
+import cors from "cors";
+import "dotenv/config";
+import connection from "./db/connection.js";
+import authRouter from "./routes/auth.routes.js";
+import { auth } from "./middleware/auth.js";
+import todoRouter from "./routes/todo.routes.js";
+
+const server = express();
+const PORT = 3000;
+
+server.use(express.json());
+server.use(cors());
+
+server.use("/auth", authRouter);
+server.use("/todo", auth, todoRouter);
+
+server.listen(PORT, () => {
+  connection();
+  console.log(`Listening on port ${PORT}`);
+});

backend/middleware/auth.js

@@ -0,0 +1,19 @@
+import jwt from "jsonwebtoken";
+
+export const auth = (req, res, next) => {
+  const authorization_header = req.headers.authorization;
+  if (!authorization_header) {
+    return res.status(400).send({ msg: "Authorization header is missing" });
+  }
+  const token = authorization_header.split(" ")[1];
+
+  jwt.verify(token, process.env.JWT_SECRET, async function (err, decoded) {
+    if (decoded) {
+      const id = decoded.id;
+      req.id = id;
+      next();
+    } else {
+      return res.status(400).send({ msg: "Login first" });
+    }
+  });
+};

backend/models/Todo.model.js

@@ -0,0 +1,17 @@
+import mongoose, { Schema } from "mongoose";
+
+const todoSchema = mongoose.Schema(
+  {
+    title: { type: String, required: true },
+    userId: { type: Schema.Types.ObjectId, ref: "user" },
+    column: {
+      type: String,
+    },
+  },
+
+  {
+    timestamps: true,
+  }
+);
+
+export default mongoose.model("todo", todoSchema);

backend/models/User.model.js

@@ -0,0 +1,29 @@
+import mongoose, { Schema } from "mongoose";
+
+const userSchema = mongoose.Schema(
+  {
+    fullname: {
+      type: String,
+      lowercase: true,
+      required: true,
+      minlength: [3, "fullname must be 3 letters long"],
+    },
+    email: {
+      type: String,
+      required: true,
+      lowercase: true,
+      unique: true,
+    },
+    password: String,
+    todos: {
+      type: [Schema.Types.ObjectId],
+      ref: "todo",
+      default: [],
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+export default mongoose.model("user", userSchema);