Case Study: Social Media News Feed

import http from "node:http";
import crypto from "node:crypto";

// ===========================================
// 1. TYPES
// ===========================================
interface Post {
  id: string;
  authorId: string;
  content: string;
  likes: number;
  comments: number;
  createdAt: number;
}

interface FeedItem {
  postId: string;
  score: number;
  addedAt: number;
}

interface FeedPage {
  posts: Post[];
  cursor: string | null;
  hasMore: boolean;
  newCount: number;
}

// ===========================================
// 2. SOCIAL GRAPH
// ===========================================
class SocialGraph {
  private followers = new Map<string, Set<string>>(); // userId -> followerIds
  private following = new Map<string, Set<string>>(); // userId -> followingIds
  private readonly celebrityThreshold = 10000;

  follow(followerId: string, followeeId: string): void {
    if (!this.followers.has(followeeId)) this.followers.set(followeeId, new Set());
    if (!this.following.has(followerId)) this.following.set(followerId, new Set());
    this.followers.get(followeeId)!.add(followerId);
    this.following.get(followerId)!.add(followeeId);
  }

  unfollow(followerId: string, followeeId: string): void {
    this.followers.get(followeeId)?.delete(followerId);
    this.following.get(followeeId)?.delete(followerId);
  }

  getFollowers(userId: string): string[] {
    return [...(this.followers.get(userId) || [])];
  }

  getFollowing(userId: string): string[] {
    return [...(this.following.get(userId) || [])];
  }

  isCelebrity(userId: string): boolean {
    return (this.followers.get(userId)?.size || 0) >= this.celebrityThreshold;
  }

  getFollowerCount(userId: string): number {
    return this.followers.get(userId)?.size || 0;
  }
}

// ===========================================
// 3. POST STORE
// ===========================================
class PostStore {
  private posts = new Map<string, Post>();
  private userPosts = new Map<string, string[]>(); // userId -> postIds

  create(authorId: string, content: string): Post {
    const post: Post = {
      id: crypto.randomUUID(),
      authorId, content,
      likes: 0, comments: 0,
      createdAt: Date.now(),
    };
    this.posts.set(post.id, post);
    const list = this.userPosts.get(authorId) || [];
    list.push(post.id);
    this.userPosts.set(authorId, list);
    return post;
  }

  get(id: string): Post | null {
    return this.posts.get(id) || null;
  }

  getByUser(userId: string, limit = 50): Post[] {
    const ids = this.userPosts.get(userId) || [];
    return ids.slice(-limit).reverse()
      .map((id) => this.posts.get(id)!)
      .filter(Boolean);
  }

  getByIds(ids: string[]): Post[] {
    return ids.map((id) => this.posts.get(id)!).filter(Boolean);
  }

  like(postId: string): void {
    const post = this.posts.get(postId);
    if (post) post.likes++;
  }
}

// ===========================================
// 4. FEED STORE (Per-user timeline)
// ===========================================
class FeedStore {
  private feeds = new Map<string, FeedItem[]>();
  private readonly maxFeedSize = 1000;

  addToFeed(userId: string, postId: string, score: number): void {
    const feed = this.feeds.get(userId) || [];
    feed.push({ postId, score, addedAt: Date.now() });
    // Keep feed bounded
    if (feed.length > this.maxFeedSize) {
      feed.sort((a, b) => b.score - a.score);
      feed.length = this.maxFeedSize;
    }
    this.feeds.set(userId, feed);
  }

  getFeed(userId: string): FeedItem[] {
    return (this.feeds.get(userId) || []).sort((a, b) => b.score - a.score);
  }
}

// ===========================================
// 5. RANKING ENGINE
// ===========================================
class RankingEngine {
  score(post: Post, viewerId: string, graph: SocialGraph): number {
    const ageHours = (Date.now() - post.createdAt) / 3600000;
    const recencyScore = Math.max(0, 100 - ageHours * 2); // Decay over 50 hours
    const engagementScore = (post.likes * 2) + (post.comments * 3);

    // Author affinity: boost posts from users the viewer follows closely
    const viewerFollowing = graph.getFollowing(viewerId);
    const affinityScore = viewerFollowing.includes(post.authorId) ? 10 : 0;

    return recencyScore + engagementScore + affinityScore;
  }
}

// ===========================================
// 6. FAN-OUT SERVICE
// ===========================================
class FanOutService {
  constructor(
    private graph: SocialGraph,
    private feedStore: FeedStore,
    private ranking: RankingEngine,
  ) {}

  async fanOut(post: Post): Promise<number> {
    if (this.graph.isCelebrity(post.authorId)) {
      // Celebrity: skip fan-out on write, will be fetched on read
      console.log(`[FAN-OUT] Celebrity post ${post.id} — skip push, will pull on read`);
      return 0;
    }

    const followers = this.graph.getFollowers(post.authorId);
    let count = 0;

    for (const followerId of followers) {
      const score = this.ranking.score(post, followerId, this.graph);
      this.feedStore.addToFeed(followerId, post.id, score);
      count++;
    }

    console.log(`[FAN-OUT] Post ${post.id} pushed to ${count} feeds`);
    return count;
  }
}

// ===========================================
// 7. FEED GENERATOR
// ===========================================
class FeedGenerator {
  constructor(
    private postStore: PostStore,
    private feedStore: FeedStore,
    private graph: SocialGraph,
    private ranking: RankingEngine,
  ) {}

  generate(userId: string, cursor: string | null, limit = 20): FeedPage {
    // 1. Get pre-computed feed items (fan-out on write)
    const feedItems = this.feedStore.getFeed(userId);

    // 2. Merge celebrity posts (fan-out on read)
    const following = this.graph.getFollowing(userId);
    const celebrityPosts: Post[] = [];

    for (const followeeId of following) {
      if (this.graph.isCelebrity(followeeId)) {
        const recent = this.postStore.getByUser(followeeId, 10);
        celebrityPosts.push(...recent);
      }
    }

    // 3. Combine and deduplicate
    const allPostIds = new Set<string>();
    const allPosts: { post: Post; score: number }[] = [];

    for (const item of feedItems) {
      if (allPostIds.has(item.postId)) continue;
      const post = this.postStore.get(item.postId);
      if (!post) continue;
      allPostIds.add(item.postId);
      allPosts.push({ post, score: item.score });
    }

    for (const post of celebrityPosts) {
      if (allPostIds.has(post.id)) continue;
      allPostIds.add(post.id);
      const score = this.ranking.score(post, userId, this.graph);
      allPosts.push({ post, score });
    }

    // 4. Sort by score
    allPosts.sort((a, b) => b.score - a.score);

    // 5. Cursor-based pagination
    let startIdx = 0;
    if (cursor) {
      const cursorIdx = allPosts.findIndex((p) => p.post.id === cursor);
      if (cursorIdx >= 0) startIdx = cursorIdx + 1;
    }

    const page = allPosts.slice(startIdx, startIdx + limit);
    const hasMore = startIdx + limit < allPosts.length;
    const nextCursor = page.length > 0 ? page[page.length - 1].post.id : null;

    return {
      posts: page.map((p) => p.post),
      cursor: hasMore ? nextCursor : null,
      hasMore,
      newCount: 0,
    };
  }
}

// ===========================================
// 8. REAL-TIME NEW POST COUNTER
// ===========================================
class NewPostTracker {
  private lastSeen = new Map<string, number>(); // userId -> timestamp

  markSeen(userId: string): void {
    this.lastSeen.set(userId, Date.now());
  }

  getNewCount(userId: string, feedItems: FeedItem[]): number {
    const lastSeen = this.lastSeen.get(userId) || 0;
    return feedItems.filter((item) => item.addedAt > lastSeen).length;
  }
}

// ===========================================
// 9. HTTP SERVER
// ===========================================
const graph = new SocialGraph();
const postStore = new PostStore();
const feedStore = new FeedStore();
const ranking = new RankingEngine();
const fanOut = new FanOutService(graph, feedStore, ranking);
const feedGen = new FeedGenerator(postStore, feedStore, graph, ranking);
const tracker = new NewPostTracker();

function parseBody(req: http.IncomingMessage): Promise<unknown> {
  return new Promise((resolve, reject) => {
    const chunks: Buffer[] = [];
    req.on("data", (c) => chunks.push(c));
    req.on("end", () => {
      try { resolve(JSON.parse(Buffer.concat(chunks).toString())); }
      catch { reject(new Error("Invalid JSON")); }
    });
  });
}

function json(res: http.ServerResponse, status: number, data: unknown): void {
  res.writeHead(status, { "Content-Type": "application/json" });
  res.end(JSON.stringify(data));
}

const server = http.createServer(async (req, res) => {
  const url = new URL(req.url || "/", `http://${req.headers.host}`);
  const method = req.method || "GET";

  try {
    // POST /api/posts
    if (url.pathname === "/api/posts" && method === "POST") {
      const body = await parseBody(req) as any;
      if (!body.authorId || !body.content) {
        json(res, 400, { error: "authorId and content required" }); return;
      }
      const post = postStore.create(body.authorId, body.content);
      await fanOut.fanOut(post);
      json(res, 201, post); return;
    }

    // POST /api/follow/:userId
    const followMatch = url.pathname.match(/^\/api\/follow\/([^/]+)$/);
    if (followMatch && method === "POST") {
      const body = await parseBody(req) as any;
      if (!body.followerId) { json(res, 400, { error: "followerId required" }); return; }
      graph.follow(body.followerId, followMatch[1]);
      json(res, 200, { followed: followMatch[1] }); return;
    }

    // DELETE /api/follow/:userId
    if (followMatch && method === "DELETE") {
      const body = await parseBody(req) as any;
      if (!body.followerId) { json(res, 400, { error: "followerId required" }); return; }
      graph.unfollow(body.followerId, followMatch[1]);
      json(res, 200, { unfollowed: followMatch[1] }); return;
    }

    // GET /api/feed?userId=&cursor=&limit=
    if (url.pathname === "/api/feed" && method === "GET") {
      const userId = url.searchParams.get("userId");
      if (!userId) { json(res, 400, { error: "userId required" }); return; }
      const cursor = url.searchParams.get("cursor");
      const limit = parseInt(url.searchParams.get("limit") || "20");
      const feed = feedGen.generate(userId, cursor, limit);
      tracker.markSeen(userId);
      json(res, 200, feed); return;
    }

    // GET /api/feed/new-count?userId=
    if (url.pathname === "/api/feed/new-count" && method === "GET") {
      const userId = url.searchParams.get("userId");
      if (!userId) { json(res, 400, { error: "userId required" }); return; }
      const items = feedStore.getFeed(userId);
      const count = tracker.getNewCount(userId, items);
      json(res, 200, { newCount: count }); return;
    }

    if (url.pathname === "/health") { json(res, 200, { status: "ok" }); return; }
    json(res, 404, { error: "Not found" });
  } catch (err: any) {
    json(res, 500, { error: err.message || "Internal server error" });
  }
});

const PORT = parseInt(process.env.PORT || "3000");
server.listen(PORT, () => console.log(`News Feed on http://localhost:${PORT}`));
process.on("SIGTERM", () => server.close());