feat: add fetchNames to getAddresses

package.json

@@ -1,6 +1,6 @@
 {
   "name": "krist",
-  "version": "2.8.16",
+  "version": "2.9.0",
   "description": "The new Krist node written in node.js.",
   "main": "index.js",
   "scripts": {

src/addresses.js

@@ -39,8 +39,28 @@ promAddressesVerifiedCounter.inc({ type: "authed" }, 0);
 
 function Addresses() {}
 
-Addresses.getAddress = function(address) {
-  return schemas.address.findOne({where: {address: address}});
+Addresses.getAddress = async function(address, fetchNames) {
+  if (fetchNames) {
+    // Fetch the name count if requested
+    const rows = await database.getSequelize().query(`
+      SELECT
+        \`addresses\`.*,
+        COUNT(\`names\`.\`id\`) AS \`names\`
+      FROM \`addresses\`
+      LEFT JOIN \`names\` ON \`addresses\`.\`address\` = \`names\`.\`owner\`
+      WHERE \`addresses\`.\`address\` = :address
+      LIMIT 1
+    `, {
+      replacements: { address },
+      type: QueryTypes.SELECT
+    });
+
+    // Only return the first result
+    return rows && rows.length ? rows[0] : null;
+  } else {
+    // Perform the regular lookup
+    return schemas.address.findOne({ where: { address: address } });
+  }
 };
 
 Addresses.getAddresses = function(limit, offset) {
@@ -57,7 +77,7 @@ Addresses.lookupAddresses = function(addressList, fetchNames) {
       LEFT JOIN \`names\` ON \`addresses\`.\`address\` = \`names\`.\`owner\`
       WHERE \`addresses\`.\`address\` IN (:addresses)
       GROUP BY \`addresses\`.\`address\`
-      ORDER BY \`names\` DESC;
+      ORDER BY \`names\` DESC
     `, {
       replacements: { addresses: addressList },
       type: QueryTypes.SELECT
@@ -154,7 +174,12 @@ Addresses.addressToJSON = function(address) {
     balance: address.balance,
     totalin: address.totalin,
     totalout: address.totalout,
-    firstseen: address.firstseen
+    firstseen: address.firstseen,
+
+    // Add the name count, but only if it was requested
+    ...(typeof address.names !== "undefined"
+      ? { names: address.names }
+      : {})
   };
 };
 

src/controllers/addresses.js

@@ -53,20 +53,14 @@ AddressesController.getRich = function(limit, offset) {
   });
 };
 
-AddressesController.getAddress = function(address) {
-  return new Promise(function(resolve, reject) {
-    if (!krist.isValidKristAddress(address)) {
-      return reject(new errors.ErrorInvalidParameter("address"));
-    }
+AddressesController.getAddress = async function(address, fetchNames) {
+  if (!krist.isValidKristAddress(address))
+    throw new errors.ErrorInvalidParameter("address");
 
-    addresses.getAddress(address).then(function(result) {
-      if (!result) {
-        return reject(new errors.ErrorAddressNotFound());
-      }
+  const result = await addresses.getAddress(address, !!fetchNames);
+  if (!result) throw new errors.ErrorAddressNotFound();
 
-      resolve(result);
-    }).catch(reject);
-  });
+  return result;
 };
 
 AddressesController.getAlert = function(privatekey) {

src/routes/addresses.js

@@ -279,6 +279,8 @@ module.exports = function(app) {
 	 * @apiVersion 2.0.0
 	 *
 	 * @apiParam (URLParameter) {String} address The address.
+	 * @apiParam (QueryParameter) {Boolean} [fetchNames] When supplied, fetch the
+   *   count of names owned by the address.
 	 *
 	 * @apiSuccess {Number} count The count of results.
 	 * @apiUse Address
@@ -308,15 +310,20 @@ module.exports = function(app) {
 	 *     "parameter": "address"
 	 * }
 	 */
-  app.get("/addresses/:address", function(req, res) {
-    addressesController.getAddress(req.params.address).then(function(address) {
+  app.get("/addresses/:address", async function(req, res) {
+    const fetchNames = typeof req.query.fetchNames !== "undefined";
+
+    try {
+      const address = await addressesController.getAddress(
+        req.params.address, fetchNames);
+
       res.json({
         ok: true,
         address: addressesController.addressToJSON(address)
       });
-    }).catch(function(error) {
-      utils.sendErrorToRes(req, res, error);
-    });
+    } catch (err) {
+      utils.sendErrorToRes(req, res, err);
+    }
   });
 
 

src/routes/lookup.js

@@ -190,10 +190,7 @@ module.exports = function(app) {
 
     // Populate the output object with the addresses we actually found
     for (const address of rows) {
-      out[address.address] = {
-        ...Addresses.addressToJSON(address),
-        ...(fetchNames ? { names: address.names } : {})
-      };
+      out[address.address] = Addresses.addressToJSON(address);
     }
 
     return res.json({

src/websocket_routes/addresses.js

@@ -31,18 +31,18 @@ module.exports = function(websockets) {
 	 * @apiParam (WebsocketParameter) {Number} id
 	 * @apiParam (WebsocketParameter) {String="login"} type
 	 * @apiParam (WebsocketParameter) {String} address
+	 * @apiParam (WebsocketParameter) {Boolean} [fetchNames] When supplied, fetch
+   *   the count of names owned by the address.
 	 *
 	 * @apiUse Address
 	 */
 
-  websockets.addMessageHandler("address", function(ws, message) {
-    return new Promise(function(resolve, reject) {
-      addr.getAddress(message.address).then(function(address) {
-        resolve({
-          ok: true,
-          address: addr.addressToJSON(address)
-        });
-      }).catch(reject);
-    });
+  websockets.addMessageHandler("address", async function(ws, message) {
+    const fetchNames = !!message.fetchNames;
+    const address = await addr.getAddress(message.address, fetchNames);
+    return {
+      ok: true,
+      address: addr.addressToJSON(address)
+    };
   });
 };

test/routes/addresses.test.js

@@ -13,14 +13,14 @@ describe("v1 routes: addresses", () => {
       expect(res).to.be.text;
       expect(res.text).to.equal("10");
     });
-    
+
     it("should return the balance", async () => {
       const res = await api().get("/?getbalance=k7oax47quv");
       expect(res).to.have.status(200);
       expect(res).to.be.text;
       expect(res.text).to.equal("0");
     });
-    
+
     it("should return 0 for a non-existent address", async () => {
       const res = await api().get("/?getbalance=knotfound0");
       expect(res).to.have.status(200);
@@ -93,6 +93,15 @@ describe("v2 routes: addresses", () => {
       expect(res.body).to.include({ ok: true });
       expect(res.body.address).to.be.an("object");
       expect(res.body.address).to.include.all.keys("address", "balance", "totalin", "totalout", "firstseen");
+      expect(res.body.address).to.not.include.key("names");
+    });
+
+    it("should get an address with names", async () => {
+      const res = await api().get("/addresses/k8juvewcui?fetchNames");
+      expect(res).to.be.json;
+      expect(res.body).to.include({ ok: true });
+      expect(res.body.address).to.be.an("object");
+      expect(res.body.address.names).to.equal(0);
     });
 
     it("should not contain private parts", async () => {
@@ -109,7 +118,7 @@ describe("v2 routes: addresses", () => {
       expect(res.body).to.deep.equal({ ok: false, error: "address_not_found" });
     });
   });
-  
+
   // TODO: GET /addresses/:address/names
   // TODO: GET /addresses/:address/transactions
 });

test/websocket_routes/addresses.test.js

@@ -22,6 +22,18 @@ describe("websocket routes: addresses", function() {
       ws.close();
     });
 
+    it("should get an address with names", async () => {
+      const ws = await newConnection();
+      expect(ws).to.nested.include({ "wsp.isOpened": true });
+
+      const data = await ws.sendAndWait({ type: "address", address: "k8juvewcui", fetchNames: true });
+      expect(data).to.deep.include({ ok: true });
+      expect(data.address).to.be.an("object");
+      expect(data.address.names).to.equal(0);
+
+      ws.close();
+    });
+
     it("should error for missing addresses", async () => {
       const ws = await newConnection();
       expect(ws).to.nested.include({ "wsp.isOpened": true });