From e5cbc3e4d41cd909325232bfdb4cad84f6e6385b Mon Sep 17 00:00:00 2001 From: dahyeon Date: Fri, 3 Jul 2026 04:47:16 -0700 Subject: [PATCH] Avoid storing match timelines --- .../analysis-pipeline.service.spec.ts | 176 ++++++++--- .../analysis/analysis-pipeline.service.ts | 286 ++++++++++++++---- 2 files changed, 365 insertions(+), 97 deletions(-) diff --git a/apps/api/src/modules/analysis/analysis-pipeline.service.spec.ts b/apps/api/src/modules/analysis/analysis-pipeline.service.spec.ts index ad84130..8ef8491 100644 --- a/apps/api/src/modules/analysis/analysis-pipeline.service.spec.ts +++ b/apps/api/src/modules/analysis/analysis-pipeline.service.spec.ts @@ -148,6 +148,10 @@ type UpdateOneMock = jest.Mock< ExecQuery, [Record, Record, Record?] >; +type BulkWriteMock = jest.Mock< + Promise, + [Array>] +>; function asRecord(value: unknown): Record { if (typeof value === 'object' && value !== null && !Array.isArray(value)) { @@ -156,12 +160,35 @@ function asRecord(value: unknown): Record { return {}; } -function findTimelineSet(updateRiotMatch: UpdateOneMock) { - const timelineUpdate = updateRiotMatch.mock.calls.find(([, update]) => +function findTimelinePersistUpdate(updateRiotMatch: UpdateOneMock) { + return updateRiotMatch.mock.calls.find(([, update]) => Boolean(asRecord(asRecord(update).$set).timeline), ); - expect(timelineUpdate).toBeDefined(); - return asRecord(asRecord(timelineUpdate?.[1]).$set); +} + +function findTimelineDiscardUpdate(updateRiotMatch: UpdateOneMock) { + return updateRiotMatch.mock.calls.find(([, update]) => + Object.prototype.hasOwnProperty.call( + asRecord(asRecord(update).$unset), + 'timeline', + ), + ); +} + +function playerMatchFeatureBulkSet( + bulkWritePlayerMatchFeature: BulkWriteMock, + puuid = 'target-puuid', +) { + const operations = bulkWritePlayerMatchFeature.mock.calls.flatMap( + ([bulkWriteOperations]) => bulkWriteOperations, + ); + const operation = operations.find((candidate) => { + const updateOne = asRecord(candidate.updateOne); + const filter = asRecord(updateOne.filter); + return filter.puuid === puuid; + }); + expect(operation).toBeDefined(); + return asRecord(asRecord(asRecord(operation?.updateOne).update).$set); } function execResolved(value: T): ExecQuery { @@ -264,6 +291,7 @@ interface PipelineHarnessOptions { accountError?: Error; computeMetricBaselines?: jest.Mock; existingMatchRaw?: Record | null; + existingTargetFeatures?: PlayerMatchFeature[]; existingTimeline?: Record; findOneAccountResult?: Account | null; getMatch?: jest.Mock>, [string, string]>; @@ -313,6 +341,12 @@ function createPipelineHarness(options: PipelineHarnessOptions = {}) { const updatePlayerMatchFeature: UpdateOneMock = jest .fn, Parameters>() .mockReturnValue(execResolved({ acknowledged: true })); + const bulkWritePlayerMatchFeature: BulkWriteMock = jest + .fn, Parameters>() + .mockResolvedValue({ acknowledged: true }); + const findPlayerMatchFeatures = jest + .fn() + .mockReturnValue(leanExecResolved(options.existingTargetFeatures ?? [])); const updatePlayerProfile: UpdateOneMock = jest .fn, Parameters>() .mockReturnValue(execResolved({ acknowledged: true })); @@ -327,6 +361,8 @@ function createPipelineHarness(options: PipelineHarnessOptions = {}) { updateOne: updateAnalysisJob, }, playerMatchFeature: { + bulkWrite: bulkWritePlayerMatchFeature, + find: findPlayerMatchFeatures, updateOne: updatePlayerMatchFeature, }, playerProfile: { @@ -388,7 +424,9 @@ function createPipelineHarness(options: PipelineHarnessOptions = {}) { return { findOneAccount, + findPlayerMatchFeatures, findOneRiotMatch, + bulkWritePlayerMatchFeature, computeMetricBaselines, getMatchIds, getMatch, @@ -526,11 +564,11 @@ describe('AnalysisPipelineService', () => { it('fetches missing match details, stores features, builds a profile, and completes the job', async () => { const { findOneRiotMatch, + bulkWritePlayerMatchFeature, getMatch, getMatchTimeline, service, updateAnalysisJob, - updatePlayerMatchFeature, updatePlayerProfile, updateRiotMatch, } = createPipelineHarness(); @@ -548,16 +586,17 @@ describe('AnalysisPipelineService', () => { queueId: 420, }, }); - const timelineSet = findTimelineSet(updateRiotMatch); - expect(timelineSet.timeline).toEqual(createTimelinePayload()); - expect(timelineSet.timelineFetchedAt).toBeInstanceOf(Date); + expect(findTimelinePersistUpdate(updateRiotMatch)).toBeUndefined(); - const playerMatchFeatureUpdate = updatePlayerMatchFeature.mock.calls[0][1]; - expect(playerMatchFeatureUpdate).toMatchObject({ - $set: { - featureSchemaVersion: FEATURE_SCHEMA_VERSION, - matchId: 'KR_1', - }, + expect(bulkWritePlayerMatchFeature).toHaveBeenCalledTimes(1); + expect(bulkWritePlayerMatchFeature.mock.calls[0]?.[0]).toHaveLength(3); + const playerMatchFeatureSet = playerMatchFeatureBulkSet( + bulkWritePlayerMatchFeature, + ); + expect(playerMatchFeatureSet).toMatchObject({ + featureSchemaVersion: FEATURE_SCHEMA_VERSION, + matchId: 'KR_1', + puuid: 'target-puuid', }); const playerProfileUpdate = updatePlayerProfile.mock.calls[0][1]; @@ -582,10 +621,10 @@ describe('AnalysisPipelineService', () => { it('processes a stored seed account through the shared match feature pipeline', async () => { const { findOneAccount, + bulkWritePlayerMatchFeature, getMatchIds, service, updateAnalysisJob, - updatePlayerMatchFeature, updatePlayerProfile, } = createPipelineHarness({ findOneAccountResult: createStoredAccount({ @@ -620,7 +659,7 @@ describe('AnalysisPipelineService', () => { queue: 420, regionalRoute: 'asia', }); - expect(updatePlayerMatchFeature).toHaveBeenCalledTimes(1); + expect(bulkWritePlayerMatchFeature).toHaveBeenCalledTimes(1); const playerProfileUpdate = updatePlayerProfile.mock.calls[0][1]; expect(playerProfileUpdate).toMatchObject({ @@ -650,17 +689,15 @@ describe('AnalysisPipelineService', () => { normalizationMethod: 'population-percentile', }), ); - const { service, updatePlayerMatchFeature, updatePlayerProfile } = + const { bulkWritePlayerMatchFeature, service, updatePlayerProfile } = createPipelineHarness({ normalizeFeature, }); await service.processUserAnalysisJob(createJobData(), 'analysis-job-1'); - expect(normalizeFeature).toHaveBeenCalledTimes(1); - const featureSet = asRecord( - asRecord(updatePlayerMatchFeature.mock.calls[0]?.[1]).$set, - ); + expect(normalizeFeature).toHaveBeenCalledTimes(3); + const featureSet = playerMatchFeatureBulkSet(bulkWritePlayerMatchFeature); expect(asRecord(featureSet.normalized).kda).toBe(0.42); expect(featureSet.normalizationMethod).toBe('population-percentile'); @@ -787,7 +824,7 @@ describe('AnalysisPipelineService', () => { getMatch, getMatchTimeline, service, - updatePlayerMatchFeature, + bulkWritePlayerMatchFeature, updateRiotMatch, } = createPipelineHarness({ existingMatchRaw: createMatchPayload(), @@ -798,41 +835,88 @@ describe('AnalysisPipelineService', () => { expect(getMatch).not.toHaveBeenCalled(); expect(getMatchTimeline).not.toHaveBeenCalled(); - expect( - updateRiotMatch.mock.calls.find(([, update]) => - Boolean(asRecord(asRecord(update).$set).timeline), - ), - ).toBeUndefined(); - expect(updatePlayerMatchFeature).toHaveBeenCalledTimes(1); + expect(findTimelinePersistUpdate(updateRiotMatch)).toBeUndefined(); + expect(findTimelineDiscardUpdate(updateRiotMatch)).toBeDefined(); + expect(bulkWritePlayerMatchFeature).toHaveBeenCalledTimes(1); }); - it('fetches a missing timeline for cached match details', async () => { - const { getMatch, getMatchTimeline, service, updateRiotMatch } = - createPipelineHarness({ - existingMatchRaw: createMatchPayload(), - }); + it('uses a current precomputed target feature without fetching match details or timeline', async () => { + const existingFeature = createStoredFeature({ + featureSchemaVersion: FEATURE_SCHEMA_VERSION, + normalized: { kda: 1 }, + vector: VECTOR_METRICS.map((metric) => (metric.id === 'kda' ? 1 : 0)), + timelineProcessed: true, + }); + const { + bulkWritePlayerMatchFeature, + findOneRiotMatch, + findPlayerMatchFeatures, + getMatch, + getMatchTimeline, + service, + updatePlayerProfile, + } = createPipelineHarness({ + existingTargetFeatures: [existingFeature], + }); + + await service.processUserAnalysisJob(createJobData(), 'analysis-job-1'); + + expect(findPlayerMatchFeatures).toHaveBeenCalledWith({ + matchId: { $in: ['KR_1'] }, + puuid: 'target-puuid', + queueId: 420, + featureSchemaVersion: FEATURE_SCHEMA_VERSION, + timelineProcessed: true, + }); + expect(findOneRiotMatch).not.toHaveBeenCalled(); + expect(getMatch).not.toHaveBeenCalled(); + expect(getMatchTimeline).not.toHaveBeenCalled(); + expect(bulkWritePlayerMatchFeature).not.toHaveBeenCalled(); + + const playerProfileUpdate = updatePlayerProfile.mock.calls[0][1]; + expect(playerProfileUpdate).toMatchObject({ + $set: { + puuid: 'target-puuid', + sampleGameCount: 1, + }, + }); + }); + + it('fetches but does not persist a missing timeline for cached match details', async () => { + const { + bulkWritePlayerMatchFeature, + getMatch, + getMatchTimeline, + service, + updateRiotMatch, + } = createPipelineHarness({ + existingMatchRaw: createMatchPayload(), + }); await service.processUserAnalysisJob(createJobData(), 'analysis-job-1'); expect(getMatch).not.toHaveBeenCalled(); expect(getMatchTimeline).toHaveBeenCalledWith('KR_1', 'asia'); - const timelineSet = findTimelineSet(updateRiotMatch); - expect(timelineSet.timeline).toEqual(createTimelinePayload()); - expect(timelineSet.timelineFetchedAt).toBeInstanceOf(Date); + expect(findTimelinePersistUpdate(updateRiotMatch)).toBeUndefined(); + expect(bulkWritePlayerMatchFeature).toHaveBeenCalledTimes(1); }); it('refetches cached timeline data when it is malformed', async () => { - const { getMatchTimeline, service, updateRiotMatch } = - createPipelineHarness({ - existingMatchRaw: createMatchPayload(), - existingTimeline: {}, - }); + const { + bulkWritePlayerMatchFeature, + getMatchTimeline, + service, + updateRiotMatch, + } = createPipelineHarness({ + existingMatchRaw: createMatchPayload(), + existingTimeline: {}, + }); await service.processUserAnalysisJob(createJobData(), 'analysis-job-1'); expect(getMatchTimeline).toHaveBeenCalledWith('KR_1', 'asia'); - const timelineSet = findTimelineSet(updateRiotMatch); - expect(timelineSet.timeline).toEqual(createTimelinePayload()); + expect(findTimelinePersistUpdate(updateRiotMatch)).toBeUndefined(); + expect(bulkWritePlayerMatchFeature).toHaveBeenCalledTimes(1); }); it('stores derived timeline data when a timeline is available', async () => { @@ -894,15 +978,15 @@ describe('AnalysisPipelineService', () => { const getMatchTimeline = jest .fn>, [string, string]>() .mockResolvedValue(timeline); - const { service, updatePlayerMatchFeature, updatePlayerProfile } = + const { bulkWritePlayerMatchFeature, service, updatePlayerProfile } = createPipelineHarness({ getMatchTimeline, }); await service.processUserAnalysisJob(createJobData(), 'analysis-job-1'); - const playerMatchFeatureSet = asRecord( - asRecord(updatePlayerMatchFeature.mock.calls[0][1]).$set, + const playerMatchFeatureSet = playerMatchFeatureBulkSet( + bulkWritePlayerMatchFeature, ); const playerMatchFeatureSetFeatures = asRecord( playerMatchFeatureSet.features, diff --git a/apps/api/src/modules/analysis/analysis-pipeline.service.ts b/apps/api/src/modules/analysis/analysis-pipeline.service.ts index 6c771c9..ef89653 100644 --- a/apps/api/src/modules/analysis/analysis-pipeline.service.ts +++ b/apps/api/src/modules/analysis/analysis-pipeline.service.ts @@ -41,9 +41,15 @@ import { TimelineMetricService } from './timeline-metric.service'; interface MatchRecord { matchId: string; raw: Record; + shouldDiscardStoredTimeline?: boolean; timeline?: Record; } +interface MatchFetchProgressOptions { + initialFetchedMatches?: number; + totalMatches?: number; +} + interface ParsedMatchSummary { gameCreation: number; gameDuration: number; @@ -155,10 +161,32 @@ export class AnalysisPipelineService { return; } - const matchRecords = await this.fetchAndStoreMatches( + const reusableFeaturesByMatchId = await this.findReusableMatchFeatures({ matchIds, + puuid: account.puuid, + queueId: normalizedData.queueId, + }); + const matchIdsRequiringFeatureExtraction = matchIds.filter( + (matchId) => !reusableFeaturesByMatchId.has(matchId), + ); + if (matchIdsRequiringFeatureExtraction.length === 0) { + await this.updateJob(jobId, { + progress: { + fetchedMatches: matchIds.length, + totalMatches: matchIds.length, + }, + }); + } + + const matchRecords = await this.fetchAndStoreMatches( + matchIdsRequiringFeatureExtraction, normalizedData, jobId, + USER_ANALYSIS_JOB_NAME, + { + initialFetchedMatches: reusableFeaturesByMatchId.size, + totalMatches: matchIds.length, + }, ); await this.updateJob(jobId, { stage: 'extract-features', @@ -169,15 +197,20 @@ export class AnalysisPipelineService { account.puuid, normalizedData.queueId, ); + const profileFeatures = this.mergeProfileFeatures( + matchIds, + reusableFeaturesByMatchId, + extractedFeatures, + ); await this.updateJob(jobId, { stage: 'build-profile', }); - if (extractedFeatures.length > 0) { + if (profileFeatures.length > 0) { await this.buildAndStoreProfile( account, normalizedData, - extractedFeatures, + profileFeatures, ); } @@ -405,11 +438,36 @@ export class AnalysisPipelineService { }; } - const matchRecords = await this.fetchAndStoreMatches( + const reusableFeaturesByMatchId = await this.findReusableMatchFeatures({ matchIds, + puuid: account.puuid, + queueId: normalizedData.queueId, + }); + const matchIdsRequiringFeatureExtraction = matchIds.filter( + (matchId) => !reusableFeaturesByMatchId.has(matchId), + ); + if (matchIdsRequiringFeatureExtraction.length === 0) { + await this.updateJob( + jobId, + { + progress: { + fetchedMatches: matchIds.length, + totalMatches: matchIds.length, + }, + }, + SEED_COLLECTION_JOB_NAME, + ); + } + + const matchRecords = await this.fetchAndStoreMatches( + matchIdsRequiringFeatureExtraction, normalizedData, jobId, SEED_COLLECTION_JOB_NAME, + { + initialFetchedMatches: reusableFeaturesByMatchId.size, + totalMatches: matchIds.length, + }, ); await this.updateJob( jobId, @@ -424,6 +482,11 @@ export class AnalysisPipelineService { account.puuid, normalizedData.queueId, ); + const profileFeatures = this.mergeProfileFeatures( + matchIds, + reusableFeaturesByMatchId, + extractedFeatures, + ); await this.updateJob( jobId, { @@ -432,19 +495,15 @@ export class AnalysisPipelineService { SEED_COLLECTION_JOB_NAME, ); - if (extractedFeatures.length > 0) { - await this.buildAndStoreProfile( - account, - normalizedData, - extractedFeatures, - ); + if (profileFeatures.length > 0) { + await this.buildAndStoreProfile(account, normalizedData, profileFeatures); } return { puuid: account.puuid, fetchedMatches: matchRecords.length, extractedFeatures: extractedFeatures.length, - profileBuilt: extractedFeatures.length > 0, + profileBuilt: profileFeatures.length > 0, }; } @@ -500,14 +559,72 @@ export class AnalysisPipelineService { return storedAccount; } + private async findReusableMatchFeatures(params: { + matchIds: string[]; + puuid: string; + queueId: number; + }): Promise> { + if (params.matchIds.length === 0) { + return new Map(); + } + + const playerMatchFeatureModel = + await this.connectionService.getModel('playerMatchFeature'); + const features = await playerMatchFeatureModel + .find({ + matchId: { $in: params.matchIds }, + puuid: params.puuid, + queueId: params.queueId, + featureSchemaVersion: FEATURE_SCHEMA_VERSION, + timelineProcessed: true, + }) + .lean() + .exec(); + + return new Map( + features.map((feature) => [feature.matchId, feature] as const), + ); + } + + private mergeProfileFeatures( + matchIds: string[], + reusableFeaturesByMatchId: Map, + extractedFeatures: ExtractedPlayerMatchFeature[], + ): Array { + const extractedFeaturesByMatchId = new Map( + extractedFeatures.map((feature) => [feature.matchId, feature] as const), + ); + const profileFeatures: Array< + PlayerMatchFeature | ExtractedPlayerMatchFeature + > = []; + + for (const matchId of matchIds) { + const reusableFeature = reusableFeaturesByMatchId.get(matchId); + if (reusableFeature) { + profileFeatures.push(reusableFeature); + continue; + } + + const extractedFeature = extractedFeaturesByMatchId.get(matchId); + if (extractedFeature) { + profileFeatures.push(extractedFeature); + } + } + + return profileFeatures; + } + private async fetchAndStoreMatches( matchIds: string[], data: Pick, jobId: string, jobType = USER_ANALYSIS_JOB_NAME, + progressOptions: MatchFetchProgressOptions = {}, ): Promise { const matchRecords: MatchRecord[] = []; const riotMatchModel = await this.connectionService.getModel('riotMatch'); + const totalMatches = progressOptions.totalMatches ?? matchIds.length; + const initialFetchedMatches = progressOptions.initialFetchedMatches ?? 0; for (const [index, matchId] of matchIds.entries()) { try { @@ -518,7 +635,7 @@ export class AnalysisPipelineService { if (existingMatch) { if (this.isEligibleMatch(existingMatch.raw, data.queueId)) { - const timeline = await this.fetchAndStoreMissingTimeline( + const timeline = await this.fetchMissingTimeline( matchId, existingMatch.timeline, data.regionalRoute, @@ -526,6 +643,7 @@ export class AnalysisPipelineService { matchRecords.push({ matchId, raw: existingMatch.raw, + shouldDiscardStoredTimeline: existingMatch.timeline !== undefined, ...(timeline ? { timeline } : {}), }); } @@ -536,7 +654,7 @@ export class AnalysisPipelineService { ); await this.storeRiotMatch(matchId, rawMatch); if (this.isEligibleMatch(rawMatch, data.queueId)) { - const timeline = await this.fetchAndStoreMissingTimeline( + const timeline = await this.fetchMissingTimeline( matchId, undefined, data.regionalRoute, @@ -557,8 +675,8 @@ export class AnalysisPipelineService { jobId, { progress: { - fetchedMatches: index + 1, - totalMatches: matchIds.length, + fetchedMatches: initialFetchedMatches + index + 1, + totalMatches, }, }, jobType, @@ -596,7 +714,7 @@ export class AnalysisPipelineService { .exec(); } - private async fetchAndStoreMissingTimeline( + private async fetchMissingTimeline( matchId: string, existingTimeline: unknown, regionalRoute: UserAnalysisJobData['regionalRoute'], @@ -616,7 +734,6 @@ export class AnalysisPipelineService { ); return undefined; } - await this.storeRiotMatchTimeline(matchId, timeline); return timeline; } catch (error) { this.logger.warn( @@ -626,19 +743,16 @@ export class AnalysisPipelineService { } } - private async storeRiotMatchTimeline( - matchId: string, - timeline: Record, - ): Promise { + private async discardStoredMatchTimeline(matchId: string): Promise { const riotMatchModel = await this.connectionService.getModel('riotMatch'); await riotMatchModel .updateOne( - { matchId }, + { matchId, timeline: { $exists: true } }, { - $set: { - timeline, - timelineFetchedAt: new Date(), + $unset: { + timeline: '', + timelineFetchedAt: '', }, }, ) @@ -650,22 +764,62 @@ export class AnalysisPipelineService { puuid: string, queueId: number, ): Promise { - const playerMatchFeatureModel = - await this.connectionService.getModel('playerMatchFeature'); const extractedFeatures: ExtractedPlayerMatchFeature[] = []; for (const matchRecord of matchRecords) { + try { + const participantPuuids = matchRecord.timeline + ? this.resolveMatchParticipantPuuids(matchRecord.raw) + : [puuid]; + const matchFeatures = await this.extractMatchParticipantFeatures( + matchRecord, + participantPuuids, + queueId, + ); + await this.storePlayerMatchFeatures(matchFeatures); + if (matchRecord.shouldDiscardStoredTimeline === true) { + await this.discardStoredMatchTimeline(matchRecord.matchId); + } + + const targetFeature = matchFeatures.find( + (feature) => feature.puuid === puuid, + ); + if (targetFeature) { + extractedFeatures.push(targetFeature); + } + } catch (error) { + this.logger.warn( + `Skipping feature extraction for matchId="${this.safeLogText(matchRecord.matchId)}": ${this.safeLogText(errorMessage(error))}`, + ); + } + } + + return extractedFeatures; + } + + private async extractMatchParticipantFeatures( + matchRecord: MatchRecord, + participantPuuids: string[], + queueId: number, + ): Promise { + const features: ExtractedPlayerMatchFeature[] = []; + const uniqueParticipantPuuids = [...new Set(participantPuuids)]; + const derived = matchRecord.timeline + ? this.timelineDerivedService.buildDerivedData( + matchRecord.timeline, + matchRecord.raw, + ) + : undefined; + + for (const participantPuuid of uniqueParticipantPuuids) { try { const feature = this.featureExtractorService.extractPlayerMatchFeature( matchRecord.raw, - puuid, + participantPuuid, ); if (feature.queueId !== queueId) continue; - if (matchRecord.timeline) { - const derived = this.timelineDerivedService.buildDerivedData( - matchRecord.timeline, - matchRecord.raw, - ); + + if (matchRecord.timeline && derived) { const timelineMetrics = this.timelineMetricService.extractTimelineMetrics( feature, @@ -688,27 +842,57 @@ export class AnalysisPipelineService { feature.timelineProcessed = true; } - const normalizedFeature = await this.normalizeExtractedFeature(feature); - - await playerMatchFeatureModel - .updateOne( - { - matchId: normalizedFeature.matchId, - puuid: normalizedFeature.puuid, - }, - { $set: normalizedFeature }, - { upsert: true }, - ) - .exec(); - extractedFeatures.push(normalizedFeature); + features.push(await this.normalizeExtractedFeature(feature)); } catch (error) { this.logger.warn( - `Skipping feature extraction for matchId="${this.safeLogText(matchRecord.matchId)}": ${this.safeLogText(errorMessage(error))}`, + `Skipping feature extraction for matchId="${this.safeLogText(matchRecord.matchId)}" puuid="${this.safeLogText(participantPuuid)}": ${this.safeLogText(errorMessage(error))}`, ); } } - return extractedFeatures; + return features; + } + + private async storePlayerMatchFeatures( + features: ExtractedPlayerMatchFeature[], + ): Promise { + if (features.length === 0) return; + + const playerMatchFeatureModel = + await this.connectionService.getModel('playerMatchFeature'); + await playerMatchFeatureModel.bulkWrite( + features.map((feature) => ({ + updateOne: { + filter: { + matchId: feature.matchId, + puuid: feature.puuid, + }, + update: { + $set: feature, + }, + upsert: true, + }, + })), + ); + } + + private resolveMatchParticipantPuuids( + rawMatch: Record, + ): string[] { + const info = asRecord(rawMatch.info); + const participants = Array.isArray(info.participants) + ? info.participants + : []; + const participantPuuids = participants + .map((participant) => asString(asRecord(participant).puuid)) + .filter((participantPuuid): participantPuuid is string => + Boolean(participantPuuid), + ); + + if (participantPuuids.length > 0) { + return participantPuuids; + } + return this.parseMatchSummary(rawMatch).participantPuuids; } private async normalizeExtractedFeature( @@ -863,10 +1047,10 @@ export class AnalysisPipelineService { private async buildAndStoreProfile( account: Account, data: Pick, - extractedFeatures: ExtractedPlayerMatchFeature[], + profileFeatures: Array, ): Promise { await this.storeBuiltProfile({ - features: extractedFeatures, + features: profileFeatures, isSeed: account.isSeed, tierInfo: this.resolveRankedSoloTier(account), puuid: account.puuid, @@ -929,7 +1113,7 @@ export class AnalysisPipelineService { } private async storeBuiltProfile(params: { - features: PlayerMatchFeature[] | ExtractedPlayerMatchFeature[]; + features: Array; isSeed: boolean; tierInfo?: TierInfo; puuid: string;