chore: less async await

lib/agent.js

@@ -118,7 +118,7 @@ class Agent extends DispatcherBase {
     return dispatcher.dispatch(opts, handler)
   }
 
-  async [kClose] () {
+  [kClose] () {
     const closePromises = []
     for (const ref of this[kClients].values()) {
       const client = ref.deref()
@@ -128,10 +128,10 @@ class Agent extends DispatcherBase {
       }
     }
 
-    await Promise.all(closePromises)
+    return Promise.all(closePromises)
   }
 
-  async [kDestroy] (err) {
+  [kDestroy] (err) {
     const destroyPromises = []
     for (const ref of this[kClients].values()) {
       const client = ref.deref()
@@ -141,7 +141,7 @@ class Agent extends DispatcherBase {
       }
     }
 
-    await Promise.all(destroyPromises)
+    return Promise.all(destroyPromises)
   }
 }
 

lib/api/readable.js

@@ -209,12 +209,14 @@ function isUnusable (self) {
   return util.isDisturbed(self) || isLocked(self)
 }
 
-async function consume (stream, type) {
+function consume (stream, type) {
   if (isUnusable(stream)) {
-    throw new TypeError('unusable')
+    return Promise.reject(new TypeError('unusable'))
   }
 
-  assert(!stream[kConsume])
+  if (stream[kConsume]) {
+    return Promise.reject(new assert.AssertionError('null != true'))
+  }
 
   return new Promise((resolve, reject) => {
     stream[kConsume] = {

lib/client.js

@@ -380,7 +380,7 @@ class Client extends DispatcherBase {
     return this[kNeedDrain] < 2
   }
 
-  async [kClose] () {
+  [kClose] () {
     // TODO: for H2 we need to gracefully flush the remaining enqueued
     // request and close each stream.
     return new Promise((resolve) => {
@@ -392,7 +392,7 @@ class Client extends DispatcherBase {
     })
   }
 
-  async [kDestroy] (err) {
+  [kDestroy] (err) {
     return new Promise((resolve) => {
       const requests = this[kQueue].splice(this[kPendingIdx])
       for (let i = 0; i < requests.length; i++) {

lib/fetch/body.js

@@ -234,8 +234,8 @@ function extractBody (object, keepalive = false) {
         }
         return controller.desiredSize > 0
       },
-      async cancel (reason) {
-        await iterator.return()
+      cancel (reason) {
+        return iterator.return()
       },
       type: undefined
     })

lib/fetch/index.js

@@ -1807,11 +1807,11 @@ async function httpNetworkFetch (
       async start (controller) {
         fetchParams.controller.controller = controller
       },
-      async pull (controller) {
-        await pullAlgorithm(controller)
+      pull (controller) {
+        return pullAlgorithm(controller)
       },
-      async cancel (reason) {
-        await cancelAlgorithm(reason)
+      cancel (reason) {
+        return cancelAlgorithm(reason)
       }
     },
     {

lib/pool-base.js

@@ -111,7 +111,7 @@ class PoolBase extends DispatcherBase {
     return this[kStats]
   }
 
-  async [kClose] () {
+  [kClose] () {
     if (this[kQueue].isEmpty()) {
       return Promise.all(this[kClients].map(c => c.close()))
     } else {
@@ -121,7 +121,7 @@ class PoolBase extends DispatcherBase {
     }
   }
 
-  async [kDestroy] (err) {
+  [kDestroy] (err) {
     while (true) {
       const item = this[kQueue].shift()
       if (!item) {

lib/proxy-agent.js

@@ -82,40 +82,38 @@ class ProxyAgent extends DispatcherBase {
     this[kClient] = clientFactory(resolvedUrl, { connect })
     this[kAgent] = new Agent({
       ...opts,
-      connect: async (opts, callback) => {
+      connect: (opts, callback) => {
         let requestedHost = opts.host
         if (!opts.port) {
           requestedHost += `:${defaultProtocolPort(opts.protocol)}`
         }
-        try {
-          const { socket, statusCode } = await this[kClient].connect({
-            origin,
-            port,
-            path: requestedHost,
-            signal: opts.signal,
-            headers: {
-              ...this[kProxyHeaders],
-              host
-            }
-          })
-          if (statusCode !== 200) {
-            socket.on('error', () => {}).destroy()
-            callback(new RequestAbortedError('Proxy response !== 200 when HTTP Tunneling'))
-          }
-          if (opts.protocol !== 'https:') {
-            callback(null, socket)
-            return
+        this[kClient].connect({
+          origin,
+          port,
+          path: requestedHost,
+          signal: opts.signal,
+          headers: {
+            ...this[kProxyHeaders],
+            host
           }
-          let servername
-          if (this[kRequestTls]) {
-            servername = this[kRequestTls].servername
-          } else {
-            servername = opts.servername
-          }
-          this[kConnectEndpoint]({ ...opts, servername, httpSocket: socket }, callback)
-        } catch (err) {
-          callback(err)
-        }
+        }).catch(callback)
+          .then(({ socket, statusCode }) => {
+            if (statusCode !== 200) {
+              socket.on('error', () => { }).destroy()
+              callback(new RequestAbortedError('Proxy response !== 200 when HTTP Tunneling'))
+            }
+            if (opts.protocol !== 'https:') {
+              callback(null, socket)
+              return
+            }
+            let servername
+            if (this[kRequestTls]) {
+              servername = this[kRequestTls].servername
+            } else {
+              servername = opts.servername
+            }
+            this[kConnectEndpoint]({ ...opts, servername, httpSocket: socket }, callback)
+          }).catch(callback)
       }
     })
   }
@@ -136,14 +134,12 @@ class ProxyAgent extends DispatcherBase {
     )
   }
 
-  async [kClose] () {
-    await this[kAgent].close()
-    await this[kClient].close()
+  [kClose] () {
+    return Promise.all([this[kAgent].close, this[kClient].close])
   }
 
-  async [kDestroy] () {
-    await this[kAgent].destroy()
-    await this[kClient].destroy()
+  [kDestroy] () {
+    return Promise.all([this[kAgent].destroy, this[kClient].destroy])
   }
 }