chore: convert getResponse to async/await syntax

Author: Pedro Santos

package.json

@@ -41,7 +41,7 @@
     "mime-types": "^2.1.21",
     "multihashes": "~0.4.14",
     "promisify-es6": "^1.0.3",
-    "stream-to-blob": "^1.0.1"
+    "stream-to-blob": "^2.0.0"
   },
   "devDependencies": {
     "aegir": "^18.0.3",

src/index.js

@@ -19,103 +19,94 @@ const header = (status = 200, statusText = 'OK', headers = {}) => ({
   headers
 })
 
-const response = (ipfsNode, ipfsPath) => {
+const response = async (ipfsNode, ipfsPath) => {
   // handle hash resolve error (simple hash, test for directory now)
-  const handleResolveError = (node, path, error) => {
+  const handleResolveError = async (node, path, error) => {
     if (error) {
       const errorString = error.toString()
 
-      return new Promise((resolve, reject) => {
-        // switch case with true feels so wrong.
-        switch (true) {
-          case (errorString.includes('dag node is a directory')):
-            resolver.directory(node, path, error.cid)
-              .then((content) => {
-                // dir render
-                if (typeof content === 'string') {
-                  resolve(new Response(content, header(200, 'OK', { 'Content-Type': 'text/html' })))
-                }
-
-                // redirect to dir entry point (index)
-                resolve(Response.redirect(pathUtils.joinURLParts(path, content[0].Name)))
-              })
-              .catch((error) => {
-                log(error)
-                resolve(new Response(errorString, header(500, error.toString())))
-              })
-            break
-          case errorString.startsWith('Error: no link named'):
-            resolve(new Response(errorString, header(404, errorString)))
-            break
-          case errorString.startsWith('Error: multihash length inconsistent'):
-          case errorString.startsWith('Error: Non-base58 character'):
-            resolve(new Response(errorString, header(400, errorString)))
-            break
-          default:
-            log(error)
-            resolve(new Response(errorString, header(500, errorString)))
+      if (errorString.includes('dag node is a directory')) {
+        try {
+          const content = await resolver.directory(node, path, error.cid)
+          // dir render
+          if (typeof content === 'string') {
+            return new Response(content, header(200, 'OK', { 'Content-Type': 'text/html' }))
+          }
+
+          // redirect to dir entry point (index)
+          return Response.redirect(pathUtils.joinURLParts(path, content[0].Name))
+        } catch (error) {
+          log(error)
+          return new Response(errorString, header(500, error.toString()))
         }
-      })
+      }
+
+      if (errorString.startsWith('Error: no link named')) {
+        return new Response(errorString, header(404, errorString))
+      }
+
+      if (errorString.startsWith('Error: multihash length inconsistent') || errorString.startsWith('Error: Non-base58 character')) {
+        return new Response(errorString, header(400, errorString))
+      }
+
+      log(error)
+      return new Response(errorString, header(500, errorString))
     }
   }
 
-  return new Promise((resolve, reject) => {
-    // remove trailing slash for files if needed
-    if (ipfsPath.endsWith('/')) {
-      resolve(Response.redirect(pathUtils.removeTrailingSlash(ipfsPath)))
-    }
+  // remove trailing slash for files if needed
+  if (ipfsPath.endsWith('/')) {
+    return Response.redirect(pathUtils.removeTrailingSlash(ipfsPath))
+  }
 
-    resolver.cid(ipfsNode, ipfsPath)
-      .then((resolvedData) => {
-        const readableStream = ipfsNode.catReadableStream(resolvedData.cid)
-        const responseStream = new stream.PassThrough({ highWaterMark: 1 })
-        readableStream.pipe(responseStream)
+  try {
+    const resolvedData = await resolver.cid(ipfsNode, ipfsPath)
 
-        readableStream.once('error', (error) => {
-          if (error) {
-            log(error)
-            resolve(new Response(error.toString(), header(500, 'Error fetching the file')))
-          }
-        })
-
-        // return only after first chunk being checked
-        let contentTypeDetected = false
-        readableStream.on('data', (chunk) => {
-          // check mime on first chunk
-          if (contentTypeDetected) {
-            return
-          }
+    const readableStream = ipfsNode.catReadableStream(resolvedData.cid)
+    const responseStream = new stream.PassThrough({ highWaterMark: 1 })
+    readableStream.pipe(responseStream)
 
-          contentTypeDetected = true
-          // return Response with mime type
-          const contentType = detectContentType(ipfsPath, chunk)
-
-          if (typeof Blob === 'undefined') {
-            if (contentType) {
-              resolve(new Response(responseStream, header(200, 'OK', { 'Content-Type': contentType })))
-            } else {
-              resolve(new Response(responseStream, header()))
-            }
-          } else {
-            toBlob(responseStream, (err, blob) => {
-              if (err) {
-                resolve(new Response(err.toString(), header(500, 'Error fetching the file')))
-              }
-
-              if (contentType) {
-                resolve(new Response(blob, header(200, 'OK', { 'Content-Type': contentType })))
-              } else {
-                resolve(new Response(blob, header()))
-              }
-            })
-          }
-        })
+    return new Promise((resolve, reject) => {
+      readableStream.once('error', (error) => {
+        if (error) {
+          log(error)
+          return resolve(new Response(error.toString(), header(500, 'Error fetching the file')))
+        }
       })
-      .catch((error) => {
-        log(error)
-        resolve(handleResolveError(ipfsNode, ipfsPath, error))
+
+      // return only after first chunk being checked
+      let contentTypeDetected = false
+      readableStream.on('data', async (chunk) => {
+        // check mime on first chunk
+        if (contentTypeDetected) {
+          return
+        }
+
+        contentTypeDetected = true
+        // return Response with mime type
+        const contentType = detectContentType(ipfsPath, chunk)
+
+        if (typeof Blob === 'undefined') {
+          return contentType
+            ? resolve(new Response(responseStream, header(200, 'OK', { 'Content-Type': contentType })))
+            : resolve(new Response(responseStream, header()))
+        }
+
+        try {
+          const blob = await toBlob(responseStream)
+
+          return contentType
+            ? resolve(new Response(blob, header(200, 'OK', { 'Content-Type': contentType })))
+            : resolve(new Response(blob, header()))
+        } catch (err) {
+          return resolve(new Response(err.toString(), header(500, 'Error fetching the file')))
+        }
       })
-  })
+    })
+  } catch (error) {
+    log(error)
+    return handleResolveError(ipfsNode, ipfsPath, error)
+  }
 }
 
 module.exports = {