feat: add multiplayer typing races (@jhonsfranky17)

backend/package.json

@@ -51,6 +51,7 @@
     "prom-client": "15.1.3",
     "rate-limiter-flexible": "5.0.3",
     "simple-git": "3.36.0",
+    "socket.io": "4.8.3",
     "string-similarity": "4.0.4",
     "swagger-stats": "0.99.7",
     "ua-parser-js": "0.7.33",

backend/src/api/controllers/multiplayer.ts

@@ -0,0 +1,41 @@
+import {
+  CreateRoomRequest,
+  CreateRoomResponse,
+  GetRoomPath,
+  GetRoomResponse,
+} from "@monkeytype/contracts/multiplayer";
+import { MonkeyRequest } from "../types";
+import { MonkeyResponse } from "../../utils/monkey-response";
+import MonkeyError from "../../utils/error";
+import * as UserDAL from "../../dal/user";
+import * as Multiplayer from "../../utils/multiplayer";
+
+export async function createRoom(
+  req: MonkeyRequest<undefined, CreateRoomRequest>,
+): Promise<CreateRoomResponse> {
+  const { uid } = req.ctx.decodedToken;
+  const { config } = req.body;
+
+  const { name } = await UserDAL.getPartialUser(
+    uid,
+    "create multiplayer room",
+    ["name"],
+  );
+
+  const room = await Multiplayer.createRoom(uid, name, config);
+
+  return new MonkeyResponse("Room created", room);
+}
+
+export async function getRoom(
+  req: MonkeyRequest<undefined, undefined, GetRoomPath>,
+): Promise<GetRoomResponse> {
+  const { roomCode } = req.params;
+
+  const room = await Multiplayer.getRoom(roomCode);
+  if (room === null) {
+    throw new MonkeyError(404, "Room not found");
+  }
+
+  return new MonkeyResponse("Room found", room);
+}

backend/src/api/routes/index.ts

@@ -16,6 +16,7 @@ import configuration from "./configuration";
 import { version } from "../../version";
 import leaderboards from "./leaderboards";
 import connections from "./connections";
+import multiplayer from "./multiplayer";
 import addSwaggerMiddlewares from "./swagger";
 import { MonkeyResponse } from "../../utils/monkey-response";
 import {
@@ -60,6 +61,7 @@ const router = s.router(contract, {
   quotes,
   webhooks,
   connections,
+  multiplayer,
 });
 
 export function addApiRoutes(app: Application): void {

backend/src/api/routes/multiplayer.ts

@@ -0,0 +1,14 @@
+import { multiplayerContract } from "@monkeytype/contracts/multiplayer";
+import { initServer } from "@ts-rest/express";
+import * as MultiplayerController from "../controllers/multiplayer";
+import { callController } from "../ts-rest-adapter";
+
+const s = initServer();
+export default s.router(multiplayerContract, {
+  createRoom: {
+    handler: async (r) => callController(MultiplayerController.createRoom)(r),
+  },
+  getRoom: {
+    handler: async (r) => callController(MultiplayerController.getRoom)(r),
+  },
+});

backend/src/init/socket-auth.ts

@@ -0,0 +1,34 @@
+import { Socket } from "socket.io";
+import { verifyIdToken } from "../utils/auth";
+import Logger from "../utils/logger";
+import { getErrorMessage } from "../utils/error";
+
+export type SocketData = {
+  uid: string;
+  email: string;
+  roomCode?: string;
+};
+
+export async function socketAuthMiddleware(
+  socket: Socket,
+  next: (err?: Error) => void,
+): Promise<void> {
+  const token = socket.handshake.auth["token"] as string | undefined;
+
+  if (token === undefined || token === "") {
+    next(new Error("unauthorized"));
+    return;
+  }
+
+  try {
+    const decoded = await verifyIdToken(token);
+    (socket.data as SocketData).uid = decoded.uid;
+    (socket.data as SocketData).email = decoded.email ?? "";
+    next();
+  } catch (error) {
+    Logger.warning(
+      `Rejected socket auth: ${getErrorMessage(error) ?? "unknown error"}`,
+    );
+    next(new Error("unauthorized"));
+  }
+}

backend/src/init/socket.ts

@@ -0,0 +1,69 @@
+import { Server as HttpServer } from "http";
+import { Server as SocketIOServer } from "socket.io";
+import { RateLimiterMemory, RateLimiterRedis } from "rate-limiter-flexible";
+import type {
+  ClientToServerEvents,
+  ServerToClientEvents,
+} from "@monkeytype/schemas/multiplayer-events";
+import * as RedisClient from "./redis";
+import { socketAuthMiddleware, SocketData } from "./socket-auth";
+import { registerRoomHandlers } from "../sockets/room-handlers";
+import Logger from "../utils/logger";
+
+export type MultiplayerIO = SocketIOServer<
+  ClientToServerEvents,
+  ServerToClientEvents,
+  Record<string, never>,
+  SocketData
+>;
+
+let io: MultiplayerIO | undefined;
+
+const GENERAL_EVENT_LIMIT_PER_SECOND = 20;
+
+export function attachSocketServer(httpServer: HttpServer): MultiplayerIO {
+  io = new SocketIOServer(httpServer, {
+    cors: { origin: true, credentials: true },
+  });
+
+  const connection = RedisClient.getConnection();
+  const generalLimiter = connection
+    ? new RateLimiterRedis({
+        storeClient: connection,
+        keyPrefix: "multiplayer-rl-general",
+        points: GENERAL_EVENT_LIMIT_PER_SECOND,
+        duration: 1,
+      })
+    : new RateLimiterMemory({
+        points: GENERAL_EVENT_LIMIT_PER_SECOND,
+        duration: 1,
+      });
+
+  io.use(socketAuthMiddleware);
+
+  io.on("connection", (socket) => {
+    Logger.info(`Multiplayer socket connected: ${socket.data.uid}`);
+
+    socket.use((event, next) => {
+      generalLimiter
+        .consume(socket.data.uid)
+        .then(() => next())
+        .catch(() => {
+          // rate limited: silently drop the event rather than disconnecting,
+          // since a burst is likely a slow client tab, not abuse
+          next(new Error("rate limited"));
+        });
+    });
+
+    registerRoomHandlers(io as MultiplayerIO, socket);
+  });
+
+  return io;
+}
+
+export function getIO(): MultiplayerIO {
+  if (!io) {
+    throw new Error("Socket.IO server has not been attached yet");
+  }
+  return io;
+}

backend/src/server.ts

@@ -6,7 +6,8 @@ import {
   updateFromConfigurationFile,
 } from "./init/configuration";
 import app from "./app";
-import { Server } from "http";
+import { createServer, Server } from "http";
+import { attachSocketServer } from "./init/socket";
 import { version } from "./version";
 import { recordServerVersion } from "./utils/prometheus";
 import * as RedisClient from "./init/redis";
@@ -89,7 +90,10 @@ async function bootServer(port: number): Promise<Server> {
     return process.exit(1);
   }
 
-  return app.listen(port, () => {
+  const httpServer = createServer(app);
+  attachSocketServer(httpServer);
+
+  return httpServer.listen(port, () => {
     Logger.success(`API server listening on port ${port}`);
   });
 }