@unavatar/core 3.19.4 → 3.19.5

package/package.json

@@ -2,7 +2,7 @@
   "name": "@unavatar/core",
   "description": "Get unified user avatar from social networks, including Instagram, SoundCloud, Telegram, Twitter, YouTube & more.",
   "homepage": "https://unavatar.io",
-  "version": "3.19.4",
+  "version": "3.19.5",
   "main": "src/index.js",
   "exports": {
     ".": "./src/index.js",

package/src/providers/github.js

@@ -9,9 +9,11 @@ const SEARCH_USERS_PER_PAGE = 10
 const SEARCH_COMMITS_PER_PAGE = 20
 const COMMIT_SEARCH_ACCEPT_HEADER = 'application/vnd.github+json'
 
-const normalizeCacheKey = value => value.trim().toLowerCase()
-const createLookupCacheKey = prefix => value =>
-  `${prefix}:${normalizeCacheKey(value)}`
+const normalizeValue = value =>
+  typeof value === 'string' ? value.trim().toLowerCase() : ''
+const getSearchItems = body => body?.items ?? []
+const getUniqueLogins = candidates =>
+  [...new Set(candidates.map(({ login }) => login).filter(Boolean))]
 
 const fetchJsonBody = async ({ got, url, options }) => {
   const { body } = await got(url, {
@@ -22,26 +24,35 @@ const fetchJsonBody = async ({ got, url, options }) => {
   return body
 }
 
+const isResolvableAccount = (user, accountType) =>
+  user?.type === accountType &&
+  typeof user.login === 'string' &&
+  typeof user.avatar_url === 'string'
+
+const isResolvablePerson = user => isResolvableAccount(user, 'User')
+const isResolvableOrganization = user =>
+  isResolvableAccount(user, 'Organization')
+
+const pickLinkedUser = item => {
+  if (isResolvablePerson(item.author)) return item.author
+  if (isResolvablePerson(item.committer)) return item.committer
+}
+
 const getUsernameAvatarUrl = ({ constants, input }) =>
   `https://github.com/${input}.png?${stringify({
     size: constants.AVATAR_SIZE
   })}`
 
-const createSearchUsersByEmail = ({ githubSearchCache, got }) =>
-  memoize(
-    async email => {
-      const body = await fetchJsonBody({
-        got,
-        url: `${GITHUB_API_URL}/search/users?q=${encodeURIComponent(
-          email
-        )}&per_page=${SEARCH_USERS_PER_PAGE}`
-      })
-
-      return body?.items ?? []
-    },
-    githubSearchCache,
-    { key: createLookupCacheKey('search-users') }
-  )
+const createSearchUsersByEmail = ({ got }) =>
+  async email => {
+    const body = await fetchJsonBody({
+      got,
+      url: `${GITHUB_API_URL}/search/users?q=${encodeURIComponent(
+        email
+      )}&per_page=${SEARCH_USERS_PER_PAGE}`
+    })
+    return getSearchItems(body)
+  }
 
 const createGetUser = ({ githubSearchCache, got }) =>
   memoize(
@@ -51,52 +62,74 @@ const createGetUser = ({ githubSearchCache, got }) =>
         url: `${GITHUB_API_URL}/users/${encodeURIComponent(login)}`
       }),
     githubSearchCache,
-    { key: createLookupCacheKey('user') }
+    { key: login => `user:${normalizeValue(login)}` }
   )
 
-const createSearchCommitsByEmail = ({ githubSearchCache, got }) =>
-  memoize(
-    async email => {
-      const body = await fetchJsonBody({
-        got,
-        url: `${GITHUB_API_URL}/search/commits?q=${encodeURIComponent(
-          `author-email:${email}`
-        )}&per_page=${SEARCH_COMMITS_PER_PAGE}`,
-        options: {
-          headers: { accept: COMMIT_SEARCH_ACCEPT_HEADER }
-        }
-      })
+const createSearchCommitsByEmail = ({ got }) =>
+  async email => {
+    const body = await fetchJsonBody({
+      got,
+      url: `${GITHUB_API_URL}/search/commits?q=${encodeURIComponent(
+        `author-email:${email}`
+      )}&per_page=${SEARCH_COMMITS_PER_PAGE}`,
+      options: {
+        headers: { accept: COMMIT_SEARCH_ACCEPT_HEADER }
+      }
+    })
 
-      return body?.items ?? []
-    },
-    githubSearchCache,
-    { key: createLookupCacheKey('search-commits') }
-  )
+    return getSearchItems(body)
+  }
 
-const findExactPublicProfileMatch = async ({
+const findExactPublicProfileMatches = async ({
   email,
   getUser,
   searchUsersByEmail
 }) => {
+  // `searchUsersByEmail` returns lightweight candidate accounts (search items),
+  // so we use each login to fetch full profiles.
   const candidates = await searchUsersByEmail(email)
-  const normalizedEmail = email.toLowerCase()
 
-  for (const candidate of candidates) {
-    const user = await getUser(candidate.login)
+  const candidateLogins = getUniqueLogins(candidates)
+
+  // Candidate items don't include the public email field, so we hydrate each
+  // login in parallel with /users/:login to validate exact matches.
+  const profiles = await Promise.all(
+    candidateLogins.map(login => getUser(login))
+  )
+
+  let userAvatarUrl
+  let organizationAvatarUrl
+
+  for (const profile of profiles) {
+    if (normalizeValue(profile?.email) !== email) continue
 
-    if (user?.email?.toLowerCase() === normalizedEmail) {
-      return user.avatar_url
+    // Keep first exact match per account type. Caller prioritizes user avatar
+    // and only falls back to organization when no user signal is found.
+    if (!userAvatarUrl && isResolvablePerson(profile)) {
+      userAvatarUrl = profile.avatar_url
     }
+
+    if (!organizationAvatarUrl && isResolvableOrganization(profile)) {
+      organizationAvatarUrl = profile.avatar_url
+    }
+
+    if (userAvatarUrl && organizationAvatarUrl) break
   }
+
+  return { userAvatarUrl, organizationAvatarUrl }
 }
 
 const findCommitConsensusMatch = async ({ email, searchCommitsByEmail }) => {
   const commits = await searchCommitsByEmail(email)
+  if (commits.length === 0) return
+
   const counts = new Map()
 
   for (const item of commits) {
-    const linkedUser = item.author ?? item.committer
-    if (!linkedUser?.login || !linkedUser?.avatar_url) continue
+    // Commit search can reference org/bot identities; pickLinkedUser enforces
+    // that only real user identities are considered in this fallback.
+    const linkedUser = pickLinkedUser(item)
+    if (!linkedUser) continue
 
     const entry = counts.get(linkedUser.login) ?? {
       avatarUrl: linkedUser.avatar_url,
@@ -106,41 +139,47 @@ const findCommitConsensusMatch = async ({ email, searchCommitsByEmail }) => {
     entry.count += 1
     counts.set(linkedUser.login, entry)
   }
+  if (counts.size === 0) return
 
   let winner
   for (const entry of counts.values()) {
     if (!winner || entry.count > winner.count) winner = entry
   }
 
+  // Return the dominant user across matched commits.
   return winner?.avatarUrl
 }
 
 module.exports = ({ constants, githubSearchCache, got }) => {
-  const searchUsersByEmail = createSearchUsersByEmail({
-    githubSearchCache,
-    got
-  })
+  const searchUsersByEmail = createSearchUsersByEmail({ got })
   const getUser = createGetUser({ githubSearchCache, got })
-  const searchCommitsByEmail = createSearchCommitsByEmail({
-    githubSearchCache,
-    got
-  })
+  const searchCommitsByEmail = createSearchCommitsByEmail({ got })
 
   return async function github (input) {
     if (!isEmail(input)) return getUsernameAvatarUrl({ constants, input })
+    const email = normalizeValue(input)
+
+    // Strategy: exact public user email -> user commit consensus ->
+    // exact organization email.
+    const { userAvatarUrl, organizationAvatarUrl } =
+      await findExactPublicProfileMatches({
+        email,
+        getUser,
+        searchUsersByEmail
+      })
 
-    const exactMatch = await findExactPublicProfileMatch({
-      email: input,
-      getUser,
-      searchUsersByEmail
-    })
+    if (userAvatarUrl) return userAvatarUrl
 
-    if (exactMatch) return exactMatch
+    const userCommitMatch = await findCommitConsensusMatch({
+      email,
+      searchCommitsByEmail
+    })
+    if (userCommitMatch) return userCommitMatch
 
-    return findCommitConsensusMatch({ email: input, searchCommitsByEmail })
+    return organizationAvatarUrl
   }
 }
 
 module.exports.getUsernameAvatarUrl = getUsernameAvatarUrl
-module.exports.findExactPublicProfileMatch = findExactPublicProfileMatch
+module.exports.findExactPublicProfileMatches = findExactPublicProfileMatches
 module.exports.findCommitConsensusMatch = findCommitConsensusMatch