154 lines
4.8 KiB
TypeScript
154 lines
4.8 KiB
TypeScript
import { Injectable, Logger } from '@nestjs/common';
|
|
import type {
|
|
RiotMatchDocument,
|
|
RiotMatch as StoredRiotMatch,
|
|
} from '../global/database/schema';
|
|
import { ConnectionService } from '../global/database/connection.service';
|
|
import { GarnetService } from '../global/garnet/garnet.service';
|
|
import type { RiotRegionalRoute } from './riot.types';
|
|
import { RiotMatchService } from './riot-match.service';
|
|
|
|
export const RIOT_RECENT_MATCH_LIMIT = 20;
|
|
export const RIOT_SOLO_QUEUE_ID = 420;
|
|
|
|
const MATCH_ENRICHMENT_LOCK_TTL_SECONDS = 60;
|
|
const MATCH_DETAIL_CONCURRENCY = 2;
|
|
const DEFAULT_REGION: RiotRegionalRoute = 'asia';
|
|
|
|
@Injectable()
|
|
export class RiotRecentMatchesService {
|
|
private readonly logger = new Logger(RiotRecentMatchesService.name);
|
|
|
|
constructor(
|
|
private readonly connectionService: ConnectionService,
|
|
private readonly matchService: RiotMatchService,
|
|
private readonly garnetService: GarnetService,
|
|
) {}
|
|
|
|
public async syncRecentMatches(params: {
|
|
puuid: string;
|
|
region?: RiotRegionalRoute;
|
|
limit?: number;
|
|
queueId?: number;
|
|
}): Promise<RiotMatchDocument[]> {
|
|
const region = params.region ?? DEFAULT_REGION;
|
|
const limit = params.limit ?? RIOT_RECENT_MATCH_LIMIT;
|
|
const queueId = params.queueId ?? RIOT_SOLO_QUEUE_ID;
|
|
const lockKey = `riot:enrich:matches:${params.puuid}`;
|
|
const lockValue = `${process.pid}:${Date.now()}`;
|
|
|
|
const acquired = await this.garnetService.setStringIfAbsent(
|
|
lockKey,
|
|
lockValue,
|
|
MATCH_ENRICHMENT_LOCK_TTL_SECONDS,
|
|
);
|
|
if (!acquired) {
|
|
return this.loadFromDb({ puuid: params.puuid, limit, queueId });
|
|
}
|
|
|
|
try {
|
|
const matchIds = await this.matchService.getMatchIdsByPuuid(params.puuid, {
|
|
region,
|
|
queue: queueId,
|
|
count: limit,
|
|
});
|
|
if (matchIds.length === 0) {
|
|
return this.loadFromDb({ puuid: params.puuid, limit, queueId });
|
|
}
|
|
|
|
const RiotMatchModel = await this.connectionService.getModel('riotMatch');
|
|
const existingMatches = await RiotMatchModel.find({
|
|
matchId: { $in: matchIds },
|
|
})
|
|
.select({ matchId: 1 })
|
|
.lean()
|
|
.exec();
|
|
const existingMatchIds = new Set(existingMatches.map((match) => match.matchId));
|
|
const missingMatchIds = matchIds.filter((matchId) => !existingMatchIds.has(matchId));
|
|
|
|
await runWithConcurrency(missingMatchIds, MATCH_DETAIL_CONCURRENCY, async (matchId) => {
|
|
const dto = await this.matchService.getMatch(matchId, { region });
|
|
if (dto.info.queueId !== queueId) {
|
|
this.logger.warn(
|
|
`Skipping unexpected queue ${dto.info.queueId} for ${matchId} while syncing ${params.puuid}.`,
|
|
);
|
|
return;
|
|
}
|
|
|
|
const payload: Partial<StoredRiotMatch> = {
|
|
matchId: dto.metadata.matchId,
|
|
gameCreation: dto.info.gameCreation,
|
|
gameDuration: dto.info.gameDuration,
|
|
gameVersion: dto.info.gameVersion,
|
|
queueId: dto.info.queueId,
|
|
participantPuuids: dto.metadata.participants,
|
|
raw: dto as unknown as Record<string, unknown>,
|
|
fetchedAt: new Date(),
|
|
};
|
|
|
|
await RiotMatchModel.updateOne(
|
|
{ matchId: dto.metadata.matchId },
|
|
{ $setOnInsert: payload },
|
|
{ upsert: true },
|
|
).exec();
|
|
});
|
|
|
|
return this.loadFromDb({ puuid: params.puuid, limit, queueId });
|
|
} finally {
|
|
await this.garnetService.delete(lockKey).catch((error: unknown) => {
|
|
this.logger.warn(
|
|
`Failed to release recent matches lock for ${params.puuid}: ${
|
|
(error as Error)?.message ?? error
|
|
}`,
|
|
);
|
|
});
|
|
}
|
|
}
|
|
|
|
public async ensureFreshForQueue(params: {
|
|
puuid: string;
|
|
region?: RiotRegionalRoute;
|
|
queueId: number;
|
|
limit?: number;
|
|
}): Promise<RiotMatchDocument[]> {
|
|
return this.syncRecentMatches(params);
|
|
}
|
|
|
|
public async loadFromDb(params: {
|
|
puuid: string;
|
|
limit?: number;
|
|
queueId?: number;
|
|
}): Promise<RiotMatchDocument[]> {
|
|
const limit = params.limit ?? RIOT_RECENT_MATCH_LIMIT;
|
|
const queueId = params.queueId ?? RIOT_SOLO_QUEUE_ID;
|
|
const RiotMatchModel = await this.connectionService.getModel('riotMatch');
|
|
|
|
return RiotMatchModel.find({
|
|
participantPuuids: params.puuid,
|
|
queueId,
|
|
})
|
|
.sort({ gameCreation: -1 })
|
|
.limit(limit)
|
|
.exec();
|
|
}
|
|
}
|
|
|
|
async function runWithConcurrency<T>(
|
|
items: T[],
|
|
concurrency: number,
|
|
worker: (item: T) => Promise<void>,
|
|
): Promise<void> {
|
|
if (items.length === 0) return;
|
|
|
|
const queue = [...items];
|
|
const runners = Array.from({ length: Math.min(concurrency, queue.length) }, async () => {
|
|
while (queue.length > 0) {
|
|
const item = queue.shift();
|
|
if (item === undefined) return;
|
|
await worker(item);
|
|
}
|
|
});
|
|
|
|
await Promise.all(runners);
|
|
}
|