feat: playlist follow/subscribe + comment flagging (#408 #411)

src/controllers/CommentReportController.ts

@@ -0,0 +1,69 @@
+import { Request, Response } from "express";
+import { AppDataSource } from "../config/data-source";
+import { CommentReport, CommentReportStatus } from "../entities/CommentReport";
+import { handleError } from "../utils/helpers";
+import { AppError } from "../errors/AppError";
+
+export class CommentReportController {
+  flag = async (req: Request, res: Response): Promise<void> => {
+    try {
+      const userId = (req as any).user?.id;
+      if (!userId) return handleError(req, res, AppError.authentication("Not authenticated"));
+
+      const { commentId, reason, description } = req.body;
+      if (!commentId) return handleError(req, res, AppError.badRequest("commentId required"));
+
+      const repo = AppDataSource.getRepository(CommentReport);
+      const existing = await repo.findOne({ where: { commentId, reporterId: userId } });
+      if (existing) return handleError(req, res, AppError.conflict("Already flagged this comment"));
+
+      const report = repo.create({
+        commentId,
+        reporterId: userId,
+        reason: reason || "other",
+        description: description || null,
+      });
+      await repo.save(report);
+      res.status(201).json({ report });
+    } catch (error) {
+      handleError(req, res, error);
+    }
+  };
+
+  getQueue = async (req: Request, res: Response): Promise<void> => {
+    try {
+      const repo = AppDataSource.getRepository(CommentReport);
+      const reports = await repo.find({
+        where: { status: CommentReportStatus.PENDING },
+        relations: ["comment", "reporter"],
+        order: { createdAt: "ASC" },
+      });
+      res.json({ reports, count: reports.length });
+    } catch (error) {
+      handleError(req, res, error);
+    }
+  };
+
+  resolve = async (req: Request, res: Response): Promise<void> => {
+    try {
+      const moderatorId = (req as any).user?.id;
+      const { id } = req.params;
+      const { action, note } = req.body;
+
+      const repo = AppDataSource.getRepository(CommentReport);
+      const report = await repo.findOneBy({ id });
+      if (!report) return handleError(req, res, AppError.notFound("Report not found"));
+
+      report.status = CommentReportStatus.RESOLVED;
+      report.actionTaken = action || "no_action";
+      report.resolvedBy = moderatorId;
+      report.resolvedAt = new Date();
+      report.resolutionNote = note || null;
+      await repo.save(report);
+
+      res.json({ report });
+    } catch (error) {
+      handleError(req, res, error);
+    }
+  };
+}

src/controllers/PlaylistFollowController.ts

@@ -0,0 +1,68 @@
+import { Request, Response } from "express";
+import { AppDataSource } from "../config/data-source";
+import { PlaylistFollow } from "../entities/PlaylistFollow";
+import { handleError } from "../utils/helpers";
+import { AppError } from "../errors/AppError";
+
+export class PlaylistFollowController {
+  follow = async (req: Request, res: Response): Promise<void> => {
+    try {
+      const userId = (req as any).user?.id;
+      if (!userId) return handleError(req, res, AppError.authentication("Not authenticated"));
+
+      const { playlistId } = req.body;
+      if (!playlistId) return handleError(req, res, AppError.badRequest("playlistId required"));
+
+      const repo = AppDataSource.getRepository(PlaylistFollow);
+      const existing = await repo.findOne({ where: { userId, playlistId } });
+      if (existing) return res.status(200).json({ follow: existing });
+
+      const follow = repo.create({ userId, playlistId });
+      await repo.save(follow);
+      res.status(201).json({ follow });
+    } catch (error) {
+      handleError(req, res, error);
+    }
+  };
+
+  unfollow = async (req: Request, res: Response): Promise<void> => {
+    try {
+      const userId = (req as any).user?.id;
+      if (!userId) return handleError(req, res, AppError.authentication("Not authenticated"));
+
+      const { playlistId } = req.params;
+      const repo = AppDataSource.getRepository(PlaylistFollow);
+      const follow = await repo.findOne({ where: { userId, playlistId } });
+      if (!follow) return handleError(req, res, AppError.notFound("Not following this playlist"));
+
+      await repo.remove(follow);
+      res.json({ deleted: true });
+    } catch (error) {
+      handleError(req, res, error);
+    }
+  };
+
+  getFollowers = async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { playlistId } = req.params;
+      const repo = AppDataSource.getRepository(PlaylistFollow);
+      const follows = await repo.find({ where: { playlistId }, relations: ["user"] });
+      res.json({ followers: follows.map((f) => f.user), count: follows.length });
+    } catch (error) {
+      handleError(req, res, error);
+    }
+  };
+
+  getMyFollows = async (req: Request, res: Response): Promise<void> => {
+    try {
+      const userId = (req as any).user?.id;
+      if (!userId) return handleError(req, res, AppError.authentication("Not authenticated"));
+
+      const repo = AppDataSource.getRepository(PlaylistFollow);
+      const follows = await repo.find({ where: { userId }, relations: ["playlist"] });
+      res.json({ playlists: follows.map((f) => f.playlist) });
+    } catch (error) {
+      handleError(req, res, error);
+    }
+  };
+}

src/entities/CommentReport.ts

@@ -0,0 +1,93 @@
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  Column,
+  CreateDateColumn,
+  UpdateDateColumn,
+  ManyToOne,
+  JoinColumn,
+  Index,
+  Unique,
+} from "typeorm";
+import { User } from "./User";
+import { Comment } from "./Comment";
+
+export enum CommentReportReason {
+  SPAM = "spam",
+  HARASSMENT = "harassment",
+  INAPPROPRIATE = "inappropriate",
+  COPYRIGHT = "copyright",
+  OTHER = "other",
+}
+
+export enum CommentReportStatus {
+  PENDING = "pending",
+  RESOLVED = "resolved",
+}
+
+export enum CommentReportAction {
+  NO_ACTION = "no_action",
+  COMMENT_HIDDEN = "comment_hidden",
+  COMMENT_REMOVED = "comment_removed",
+  USER_WARNED = "user_warned",
+  USER_SUSPENDED = "user_suspended",
+  DISMISSED = "dismissed",
+}
+
+/**
+ * Comment flagging integrated into moderation queue (Issue #411).
+ *
+ * When a user flags a comment, it creates a report that appears in the
+ * moderation queue alongside song ContentReports. Moderators can review,
+ * hide, remove, or take action against the commenter.
+ */
+@Entity("comment_reports")
+@Unique("UQ_comment_report_user_comment", ["commentId", "reporterId"])
+@Index(["commentId"])
+@Index(["reporterId"])
+@Index(["status"])
+export class CommentReport {
+  @PrimaryGeneratedColumn("uuid")
+  id!: string;
+
+  @Column({ type: "uuid" })
+  commentId!: string;
+
+  @ManyToOne(() => Comment, { onDelete: "CASCADE" })
+  @JoinColumn({ name: "commentId" })
+  comment!: Comment;
+
+  @Column({ type: "uuid" })
+  reporterId!: string;
+
+  @ManyToOne(() => User, { onDelete: "CASCADE" })
+  @JoinColumn({ name: "reporterId" })
+  reporter!: User;
+
+  @Column({ type: "varchar", default: CommentReportReason.OTHER })
+  reason!: CommentReportReason;
+
+  @Column({ type: "text", nullable: true })
+  description?: string | null;
+
+  @Column({ type: "varchar", default: CommentReportStatus.PENDING })
+  status!: CommentReportStatus;
+
+  @Column({ type: "varchar", nullable: true })
+  actionTaken?: CommentReportAction | null;
+
+  @Column({ nullable: true })
+  resolvedBy?: string | null;
+
+  @Column({ type: "timestamp", nullable: true })
+  resolvedAt?: Date | null;
+
+  @Column({ type: "text", nullable: true })
+  resolutionNote?: string | null;
+
+  @CreateDateColumn()
+  createdAt!: Date;
+
+  @UpdateDateColumn()
+  updatedAt!: Date;
+}

src/entities/PlaylistFollow.ts

@@ -0,0 +1,44 @@
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  Column,
+  CreateDateColumn,
+  ManyToOne,
+  JoinColumn,
+  Index,
+  Unique,
+} from "typeorm";
+import { User } from "./User";
+import { Playlist } from "./Playlist";
+
+/**
+ * Playlist follow/subscribe (Issue #408).
+ *
+ * Listeners can follow a playlist to receive notifications when new songs
+ * are added. One follow per user per playlist.
+ */
+@Entity("playlist_follows")
+@Unique("UQ_playlist_follow_user_playlist", ["userId", "playlistId"])
+@Index(["playlistId"])
+@Index(["userId"])
+export class PlaylistFollow {
+  @PrimaryGeneratedColumn("uuid")
+  id!: string;
+
+  @Column({ type: "uuid" })
+  userId!: string;
+
+  @ManyToOne(() => User, { onDelete: "CASCADE" })
+  @JoinColumn({ name: "userId" })
+  user!: User;
+
+  @Column({ type: "uuid" })
+  playlistId!: string;
+
+  @ManyToOne(() => Playlist, { onDelete: "CASCADE" })
+  @JoinColumn({ name: "playlistId" })
+  playlist!: Playlist;
+
+  @CreateDateColumn()
+  createdAt!: Date;
+}

src/routes/commentReportRoutes.ts

@@ -0,0 +1,15 @@
+import { Router } from "express";
+import { CommentReportController } from "../controllers/CommentReportController";
+import { requireAuth } from "../middlewares/authMiddleware";
+
+const router = Router();
+const c = new CommentReportController();
+
+// Any authenticated user can flag a comment
+router.post("/flag", requireAuth, c.flag);
+
+// Moderators: view pending queue and resolve reports
+router.get("/queue", requireAuth, c.getQueue);
+router.post("/:id/resolve", requireAuth, c.resolve);
+
+export default router;

src/routes/playlistFollowRoutes.ts

@@ -0,0 +1,13 @@
+import { Router } from "express";
+import { PlaylistFollowController } from "../controllers/PlaylistFollowController";
+import { requireAuth } from "../middlewares/authMiddleware";
+
+const router = Router();
+const c = new PlaylistFollowController();
+
+router.post("/follow", requireAuth, c.follow);
+router.delete("/follow/:playlistId", requireAuth, c.unfollow);
+router.get("/followed", requireAuth, c.getMyFollows);
+router.get("/:playlistId/followers", requireAuth, c.getFollowers);
+
+export default router;