Comments System

interface Comment {
  id: number;
  postId: string | number;
  postTitle?: string;
  authorId: number;
  author: {
    id: number;
    name: string;
    email: string;
    avatar: string | null;
    username?: string;
  };
  content: string;
  status: 'pending' | 'approved' | 'rejected' | 'spam';
  parentId?: number | null;        // For nested replies
  likes: number;
  createdAt: string;
  updatedAt: string;
  moderatedBy?: number | null;     // Moderator user ID
  moderatedAt?: string | null;
  moderationNotes?: string | null;
  isEdited?: boolean;
  editedAt?: string | null;
  depth?: number;                  // Nesting level (0-based)
  path?: number[];                 // Comment hierarchy path
  replies?: Comment[];             // Nested replies
}

import { createComment } from '@/services/commentsService';

const newComment = await createComment({
  postId: 42,
  authorId: userId,
  content: 'Great article! Very informative.',
  status: 'pending' // New comments start as pending
});

const reply = await createComment({
  postId: 42,
  authorId: userId,
  content: 'Thanks! Glad you found it helpful.',
  parentId: 123, // ID of parent comment
  status: 'pending'
});

import { getAllComments } from '@/services/commentsService';

const comments = await getAllComments();

import { getCommentsByPostId } from '@/services/commentsService';

const { comments, total, page, pages } = await getCommentsByPostId(42, {
  withUser: true,      // Include author data
  withReplies: true,   // Include nested replies
  page: 1,
  limit: 20
});

console.log(`Showing ${comments.length} of ${total} comments`);

import { getPendingComments } from '@/services/commentsService';

const pending = getPendingComments();
console.log(`${pending.length} comments need review`);

import { getCommentReplies } from '@/services/commentsService';

const replies = await getCommentReplies(commentId);

import { updateCommentStatus } from '@/services/commentsService';

const approved = await updateCommentStatus(
  commentId,
  'approved',
  'Comment meets community guidelines'
);

const rejected = await updateCommentStatus(
  commentId,
  'rejected',
  'Contains inappropriate language'
);

const spam = await updateCommentStatus(
  commentId,
  'spam',
  'Detected as spam by moderator'
);

interface Comment {
  // ... other fields
  moderatedBy?: number;        // User ID of moderator
  moderatedAt?: string;        // Timestamp of moderation
  moderationNotes?: string;    // Moderator's notes
}

// Example moderated comment
const comment = {
  id: 123,
  content: 'Original comment text',
  status: 'approved',
  moderatedBy: 5,
  moderatedAt: '2024-01-15T10:30:00Z',
  moderationNotes: 'Approved after review'
};

// Comment structure with nested replies
const commentThread = {
  id: 1,
  content: 'Top-level comment',
  depth: 0,
  path: [1],
  replies: [
    {
      id: 2,
      content: 'First reply',
      parentId: 1,
      depth: 1,
      path: [1, 2],
      replies: [
        {
          id: 3,
          content: 'Nested reply',
          parentId: 2,
          depth: 2,
          path: [1, 2, 3],
          replies: []
        }
      ]
    },
    {
      id: 4,
      content: 'Second reply',
      parentId: 1,
      depth: 1,
      path: [1, 4],
      replies: []
    }
  ]
};

import { likeComment } from '@/services/commentsService';

const success = await likeComment(commentId);
if (success) {
  console.log('Comment liked!');
}

import { reportComment } from '@/services/commentsService';

const reported = await reportComment(commentId, {
  reason: 'spam',
  description: 'This comment appears to be promotional spam'
});

import { getCommentsStats } from '@/services/commentsService';

const stats = await getCommentsStats();
// Returns:
// {
//   total: 1247,
//   approved: 1180,
//   pending: 45,
//   spam: 22
// }

import { getTopCommentedPosts } from '@/services/commentsService';

const topPosts = await getTopCommentedPosts(10);
// Returns posts sorted by comment count

import { getMostActiveCommenters } from '@/services/commentsService';

const activeUsers = await getMostActiveCommenters(10);
// Returns users sorted by comment count

import { deleteComment } from '@/services/commentsService';

const deleted = await deleteComment(commentId);
if (deleted) {
  console.log('Comment removed');
}

interface Comment {
  isEdited?: boolean;      // True if comment was modified
  editedAt?: string;       // Timestamp of last edit
}

// The edit history is tracked automatically
const editedComment = {
  id: 123,
  content: 'Updated comment text',
  isEdited: true,
  editedAt: '2024-01-15T11:00:00Z'
};

// Subscribe to new comments on a post
function subscribeToPostComments(postId: number) {
  // Poll for new comments
  const interval = setInterval(async () => {
    const { comments } = await getCommentsByPostId(postId, {
      page: 1,
      limit: 10
    });
    
    // Update UI with new comments
    updateCommentsUI(comments);
  }, 5000); // Check every 5 seconds
  
  return () => clearInterval(interval);
}

// Average comments per post
const stats = await getCommentsStats();
const avgPerPost = stats.total / totalPosts;

// Engagement rate
const engagementRate = (stats.approved / totalPosts) * 100;

// Moderation efficiency
const approvalRate = (stats.approved / stats.total) * 100;