Add analysis REST API

This commit is contained in:
dahyeon committed 2026-07-02 21:01:26 -07:00
1 parent 770c198ccd
commit e1164e0b47
10 files changed
+867 -5

No files matched your search

@@ -0,0 +1,178 @@
import { Injectable, NotFoundException } from '@nestjs/common';
import {
METRICS,
type AnalysisJobStatusDto,
type MetricValueDto,
type PlayerAnalysisDto,
} from '@persona-lenz/shared';
import { ConnectionService } from '../global/database/connection.service';
import type {
Account,
AnalysisJob,
PlayerProfile,
TierInfo,
} from '../global/database/schemas';
type JobStatusRecord = Pick<
AnalysisJob,
'error' | 'jobId' | 'progress' | 'puuid' | 'stage' | 'status'
>;
type AccountSummaryRecord = Pick<
Account,
'gameName' | 'profileIconId' | 'tagLine' | 'tiers'
>;
type PlayerProfileRecord = Pick<
PlayerProfile,
| 'championPool'
| 'confidence'
| 'featureSchemaVersion'
| 'mainRole'
| 'profile'
| 'queueId'
| 'sampleGameCount'
| 'updatedAt'
>;
@Injectable()
export class AnalysisReadService {
constructor(private readonly connectionService: ConnectionService) {}
public async getJobStatus(jobId: string): Promise<AnalysisJobStatusDto> {
const analysisJobModel =
await this.connectionService.getModel('analysisJob');
const job = await analysisJobModel
.findOne({ jobId })
.lean<JobStatusRecord>()
.exec();
if (!job) {
throw new NotFoundException('Analysis job not found.');
}
return {
jobId: job.jobId,
status: job.status,
stage: job.stage,
puuid: job.puuid,
progress: job.progress,
error: this.publicJobError(job.error),
};
}
public async getLatestPlayerAnalysis(
puuid: string,
queueId: number,
): Promise<PlayerAnalysisDto> {
const [account, profile] = await Promise.all([
this.findAccount(puuid),
this.findPlayerProfile(puuid, queueId),
]);
if (!account) {
throw new NotFoundException('Player account not found.');
}
if (!profile) {
throw new NotFoundException('분석할 랭크 게임이 없음');
}
return {
account: {
gameName: account.gameName,
tagLine: account.tagLine,
profileIconId: account.profileIconId,
tiers: account.tiers.map((tier) => this.toTierDto(tier)),
},
profile: {
mainRole: profile.mainRole,
queueId: profile.queueId,
sampleGameCount: profile.sampleGameCount,
championPool: profile.championPool,
playstyle: Object.fromEntries(
METRICS.map((metric) => [
metric.id,
this.clampMetricValue(profile.profile[metric.id]),
]),
) as PlayerAnalysisDto['profile']['playstyle'],
featureSchemaVersion: profile.featureSchemaVersion,
confidence: profile.confidence,
},
strengths: this.resolveMetricHighlights(profile.profile, 'strength'),
weaknesses: this.resolveMetricHighlights(profile.profile, 'weakness'),
updatedAt: profile.updatedAt.toISOString(),
};
}
private async findAccount(
puuid: string,
): Promise<AccountSummaryRecord | null> {
const accountModel = await this.connectionService.getModel('account');
return accountModel.findOne({ puuid }).lean<AccountSummaryRecord>().exec();
}
private async findPlayerProfile(
puuid: string,
queueId: number,
): Promise<PlayerProfileRecord | null> {
const playerProfileModel =
await this.connectionService.getModel('playerProfile');
return playerProfileModel
.findOne({ puuid, queueId })
.lean<PlayerProfileRecord>()
.exec();
}
private resolveMetricHighlights(
profile: Record<string, number>,
direction: 'strength' | 'weakness',
): MetricValueDto[] {
return METRICS.map((metric) => {
const value = this.clampMetricValue(profile[metric.id]);
return {
metricId: metric.id,
score: metric.direction === 'lowerIsBetter' ? 1 - value : value,
value,
};
})
.sort((left, right) =>
direction === 'strength'
? right.score - left.score
: left.score - right.score,
)
.slice(0, 3)
.map(({ metricId, value }) => ({ metricId, value }));
}
private clampMetricValue(value: unknown): number {
return typeof value === 'number' && Number.isFinite(value)
? Math.max(0, Math.min(1, value))
: 0;
}
private toTierDto(
tier: TierInfo,
): PlayerAnalysisDto['account']['tiers'][number] {
return {
queueType: tier.queueType,
tier: tier.tier,
rank: tier.rank,
leaguePoints: tier.leaguePoints,
wins: tier.wins,
losses: tier.losses,
fetchedAt: tier.fetchedAt?.toISOString(),
};
}
private publicJobError(error: string | undefined): string | null {
if (!error) return null;
if (
error === 'Analysis failed during processing.' ||
error === 'Riot API key is invalid or expired.' ||
error === 'Analysis could not be queued.'
) {
return error;
}
return 'Analysis failed during processing.';
}
}