mtg-playerinfo 1.2.0 → 1.3.0

package/src/fetchers/topdeck.js

@@ -1,106 +1,109 @@
-const { request } = require('../utils/httpClient');
-const cheerio = require('cheerio');
+const httpClient = require('../utils/httpClient')
+const cheerio = require('cheerio')
 
 class TopdeckFetcher {
-  async fetchById(handle) {
-    const cleanHandle = handle.startsWith('@') ? handle : `@${handle}`;
-    const url = `https://topdeck.gg/profile/${cleanHandle}`;
+  async fetchById (handle) {
+    const cleanHandle = handle.startsWith('@') ? handle : `@${handle}`
+    const url = `https://topdeck.gg/profile/${cleanHandle}`
     try {
-      const { data } = await request(url);
-      const playerInfo = this.parseHtml(data, url, cleanHandle);
+      const { data } = await httpClient.request(url)
+      const playerInfo = this.parseHtml(data, url, cleanHandle)
 
-      // Try to fetch stats via XHR if internal ID is found
-      const internalIdMatch = data.match(/https:\/\/topdeck\.gg\/profile\/([a-zA-Z0-9]+)\/stats/) || data.match(/const playerId = "([a-zA-Z0-9]+)";/);
-      const internalId = internalIdMatch ? internalIdMatch[1] : null;
+      const internalIdMatch = data.match(/https:\/\/topdeck\.gg\/profile\/([a-zA-Z0-9]+)\/stats/) || data.match(/const playerId = "([a-zA-Z0-9]+)";/)
+      const internalId = internalIdMatch ? internalIdMatch[1] : null
 
       if (internalId) {
-        try {
-          const statsUrl = `https://topdeck.gg/profile/${internalId}/stats`;
-          const statsResponse = await request(statsUrl);
-          const statsJson = statsResponse.data;
-          const stats = typeof statsJson === 'string' ? JSON.parse(statsJson) : statsJson;
+        await this.fetchStats(internalId, playerInfo)
+      }
+
+      return playerInfo
+    } catch (error) {
+      console.error(`Error fetching Topdeck profile ${handle}:`, error.message)
+      return null
+    }
+  }
 
-          if (stats) {
-            if (stats.yearlyStats) {
-              let totalTournaments = 0;
-              let wins = 0;
-              let losses = 0;
-              let draws = 0;
+  async fetchStats (internalId, playerInfo) {
+    try {
+      const statsUrl = `https://topdeck.gg/profile/${internalId}/stats`
+      const statsResponse = await httpClient.request(statsUrl)
+      const statsJson = statsResponse.data
+      const stats = typeof statsJson === 'string' ? JSON.parse(statsJson) : statsJson
 
-              Object.values(stats.yearlyStats).forEach(yearData => {
-                if (yearData.overall) {
-                  totalTournaments += yearData.overall.totalTournaments || 0;
-                  wins += yearData.overall.wins || 0;
-                  losses += yearData.overall.losses || 0;
-                  draws += yearData.overall.draws || 0;
-                }
-              });
+      if (stats) {
+        if (stats.yearlyStats) {
+          let totalTournaments = 0
+          let wins = 0
+          let losses = 0
+          let draws = 0
 
-              if (totalTournaments > 0) {
-                playerInfo['tournaments'] = totalTournaments.toString();
-                playerInfo['record'] = `${wins}-${losses}-${draws}`;
-                playerInfo['win rate'] = ((wins / (wins + losses + draws)) * 100).toFixed(2) + '%';
-              }
-            } else {
-              playerInfo['tournaments'] = stats.totalTournaments || playerInfo['tournaments'] || '0';
-              playerInfo['record'] = stats.overallRecord || playerInfo['record'] || '0-0-0';
-              playerInfo['win rate'] = stats.overallWinRate || playerInfo['win rate'] || '0.00%';
-              playerInfo['conversion'] = stats.conversionRate || playerInfo['conversion'] || '0.00%';
+          Object.values(stats.yearlyStats).forEach(yearData => {
+            if (yearData.overall) {
+              totalTournaments += yearData.overall.totalTournaments || 0
+              wins += yearData.overall.wins || 0
+              losses += yearData.overall.losses || 0
+              draws += yearData.overall.draws || 0
             }
+          })
+
+          if (totalTournaments > 0) {
+            playerInfo.tournaments = totalTournaments.toString()
+            playerInfo.record = `${wins}-${losses}-${draws}`
+            playerInfo['win rate'] = ((wins / (wins + losses + draws)) * 100).toFixed(2) + '%'
           }
-        } catch (statsError) {
-          console.error(`Error fetching Topdeck stats for ${handle}:`, statsError.message);
+        } else {
+          playerInfo.tournaments = stats.totalTournaments || playerInfo.tournaments || '0'
+          playerInfo.record = stats.overallRecord || playerInfo.record || '0-0-0'
+          playerInfo['win rate'] = stats.overallWinRate || playerInfo['win rate'] || '0.00%'
+          playerInfo.conversion = stats.conversionRate || playerInfo.conversion || '0.00%'
         }
       }
-
-      return playerInfo;
-    } catch (error) {
-      console.error(`Error fetching Topdeck profile ${handle}:`, error.message);
-      return null;
+    } catch (statsError) {
+      console.error(`Error fetching Topdeck stats for ${internalId}:`, statsError.message)
     }
   }
 
-  parseHtml(html, url, handle) {
-    const $ = cheerio.load(html);
-    const name = $('h2.text-white.fw-bold.mb-1').first().text().trim() || $('h1').first().text().trim() || handle;
-    const photo = $('img.rounded-circle.shadow-lg').first().attr('src') || $('img[src*="avatar"], img[src*="profile"]').first().attr('src');
+  parseHtml (html, url, handle) {
+    const $ = cheerio.load(html)
+    const name = $('h2.text-white.fw-bold.mb-1').first().text().trim() || $('h1').first().text().trim() || handle
+    const photo = $('img.rounded-circle.shadow-lg').first().attr('src') || $('img[src*="avatar"], img[src*="profile"]').first().attr('src')
 
     const data = {
       source: 'Topdeck',
       url,
       name,
       photo: photo ? (photo.startsWith('http') ? photo : `https://topdeck.gg${photo}`) : null
-    };
+    }
 
     const statsMap = {
-      'totalTournaments': 'tournaments',
-      'overallRecord': 'record',
-      'overallWinRate': 'win rate',
-      'conversionRate': 'conversion'
-    };
+      totalTournaments: 'tournaments',
+      overallRecord: 'record',
+      overallWinRate: 'win rate',
+      conversionRate: 'conversion'
+    }
 
     Object.entries(statsMap).forEach(([id, label]) => {
-      const val = $(`#${id}`).text().trim();
+      const val = $(`#${id}`).text().trim()
       if (val) {
-        data[label] = val;
+        data[label] = val
       }
-    });
+    })
 
-    const currentStats = Object.keys(data).filter(k => Object.values(statsMap).includes(k));
+    const currentStats = Object.keys(data).filter(k => Object.values(statsMap).includes(k))
     if (currentStats.length <= 1) {
       $('.stats-container, .player-stats').each((i, el) => {
         $(el).find('.stat').each((j, statEl) => {
-          const label = $(statEl).find('.label').text().trim().toLowerCase();
-          const value = $(statEl).find('.value').text().trim();
+          const label = $(statEl).find('.label').text().trim().toLowerCase()
+          const value = $(statEl).find('.value').text().trim()
           if (label && value) {
-            data[label] = value;
+            data[label] = value
           }
-        });
-      });
+        })
+      })
     }
 
-    return data;
+    return data
   }
 }
 
-module.exports = TopdeckFetcher;
+module.exports = TopdeckFetcher

package/src/fetchers/unityLeague.js

@@ -1,24 +1,24 @@
-const { request } = require('../utils/httpClient');
-const cheerio = require('cheerio');
+const { request } = require('../utils/httpClient')
+const cheerio = require('cheerio')
 
 class UnityLeagueFetcher {
-  async fetchById(id) {
-    const url = `https://unityleague.gg/player/${id}/`;
+  async fetchById (id) {
+    const url = `https://unityleague.gg/player/${id}/`
     try {
-      const { data } = await request(url);
-      return this.parseHtml(data, url);
+      const { data } = await request(url)
+      return this.parseHtml(data, url)
     } catch (error) {
-      console.error(`Error fetching Unity League player ${id}:`, error.message);
-      return null;
+      console.error(`Error fetching Unity League player ${id}:`, error.message)
+      return null
     }
   }
 
-  parseHtml(html, url) {
-    const $ = cheerio.load(html);
-    const name = $('h1.d-inline').text().trim();
-    let photo = $('.card-body img.img-fluid').first().attr('src');
+  parseHtml (html, url) {
+    const $ = cheerio.load(html)
+    const name = $('h1.d-inline').text().trim()
+    let photo = $('.card-body img.img-fluid').first().attr('src')
     if (photo && !photo.includes('player_profile')) {
-      photo = null;
+      photo = null
     }
 
     const data = {
@@ -26,74 +26,74 @@ class UnityLeagueFetcher {
       url,
       name,
       photo: photo ? (photo.startsWith('http') ? photo : `https://unityleague.gg${photo}`) : null
-    };
+    }
 
-    const headerFlag = $('.card-body i.fi').first();
+    const headerFlag = $('.card-body i.fi').first()
     if (headerFlag.length > 0) {
-      const classes = headerFlag.attr('class').split(' ');
-      const countryClass = classes.find(c => c.startsWith('fi-'));
+      const classes = headerFlag.attr('class').split(' ')
+      const countryClass = classes.find(c => c.startsWith('fi-'))
       if (countryClass) {
-        data.country = countryClass.replace('fi-', '');
+        data.country = countryClass.replace('fi-', '')
       }
     }
 
     $('dt.small.text-muted').each((i, el) => {
-      const key = $(el).text().trim().replace(/:$/, '').toLowerCase();
-      const dd = $(el).next('dd');
-      let value = dd.text().trim();
+      const key = $(el).text().trim().replace(/:$/, '').toLowerCase()
+      const dd = $(el).next('dd')
+      let value = dd.text().trim()
 
       if (key === 'country') {
-        const flagIcon = dd.find('i.fi');
+        const flagIcon = dd.find('i.fi')
         if (flagIcon.length > 0) {
-          const classes = flagIcon.attr('class').split(' ');
-          const countryClass = classes.find(c => c.startsWith('fi-'));
+          const classes = flagIcon.attr('class').split(' ')
+          const countryClass = classes.find(c => c.startsWith('fi-'))
           if (countryClass) {
-            value = countryClass.replace('fi-', '');
+            value = countryClass.replace('fi-', '')
           }
         }
       }
 
-      data[key] = value;
-    });
+      data[key] = value
+    })
 
-    const bioElement = $('.card-body > small.mt-2').first();
+    const bioElement = $('.card-body > small.mt-2').first()
     if (bioElement.length > 0) {
-      data.bio = bioElement.text().trim();
+      data.bio = bioElement.text().trim()
     }
 
-    const rankingTable = $('table.table-sm').first();
+    const rankingTable = $('table.table-sm').first()
     if (rankingTable.length) {
-      const headers = rankingTable.find('th').map((i, el) => $(el).text().trim()).get();
-      const values = rankingTable.find('tbody td').map((i, el) => $(el).text().trim()).get();
+      const headers = rankingTable.find('th').map((i, el) => $(el).text().trim()).get()
+      const values = rankingTable.find('tbody td').map((i, el) => $(el).text().trim()).get()
 
       headers.forEach((header, i) => {
         if (header && values[i]) {
-          let val = values[i];
-          val = val.replace(/\D/g, ''); // remove non-numeric characters to support #23->23, 1st->1, and 42nd->42 etc.
+          let val = values[i]
+          val = val.replace(/\D/g, '') // remove non-numeric characters to support #23->23, 1st->1, and 42nd->42 etc.
           if (val) {
-            data[`rank ${header.toLowerCase()}`] = val;
+            data[`rank ${header.toLowerCase()}`] = val
           }
         }
-      });
+      })
     }
 
     // Extract tournament record and win rate
     const overallRow = $('table.table tr').filter((i, el) => {
-      return $(el).find('td').first().text().trim() === 'Overall';
-    });
+      return $(el).find('td').first().text().trim() === 'Overall'
+    })
 
     if (overallRow.length > 0) {
-      const cells = overallRow.find('td');
+      const cells = overallRow.find('td')
       if (cells.length >= 3) {
-        const record = $(cells[1]).text().trim().replace(/\s+/g, '');
-        const winRate = $(cells[2]).text().trim();
-        data.record = record;
-        data['win rate'] = winRate;
+        const record = $(cells[1]).text().trim().replace(/\s+/g, '')
+        const winRate = $(cells[2]).text().trim()
+        data.record = record
+        data['win rate'] = winRate
       }
     }
 
-    return data;
+    return data
   }
 }
 
-module.exports = UnityLeagueFetcher;
+module.exports = UnityLeagueFetcher

package/src/fetchers/untapped.js

@@ -0,0 +1,54 @@
+const { request } = require('../utils/httpClient')
+
+class UntappedFetcher {
+  async fetchById (id) {
+    // Split the two-part ID
+    const parts = id.split('/')
+    if (parts.length !== 2) {
+      console.error('Untapped ID must be in format "userId/playerCode"')
+      return null
+    }
+
+    const userId = parts[0]
+    const playerCode = parts[1]
+    const url = `https://mtga.untapped.gg/profile/${userId}/${playerCode}`
+    const apiUrl = `https://api.mtga.untapped.gg/api/v1/games/users/${userId}/players/${playerCode}/?card_set=ECL`
+
+    try {
+      const { data } = await request(apiUrl)
+      const matches = typeof data === 'string' ? JSON.parse(data) : data
+
+      if (!Array.isArray(matches) || matches.length === 0) {
+        console.warn(`No matches found for Untapped player ${id}`)
+        return null
+      }
+
+      const mostRecentMatch = matches.reduce((latest, current) => {
+        return (current.match_start > latest.match_start) ? current : latest
+      })
+
+      return this.parseMatch(mostRecentMatch, url)
+    } catch (error) {
+      console.error(`Error fetching Untapped profile ${id}:`, error.message)
+      return null
+    }
+  }
+
+  parseMatch (match, url) {
+    const data = {
+      source: 'Untapped.gg',
+      url,
+      mtga_rank: null
+    }
+
+    if (match.friendly_ranking_class_after && match.friendly_ranking_tier_after !== null && match.friendly_ranking_tier_after !== undefined) {
+      data.mtga_rank = `${match.friendly_ranking_class_after} ${match.friendly_ranking_tier_after}`
+    }
+
+    return data
+  }
+}
+
+module.exports = UntappedFetcher
+
+

package/src/index.js

@@ -1,89 +1,122 @@
-const UnityLeagueFetcher = require('./fetchers/unityLeague');
-const MtgEloFetcher = require('./fetchers/mtgElo');
-const MeleeFetcher = require('./fetchers/melee');
-const TopdeckFetcher = require('./fetchers/topdeck');
+const UnityLeagueFetcher = require('./fetchers/unityLeague')
+const MtgEloFetcher = require('./fetchers/mtgElo')
+const MeleeFetcher = require('./fetchers/melee')
+const TopdeckFetcher = require('./fetchers/topdeck')
+const UntappedFetcher = require('./fetchers/untapped')
 
 class PlayerInfoManager {
-  constructor() {
+  constructor () {
     this.fetchers = {
       unity: new UnityLeagueFetcher(),
       mtgelo: new MtgEloFetcher(),
       melee: new MeleeFetcher(),
-      topdeck: new TopdeckFetcher()
-    };
+      topdeck: new TopdeckFetcher(),
+      untapped: new UntappedFetcher()
+    }
   }
 
-  async getPlayerInfo(options) {
-    const results = [];
+  async getPlayerInfo (options, priorityOrder = []) {
+    const fetcherMap = {
+      unity: { option: 'unityId', fetcher: this.fetchers.unity },
+      mtgelo: { option: 'mtgeloId', fetcher: this.fetchers.mtgelo },
+      melee: { option: 'meleeUser', fetcher: this.fetchers.melee },
+      topdeck: { option: 'topdeckHandle', fetcher: this.fetchers.topdeck },
+      untapped: { option: 'untappedId', fetcher: this.fetchers.untapped }
+    }
+
+    // Default order if no priority specified
+    const defaultOrder = ['unity', 'mtgelo', 'melee', 'topdeck', 'untapped']
+    const order = priorityOrder.length > 0 ? priorityOrder : defaultOrder
 
-    if (options.unityId) results.push(await this.fetchers.unity.fetchById(options.unityId));
-    if (options.mtgeloId) results.push(await this.fetchers.mtgelo.fetchById(options.mtgeloId));
-    if (options.meleeUser) results.push(await this.fetchers.melee.fetchById(options.meleeUser));
-    if (options.topdeckHandle) results.push(await this.fetchers.topdeck.fetchById(options.topdeckHandle));
+    const results = []
+
+    for (const source of order) {
+      const config = fetcherMap[source]
+      if (config && options[config.option]) {
+        const result = await config.fetcher.fetchById(options[config.option])
+        results.push(result)
+      }
+    }
 
-    const filteredResults = results.filter(r => r !== null);
-    return this.mergeData(filteredResults, options.verbose);
+    const filteredResults = results.filter(r => r !== null)
+    return this.mergeData(filteredResults, options.verbose)
   }
 
-  mergeData(results, verbose = false) {
+  mergeData (results, verbose = false) {
     const player = {
       general: {},
       sources: {}
-    };
+    }
 
-    const seenUrls = new Set();
-    const firstSeenValues = {};
+    const seenUrls = new Set()
+    const firstSeenValues = {}
 
-    const winRates = [];
+    const winRates = []
+    let totalWins = 0
+    let totalLosses = 0
+    let totalDraws = 0
 
     results.forEach(res => {
-      if (seenUrls.has(res.url)) return;
-      seenUrls.add(res.url);
+      if (seenUrls.has(res.url)) return
+      seenUrls.add(res.url)
 
-      const generalProps = ['name', 'photo', 'age', 'bio', 'team', 'country', 'hometown', 'pronouns', 'facebook', 'twitch', 'youtube'];
+      const generalProps = ['name', 'photo', 'age', 'bio', 'team', 'country', 'hometown', 'pronouns', 'facebook', 'twitch', 'youtube', 'mtga_rank']
       generalProps.forEach(prop => {
         if (res[prop]) {
           if (!player.general[prop]) {
-            player.general[prop] = res[prop];
-            firstSeenValues[prop] = res[prop];
+            player.general[prop] = res[prop]
+            firstSeenValues[prop] = res[prop]
             if (verbose) {
-              console.log(`⬆️: Promoted '${prop}' from ${res.source} to general information: ${res[prop]}`);
+              console.log(`⬆️: Promoted '${prop}' from ${res.source} to general information: ${res[prop]}`)
             }
           } else if (verbose) {
             if (res[prop] === firstSeenValues[prop]) {
-              console.log(`🆗: ${res.source} has the same '${prop}' as seen before: ${res[prop]}`);
+              console.log(`🆗: ${res.source} has the same '${prop}' as seen before: ${res[prop]}`)
             } else {
-              console.log(`${prop === 'photo' ? '🆕': '🆚'}️: ${res.source} has different '${prop}' than seen before: ${res[prop]} (instead of ${firstSeenValues[prop]})`);
+              console.log(`${prop === 'photo' ? '🆕' : '🆚'}️: ${res.source} has different '${prop}' than seen before: ${res[prop]} (instead of ${firstSeenValues[prop]})`)
             }
           }
         }
-      });
+      })
 
-      const winRateStr = res['win rate'] || res.winRate;
+      const winRateStr = res['win rate'] || res.winRate
       if (winRateStr && typeof winRateStr === 'string') {
-        const winRate = parseFloat(winRateStr.replace('%', ''));
+        const winRate = parseFloat(winRateStr.replace('%', ''))
         if (!isNaN(winRate)) {
-          winRates.push(winRate);
+          winRates.push(winRate)
         }
       }
 
-      const sourceData = { ...res };
-      delete sourceData.source;
-      delete sourceData.url;
+      if (res.record && typeof res.record === 'string' && res.record.includes('-')) {
+        const parts = res.record.split('-').map(Number)
+        if (parts.length >= 2 && parts.every(p => !isNaN(p))) {
+          totalWins += parts[0]
+          totalLosses += parts[1]
+          totalDraws += parts[2] || 0
+        }
+      }
+
+      const sourceData = { ...res }
+      delete sourceData.source
+      delete sourceData.url
 
       player.sources[res.source] = {
         url: res.url,
         data: sourceData
-      };
-    });
+      }
+    })
 
-    if (winRates.length > 0) {
-      const avgWinRate = winRates.reduce((a, b) => a + b, 0) / winRates.length;
-      player.general['win rate'] = avgWinRate.toFixed(2) + '%';
+    const totalGames = totalWins + totalLosses + totalDraws
+    if (totalGames > 0) {
+      const overall = (totalWins / totalGames) * 100
+      player.general['win rate'] = overall.toFixed(2) + '%'
+    } else if (winRates.length > 0) {
+      const avgWinRate = winRates.reduce((a, b) => a + b, 0) / winRates.length
+      player.general['win rate'] = avgWinRate.toFixed(2) + '%'
     }
 
-    return player;
+    return player
   }
 }
 
-module.exports = PlayerInfoManager;
+module.exports = PlayerInfoManager

package/src/utils/httpClient.js

@@ -1,41 +1,41 @@
-const https = require('https');
-const http = require('http');
-const { URL } = require('url');
+const https = require('https')
+const http = require('http')
+const { URL } = require('url')
 
-function request(url, options = {}) {
+function request (url, options = {}) {
   return new Promise((resolve, reject) => {
-    const parsedUrl = new URL(url);
-    const protocol = parsedUrl.protocol === 'https:' ? https : http;
-    
+    const parsedUrl = new URL(url)
+    const protocol = parsedUrl.protocol === 'https:' ? https : http
+
     const headers = {
       'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
       ...options.headers
-    };
+    }
 
     const requestOptions = {
       method: options.method || 'GET',
-      headers: headers,
+      headers,
       timeout: 30000,
       ...options
-    };
+    }
 
     const req = protocol.request(url, requestOptions, (res) => {
       if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-        const redirectUrl = new URL(res.headers.location, url).href;
-        const maxRedirects = options.maxRedirects || 5;
+        const redirectUrl = new URL(res.headers.location, url).href
+        const maxRedirects = options.maxRedirects || 5
         if (maxRedirects > 0) {
           return request(redirectUrl, { ...options, maxRedirects: maxRedirects - 1 })
             .then(resolve)
-            .catch(reject);
+            .catch(reject)
         } else {
-          return reject(new Error('Too many redirects'));
+          return reject(new Error('Too many redirects'))
         }
       }
 
-      let data = '';
+      let data = ''
       res.on('data', (chunk) => {
-        data += chunk;
-      });
+        data += chunk
+      })
 
       res.on('end', () => {
         if (res.statusCode >= 200 && res.statusCode < 300) {
@@ -43,27 +43,27 @@ function request(url, options = {}) {
             data,
             status: res.statusCode,
             headers: res.headers
-          });
+          })
         } else {
-          reject(new Error(`Request failed with status ${res.statusCode}`));
+          reject(new Error(`Request failed with status ${res.statusCode}`))
         }
-      });
-    });
+      })
+    })
 
     req.on('error', (err) => {
-      reject(err);
-    });
+      reject(err)
+    })
 
     req.on('timeout', () => {
-      req.destroy();
-      reject(new Error('Request timed out'));
-    });
+      req.destroy()
+      reject(new Error('Request timed out'))
+    })
 
     if (options.body) {
-      req.write(options.body);
+      req.write(options.body)
     }
-    req.end();
-  });
+    req.end()
+  })
 }
 
-module.exports = { request };
+module.exports = { request }