Echtzeit.
Keine Kompromisse.

// server/middleware/socket-auth.ts
import { Server } from "socket.io";
import jwt from "jsonwebtoken";

interface AuthPayload {
  userId: string;
  role: "buyer" | "seller" | "admin";
}

export function registerAuthMiddleware(io: Server) {
  io.use((socket, next) => {
    const token = socket.handshake.auth?.token;

    if (!token) {
      return next(new Error("AUTH_REQUIRED"));
    }

    try {
      const payload = jwt.verify(
        token,
        process.env.JWT_SECRET!
      ) as AuthPayload;

      // Nutzerdaten am Socket-Objekt speichern
      socket.data.userId = payload.userId;
      socket.data.role = payload.role;

      next();
    } catch {
      next(new Error("TOKEN_INVALID"));
    }
  });
}

// server/handlers/presence.ts
import { Server, Socket } from "socket.io";

const onlineUsers = new Map<string, {
  socketId: string;
  lastSeen: Date;
}>();

export function registerPresence(
  io: Server,
  socket: Socket
) {
  const userId = socket.data.userId;

  // Nutzer als online markieren
  onlineUsers.set(userId, {
    socketId: socket.id,
    lastSeen: new Date(),
  });

  // Allen Kontakten mitteilen: Nutzer ist online
  socket.broadcast.emit("presence:update", {
    userId,
    status: "online",
  });

  // Bei Verbindungsabbruch: Offline-Status senden
  socket.on("disconnect", () => {
    onlineUsers.delete(userId);
    io.emit("presence:update", {
      userId,
      status: "offline",
      lastSeen: new Date(),
    });
  });

  // Aktuelle Online-Liste an neuen Nutzer senden
  socket.emit(
    "presence:list",
    Array.from(onlineUsers.keys())
  );
}

// server/index.ts
import { Server } from "socket.io";
import { createAdapter } from "@socket.io/redis-adapter";
import { createClient } from "redis";
import { registerAuthMiddleware } from "./middleware/socket-auth";

const pubClient = createClient({
  url: process.env.REDIS_URL,
});
const subClient = pubClient.duplicate();

async function bootstrap() {
  await Promise.all([
    pubClient.connect(),
    subClient.connect(),
  ]);

  const io = new Server(3001, {
    cors: { origin: process.env.CLIENT_URL },
    // MessagePack fuer 60% weniger Bandbreite
    parser: require("socket.io-msgpack-parser"),
  });

  // Redis Adapter fuer Cross-Instance Events
  io.adapter(createAdapter(pubClient, subClient));

  // Auth Middleware registrieren
  registerAuthMiddleware(io);

  io.on("connection", (socket) => {
    // Room beitreten (z.B. Konversation)
    socket.on("room:join", (roomId: string) => {
      socket.join(roomId);
    });

    // Nachricht an Room senden
    socket.on("message:send", (data) => {
      // Nur an andere Nutzer im Room
      socket.to(data.roomId).emit("message:new", {
        from: socket.data.userId,
        text: data.text,
        timestamp: Date.now(),
      });
    });
  });
}

bootstrap();