feat: redesign auction engine with redis sot

This commit is contained in:
dahyeon committed 2026-06-23 03:16:04 -07:00
1 parent 737702d78c
commit e8bb20d988
75 files changed
+12737 -542

No files matched your search

+267 -108
View File
@@ -1,9 +1,11 @@
import { Logger } from '@nestjs/common';
import { randomUUID } from 'crypto';
import {
Ack,
ConnectedSocket,
MessageBody,
OnGatewayConnection,
OnGatewayDisconnect,
OnGatewayInit,
SubscribeMessage,
WebSocketGateway,
WebSocketServer,
@@ -23,26 +25,50 @@ import type {
UserDocument,
} from '../global/database/schema';
import { AuctionService } from './auction.service';
import type { AuctionStateResponse } from './auction.service';
import { AuctionEventBusService } from './auction-event-bus.service';
import type { MatchSideEffectDelta } from './auction-side-effect.service';
interface JoinAuctionPayload {
matchId: string;
}
interface BidPayload {
teamIndex: number;
amount: number;
bidderUserId?: string;
bidderTeamIndex: number;
bidPointAmount: number;
bidRequestId?: string;
clientObservedAuctionLifecycleId?: string;
clientObservedCurrentBidRoundPlayerUserId?: string;
}
interface SoldPayload {
auctionActionRequestId?: string;
assignedPosition?: Position;
clientObservedAuctionLifecycleId?: string;
clientObservedCurrentAuctionPlayerOrderIndex?: number;
clientObservedCurrentBidRoundPlayerUserId?: string;
clientObservedPhase?: string;
clientObservedRevision?: number;
}
type AuctionActionPayload = Omit<SoldPayload, 'assignedPosition'>;
interface ChatMessagePayload {
message?: string;
displayName?: string;
}
interface BidRateLimitState {
count: number;
windowStartedAtTimestampMS: number;
}
const BID_RATE_LIMIT_WINDOW_MS = 1000;
const BID_RATE_LIMIT_MAX_REQUESTS_PER_WINDOW = 8;
const BID_RATE_LIMIT_REJECTION_CODE = 'BID_RATE_LIMITED';
const BID_RATE_LIMIT_REJECTION_MESSAGE =
'입찰 요청이 너무 많습니다. 잠시 후 다시 시도해주세요.';
@WebSocketGateway({
namespace: '/auction',
cors: {
@@ -52,13 +78,12 @@ interface ChatMessagePayload {
},
})
export class AuctionGateway
implements OnGatewayConnection, OnGatewayDisconnect
implements OnGatewayConnection, OnGatewayInit
{
@WebSocketServer()
private server!: Namespace;
private readonly logger = new Logger(AuctionGateway.name);
private readonly roomTimers = new Map<string, NodeJS.Timeout>();
constructor(
private readonly auctionService: AuctionService,
@@ -66,8 +91,13 @@ export class AuctionGateway
private readonly jwtService: JwtService,
private readonly identityService: IdentityService,
private readonly connectionService: ConnectionService,
private readonly auctionEventBusService: AuctionEventBusService,
) {}
public afterInit(server: Namespace): void {
this.auctionEventBusService.attachAuctionNamespace(server);
}
public async handleConnection(socket: Socket) {
try {
await this.authenticateSocket(socket);
@@ -82,12 +112,6 @@ export class AuctionGateway
}
}
public handleDisconnect(socket: Socket) {
const matchId = this.getSocketMatchId(socket);
if (!matchId) return;
this.maybeClearRoomTimer(matchId);
}
@SubscribeMessage('join')
public async handleJoin(
@ConnectedSocket() socket: Socket,
@@ -106,8 +130,11 @@ export class AuctionGateway
const auction = await this.auctionService.getByMatchId(
new mongoose.Types.ObjectId(payload.matchId),
);
const auctionState = await this.auctionService.getStateByMatchId(
new mongoose.Types.ObjectId(payload.matchId),
);
this.emitChatHistory(socket, auction);
this.broadcastState(payload.matchId, auction);
this.broadcastState(payload.matchId, auctionState);
} catch (error) {
this.emitKnownError(socket, error);
}
@@ -117,41 +144,85 @@ export class AuctionGateway
public async handleBid(
@ConnectedSocket() socket: Socket,
@MessageBody() payload: BidPayload,
@Ack() ack?: (response: Record<string, unknown>) => void,
) {
const matchId = this.requireJoinedMatchId(socket);
if (!matchId) return;
const bidderUserId = this.resolveBidderUserId(socket, payload?.bidderUserId);
if (payload?.bidderUserId && !bidderUserId) {
this.emitError(socket, 'Invalid bidderUserId.');
const bidRequestId = payload.bidRequestId ?? randomUUID();
if (!this.consumeBidRateLimit(socket)) {
this.emitError(socket, BID_RATE_LIMIT_REJECTION_MESSAGE);
ack?.({
bidRequestId,
code: BID_RATE_LIMIT_REJECTION_CODE,
message: BID_RATE_LIMIT_REJECTION_MESSAGE,
rejected: true,
});
return;
}
try {
const auction = await this.auctionService.placeBid({
matchId: new mongoose.Types.ObjectId(matchId),
teamIndex: payload.teamIndex,
amount: payload.amount,
bidderUserId,
teamIndex: payload.bidderTeamIndex,
amount: payload.bidPointAmount,
bidRequestId,
clientObservedAuctionLifecycleId:
payload.clientObservedAuctionLifecycleId,
clientObservedCurrentBidRoundPlayerUserId:
payload.clientObservedCurrentBidRoundPlayerUserId,
});
const bidDelta = this.buildBidDeltaFromAuctionState(
auction,
bidRequestId,
);
if (bidDelta) {
this.broadcastBid(matchId, bidDelta);
} else {
this.broadcastState(matchId, auction);
}
ack?.({
ok: true,
bidRequestId,
state: this.serializeAuction(auction),
});
this.broadcastState(matchId, auction);
} catch (error) {
this.emitKnownError(socket, error);
ack?.({
bidRequestId,
code: error instanceof Error ? error.message : 'UNKNOWN',
rejected: true,
});
}
}
@SubscribeMessage('open-bidding')
public async handleOpenBidding(@ConnectedSocket() socket: Socket) {
public async handleOpenBidding(
@ConnectedSocket() socket: Socket,
@MessageBody() payload: AuctionActionPayload,
@Ack() ack?: (response: Record<string, unknown>) => void,
) {
const matchId = this.requireJoinedMatchId(socket);
if (!matchId) return;
try {
const auction = await this.auctionService.openBidding(
new mongoose.Types.ObjectId(matchId),
this.toAuctionActionRequest(payload),
);
this.broadcastState(matchId, auction);
ack?.({
auctionActionRequestId: payload?.auctionActionRequestId,
ok: true,
state: this.serializeAuction(auction),
});
} catch (error) {
this.emitKnownError(socket, error);
ack?.({
auctionActionRequestId: payload?.auctionActionRequestId,
code: error instanceof Error ? error.message : 'UNKNOWN',
rejected: true,
});
}
}
@@ -159,6 +230,7 @@ export class AuctionGateway
public async handleSold(
@ConnectedSocket() socket: Socket,
@MessageBody() payload: SoldPayload,
@Ack() ack?: (response: Record<string, unknown>) => void,
) {
const matchId = this.requireJoinedMatchId(socket);
if (!matchId) return;
@@ -167,25 +239,81 @@ export class AuctionGateway
const auction = await this.auctionService.markSold({
matchId: new mongoose.Types.ObjectId(matchId),
assignedPosition: payload?.assignedPosition,
...this.toAuctionActionRequest(payload),
});
this.broadcastState(matchId, auction);
ack?.({
auctionActionRequestId: payload?.auctionActionRequestId,
ok: true,
state: this.serializeAuction(auction),
});
} catch (error) {
this.emitKnownError(socket, error);
ack?.({
auctionActionRequestId: payload?.auctionActionRequestId,
code: error instanceof Error ? error.message : 'UNKNOWN',
rejected: true,
});
}
}
@SubscribeMessage('next')
public async handleNext(@ConnectedSocket() socket: Socket) {
public async handleNext(
@ConnectedSocket() socket: Socket,
@MessageBody() payload: AuctionActionPayload,
@Ack() ack?: (response: Record<string, unknown>) => void,
) {
const matchId = this.requireJoinedMatchId(socket);
if (!matchId) return;
try {
const auction = await this.auctionService.next(
new mongoose.Types.ObjectId(matchId),
this.toAuctionActionRequest(payload),
);
this.broadcastState(matchId, auction);
ack?.({
auctionActionRequestId: payload?.auctionActionRequestId,
ok: true,
state: this.serializeAuction(auction),
});
} catch (error) {
this.emitKnownError(socket, error);
ack?.({
auctionActionRequestId: payload?.auctionActionRequestId,
code: error instanceof Error ? error.message : 'UNKNOWN',
rejected: true,
});
}
}
@SubscribeMessage('passed')
public async handlePassed(
@ConnectedSocket() socket: Socket,
@MessageBody() payload: AuctionActionPayload,
@Ack() ack?: (response: Record<string, unknown>) => void,
) {
const matchId = this.requireJoinedMatchId(socket);
if (!matchId) return;
try {
const auction = await this.auctionService.markPassed(
new mongoose.Types.ObjectId(matchId),
this.toAuctionActionRequest(payload),
);
this.broadcastState(matchId, auction);
ack?.({
auctionActionRequestId: payload?.auctionActionRequestId,
ok: true,
state: this.serializeAuction(auction),
});
} catch (error) {
this.emitKnownError(socket, error);
ack?.({
auctionActionRequestId: payload?.auctionActionRequestId,
code: error instanceof Error ? error.message : 'UNKNOWN',
rejected: true,
});
}
}
@@ -226,24 +354,45 @@ export class AuctionGateway
return matchId;
}
private consumeBidRateLimit(socket: Socket): boolean {
const currentTimestampMS = Date.now();
const previousState = socket.data
.auctionBidRateLimit as BidRateLimitState | undefined;
if (
!previousState ||
currentTimestampMS - previousState.windowStartedAtTimestampMS >=
BID_RATE_LIMIT_WINDOW_MS
) {
socket.data.auctionBidRateLimit = {
count: 1,
windowStartedAtTimestampMS: currentTimestampMS,
};
return true;
}
previousState.count += 1;
socket.data.auctionBidRateLimit = previousState;
return previousState.count <= BID_RATE_LIMIT_MAX_REQUESTS_PER_WINDOW;
}
private getSocketMatchId(socket: Socket): string | undefined {
return typeof socket.data.matchId === 'string'
? socket.data.matchId
: undefined;
}
private resolveBidderUserId(
socket: Socket,
payloadBidderUserId?: string,
): mongoose.Types.ObjectId | undefined {
const candidate =
payloadBidderUserId ??
(socket.data.user as UserDocument | undefined)?._id.toString() ??
this.readHandshakeUserId(socket);
if (!candidate || !mongoose.isValidObjectId(candidate)) {
return undefined;
}
return new mongoose.Types.ObjectId(candidate);
private toAuctionActionRequest(payload?: AuctionActionPayload) {
return {
auctionActionRequestId: payload?.auctionActionRequestId,
clientObservedAuctionLifecycleId:
payload?.clientObservedAuctionLifecycleId,
clientObservedCurrentAuctionPlayerOrderIndex:
payload?.clientObservedCurrentAuctionPlayerOrderIndex,
clientObservedCurrentBidRoundPlayerUserId:
payload?.clientObservedCurrentBidRoundPlayerUserId,
clientObservedPhase: payload?.clientObservedPhase,
clientObservedRevision: payload?.clientObservedRevision,
};
}
private readHandshakeUserId(socket: Socket): string | undefined {
@@ -359,16 +508,25 @@ export class AuctionGateway
return typeof value === 'string' && value.length > 0 ? value : undefined;
}
public broadcastState(matchId: string, auction: AuctionDocument) {
public broadcastState(matchId: string, auction: AuctionStateResponse) {
this.server.to(matchId).emit('state', this.serializeAuction(auction));
this.syncRoomTimer(matchId, auction);
}
public broadcastBid(matchId: string, delta: Record<string, unknown>) {
this.server.to(matchId).emit('bid', delta);
}
public broadcastReset(matchId: string) {
this.clearRoomTimer(matchId);
this.server.to(matchId).emit('reset', { matchId });
}
public broadcastMatchSideEffect(
matchId: string,
delta: MatchSideEffectDelta,
) {
this.server.to(matchId).emit('match-side-effect', delta);
}
private emitChatHistory(socket: Socket, auction: AuctionDocument) {
socket.emit('chat-history', {
messages: (auction.chatMessages ?? []).map((message) =>
@@ -377,90 +535,91 @@ export class AuctionGateway
});
}
private syncRoomTimer(matchId: string, auction: AuctionDocument) {
this.clearRoomTimer(matchId);
if (!auction.currentDeadline) return;
const deadline = auction.currentDeadline;
const deadlineIso = deadline.toISOString();
if (Date.now() >= deadline.getTime()) {
void this.handleDeadlineExpiry(matchId);
return;
}
this.server.to(matchId).emit('tick', {
deadline: deadlineIso,
serverTime: new Date().toISOString(),
});
const timer = setInterval(() => {
this.server.to(matchId).emit('tick', {
deadline: deadlineIso,
serverTime: new Date().toISOString(),
});
if (Date.now() >= deadline.getTime()) {
this.clearRoomTimer(matchId);
void this.handleDeadlineExpiry(matchId);
}
}, 1000);
this.roomTimers.set(matchId, timer);
}
private async handleDeadlineExpiry(matchIdStr: string) {
const matchId = new mongoose.Types.ObjectId(matchIdStr);
const auction = await this.auctionService
.getByMatchId(matchId)
.catch(() => null);
if (!auction || auction.phase !== 'bidding') return;
if (!auction.currentDeadline || auction.currentDeadline.getTime() > Date.now()) {
return;
}
try {
const nextAuction =
auction.currentBid > 0
? await this.auctionService.markSold({ matchId })
: await this.auctionService.markPassed(matchId);
this.broadcastState(matchIdStr, nextAuction);
} catch (error) {
this.emitKnownErrorToRoom(matchIdStr, error);
}
}
private maybeClearRoomTimer(matchId: string) {
const room = this.server.adapter.rooms.get(matchId);
if (room && room.size > 0) return;
this.clearRoomTimer(matchId);
}
private clearRoomTimer(matchId: string) {
const timer = this.roomTimers.get(matchId);
if (!timer) return;
clearInterval(timer);
this.roomTimers.delete(matchId);
}
private emitKnownError(socket: Socket, error: unknown) {
const message =
error instanceof Error ? error.message : 'Unexpected auction gateway error.';
this.emitError(socket, message);
}
private emitKnownErrorToRoom(matchId: string, error: unknown) {
const message =
error instanceof Error ? error.message : 'Unexpected auction gateway error.';
this.server.to(matchId).emit('error', { message });
}
private emitError(socket: Socket, message: string) {
socket.emit('error', { message });
}
private serializeAuction(auction: AuctionDocument) {
private serializeAuction(auction: AuctionStateResponse) {
return JSON.parse(JSON.stringify(auction));
}
private buildBidDeltaFromAuctionState(
auction: AuctionStateResponse,
bidRequestId?: string,
): Record<string, unknown> | null {
const serialized = this.serializeAuction(auction) as Record<string, unknown>;
const revision = Number(serialized.revision);
const currentHighestBidPointAmount = Number(
serialized.currentHighestBidPointAmount ?? serialized.currentBid,
);
const currentHighestBidderTeamIndex = Number(
serialized.currentHighestBidderTeamIndex ??
serialized.currentBidderTeamIndex,
);
const currentBidRoundDeadlineTimestampMS = Number(
serialized.currentBidRoundDeadlineTimestampMS ??
(typeof serialized.currentDeadline === 'string'
? Date.parse(serialized.currentDeadline)
: 0),
);
const redisBidHistory = Array.isArray(serialized.auctionBidHistory)
? serialized.auctionBidHistory
: [];
const legacyBidHistory = Array.isArray(serialized.bids)
? serialized.bids
: [];
const auctionBidHistoryEntry =
redisBidHistory[redisBidHistory.length - 1] ??
this.convertLegacyBidToRedisBidHistoryEntry(
legacyBidHistory[legacyBidHistory.length - 1],
);
if (
!Number.isFinite(currentHighestBidPointAmount) ||
!Number.isFinite(currentHighestBidderTeamIndex) ||
!auctionBidHistoryEntry
) {
return null;
}
return {
auctionBidHistoryEntry,
auctionLifecycleId: serialized.auctionLifecycleId,
bidRequestId,
currentBidRoundDeadlineTimestampMS: Number.isFinite(
currentBidRoundDeadlineTimestampMS,
)
? currentBidRoundDeadlineTimestampMS
: undefined,
currentHighestBidPointAmount,
currentHighestBidderTeamIndex,
currentServerTimestampMS: serialized.currentServerTimestampMS,
revision: Number.isFinite(revision) ? revision : undefined,
};
}
private convertLegacyBidToRedisBidHistoryEntry(
bid: unknown,
): Record<string, unknown> | null {
if (!bid || typeof bid !== 'object') return null;
const record = bid as Record<string, unknown>;
return {
bidderTeamIndex: record.teamIndex,
bidPointAmount: record.amount,
bidderUserId: record.bidderUserId,
bidPlacedAtTimestampMS:
typeof record.timestamp === 'string'
? Date.parse(record.timestamp)
: undefined,
};
}
private serializeChatMessage(message: AuctionChatMessage) {
return JSON.parse(JSON.stringify(message));
}