feat: add auction chat

This commit is contained in:
dahyeon committed 2026-06-07 07:20:35 -07:00
1 parent c4f19d256d
commit 5ad0f8a1c2
7 files changed
+449 -20

No files matched your search

@@ -16,6 +16,7 @@ import { IdentityService } from '../auth/identity.service';
import { JwtService } from '../auth/jwt.service';
import { ConnectionService } from '../global/database/connection.service';
import type {
AuctionChatMessage,
AuctionDocument,
IdentityDocument,
Position,
@@ -37,6 +38,11 @@ interface SoldPayload {
assignedPosition?: Position;
}
interface ChatMessagePayload {
message?: string;
displayName?: string;
}
@WebSocketGateway({
namespace: '/auction',
cors: {
@@ -100,6 +106,7 @@ export class AuctionGateway
const auction = await this.auctionService.getByMatchId(
new mongoose.Types.ObjectId(payload.matchId),
);
this.emitChatHistory(socket, auction);
this.broadcastState(payload.matchId, auction);
} catch (error) {
this.emitKnownError(socket, error);
@@ -182,6 +189,34 @@ export class AuctionGateway
}
}
@SubscribeMessage('chat-message')
public async handleChatMessage(
@ConnectedSocket() socket: Socket,
@MessageBody() payload: ChatMessagePayload,
) {
const matchId = this.requireJoinedMatchId(socket);
if (!matchId) return;
if (typeof payload?.message !== 'string') {
this.emitError(socket, 'Chat message is required.');
return;
}
try {
const { message } = await this.auctionService.appendChatMessage({
matchId: new mongoose.Types.ObjectId(matchId),
userId: this.resolveSocketUserId(socket),
displayName: this.resolveChatDisplayName(socket, payload.displayName),
message: payload.message,
});
this.server
.to(matchId)
.emit('chat-message', this.serializeChatMessage(message));
} catch (error) {
this.emitKnownError(socket, error);
}
}
private requireJoinedMatchId(socket: Socket): string | null {
const matchId = this.getSocketMatchId(socket);
if (!matchId) {
@@ -219,6 +254,36 @@ export class AuctionGateway
return Array.isArray(header) ? header[0] : header;
}
private resolveSocketUserId(
socket: Socket,
): mongoose.Types.ObjectId | undefined {
return (socket.data.user as UserDocument | undefined)?._id;
}
private resolveChatDisplayName(
socket: Socket,
fallbackDisplayName?: string,
): string {
const user = socket.data.user as UserDocument | undefined;
const primaryRiotAccount =
user?.riotAccounts.find((entry) => entry.isPrimary) ??
user?.riotAccounts[0];
if (primaryRiotAccount?.gameName) {
return primaryRiotAccount.tagLine
? `${primaryRiotAccount.gameName}#${primaryRiotAccount.tagLine}`
: primaryRiotAccount.gameName;
}
if (user?.kakaoTalkNickname) return user.kakaoTalkNickname;
if (user?.discordNickname) return user.discordNickname;
const identity = socket.data.identity as IdentityDocument | undefined;
if (identity?.displayName) return identity.displayName;
if (identity?.email) return identity.email;
return fallbackDisplayName ?? '관전자';
}
private async authenticateSocket(socket: Socket): Promise<void> {
const fallback = await this.authService.resolveDevUserById(
this.readHandshakeUserId(socket),
@@ -299,6 +364,14 @@ export class AuctionGateway
this.syncRoomTimer(matchId, auction);
}
private emitChatHistory(socket: Socket, auction: AuctionDocument) {
socket.emit('chat-history', {
messages: (auction.chatMessages ?? []).map((message) =>
this.serializeChatMessage(message),
),
});
}
private syncRoomTimer(matchId: string, auction: AuctionDocument) {
this.clearRoomTimer(matchId);
if (!auction.currentDeadline) return;
@@ -382,4 +455,8 @@ export class AuctionGateway
private serializeAuction(auction: AuctionDocument) {
return JSON.parse(JSON.stringify(auction));
}
private serializeChatMessage(message: AuctionChatMessage) {
return JSON.parse(JSON.stringify(message));
}
}
@@ -159,6 +159,76 @@ describe('AuctionService', () => {
expect(tournamentResultService.scheduleInitialPoll).not.toHaveBeenCalled();
});
it('appends a chat message and keeps only the latest 200 messages', async () => {
const matchId = new mongoose.Types.ObjectId();
const userId = new mongoose.Types.ObjectId();
const oldMessages = Array.from({ length: 200 }, (_, index) => ({
id: `old-${index}`,
displayName: 'Old',
message: `old message ${index}`,
sentAt: new Date(index),
}));
const auction = {
matchId,
chatMessages: oldMessages,
save: jest.fn().mockResolvedValue(undefined),
};
const { service } = createService({
auction: {
findOne: jest.fn().mockResolvedValue(auction),
},
});
const appended = await service.appendChatMessage({
matchId,
userId,
displayName: ' Captain One ',
message: ' 좋은 픽입니다 ',
});
expect(appended.message).toMatchObject({
userId,
displayName: 'Captain One',
message: '좋은 픽입니다',
});
expect(appended.message.id).toHaveLength(36);
expect(appended.message.sentAt).toBeInstanceOf(Date);
expect(auction.chatMessages).toHaveLength(200);
expect(auction.chatMessages[0].id).toBe('old-1');
expect(auction.chatMessages.at(-1)).toBe(appended.message);
expect(auction.save).toHaveBeenCalledTimes(1);
});
it('rejects blank and overly long chat messages', async () => {
const matchId = new mongoose.Types.ObjectId();
const auction = {
matchId,
chatMessages: [],
save: jest.fn().mockResolvedValue(undefined),
};
const { service } = createService({
auction: {
findOne: jest.fn().mockResolvedValue(auction),
},
});
await expect(
service.appendChatMessage({
matchId,
displayName: 'Spectator',
message: ' ',
}),
).rejects.toThrow('Chat message is required.');
await expect(
service.appendChatMessage({
matchId,
displayName: 'Spectator',
message: 'a'.repeat(301),
}),
).rejects.toThrow('Chat message must be 300 characters or less.');
expect(auction.save).not.toHaveBeenCalled();
});
it('randomizes the non-captain player order when starting an auction', async () => {
const randomSpy = jest.spyOn(Math, 'random').mockReturnValue(0);
const matchId = new mongoose.Types.ObjectId();
@@ -5,10 +5,12 @@ import {
Logger,
NotFoundException,
} from '@nestjs/common';
import { randomUUID } from 'crypto';
import mongoose from 'mongoose';
import { ConnectionService } from '../global/database/connection.service';
import {
AuctionActionType,
AuctionChatMessage,
AuctionDocument,
AuctionPlayerSnapshot,
AuctionTeam,
@@ -26,6 +28,9 @@ import { TournamentResultService } from '../tournament-result/tournament-result.
const AUCTION_MAX_TEAM_SIZE = 5;
const AUCTION_BACKGROUND_ENRICHMENT_CONCURRENCY = 1;
const AUCTION_ENRICHMENT_COOLDOWN_MS = 3 * 60 * 60 * 1000;
const AUCTION_CHAT_MAX_MESSAGES = 200;
const AUCTION_CHAT_MAX_MESSAGE_LENGTH = 300;
const AUCTION_CHAT_MAX_DISPLAY_NAME_LENGTH = 24;
interface StartAuctionParams {
matchId: mongoose.Types.ObjectId;
@@ -54,6 +59,13 @@ interface MarkSoldParams {
assignedPosition?: Position;
}
interface AppendChatMessageParams {
matchId: mongoose.Types.ObjectId;
userId?: mongoose.Types.ObjectId;
displayName?: string;
message: string;
}
export interface AuctionHistoryView {
sequence: number;
action: AuctionActionType;
@@ -221,6 +233,31 @@ export class AuctionService {
return auction;
}
public async appendChatMessage(params: AppendChatMessageParams): Promise<{
auction: AuctionDocument;
message: AuctionChatMessage;
}> {
const auction = await this.getByMatchId(params.matchId);
const messageText = this.normalizeChatMessage(params.message);
const message: AuctionChatMessage = {
id: randomUUID(),
userId: params.userId,
displayName: this.normalizeChatDisplayName(params.displayName),
message: messageText,
sentAt: new Date(),
};
auction.chatMessages ??= [];
auction.chatMessages.push(message);
const overflow = auction.chatMessages.length - AUCTION_CHAT_MAX_MESSAGES;
if (overflow > 0) {
auction.chatMessages.splice(0, overflow);
}
await auction.save();
return { auction, message };
}
public async listHistory(params: {
matchId: mongoose.Types.ObjectId;
communityId: mongoose.Types.ObjectId;
@@ -601,6 +638,28 @@ export class AuctionService {
return JSON.parse(JSON.stringify(player)) as AuctionPlayerSnapshot;
}
private normalizeChatMessage(message: string): string {
const normalized = message.trim();
if (!normalized) {
throw new BadRequestException('Chat message is required.');
}
if (Array.from(normalized).length > AUCTION_CHAT_MAX_MESSAGE_LENGTH) {
throw new BadRequestException(
`Chat message must be ${AUCTION_CHAT_MAX_MESSAGE_LENGTH} characters or less.`,
);
}
return normalized;
}
private normalizeChatDisplayName(displayName: string | undefined): string {
const normalized = displayName?.trim() || '관전자';
const chars = Array.from(normalized);
if (chars.length <= AUCTION_CHAT_MAX_DISPLAY_NAME_LENGTH) {
return normalized;
}
return chars.slice(0, AUCTION_CHAT_MAX_DISPLAY_NAME_LENGTH).join('');
}
private async recordSnapshot(
auction: AuctionDocument,
action: AuctionActionType,
@@ -618,6 +618,14 @@ export interface AuctionBid {
timestamp: Date;
}
export interface AuctionChatMessage {
id: string;
userId?: mongoose.Types.ObjectId;
displayName: string;
message: string;
sentAt: Date;
}
export interface Auction extends MongooseTimestamps {
matchId: mongoose.Types.ObjectId;
phase: AuctionPhase;
@@ -635,6 +643,7 @@ export interface Auction extends MongooseTimestamps {
initialPoints: number;
topTierThreshold: AuctionTopTierThreshold;
manualTopTierUserIds: mongoose.Types.ObjectId[];
chatMessages: AuctionChatMessage[];
startedAt?: Date;
completedAt?: Date;
}
@@ -1566,6 +1575,17 @@ const AuctionBidSubSchema = new Schema<AuctionBid>(
{ _id: false },
);
const AuctionChatMessageSubSchema = new Schema<AuctionChatMessage>(
{
id: { type: String, required: true },
userId: { type: Schema.Types.ObjectId, ref: 'user', required: false },
displayName: { type: String, required: true },
message: { type: String, required: true },
sentAt: { type: Date, required: true, default: Date.now },
},
{ _id: false },
);
export const AuctionSchema = new Schema<Auction>(
{
matchId: {
@@ -1612,6 +1632,11 @@ export const AuctionSchema = new Schema<Auction>(
required: true,
default: [],
},
chatMessages: {
type: [AuctionChatMessageSubSchema],
required: true,
default: [],
},
startedAt: { type: Date, required: false },
completedAt: { type: Date, required: false },
},