Social Proof System

// Review submission validation
const canReview = await prisma.orderItem.findFirst({
  where: {
    order: {
      userId: userId,
      status: 'completed'
    },
    productId: productId
  }
});

if (!canReview) {
  throw new Error('Must purchase product to leave review');
}

interface Review {
  id: string;
  productId: string;
  userId: string;
  orderId: string; // Links to verified purchase
  rating: number; // 1-5 stars
  title: string;
  content: string;
  verified: boolean; // Always true for purchase reviews
  helpful: number; // Community voting
  photos: string[]; // User-generated content
  createdAt: Date;
  updatedAt: Date;
}

// Enforce single review policy
const existingReview = await prisma.review.findFirst({
  where: {
    productId: productId,
    userId: userId
  }
});

if (existingReview) {
  throw new Error('You have already reviewed this product');
}

// Content analysis pipeline
const analysis = await analyzeReviewContent({
  title: review.title,
  content: review.content,
  rating: review.rating
});

// Results include:
// - Spam detection score
// - Sentiment analysis
// - Language quality metrics
// - Brand safety flags

// Review queue management
const pendingReviews = await prisma.review.findMany({
  where: { status: 'pending' },
  include: {
    user: true,
    product: true,
    analysis: true // AI analysis results
  },
  orderBy: { createdAt: 'desc' }
});

// Approve review
await prisma.review.update({
  where: { id: reviewId },
  data: { status: 'approved', moderatedAt: new Date() }
});

// Reject with feedback
await prisma.review.update({
  where: { id: reviewId },
  data: {
    status: 'rejected',
    moderationReason: 'Inappropriate content',
    moderatedAt: new Date()
  }
});

// Request revisions
await notifyUser({
  userId: review.userId,
  message: 'Please revise your review to meet guidelines',
  reviewId: reviewId
});

// Vote on review helpfulness
const vote = await prisma.reviewVote.upsert({
  where: {
    reviewId_userId: {
      reviewId: reviewId,
      userId: currentUserId
    }
  },
  update: { helpful: isHelpful },
  create: {
    reviewId: reviewId,
    userId: currentUserId,
    helpful: isHelpful
  }
});

// Update review helpfulness score
const helpfulCount = await prisma.reviewVote.count({
  where: { reviewId: reviewId, helpful: true }
});

await prisma.review.update({
  where: { id: reviewId },
  data: { helpfulVotes: helpfulCount }
});

// Brand response to review
const response = await prisma.reviewResponse.create({
  data: {
    reviewId: reviewId,
    userId: brandUserId, // Brand representative
    content: 'Thank you for your feedback! We appreciate your support.',
    isBrandResponse: true
  }
});

// Review performance metrics
const analytics = await prisma.review.aggregate({
  where: { productId: productId },
  _count: { id: true },
  _avg: { rating: true, helpfulVotes: true }
});

// Individual review engagement
const engagement = await prisma.reviewEngagement.findMany({
  where: { reviewId: reviewId },
  include: { user: true, type: true } // views, shares, etc.
});

// Get reviews for product display
const reviews = await prisma.review.findMany({
  where: {
    productId: productId,
    status: 'approved'
  },
  include: {
    user: { select: { name: true, avatar: true } },
    votes: { where: { helpful: true } },
    responses: {
      include: { user: true },
      orderBy: { createdAt: 'asc' }
    }
  },
  orderBy: { helpfulVotes: 'desc', createdAt: 'desc' },
  take: 10
});

// Calculate review statistics
const stats = await prisma.review.aggregate({
  where: { productId: productId, status: 'approved' },
  _count: { id: true },
  _avg: { rating: true }
});

// Rating distribution
const distribution = await prisma.review.groupBy({
  by: ['rating'],
  where: { productId: productId, status: 'approved' },
  _count: { rating: true }
});

// Get featured reviews
const featuredReviews = await prisma.review.findMany({
  where: {
    productId: productId,
    status: 'approved',
    OR: [
      { helpfulVotes: { gte: 5 } }, // Popular reviews
      { rating: 5 }, // Perfect reviews
      { photos: { isEmpty: false } } // Reviews with photos
    ]
  },
  orderBy: { helpfulVotes: 'desc' },
  take: 3
});

// Products frequently bought together (from reviews)
const recommendations = await prisma.review.groupBy({
  by: ['productId'],
  where: {
    userId: { in: reviewersWhoAlsoBought },
    rating: { gte: 4 }
  },
  _count: { productId: true },
  orderBy: { _count: { productId: 'desc' } }
});

// Extract positive highlights
const highlights = await extractReviewHighlights({
  reviews: approvedReviews,
  aspects: ['quality', 'design', 'performance', 'value']
});

// Generate marketing copy
const marketingCopy = await generateMarketingCopy({
  highlights: highlights,
  product: productData,
  targetAudience: 'social shoppers'
});

// Check for duplicate content
const similarReviews = await findSimilarReviews({
  content: newReview.content,
  productId: productId,
  threshold: 0.85 // 85% similarity threshold
});

if (similarReviews.length > 0) {
  // Flag for moderation
  await flagReview(newReview.id, 'potential_duplicate');
}

// Behavioral analysis
const botScore = await analyzeBotBehavior({
  userAgent: request.headers['user-agent'],
  ipAddress: request.ip,
  submissionPattern: userSubmissionHistory,
  timing: submissionTiming
});

if (botScore > 0.7) {
  await blockReviewSubmission(userId, 'bot_detected');
}

// Comprehensive quality analysis
const quality = await scoreReviewQuality({
  length: review.content.length,
  specificity: containsSpecificDetails(review),
  originality: !isDuplicate(review),
  helpfulness: await predictHelpfulness(review),
  sentiment: analyzeSentiment(review)
});

// Auto-approve high-quality reviews
if (quality.overall > 0.8) {
  await approveReview(review.id);
}

// Import reviews from CSV/other platforms
const importedReviews = await importReviews({
  source: 'shopify',
  data: csvData,
  mapping: {
    rating: 'star_rating',
    content: 'review_body',
    customerEmail: 'customer_email',
    productId: 'product_handle'
  }
});

// Review webhook events
{
  "event": "review.created",
  "data": {
    "reviewId": "review-123",
    "productId": "prod-456",
    "rating": 5,
    "verified": true
  }
}

{
  "event": "review.approved",
  "data": {
    "reviewId": "review-123",
    "moderatedBy": "admin-789",
    "moderatedAt": "2024-01-15T10:30:00Z"
  }
}

// Review analytics
const reviewAnalytics = {
  totalReviews: await prisma.review.count(),
  averageRating: await prisma.review.aggregate({
    _avg: { rating: true }
  }),
  reviewVelocity: calculateReviewVelocity(), // reviews per day
  helpfulnessRate: calculateHelpfulnessRate(),
  conversionImpact: measureReviewConversionImpact()
};

// Sentiment tracking over time
const sentimentTrends = await analyzeSentimentTrends({
  productId: productId,
  timeframe: '30d',
  groupBy: 'day'
});

// Identify common pain points
const painPoints = await extractPainPoints({
  reviews: recentReviews,
  minRating: 3 // Include neutral/negative reviews
});