Redis-Backed Paginated Leaderboard With a Repository and Ranking Service

import { LeaderboardRepository, RawEntry } from "./LeaderboardRepository";

export interface LeaderboardEntry {
  rank: number;
  member: string;
  score: number;
}

export interface LeaderboardPage {
  page: number;
  pageSize: number;
  totalEntries: number;
  totalPages: number;
  entries: LeaderboardEntry[];
}

const MAX_PAGE_SIZE = 100;

export class RankingService {
  constructor(private readonly repo: LeaderboardRepository) {}

  private decorate(raw: RawEntry[], offset: number): LeaderboardEntry[] {
    return raw.map((entry, index) => ({
      rank: offset + index + 1,
      member: entry.member,
      score: entry.score,
    }));
  }

  async getPage(page: number, pageSize: number): Promise<LeaderboardPage> {
    const safeSize = Math.min(Math.max(1, Math.trunc(pageSize)), MAX_PAGE_SIZE);
    const safePage = Math.max(1, Math.trunc(page));
    const start = (safePage - 1) * safeSize;
    const stop = start + safeSize - 1;

    const [totalEntries, raw] = await Promise.all([
      this.repo.total(),
      this.repo.pageByRank(start, stop),
    ]);

    return {
      page: safePage,
      pageSize: safeSize,
      totalEntries,
      totalPages: Math.max(1, Math.ceil(totalEntries / safeSize)),
      entries: this.decorate(raw, start),
    };
  }

  async getPlayerContext(member: string, radius = 3): Promise<LeaderboardEntry[] | null> {
    const rank = await this.repo.rankOf(member);
    if (rank === null) return null;

    const start = Math.max(0, rank - radius);
    const stop = rank + radius;
    const raw = await this.repo.pageByRank(start, stop);
    return this.decorate(raw, start);
  }
}

import { Router, Request, Response } from "express";
import { RankingService } from "./RankingService";

export function leaderboardRoutes(service: RankingService): Router {
  const router = Router();

  router.get("/leaderboard", async (req: Request, res: Response) => {
    const page = Number(req.query.page ?? 1);
    const pageSize = Number(req.query.pageSize ?? 20);
    const result = await service.getPage(page, pageSize);
    res.json(result);
  });

  router.get("/leaderboard/around/:member", async (req: Request, res: Response) => {
    const radius = req.query.radius ? Number(req.query.radius) : undefined;
    const context = await service.getPlayerContext(req.params.member, radius);
    if (context === null) {
      return res.status(404).json({ error: "player is not ranked" });
    }
    res.json({ member: req.params.member, window: context });
  });

  return router;
}