Api/posts

api/comments.js

@@ -0,0 +1,85 @@
+const express = require("express");
+const router = express.Router();
+const { Comments, User } = require("../database");
+const { authenticateJWT } = require("../auth");
+
+// get the comments of a specific post
+router.get("/posts/:postId/comments", async (req, res) => {
+  try {
+    const { postId } = req.params;
+
+    const comments = await Comments.findAll({
+      where: { post_id: postId },
+      include: [
+        {
+          model: User,
+          as: "author",
+          attributes: ["id", "username", "spotifyDisplayName", "profileImage", "avatarURL"]
+        }
+      ],
+      order: [["created_at", "DESC"]]
+    });
+
+    res.json(comments);
+  } catch (error) {
+    console.error('Error fetching comments:', error);
+    res.status(500).json({ error: 'Failed to fetch comments' });
+  }
+});
+
+// post comments to a specific post
+router.post("/posts/:postId/comments", authenticateJWT, async (req, res) => {
+  try {
+    const { postId } = req.params;
+    const { content, parentId } = req.body;
+    const userId = req.user.id;
+
+    const comment = await Comments.create({
+      post_id: postId,
+      user_id: userId,
+      content,
+      parent_id: parentId || null
+    });
+
+    const createdComment = await Comments.findByPk(comment.id, {
+      include: [
+        {
+          model: User,
+          as: "author",
+          attributes: ["id", "username", "spotifyDisplayName", "profileImage", "avatarURL"]
+        }
+      ]
+    });
+
+    res.json(createdComment);
+  } catch (error) {
+    console.error('Error creating comment:', error);
+    res.status(500).json({ error: 'Failed to create comment' });
+  }
+});
+
+// delete comments of a specific post
+router.delete("/:id", authenticateJWT, async (req, res) => {
+  try {
+    const commentId = req.params.id;
+    const userId = req.user.id;
+
+    const deleted = await Comments.destroy({
+      where: { 
+        id: commentId, 
+        user_id: userId 
+      }
+    });
+
+    if (deleted === 0) {
+      return res.status(404).json({ error: "Comment not found or unauthorized" });
+    }
+
+    res.status(204).end();
+  } catch (error) {
+    console.error('Error deleting comment:', error);
+    res.status(500).json({ error: 'Failed to delete comment' });
+  }
+});
+
+module.exports = router;

api/follow.js

@@ -0,0 +1,245 @@
+const express = require("express");
+const router = express.Router();
+const { User, Posts, Follows } = require("../database");
+const { authenticateJWT } = require("../auth");
+const { Op } = require("sequelize");
+
+router.get("/me/followers", authenticateJWT, async (req, res) => {
+  try {
+    const user = await User.findByPk(req.user.id);
+
+    if (!user) {
+      return res.status(404).json({ error: "User not found" });
+    }
+
+    const followers = await Follows.findAll({
+      where: { followingId: user.id },
+      include: [
+        {
+          model: User,
+          as: "follower",
+          attributes: [
+            "id",
+            "username",
+            "firstName",
+            "lastName",
+            "profileImage",
+            "spotifyProfileImage",
+            "avatarURL",
+          ],
+        },
+      ],
+      order: [["createdAt", "DESC"]],
+      limit: 50,
+    });
+
+    res.json(followers.map((follow) => follow.follower));
+  } catch (error) {
+    console.error("Error fetching my followers:", error);
+    res.status(500).json({ error: "Failed to fetch followers" });
+  }
+});
+
+// Get *my* following
+router.get("/me/following", authenticateJWT, async (req, res) => {
+  try {
+    const user = await User.findByPk(req.user.id);
+
+    if (!user) {
+      return res.status(404).json({ error: "User not found" });
+    }
+
+    const following = await Follows.findAll({
+      where: { followerId: user.id },
+      include: [
+        {
+          model: User,
+          as: "following",
+          attributes: [
+            "id",
+            "username",
+            "firstName",
+            "lastName",
+            "profileImage",
+            "spotifyProfileImage",
+            "avatarURL",
+          ],
+        },
+      ],
+      order: [["createdAt", "DESC"]],
+      limit: 50,
+    });
+
+    res.json(following.map((follow) => follow.following));
+  } catch (error) {
+    console.error("Error fetching my following:", error);
+    res.status(500).json({ error: "Failed to fetch following" });
+  }
+});
+
+// Check if current user is following another user
+router.get("/:username/following-status", authenticateJWT, async (req, res) => {
+  try {
+    const userToCheck = await User.findOne({
+      where: { username: req.params.username },
+    });
+
+    if (!userToCheck) {
+      return res.status(404).json({ error: "User not found" });
+    }
+
+    const isFollowing = await Follows.findOne({
+      where: {
+        followerId: req.user.id,
+        followingId: userToCheck.id,
+      },
+    });
+
+    res.json({ following: !!isFollowing });
+  } catch (error) {
+    console.error("Error checking following status:", error);
+    res.status(500).json({ error: "Failed to check following status" });
+  }
+});
+
+// Get user's followers
+router.get("/:username/followers", async (req, res) => {
+  try {
+    const user = await User.findOne({
+      where: { username: req.params.username },
+    });
+
+    if (!user) {
+      return res.status(404).json({ error: "User not found" });
+    }
+
+    const followers = await Follows.findAll({
+      where: { followingId: user.id },
+      include: [
+        {
+          model: User,
+          as: "follower",
+          attributes: [
+            "id",
+            "username",
+            "firstName",
+            "lastName",
+            "profileImage",
+            "spotifyProfileImage",
+            "avatarURL",
+          ],
+        },
+      ],
+      order: [["createdAt", "DESC"]],
+      limit: 50,
+    });
+
+    res.json(followers.map((follow) => follow.follower));
+  } catch (error) {
+    console.error("Error fetching followers:", error);
+    res.status(500).json({ error: "Failed to fetch followers" });
+  }
+});
+
+// Get user's following
+router.get("/:username/following", async (req, res) => {
+  try {
+    const user = await User.findOne({
+      where: { username: req.params.username },
+    });
+
+    if (!user) {
+      return res.status(404).json({ error: "User not found" });
+    }
+
+    const following = await Follows.findAll({
+      where: { followerId: user.id },
+      include: [
+        {
+          model: User,
+          as: "following",
+          attributes: [
+            "id",
+            "username",
+            "firstName",
+            "lastName",
+            "profileImage",
+            "spotifyProfileImage",
+            "avatarURL",
+          ],
+        },
+      ],
+      order: [["createdAt", "DESC"]],
+      limit: 50,
+    });
+
+    res.json(following.map((follow) => follow.following));
+  } catch (error) {
+    console.error("Error fetching following:", error);
+    res.status(500).json({ error: "Failed to fetch following" });
+  }
+});
+
+//get all users who are following one another
+router.get("/:username/friends", authenticateJWT, async (req, res) => {
+  try {
+    const user = await User.findByPk(req.user.id);
+
+    if (!user) {
+      return res.status(404).json({ error: "User not found" });
+    }
+
+    const followers = await user.getFollowers();
+    const following = await user.getFollowing();
+
+    const friends = followers.filter((follower) =>
+      following.some((followed) => followed.id === follower.id)
+    );
+
+    res.json(friends);
+  } catch (error) {
+    console.error("Error fetching mutual friends:", error);
+    res.status(500).json({ error: "Failed to fetch mutual friends" });
+  }
+});
+
+//get all users with follow status
+router.get("/all-with-follow-status", authenticateJWT, async (req, res) => {
+  try {
+    const meId = req.user.id;
+
+    // Get all users except me
+    const users = await User.findAll({
+      where: { id: { [Op.ne]: meId } },
+      attributes: [
+        "id",
+        "username",
+        "firstName",
+        "lastName",
+        "profileImage",
+        "spotifyProfileImage",
+        "avatarURL",
+      ],
+    });
+
+    // Get IDs of users I’m following
+    const following = await Follows.findAll({
+      where: { followerId: meId },
+      attributes: ["followingId"],
+    });
+    const followingIds = new Set(following.map((f) => f.followingId));
+
+    // Attach isFollowing flag to each user
+    const result = users.map((u) => ({
+      ...u.toJSON(),
+      isFollowing: followingIds.has(u.id),
+    }));
+
+    res.json(result);
+  } catch (error) {
+    console.error("Error fetching users with follow status:", error);
+    res.status(500).json({ error: "Failed to fetch follow data" });
+  }
+});
+
+module.exports = router;

api/index.js

@@ -1,7 +1,21 @@
 const express = require("express");
 const router = express.Router();
+
 const testDbRouter = require("./test-db");
+const searchRouter = require("./search");
+const postsRouter = require("./posts");
+const profileRouter = require("./profile");
+const stickersRouter = require("./stickers");
+const followRouter = require("./follow");
+const commentsRouter = require('./comments');
+
 
 router.use("/test-db", testDbRouter);
+router.use("/search-songs", searchRouter);
+router.use("/posts", postsRouter);
+router.use("/profile", profileRouter);
+router.use("/follow", followRouter);
+router.use("/stickers", stickersRouter);
+router.use('/', commentsRouter); 
 
 module.exports = router;