@unavatar/core 3.45.25 → 3.46.0

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.45.25",
+  "version": "3.46.0",
   "main": "src/index.js",
   "exports": {
     ".": "./src/index.js",
@@ -125,9 +125,10 @@
     "@keyvhq/multi": "~2.1.15",
     "@keyvhq/offline": "~2.2.0",
     "@keyvhq/redis": "~2.2.3",
-    "@metascraper/helpers": "~5.51.1",
+    "@metascraper/helpers": "~5.52.0",
     "@microlink/mql": "~0.17.0",
     "@microlink/ping-url": "~1.4.16",
+    "bimi-url": "~1.0.0",
     "browserless": "~13.6.0",
     "cacheable-lookup": "~6.1.0",
     "data-uri-regex": "~0.1.4",
@@ -137,7 +138,7 @@
     "https-tls": "~1.0.24",
     "ipaddr.js": "~2.4.0",
     "is-absolute-url": "~3.0.3",
-    "is-antibot": "~2.2.0",
+    "is-antibot": "~2.3.0",
     "is-email-like": "~1.0.0",
     "lodash": "~4.18.1",
     "ms": "~2.1.3",

package/src/avatar/auto.js

@@ -23,14 +23,8 @@ const getInputType = input => {
   return 'username'
 }
 
-const factory = ({ constants, providers, providersBy, reachableUrl }) => {
+const factory = ({ constants, providers, providerTiers, reachableUrl }) => {
   const { REQUEST_TIMEOUT } = constants
-  const providerEntriesByType = Object.fromEntries(
-    Object.entries(providersBy).map(([inputType, providerNames]) => [
-      inputType,
-      providerNames.map(provider => [provider, providers[provider]])
-    ])
-  )
 
   const getAvatarContent = provider => async output => {
     if (typeof output !== 'string' || output === '') {
@@ -68,7 +62,13 @@ const factory = ({ constants, providers, providersBy, reachableUrl }) => {
     return { type: 'url', data: url, provider }
   }
 
-  const getAvatar = async (fn, provider, input, context) => {
+  const getAvatar = async (
+    fn,
+    provider,
+    input,
+    context,
+    deadline = Date.now() + REQUEST_TIMEOUT
+  ) => {
     const promise = Promise.resolve(fn(input, context))
       .then(getAvatarContent(provider))
       .catch(error => {
@@ -79,32 +79,49 @@ const factory = ({ constants, providers, providersBy, reachableUrl }) => {
         throw error
       })
 
-    return pTimeout(promise, REQUEST_TIMEOUT).catch(error => {
-      error.provider = provider
-      throw error
-    })
+    return pTimeout(promise, Math.max(0, deadline - Date.now())).catch(
+      error => {
+        error.provider = provider
+        throw error
+      }
+    )
   }
 
-  const resolveAutoByType = async (inputType, input, context) => {
-    let collection = providerEntriesByType[inputType]
+  const raceTier = (tier, input, context, deadline) =>
+    pAny(
+      tier.map(provider =>
+        getAvatar(providers[provider], provider, input, context, deadline)
+      )
+    )
+
+  const auto = inputType => async (input, context) => {
+    const tierKey =
+      inputType === 'email' && isHash(input) ? 'emailHash' : inputType
+    const tiers = providerTiers[tierKey]
 
-    if (inputType === 'email' && isHash(input)) {
-      collection = collection.filter(([provider]) => provider === 'gravatar')
+    if (!tiers?.length) {
+      throw new ExtendableError({
+        message: `No providers declared for \`${tierKey}\`.`,
+        statusCode: httpStatus.NOT_FOUND
+      })
     }
 
-    const promises = new Array(collection.length)
+    const deadline = Date.now() + REQUEST_TIMEOUT
+
+    let firstError
 
-    for (let index = 0; index < collection.length; index++) {
-      const [provider, fn] = collection[index]
-      promises[index] = getAvatar(fn, provider, input, context)
+    for (const tier of tiers) {
+      try {
+        return await raceTier(tier, input, context, deadline)
+      } catch (error) {
+        firstError ??= error
+        if (Date.now() >= deadline) break
+      }
     }
 
-    return pAny(promises)
+    throw firstError
   }
 
-  const auto = inputType => (input, context) =>
-    resolveAutoByType(inputType, input, context)
-
   return { auto, getInputType, getAvatar }
 }
 

package/src/index.js

@@ -22,9 +22,11 @@ module.exports = ({
     redis
   })
   const cache = require('./util/cache')({ createMultiCache, createRedisCache })
+  const dnsResolver = require('./util/dns-resolver')(constants)
   const cacheableLookup = require('./util/cacheable-lookup')({
     ...constants,
-    cache: cache.dnsCache
+    cache: cache.dnsCache,
+    resolver: dnsResolver
   })
   const isReservedIp = require('./util/is-reserved-ip')({ cacheableLookup })
   const got = require('./util/got')({ cacheableLookup })
@@ -34,13 +36,16 @@ module.exports = ({
   })
   const createBrowser = require('./util/browserless')(constants)
   const getHTML = require('./util/html-get')({ createBrowser, got })
-  const { createHtmlProvider, getOgImage, NOT_FOUND } =
-    require('./util/html-provider')({
-      ...constants,
-      getHTML,
-      onFetchHTML,
-      userAgent
-    })
+  const {
+    createHtmlProvider,
+    getOgImage,
+    NOT_FOUND
+  } = require('./util/html-provider')({
+    ...constants,
+    getHTML,
+    onFetchHTML,
+    userAgent
+  })
 
   const providerCtx = {
     constants,
@@ -50,15 +55,19 @@ module.exports = ({
     got,
     reachableUrl,
     isReservedIp,
+    dnsResolver,
+    bimiCache: cache.bimiCache,
     githubSearchCache: cache.githubSearchCache,
     itunesSearchCache: cache.itunesSearchCache
   }
-  const { providers, providersBy } = require('./providers')(providerCtx)
+  const { providers, providerTiers, providersBy } = require('./providers')(
+    providerCtx
+  )
 
   const { auto, getInputType, getAvatar } = require('./avatar/auto')({
     constants,
     providers,
-    providersBy,
+    providerTiers,
     reachableUrl
   })
 

package/src/providers/bimi.js

@@ -0,0 +1,22 @@
+'use strict'
+
+const createGetLogo = require('bimi-url')
+
+const parseInput = input => input.slice(input.lastIndexOf('@') + 1)
+
+module.exports = ({ bimiCache, dnsResolver, got, isReservedIp }) => {
+  const getLogo = createGetLogo({
+    gotOpts: got.gotOpts,
+    keyvOpts: bimiCache,
+    resolveTxt: hostname => dnsResolver.resolveTxt(hostname)
+  })
+
+  return async function bimi (input) {
+    const logoUrl = await getLogo(parseInput(input))
+    if (!logoUrl) return undefined
+    if (await isReservedIp(new URL(logoUrl).hostname)) return undefined
+    return logoUrl
+  }
+}
+
+module.exports.parseInput = parseInput

package/src/providers/index.js

@@ -1,86 +1,99 @@
 'use strict'
 
-const providersBy = {
-  email: ['gravatar', 'github'],
+const providerTiers = {
+  email: [['gravatar', 'github'], ['bimi']],
+  emailHash: [['gravatar']],
   username: [
-    'apple-music',
-    'apple-store',
-    'behance',
-    'bilibili',
-    'bluesky',
-    'buymeacoffee',
-    'cashapp',
-    'codepen',
-    'cults3d',
-    'cursor',
-    'deezer',
-    'deviantart',
-    'discord',
-    'dockerhub',
-    'dribbble',
-    'facebook',
-    'flickr',
-    'gitee',
-    'github',
-    'gitlab',
-    'google-play',
-    'huggingface',
-    'hevy',
-    'instagram',
-    'juejin',
-    'ko-fi',
-    'linkedin',
-    'mastodon',
-    'medium',
-    'netease-music',
-    'npm',
-    'onlyfans',
-    'openstreetmap',
-    'patreon',
-    'paypal',
-    'pinterest',
-    'printables',
-    'primal',
-    'producthunt',
-    'psnprofiles',
-    'qq',
-    'raycast',
-    'reddit',
-    'revolut',
-    'snapchat',
-    'soundcloud',
-    'spotify',
-    'stackoverflow',
-    'steam',
-    'strava',
-    'substack',
-    'telegram',
-    'thingiverse',
-    'threads',
-    'tidal',
-    'tieba',
-    'tiktok',
-    'tumblr',
-    'twitch',
-    'venmo',
-    'vimeo',
-    'weibo',
-    'whatsapp',
-    'wise',
-    'x',
-    'xboxgamertag',
-    'youtube',
-    'zhihu'
+    [
+      'apple-music',
+      'apple-store',
+      'behance',
+      'bilibili',
+      'bluesky',
+      'buymeacoffee',
+      'cashapp',
+      'codepen',
+      'cults3d',
+      'cursor',
+      'deezer',
+      'deviantart',
+      'discord',
+      'dockerhub',
+      'dribbble',
+      'facebook',
+      'flickr',
+      'gitee',
+      'github',
+      'gitlab',
+      'google-play',
+      'huggingface',
+      'hevy',
+      'instagram',
+      'juejin',
+      'ko-fi',
+      'linkedin',
+      'mastodon',
+      'medium',
+      'netease-music',
+      'npm',
+      'onlyfans',
+      'openstreetmap',
+      'patreon',
+      'paypal',
+      'pinterest',
+      'printables',
+      'primal',
+      'producthunt',
+      'psnprofiles',
+      'qq',
+      'raycast',
+      'reddit',
+      'revolut',
+      'snapchat',
+      'soundcloud',
+      'spotify',
+      'stackoverflow',
+      'steam',
+      'strava',
+      'substack',
+      'telegram',
+      'thingiverse',
+      'threads',
+      'tidal',
+      'tieba',
+      'tiktok',
+      'tumblr',
+      'twitch',
+      'venmo',
+      'vimeo',
+      'weibo',
+      'whatsapp',
+      'wise',
+      'x',
+      'xboxgamertag',
+      'youtube',
+      'zhihu'
+    ]
   ],
-  domain: ['duckduckgo', 'google', 'microlink']
+  domain: [['bimi'], ['duckduckgo', 'google', 'microlink']]
 }
 
+const { emailHash, ...publicTiers } = providerTiers
+
+const providersBy = Object.fromEntries(
+  Object.entries(publicTiers).map(([inputType, tiers]) => [
+    inputType,
+    tiers.flat()
+  ])
+)
+
 module.exports = ctx => {
   const providers = {
     'apple-music': require('./apple-music')(ctx),
     'apple-store': require('./apple-store')(ctx),
     behance: require('./behance')(ctx),
     bilibili: require('./bilibili')(ctx),
+    bimi: require('./bimi')(ctx),
     bluesky: require('./bluesky')(ctx),
     buymeacoffee: require('./buymeacoffee')(ctx),
     cashapp: require('./cashapp')(ctx),
@@ -151,5 +164,5 @@ module.exports = ctx => {
     zhihu: require('./zhihu')(ctx)
   }
 
-  return { providers, providersBy }
+  return { providers, providerTiers, providersBy }
 }

package/src/util/cache.js

@@ -3,11 +3,21 @@
 const ms = require('ms')
 
 module.exports = ({ createMultiCache, createRedisCache }) => ({
-  dnsCache: createMultiCache(createRedisCache({ namespace: 'dns', ttl: ms('1d') })),
+  bimiCache: createMultiCache(
+    createRedisCache({ namespace: 'bimi', ttl: ms('1d') })
+  ),
+  dnsCache: createMultiCache(
+    createRedisCache({ namespace: 'dns', ttl: ms('1d') })
+  ),
   githubSearchCache: createRedisCache({
     namespace: 'github-search',
     ttl: ms('1d')
   }),
-  pingCache: createMultiCache(createRedisCache({ namespace: 'ping', ttl: ms('1d') })),
-  itunesSearchCache: createRedisCache({ namespace: 'itunes-search', ttl: ms('7d') })
+  pingCache: createMultiCache(
+    createRedisCache({ namespace: 'ping', ttl: ms('1d') })
+  ),
+  itunesSearchCache: createRedisCache({
+    namespace: 'itunes-search',
+    ttl: ms('7d')
+  })
 })

package/src/util/cacheable-lookup.js

@@ -1,22 +1,10 @@
 'use strict'
 
 const CacheableLookup = require('cacheable-lookup')
-const Tangerine = require('tangerine')
 
-module.exports = ({ TTL_DEFAULT, DNS_TIMEOUT, DNS_SERVERS, cache }) =>
+module.exports = ({ TTL_DEFAULT, cache, resolver }) =>
   new CacheableLookup({
     maxTtl: TTL_DEFAULT,
     cache,
-    resolver: new Tangerine(
-      {
-        cache: false,
-        timeout: DNS_TIMEOUT,
-        servers: DNS_SERVERS
-      },
-      require('got').extend({
-        responseType: 'buffer',
-        decompress: false,
-        retry: 0
-      })
-    )
+    resolver
   })

package/src/util/dns-resolver.js

@@ -0,0 +1,18 @@
+'use strict'
+
+const Tangerine = require('tangerine')
+const got = require('got')
+
+module.exports = ({ DNS_TIMEOUT, DNS_SERVERS }) =>
+  new Tangerine(
+    {
+      cache: false,
+      timeout: DNS_TIMEOUT,
+      servers: DNS_SERVERS
+    },
+    got.extend({
+      responseType: 'buffer',
+      decompress: false,
+      retry: 0
+    })
+  )