Improve lookup endpoint suggestions (#396)

* Add better suggestions to relayer lookup

* Improve token lookup suggestions

Author: cbovis

src/app/routes/v1/relayer-lookup.js

@@ -11,12 +11,12 @@ const createRouter = () => {
 
     const limit =
       request.query.limit !== undefined ? _.toNumber(request.query.limit) : 5;
-    const relayers = await searchRelayers(q, { limit });
+    const relayers = await searchRelayers(q || null, { limit });
 
     response.body = {
       limit,
       relayers: relayers.map(relayer => relayer),
-      q,
+      q: q || null,
     };
 
     await next();

src/app/routes/v1/token-lookup.js

@@ -13,22 +13,20 @@ const createRouter = () => {
 
     const limit =
       request.query.limit !== undefined ? _.toNumber(request.query.limit) : 5;
-    const tokens = await searchTokens(q, { limit });
+    const tokens = await searchTokens(q || null, { limit });
 
     response.body = {
       limit,
       tokens: tokens.map(token => ({
         address: token.address,
-        circulatingSupply: _.get(token, 'circulatingSupply', null),
         imageUrl: _.isString(token.imageUrl)
           ? getCdnTokenImageUrl(token.imageUrl)
           : null,
         name: _.get(token, 'name', null),
         symbol: _.get(token, 'symbol', null),
-        totalSupply: _.get(token, 'totalSupply', null),
         type: formatTokenType(token.type),
       })),
-      q,
+      q: q || null,
     };
 
     await next();

src/relayers/search-relayers.js

@@ -1,14 +1,89 @@
+const moment = require('moment');
+
+const elasticsearch = require('../util/elasticsearch');
 const Relayer = require('../model/relayer');
 
+const getSuggestedRelayers = async limit => {
+  const response = await elasticsearch.getClient().search({
+    index: 'fills',
+    body: {
+      aggs: {
+        relayers: {
+          terms: {
+            field: 'relayerId',
+            order: { tradeVolume: 'desc' },
+            size: limit,
+          },
+          aggs: {
+            tradeVolume: {
+              sum: {
+                field: 'tradeVolume',
+              },
+            },
+            bucket_truncate: {
+              bucket_sort: {
+                size: limit,
+              },
+            },
+          },
+        },
+        relayerCount: {
+          cardinality: {
+            field: 'relayerId',
+          },
+        },
+      },
+      size: 0,
+      query: {
+        range: {
+          date: {
+            gte: moment()
+              .subtract(30, 'days')
+              .toDate(),
+          },
+        },
+      },
+    },
+  });
+
+  const relayerBuckets = response.body.aggregations.relayers.buckets;
+  const relayerIds = relayerBuckets.map(bucket => bucket.key);
+  const relayers = await Relayer.find({ lookupId: { $in: relayerIds } }).lean();
+
+  const relayersWithStats = relayerBuckets.map(bucket => {
+    const relayer = relayers.find(r => r.lookupId === bucket.key);
+
+    return {
+      id: relayer.id,
+      imageUrl: relayer.imageUrl,
+      name: relayer.name,
+      slug: relayer.slug,
+      url: relayer.url,
+    };
+  });
+
+  return relayersWithStats;
+};
+
 const searchRelayers = async (query, options) => {
-  const relayers = await Relayer.find(
-    query.length > 0 ? { name: new RegExp(query, 'ig') } : {},
-  )
+  if (query === '' || query === null) {
+    const relayers = await getSuggestedRelayers(options.limit);
+
+    return relayers;
+  }
+
+  const relayers = await Relayer.find({ name: new RegExp(query, 'ig') })
     .sort({ name: 1 })
     .limit(options.limit)
     .lean();
 
-  return relayers;
+  return relayers.map(relayer => ({
+    id: relayer.id,
+    imageUrl: relayer.imageUrl,
+    name: relayer.name,
+    slug: relayer.slug,
+    url: relayer.url,
+  }));
 };
 
 module.exports = searchRelayers;

src/tokens/search-tokens.js

@@ -1,17 +1,86 @@
+const moment = require('moment');
+
+const elasticsearch = require('../util/elasticsearch');
 const Token = require('../model/token');
 
-const searchTokens = async (query, options) => {
-  const tokens = await Token.find(
-    query.length > 0
-      ? {
-          $or: [
-            { address: query },
-            { name: new RegExp(query, 'ig') },
-            { symbol: new RegExp(query, 'ig') },
+const getSuggestedTokens = async limit => {
+  const res = await elasticsearch.getClient().search({
+    index: 'traded_tokens',
+    body: {
+      aggs: {
+        tokenStats: {
+          terms: {
+            field: 'tokenAddress',
+            order: { tradeVolumeUSD: 'desc' },
+            size: limit,
+          },
+          aggs: {
+            tradeVolumeUSD: {
+              sum: { field: 'tradedAmountUSD' },
+            },
+            bucket_truncate: {
+              bucket_sort: {
+                size: limit,
+              },
+            },
+          },
+        },
+      },
+      size: 0,
+      query: {
+        bool: {
+          filter: [
+            {
+              range: {
+                date: {
+                  gte: moment()
+                    .subtract(30, 'days')
+                    .toDate(),
+                },
+              },
+            },
           ],
-        }
-      : {},
-  )
+        },
+      },
+    },
+  });
+
+  const { buckets } = res.body.aggregations.tokenStats;
+  const tokenAddresses = buckets.map(x => x.key);
+
+  const tokens = await Token.find({
+    address: { $in: tokenAddresses },
+  }).lean();
+
+  return buckets.map(bucket => {
+    const token = tokens.find(t => t.address === bucket.key);
+
+    const { address, imageUrl, name, symbol, type } = token;
+
+    return {
+      address,
+      imageUrl,
+      name,
+      symbol,
+      type,
+    };
+  });
+};
+
+const searchTokens = async (query, options) => {
+  if (query === '' || query === null) {
+    const tokens = await getSuggestedTokens(options.limit);
+
+    return tokens;
+  }
+
+  const tokens = await Token.find({
+    $or: [
+      { address: query },
+      { name: new RegExp(query, 'ig') },
+      { symbol: new RegExp(query, 'ig') },
+    ],
+  })
     .sort({ name: 1 })
     .limit(options.limit)
     .lean();