chore: convert resolver to async/await syntax

Author: Pedro Santos

package.json

@@ -31,7 +31,6 @@
   },
   "homepage": "https://github.com/ipfs/js-ipfs-http-response#readme",
   "dependencies": {
-    "async": "^2.6.1",
     "cids": "~0.7.1",
     "debug": "^4.1.1",
     "file-type": "^8.0.0",
@@ -40,7 +39,6 @@
     "ipfs-unixfs": "~0.1.16",
     "mime-types": "^2.1.21",
     "multihashes": "~0.4.14",
-    "promisify-es6": "^1.0.3",
     "stream-to-blob": "^2.0.0"
   },
   "devDependencies": {

src/resolver.js

@@ -1,89 +1,73 @@
 'use strict'
 
 const mh = require('multihashes')
-const promisify = require('promisify-es6')
 const CID = require('cids')
 const debug = require('debug')
-const tryEach = require('async/tryEach')
-const waterfall = require('async/waterfall')
 const log = debug('jsipfs:http:response:resolver')
 log.error = debug('jsipfs:http:response:resolver:error')
 const dirView = require('./dir-view')
+const pTryEeach = require('./utils/p-try-each')
 
 const INDEX_HTML_FILES = [
   'index.html',
   'index.htm',
   'index.shtml'
 ]
 
-const findIndexFile = (ipfs, path, callback) => {
-  return tryEach(INDEX_HTML_FILES.map(file => {
-    return (cb) => {
-      waterfall([
-        (cb) => ipfs.files.stat(`${path}/${file}`, cb),
-        (stats, cb) => cb(null, {
-          name: file,
-          cid: new CID(stats.hash)
-        })
-      ], cb)
+const findIndexFile = (ipfs, path) => {
+  return pTryEeach(INDEX_HTML_FILES.map(file => {
+    return async () => {
+      const stats = await ipfs.files.stat(`${path}/${file}`)
+
+      return {
+        name: file,
+        cid: new CID(stats.hash)
+      }
     }
-  }), callback)
+  }))
 }
 
-const directory = promisify((ipfs, path, cid, callback) => {
-  // Test if it is a Website
-  findIndexFile(ipfs, path, (err, res) => {
-    if (err) {
-      if (err.message.includes('does not exist')) {
-        // not a website, just show a directory listing
-        return ipfs.dag.get(cid, (err, result) => {
-          if (err) {
-            return callback(err)
-          }
-
-          return callback(null, dirView.render(path, result.value.Links))
-        })
-      }
+const directory = async (ipfs, path, cid) => {
+  try {
+    const res = await findIndexFile(ipfs, path)
 
-      return callback(err)
+    return [{ Name: res.name }]
+  } catch (err) {
+    if (err.message.includes('does not exist')) {
+      // not a website, just show a directory listing
+      const result = await ipfs.dag.get(cid)
+
+      return dirView.render(path, result.value.Links)
     }
 
-    callback(err, [{
-      Name: res.name
-    }])
-  })
-})
+    throw err
+  }
+}
 
-const cid = promisify((ipfs, path, callback) => {
-  ipfs.files.stat(path, (err, stats) => {
-    if (err) {
-      return callback(err)
-    }
+const cid = async (ipfs, path) => {
+  const stats = await ipfs.files.stat(path)
 
-    const cid = new CID(stats.hash)
+  const cid = new CID(stats.hash)
 
-    if (stats.type.includes('directory')) {
-      const err = new Error('This dag node is a directory')
-      err.cid = cid
-      err.fileName = stats.name
-      err.dagDirType = stats.type
+  if (stats.type.includes('directory')) {
+    const err = new Error('This dag node is a directory')
+    err.cid = cid
+    err.fileName = stats.name
+    err.dagDirType = stats.type
 
-      return callback(err)
-    }
+    throw err
+  }
 
-    callback(err, {
-      cid
-    })
-  })
-})
+  return { cid }
+}
 
-const multihash = promisify((ipfs, path, callback) => {
+const multihash = async (ipfs, path) => {
   // deprecated, use 'cid' instead
   // (left for backward-compatibility)
-  cid(ipfs, path)
-    .then((result) => { callback(null, { multihash: mh.toB58String(result.cid.multihash) }) })
-    .catch((err) => { callback(err) })
-})
+  const result = await cid(ipfs, path)
+
+  return { multihash: mh.toB58String(result.cid.multihash) }
+}
 
 module.exports = {
   directory: directory,

src/utils/p-try-each.js

@@ -0,0 +1,25 @@
+'use strict'
+
+const pTryEeach = async (iterable) => {
+  let error
+
+  for (const element of iterable) {
+    const type = typeof element
+
+    if (type !== 'function') {
+      throw new TypeError(`Expected element to be a \`Function\`, received \`${type}\` instead`)
+    }
+
+    try {
+      const res = await element()
+
+      return res
+    } catch (err) {
+      error = err
+    }
+  }
+
+  throw error
+}
+
+module.exports = pTryEeach