Diseño de Sistemas: Feed de Redes Sociales

// Modelos de datos principales
interface User {
  id: string;
  username: string;
  displayName: string;
  avatarUrl: string;
  followerCount: number;
  followingCount: number;
  createdAt: Date;
}

interface Post {
  id: string;           // Snowflake ID (contiene timestamp)
  userId: string;
  content: string;
  mediaUrls: string[];  // Imágenes, videos almacenados en object storage
  likeCount: number;
  repostCount: number;
  replyCount: number;
  createdAt: Date;
}

interface Follow {
  followerId: string;   // El usuario que sigue
  followeeId: string;   // El usuario siendo seguido
  createdAt: Date;
}

// Entrada de timeline (cacheada en Redis)
interface TimelineEntry {
  postId: string;
  userId: string;
  timestamp: number;    // Para ordenamiento
}

const CELEBRITY_THRESHOLD = 50_000; // Umbral de seguidores

class FeedService {
  private cache: RedisClient;
  private db: Database;
  private messageQueue: MessageQueue;

  // Cuando un usuario crea una publicación
  async publishPost(userId: string, post: Post): Promise<void> {
    // Guardar la publicación en la base de datos
    await this.db.posts.insert(post);

    const followerCount = await this.db.getFollowerCount(userId);

    if (followerCount < CELEBRITY_THRESHOLD) {
      // Fan-out en escritura: empujar a timelines de seguidores
      await this.messageQueue.publish("fanout", {
        postId: post.id,
        userId,
        timestamp: post.createdAt.getTime(),
      });
    }
    // Celebridades: sus publicaciones se obtienen en lectura (fan-out en lectura)
  }

  // El worker de fan-out procesa
  async processFanout(event: FanoutEvent): Promise<void> {
    const followers = await this.db.getFollowerIds(event.userId);

    // Empujar al caché de timeline de cada seguidor (Redis sorted set)
    const pipeline = this.cache.pipeline();
    for (const followerId of followers) {
      pipeline.zadd(`timeline:${followerId}`, event.timestamp, event.postId);
      // Recortar timeline para mantener solo las últimas 800 publicaciones
      pipeline.zremrangebyrank(`timeline:${followerId}`, 0, -801);
    }
    await pipeline.exec();
  }

  // Cuando un usuario ve su timeline
  async getTimeline(userId: string, page = 0, pageSize = 20): Promise<Post[]> {
    const start = page * pageSize;
    const end = start + pageSize - 1;

    // Obtener entradas de timeline pre-computadas del caché
    const cachedPostIds = await this.cache.zrevrange(
      `timeline:${userId}`,
      start,
      end
    );

    // Obtener publicaciones de celebridades que este usuario sigue (fan-out en lectura)
    const celebrities = await this.getCelebritiesFollowed(userId);
    const celebrityPosts = await this.getRecentPostsFromUsers(celebrities);

    // Fusionar y ordenar
    const allPostIds = this.mergeAndSort(cachedPostIds, celebrityPosts);

    // Obtener objetos completos de publicaciones
    return this.db.posts.findByIds(allPostIds.slice(0, pageSize));
  }
}

// Estructuras de datos Redis para caché de feed

class FeedCache {
  // Timeline: Sorted Set (IDs de publicación con puntuación por timestamp)
  // Key: timeline:{userId}
  // Score: timestamp
  // Member: postId
  async addToTimeline(userId: string, postId: string, timestamp: number) {
    await redis.zadd(`timeline:${userId}`, timestamp, postId);
    await redis.zremrangebyrank(`timeline:${userId}`, 0, -801); // Mantener 800 máx
  }

  // Caché de publicaciones: Hash
  // Key: post:{postId}
  async cachePost(post: Post) {
    await redis.hset(`post:${post.id}`, {
      userId: post.userId,
      content: post.content,
      likeCount: post.likeCount.toString(),
      createdAt: post.createdAt.toISOString(),
    });
    await redis.expire(`post:${post.id}`, 86400); // TTL 24h
  }

  // Caché de usuarios: Hash
  // Key: user:{userId}
  async cacheUser(user: User) {
    await redis.hset(`user:${user.id}`, {
      username: user.username,
      displayName: user.displayName,
      avatarUrl: user.avatarUrl,
    });
    await redis.expire(`user:${user.id}`, 3600); // TTL 1h
  }
}

// Ranking simplificado del feed
interface RankedPost {
  post: Post;
  score: number;
}

function rankPosts(posts: Post[], userId: string, userContext: UserContext): RankedPost[] {
  return posts
    .map((post) => ({
      post,
      score: calculateRelevanceScore(post, userId, userContext),
    }))
    .sort((a, b) => b.score - a.score);
}

function calculateRelevanceScore(
  post: Post,
  viewerId: string,
  context: UserContext
): number {
  let score = 0;

  // Recencia: decaimiento con el tiempo
  const ageHours = (Date.now() - post.createdAt.getTime()) / 3600000;
  score += Math.max(0, 100 - ageHours * 2); // Pierde 2 puntos por hora

  // Señales de engagement
  score += Math.log(post.likeCount + 1) * 10;
  score += Math.log(post.replyCount + 1) * 15; // Respuestas valen más
  score += Math.log(post.repostCount + 1) * 12;

  // Proximidad social (qué tan cercano es el autor al espectador)
  const closeness = context.interactionFrequency[post.userId] || 0;
  score += closeness * 20;

  // Bonus por tipo de contenido
  if (post.mediaUrls.length > 0) score += 5; // Publicaciones con media rankean ligeramente más alto

  return score;
}