Project-final-irisdgz

README.md

@@ -1,13 +1,35 @@
-# Final Project
+# MiniStops
 
-Replace this readme with your own information about your project.
+A web application that helps parents quickly find baby-changing facilities nearby.
 
-Start by briefly describing the assignment in a sentence or two. Keep it short and to the point.
+## View it live
+- Frontend: https://project-final-irisdgz-1.onrender.com
+- Backend API: https://project-final-irisdgz.onrender.com
 
 ## The problem
+As a parent of a toddler, finding a clean and accessible place to change a diaper can be tricky. MiniStops makes this easier by showing nearby changing facilities and allowing parents to share information about them.
 
-Describe how you approached to problem, and what tools and techniques you used to solve it. How did you plan? What technologies did you use? If you had more time, what would be next?
+## Features
+Users can:
+- Sign up and log in
+- Add new places with features and a map-picked location
+- Filter places by city, category, or amenities
+- View all places on an interactive map
+- Read and leave reviews with ratings
 
-## View it live
+## Tech stack
+**Frontend:** React, React Router, Zustand, Styled-components, React Leaflet
+
+**Backend:** Node.js, Express, MongoDB with Mongoose, JWT authentication
+
+## How I built it
+I started by defining the core features (authentication, map, reviews, adding places), built the backend API first, then connected the frontend to it.
+
+One interesting challenge was using React Leaflet's `useMapEvents` hook to let users click directly on the map to pick a location for a new place.
 
-Every project should be deployed somewhere. Be sure to include the link to the deployed project so that the viewer can click around and see what it's all about.
+## If I had more time
+- Allow browsing and viewing places without needing to log in
+- Show the user's current location on the map
+- Allow editing and deleting reviews
+- Add photos for places
+- Push notifications for new reviews

backend/package.json

@@ -2,19 +2,19 @@
   "name": "project-final-backend",
   "version": "1.0.0",
   "description": "Server part of final project",
+  "type": "module",
   "scripts": {
-    "start": "babel-node server.js",
-    "dev": "nodemon server.js --exec babel-node"
+    "start": "node src/server.js",
+    "dev": "nodemon src/server.js"
   },
-  "author": "",
-  "license": "ISC",
   "dependencies": {
-    "@babel/core": "^7.17.9",
-    "@babel/node": "^7.16.8",
-    "@babel/preset-env": "^7.16.11",
+    "bcrypt": "^6.0.0",
     "cors": "^2.8.5",
+    "dotenv": "^17.3.1",
     "express": "^4.17.3",
+    "express-list-endpoints": "^7.1.0",
+    "jsonwebtoken": "^9.0.3",
     "mongoose": "^8.4.0",
     "nodemon": "^3.0.1"
   }
-}
+}

backend/src/app.js

@@ -0,0 +1,24 @@
+import "dotenv/config";
+import express from "express";
+import cors from "cors";
+import listEndpoints from "express-list-endpoints";
+
+import routes from "./routes/index.js";
+import { errorHandler } from "./middleware/errorHandler.js";
+
+const app = express();
+
+app.use(cors());
+app.use(express.json());
+
+app.get("/", (req, res) => {
+  res.json({
+    message: "Baby Changing Places API",
+    endpoints: listEndpoints(app),
+  });
+});
+
+app.use(routes);
+app.use(errorHandler);
+
+export default app;

backend/src/db/connectDB.js

@@ -0,0 +1,13 @@
+import mongoose from "mongoose";
+
+export const connectDB = async () => {
+  const mongoUrl = process.env.MONGO_URL || "mongodb://localhost/babyplaces";
+
+  try {
+    await mongoose.connect(mongoUrl);
+    console.log("✅ Connected to MongoDB");
+  } catch (err) {
+    console.error("❌ MongoDB connection error:", err.message);
+    process.exit(1);
+  }
+};

backend/src/middleware/auth.js

@@ -0,0 +1,29 @@
+import jwt from "jsonwebtoken";
+
+export const authenticateUser = (req, res, next) => {
+  try {
+    const header = req.headers.authorization || "";
+    const [type, token] = header.split(" ");
+
+    if (type !== "Bearer" || !token) {
+      return res.status(401).json({
+        success: false,
+        message: "Missing or invalid Authorization header",
+      });
+    }
+
+    if (!process.env.JWT_SECRET) {
+      return res.status(500).json({
+        success: false,
+        message: "Server misconfigured (JWT_SECRET missing)",
+      });
+    }
+
+    const payload = jwt.verify(token, process.env.JWT_SECRET);
+    req.user = payload; 
+
+    next();
+  } catch (err) {
+    return res.status(401).json({ success: false, message: "Invalid or expired token" });
+  }
+};

backend/src/middleware/errorHandler.js

@@ -0,0 +1,9 @@
+export const errorHandler = (err, req, res, next) => {
+  console.error(err);
+
+  const status = err.status || 500;
+  res.status(status).json({
+    success: false,
+    message: err.message || "Something went wrong",
+  });
+};

backend/src/models/Place.js

@@ -0,0 +1,58 @@
+import mongoose from "mongoose";
+
+const placeSchema = new mongoose.Schema(
+  {
+    name: { type: String, required: true, trim: true, minlength: 2 },
+
+    category: {
+      type: String,
+      enum: ["cafe", "restaurant", "mall", "public", "other"],
+      default: "other",
+    },
+
+    address: { type: String, trim: true },
+
+    city: { type: String, required: true, trim: true },
+
+
+    location: {
+      type: {
+        type: String,
+        enum: ["Point"],
+        default: "Point",
+        required: true,
+      },
+      coordinates: {
+        type: [Number],
+        required: true,
+        validate: {
+          validator: (arr) =>
+            Array.isArray(arr) &&
+            arr.length === 2 &&
+            arr.every((n) => Number.isFinite(n)),
+          message: "location.coordinates must be [lng, lat] (two numbers)",
+        },
+      },
+    },
+
+    features: {
+      changingTable: { type: Boolean, default: true },
+      babyLounge: { type: Boolean, default: false },
+      strollerAccess: { type: Boolean, default: false },
+      accessible: { type: Boolean, default: false },
+      disposableMats: { type: Boolean, default: false },
+      diaperBags: { type: Boolean, default: false },
+      clean: { type: Boolean, default: false },
+    },
+
+    avgRating: { type: Number, default: 0, min: 0, max: 5 },
+    reviewCount: { type: Number, default: 0, min: 0 },
+
+    createdBy: { type: mongoose.Schema.Types.ObjectId, ref: "User" },
+  },
+  { timestamps: true }
+);
+
+placeSchema.index({ location: "2dsphere" });
+
+export const Place = mongoose.model("Place", placeSchema);

backend/src/models/Review.js

@@ -0,0 +1,16 @@
+import mongoose from "mongoose";
+
+const reviewSchema = new mongoose.Schema(
+  {
+    placeId: { type: mongoose.Schema.Types.ObjectId, ref: "Place", required: true },
+    userId: { type: mongoose.Schema.Types.ObjectId, ref: "User", required: true },
+    rating: { type: Number, required: true, min: 1, max: 5 },
+    comment: { type: String, trim: true, maxlength: 500 },
+  },
+  { timestamps: true }
+);
+
+
+reviewSchema.index({ placeId: 1, userId: 1 }, { unique: true });
+
+export const Review = mongoose.model("Review", reviewSchema);

backend/src/models/User.js

@@ -0,0 +1,30 @@
+import mongoose from "mongoose";
+
+const userSchema = new mongoose.Schema(
+  {
+    email: {
+      type: String,
+      required: true,
+      unique: true,
+      lowercase: true,
+      trim: true,
+      match: /.+\@.+\..+/, 
+    },
+
+    username: {
+      type: String,
+      trim: true,
+      maxlength: 30,
+    },
+
+    passwordHash: {
+      type: String,
+      required: true,
+    },
+  },
+  { timestamps: true }
+);
+
+userSchema.index({ email: 1 }, { unique: true });
+
+export const User = mongoose.model("User", userSchema);

backend/src/routes/auth.js

@@ -0,0 +1,99 @@
+import express from "express";
+import bcrypt from "bcrypt";
+import jwt from "jsonwebtoken";
+import { User } from "../models/User.js";
+
+const router = express.Router();
+
+router.post("/signup", async (req, res, next) => {
+  try {
+    const { email, password, username } = req.body;
+    const normalizedEmail = email?.toLowerCase().trim();
+
+    if (!normalizedEmail || !password) {
+      return res.status(400).json({
+        success: false,
+        message: "Email and password are required",
+      });
+    }
+
+    if (password.length < 6) {
+      return res.status(400).json({
+        success: false,
+        message: "Password must be at least 6 characters",
+      });
+    }
+
+    const existing = await User.findOne({ email: normalizedEmail });
+
+    if (existing) {
+      return res.status(409).json({
+        success: false,
+        message: "Email already in use",
+      });
+    }
+
+    const passwordHash = await bcrypt.hash(password, 12);
+
+    const user = await User.create({
+      email: normalizedEmail,
+      username,
+      passwordHash,
+    });
+
+    const accessToken = jwt.sign(
+      { userId: user._id, email: user.email },
+      process.env.JWT_SECRET,
+      { expiresIn: "7d" }
+    );
+
+    res.status(201).json({
+      success: true,
+      accessToken,
+      user: {
+        userId: user._id,
+        email: user.email,
+        username: user.username || "",
+      },
+    });
+  } catch (err) {
+    next(err);
+  }
+});
+
+router.post("/login", async (req, res, next) => {
+  try {
+    const { email, password } = req.body;
+    const user = await User.findOne({ email: email?.toLowerCase() });
+
+    if (!user) {
+      return res.status(401).json({ success: false, message: "Invalid credentials" });
+    }
+
+    const ok = await bcrypt.compare(password, user.passwordHash);
+
+    if (!ok) {
+      return res.status(401).json({ success: false, message: "Invalid credentials" });
+    }
+
+    const accessToken = jwt.sign(
+      { userId: user._id, email: user.email },
+      process.env.JWT_SECRET,
+      { expiresIn: "7d" }
+    );
+
+    res.json({
+      success: true,
+      accessToken,
+      user: {
+        userId: user._id,
+        email: user.email,
+        username: user.username || "",
+      },
+    });
+  } catch (err) {
+    next(err);
+  }
+});
+
+export default router;