refactor type names

Author: howardchung

global.d.ts

@@ -206,7 +206,7 @@ interface NeutralItemHistory {
 }
 
 // Data to pass to insertMatch from GC
-interface GcMatch {
+interface GcData {
   match_id: number;
   cluster: number;
   replay_salt: number;
@@ -223,7 +223,7 @@ interface GcPlayer {
   account_id?: number;
 }
 
-interface ParserMatch {
+interface ParsedData {
   match_id: number;
   // Needed to determine whether to insert pro match data
   leagueid: number;
@@ -289,7 +289,7 @@ type GcDataJob = {
   pgroup: PGroup;
 };
 
-type CountsJob = ApiMatch;
+type CountsJob = ApiData;
 type ScenariosJob = string;
 type CacheJob = string;
 
@@ -522,7 +522,7 @@ type ParseExtraData = {
   origin?: DataOrigin;
   pgroup: PGroup;
   url: string;
-  gcMatch: GcMatch;
+  gcMatch: GcData;
 };
 
 type HistoryType = {
@@ -531,8 +531,8 @@ type HistoryType = {
   player_slot: number;
 };
 
-type ApiMatchResponse = typeof import('./test/data/details_api.json');
-type ApiMatch = ApiMatchResponse['result'] & {
+type ApiDataResponse = typeof import('./test/data/details_api.json');
+type ApiData = ApiDataResponse['result'] & {
   picks_bans?: {
     hero_id: number;
     order: number;
@@ -541,10 +541,10 @@ type ApiMatch = ApiMatchResponse['result'] & {
   radiant_team_id?: number;
   dire_team_id?: number;
 };
-type ApiPlayer = ApiMatch['players'][number] & {
+type ApiDataPlayer = ApiData['players'][number] & {
   ability_upgrades_arr?: number[];
 };
-type InsertMatchInput = ApiMatch | GcMatch | ParserMatch;
+type InsertMatchInput = ApiData | GcData | ParsedData;
 
 type PeersCount = Record<
   string,

svc/backfill.ts

@@ -52,7 +52,7 @@ runInLoop(async function backfill() {
   // write to blobstore, process the blob using same function as insertMatch
   try {
     const insertResult = await Promise.all(
-      resp.map(async (origMatch: ApiMatch) => {
+      resp.map(async (origMatch: ApiData) => {
         const match = transformMatch(origMatch);
         const result = await blobArchive.archivePut(
           match.match_id + '_api',

svc/fetcher/ApiFetcher.ts

@@ -9,12 +9,12 @@ import { insertMatch } from '../util/insert.ts';
 import { config } from '../../config.ts';
 import db from '../store/db.ts';
 
-export class ApiFetcher extends MatchFetcher<ApiMatch> {
+export class ApiFetcher extends MatchFetcher<ApiData> {
   useSavedData = Boolean(config.DISABLE_REAPI);
-  getData = async (matchId: number): Promise<ApiMatch | null> => {
+  getData = async (matchId: number): Promise<ApiData | null> => {
     let data = null;
     const archive = await blobArchive.archiveGet(`${matchId}_api`);
-    data = archive ? (JSON.parse(archive.toString()) as ApiMatch) : null;
+    data = archive ? (JSON.parse(archive.toString()) as ApiData) : null;
     return data;
   };
   fetchData = async (
@@ -96,7 +96,7 @@ export class ApiFetcher extends MatchFetcher<ApiMatch> {
       url,
     });
     const match = body.result.matches.find(
-      (m: ApiMatch) => m.match_id === matchId,
+      (m: ApiData) => m.match_id === matchId,
     );
     if (!match) {
       redisCount('backfill_fail');

svc/fetcher/GcdataFetcher.ts

@@ -10,13 +10,13 @@ import { blobArchive } from '../store/archive.ts';
 import { MatchFetcher } from './base.ts';
 import config from '../../config.ts';
 
-export class GcdataFetcher extends MatchFetcher<GcMatch> {
+export class GcdataFetcher extends MatchFetcher<GcData> {
   savedDataMetricName: MetricName = 'regcdata';
   useSavedData = Boolean(config.DISABLE_REGCDATA);
-  getData = async (matchId: number): Promise<GcMatch | null> => {
+  getData = async (matchId: number): Promise<GcData | null> => {
     let data = null;
     const archive = await blobArchive.archiveGet(`${matchId}_gcdata`);
-    data = archive ? (JSON.parse(archive.toString()) as GcMatch) : null;
+    data = archive ? (JSON.parse(archive.toString()) as GcData) : null;
     // Verify data integrity
     if (
       data?.match_id == null ||
@@ -103,7 +103,7 @@ export class GcdataFetcher extends MatchFetcher<GcMatch> {
         ).length,
       }),
     );
-    const matchToInsert: GcMatch = {
+    const matchToInsert: GcData = {
       match_id: matchId,
       players,
       series_id: data.match.series_id,

svc/fetcher/ParsedFetcher.ts

@@ -6,13 +6,13 @@ import axios from 'axios';
 import { MatchFetcher } from './base.ts';
 import config from '../../config.ts';
 
-export class ParsedFetcher extends MatchFetcher<ParserMatch> {
+export class ParsedFetcher extends MatchFetcher<ParsedData> {
   savedDataMetricName: MetricName = 'reparse';
   useSavedData = Boolean(config.DISABLE_REPARSE);
-  getData = async (matchId: number): Promise<ParserMatch | null> => {
+  getData = async (matchId: number): Promise<ParsedData | null> => {
     let data = null;
     const archive = await blobArchive.archiveGet(`${matchId}_parsed`);
-    data = archive ? (JSON.parse(archive.toString()) as ParserMatch) : null;
+    data = archive ? (JSON.parse(archive.toString()) as ParsedData) : null;
     return data;
   };
   fetchData = async (
@@ -36,11 +36,11 @@ export class ParsedFetcher extends MatchFetcher<ParserMatch> {
     // process: 3278ms (node processors/createParsedDataBlob.mjs < output.log)
     const parseUrl = await getRandomParserUrl(`/blob?replay_url=${url}`);
     console.log('[PARSER]', parseUrl);
-    const resp = await axios.get<ParserMatch>(parseUrl, { timeout: 150000 });
+    const resp = await axios.get<ParsedData>(parseUrl, { timeout: 150000 });
     if (!resp.data) {
       return { data: null, error: 'Parse failed' };
     }
-    const result: ParserMatch = {
+    const result: ParsedData = {
       ...resp.data,
       match_id: matchId,
       leagueid,

svc/fullhistory.ts

@@ -58,7 +58,7 @@ async function processFullHistory(job: FullHistoryJob) {
   // const heroArray = config.NODE_ENV === 'test' ? ['0'] : Object.keys(heroes);
   // const heroId = '0';
   // use steamapi via specific player history and specific hero id (up to 500 games per hero)
-  const matchesToProcess: Record<string, ApiMatch> = {};
+  const matchesToProcess: Record<string, ApiData> = {};
   let isMatchDataDisabled = null;
   // make a request for every possible hero
   const url = SteamAPIUrls.api_history({

svc/scanner.ts

@@ -62,7 +62,7 @@ runInLoop(async function scanApi() {
   console.log('[API] match_seq_num:%s, matches:%s', seqNum, resp.length);
   console.time('insert');
   await Promise.all(
-    resp.map(async (match: ApiMatch) => {
+    resp.map(async (match: ApiData) => {
       // Optionally throttle inserts to prevent overload
       if (match.match_id % 100 >= Number(config.SCANNER_PERCENT)) {
         return;

svc/util/benchmarksUtil.ts

@@ -1,6 +1,6 @@
 export const benchmarks: Record<
   string,
-  (m: ApiMatch | Match, p: ApiPlayer | Player) => number
+  (m: ApiData | Match, p: ApiDataPlayer | Player) => number
 > = {
   gold_per_min(m, p) {
     return p.gold_per_min;

svc/util/getMatchBlob.ts

@@ -4,17 +4,17 @@ import { redisCount } from './utility.ts';
 export async function getMatchBlob(
   matchId: number,
   fetchers: {
-    apiFetcher: MatchFetcher<ApiMatch>;
-    gcFetcher: MatchFetcher<GcMatch>;
-    parsedFetcher: MatchFetcher<ParserMatch>;
+    apiFetcher: MatchFetcher<ApiData>;
+    gcFetcher: MatchFetcher<GcData>;
+    parsedFetcher: MatchFetcher<ParsedData>;
     archivedFetcher: MatchFetcher<ParsedMatch> | null;
   },
 ): Promise<[Match | ParsedMatch | null, GetMatchDataMetadata | null]> {
   let { apiFetcher, gcFetcher, parsedFetcher, archivedFetcher } = fetchers;
   let [api, gcdata, parsed, archived]: [
-    ApiMatch | null,
-    GcMatch | null,
-    ParserMatch | null,
+    ApiData | null,
+    GcData | null,
+    ParsedData | null,
     ParsedMatch | null | undefined,
   ] = await Promise.all([
     apiFetcher.getData(matchId),

svc/util/insert.ts

@@ -149,7 +149,7 @@ export async function insertMatch(
   const match = transformMatch(origMatch);
   // Use the passed pgroup if gcdata or parsed, otherwise build it
   // Do this after removing anonymous account IDs
-  const pgroup = options.pgroup ?? getPGroup(match as ApiMatch);
+  const pgroup = options.pgroup ?? getPGroup(match as ApiData);
 
   let isProTier = false;
   if ('leagueid' in match && match.leagueid) {
@@ -209,7 +209,7 @@ export async function insertMatch(
       // Only if API or parse data
       return;
     }
-    if (options.type === 'api' && !isProMatch(match as ApiMatch)) {
+    if (options.type === 'api' && !isProMatch(match as ApiData)) {
       // Check whether we care about this match for pro purposes
       // We need the basic match data to run the check, so only do it if type is api
       // console.log('[UPSERTMATCHPOSTGRES]: skipping due to check');
@@ -505,14 +505,14 @@ export async function insertMatch(
     // Update temporary match counts/hero rankings
     if (options.origin === 'scanner' && options.type === 'api') {
       await Promise.all([
-        updateHeroRankings(match as ApiMatch),
-        upsertMatchSample(match as ApiMatch),
-        updateRecords(match as ApiMatch),
-        updateLastPlayed(match as ApiMatch),
-        updateHeroSearch(match as ApiMatch),
-        updateHeroCounts(match as ApiMatch, isProTier),
-        updateMatchCounts(match as ApiMatch),
-        updateBenchmarks(match as ApiMatch),
+        updateHeroRankings(match as ApiData),
+        upsertMatchSample(match as ApiData),
+        updateRecords(match as ApiData),
+        updateLastPlayed(match as ApiData),
+        updateHeroSearch(match as ApiData),
+        updateHeroCounts(match as ApiData, isProTier),
+        updateMatchCounts(match as ApiData),
+        updateBenchmarks(match as ApiData),
       ]);
     }
   }
@@ -537,7 +537,7 @@ export async function insertMatch(
   }
   async function queueMmr(match: InsertMatchInput) {
     // Trigger an update for player rank_tier if ranked match
-    const arr = match.players.filter<ApiPlayer>((p): p is ApiPlayer => {
+    const arr = match.players.filter<ApiDataPlayer>((p): p is ApiDataPlayer => {
       return Boolean(
         options.origin === 'scanner' &&
           options.type === 'api' &&
@@ -762,7 +762,7 @@ export async function upsertPlayerCaches(
   );
 }
 
-async function updateHeroRankings(match: ApiMatch) {
+async function updateHeroRankings(match: ApiData) {
   if (!isSignificant(match)) {
     return;
   }
@@ -802,7 +802,7 @@ async function updateHeroRankings(match: ApiMatch) {
   );
 }
 
-async function upsertMatchSample(match: ApiMatch) {
+async function upsertMatchSample(match: ApiData) {
   if (
     isSignificant(match) &&
     match.match_id % 100 < Number(config.PUBLIC_SAMPLE_PERCENT)
@@ -829,24 +829,24 @@ async function upsertMatchSample(match: ApiMatch) {
   }
 }
 async function updateRecord(
-  field: keyof ApiMatch | keyof ApiPlayer,
-  match: ApiMatch,
-  player: ApiPlayer,
+  field: keyof ApiData | keyof ApiDataPlayer,
+  match: ApiData,
+  player: ApiDataPlayer,
 ) {
   redis.zadd(
     `records:${field}`,
-    (match[field as keyof ApiMatch] ||
-      player[field as keyof ApiPlayer]) as number,
+    (match[field as keyof ApiData] ||
+      player[field as keyof ApiDataPlayer]) as number,
     [match.match_id, match.start_time, player.hero_id].join(':'),
   );
   // Keep only 100 top scores
   redis.zremrangebyrank(`records:${field}`, '0', '-101');
   const expire = moment.utc().add(1, 'month').startOf('month').format('X');
   redis.expireat(`records:${field}`, expire);
 }
-async function updateRecords(match: ApiMatch) {
+async function updateRecords(match: ApiData) {
   if (isSignificant(match) && match.lobby_type === 7) {
-    updateRecord('duration', match, {} as ApiPlayer);
+    updateRecord('duration', match, {} as ApiDataPlayer);
     match.players.forEach((player) => {
       updateRecord('kills', match, player);
       updateRecord('deaths', match, player);
@@ -861,7 +861,7 @@ async function updateRecords(match: ApiMatch) {
     });
   }
 }
-async function updateLastPlayed(match: ApiMatch) {
+async function updateLastPlayed(match: ApiData) {
   const filteredPlayers = match.players.filter(
     (player) =>
       player.account_id && player.account_id !== getAnonymousAccountId(),
@@ -902,7 +902,7 @@ async function updateLastPlayed(match: ApiMatch) {
 /**
  * Update table storing heroes played in a game for lookup of games by heroes played
  * */
-async function updateHeroSearch(match: ApiMatch) {
+async function updateHeroSearch(match: ApiData) {
   const radiant = [];
   const dire = [];
   for (let i = 0; i < match.players.length; i += 1) {
@@ -934,7 +934,7 @@ async function updateHeroSearch(match: ApiMatch) {
   );
 }
 
-async function updateHeroCounts(match: ApiMatch, isProTier: boolean) {
+async function updateHeroCounts(match: ApiData, isProTier: boolean) {
   // If match has leagueid, update pro picks and wins
   // If turbo, update picks and wins
   // Otherwise, update pub picks and wins if significant
@@ -996,13 +996,13 @@ async function updateHeroCounts(match: ApiMatch, isProTier: boolean) {
   }
 }
 
-async function updateMatchCounts(match: ApiMatch) {
+async function updateMatchCounts(match: ApiData) {
   await redisCount(`${match.game_mode}_game_mode` as MetricName);
   await redisCount(`${match.lobby_type}_lobby_type` as MetricName);
   await redisCount(`${match.cluster}_cluster` as MetricName);
 }
 
-async function updateBenchmarks(match: ApiMatch) {
+async function updateBenchmarks(match: ApiData) {
   if (
     match.match_id % 100 < Number(config.BENCHMARKS_SAMPLE_PERCENT) &&
     isSignificant(match)