bare-http1 4.3.1 → 4.5.1

package/index.d.ts

@@ -99,6 +99,8 @@ export interface HTTPAgentOptions {
 }
 
 export interface HTTPAgent {
+  readonly suspended: boolean
+  readonly resumed: Promise<void> | null
   readonly sockets: IterableIterator<TCPSocket>
   readonly freeSockets: IterableIterator<TCPSocket>
 
@@ -112,6 +114,8 @@ export interface HTTPAgent {
 
   addRequest(req: HTTPClientRequest, opts: TCPSocketOptions & TCPSocketConnectOptions): void
 
+  suspend(): void
+  resume(): void
   destroy(): void
 }
 

package/lib/agent.js

@@ -1,6 +1,7 @@
 const EventEmitter = require('bare-events')
 const tcp = require('bare-tcp')
 const HTTPClientConnection = require('./client-connection')
+const errors = require('./errors')
 
 class HTTPSocketSet {
   constructor() {
@@ -66,16 +67,28 @@ class HTTPAgent extends EventEmitter {
   constructor(opts = {}) {
     super()
 
-    const { keepAlive = false, keepAliveMsecs = 1000 } = opts
+    const { keepAlive = false, keepAliveMsecs = 1000, defaultPort = 80 } = opts
+
+    this._suspended = false
+    this._resuming = null
 
     this._sockets = new HTTPSocketSet()
     this._freeSockets = new HTTPSocketSet()
 
     this._keepAlive = typeof keepAlive === 'number' ? keepAlive : keepAlive ? keepAliveMsecs : -1
+    this._defaultPort = defaultPort
 
     this._opts = { ...opts }
   }
 
+  get suspended() {
+    return this._suspended
+  }
+
+  get resumed() {
+    return this._resuming ? this._resuming.promise : null
+  }
+
   get sockets() {
     return this._sockets.sockets()
   }
@@ -84,7 +97,13 @@ class HTTPAgent extends EventEmitter {
     return this._freeSockets.sockets()
   }
 
+  get defaultPort() {
+    return this._defaultPort
+  }
+
   createConnection(opts) {
+    if (this._suspended) throw errors.AGENT_SUSPENDED()
+
     return tcp.createConnection(opts)
   }
 
@@ -120,10 +139,10 @@ class HTTPAgent extends EventEmitter {
 
       socket
         .on('free', onfree)
-        .on('timeout', ontimeout)
         .on('end', onremove)
         .on('finish', onremove)
         .on('close', onremove)
+        .on('timeout', ontimeout)
 
       function onfree() {
         if (socket.destroyed) return
@@ -137,12 +156,6 @@ class HTTPAgent extends EventEmitter {
         agent.emit('free', socket)
       }
 
-      function ontimeout() {
-        socket.destroy()
-
-        agent._freeSockets.delete(name, socket)
-      }
-
       function onremove() {
         socket.off('free', onfree)
 
@@ -151,37 +164,57 @@ class HTTPAgent extends EventEmitter {
 
         if (agent._sockets.size === 0) HTTPAgent._agents.delete(agent)
       }
+
+      function ontimeout() {
+        socket.destroy()
+
+        agent._freeSockets.delete(name, socket)
+      }
     }
 
     if (this._sockets.size === 0) HTTPAgent._agents.add(this)
 
     this._sockets.add(name, socket)
 
-    req.socket = socket
+    req._socket = socket
 
     const connection = HTTPClientConnection.from(socket, opts)
 
-    connection.req = req
+    connection._req = req
+  }
+
+  suspend() {
+    if (this._suspended) return
+
+    this._resuming = Promise.withResolvers()
+    this._suspended = true
+
+    this.destroy()
+  }
+
+  resume() {
+    if (this._resuming === null) return
+
+    this._resuming.resolve()
+    this._resuming = null
+    this._suspended = false
   }
 
   destroy() {
     for (const socket of this._sockets.sockets()) socket.destroy()
   }
 
-  static _global = new this({ keepAlive: 1000, timeout: 5000 })
   static _agents = new Set()
 
-  static get global() {
-    return this._global
-  }
-
   static _onidle() {
     for (const agent of this._agents) {
-      for (const socket of agent._sockets.sockets()) socket.destroy()
+      agent.destroy()
     }
   }
 }
 
+HTTPAgent.global = new HTTPAgent({ keepAlive: 1000, timeout: 5000 })
+
 module.exports = HTTPAgent
 
 Bare.on('idle', HTTPAgent._onidle.bind(HTTPAgent))

package/lib/client-connection.js

@@ -22,10 +22,10 @@ module.exports = class HTTPClientConnection {
   constructor(socket, opts = {}) {
     const { IncomingMessage = HTTPIncomingMessage } = opts
 
-    this.socket = socket
+    this._socket = socket
 
-    this.req = null
-    this.res = null
+    this._req = null
+    this._res = null
 
     this._IncomingMessage = IncomingMessage
 
@@ -50,20 +50,32 @@ module.exports = class HTTPClientConnection {
     HTTPClientConnection._connections.set(socket, this)
   }
 
+  get socket() {
+    return this._socket
+  }
+
+  get req() {
+    return this._req
+  }
+
+  get res() {
+    return this._res
+  }
+
   get idle() {
     return this._idle
   }
 
   _onerror(err) {
-    if (this.req) this.req.destroy(err)
+    if (this._req) this._req.destroy(err)
   }
 
   _onclose() {
-    if (this.req) this.req._continueFinal()
+    if (this._req) this._req.destroy()
   }
 
   _onend() {
-    if (this.req) this.req.destroy(errors.CONNECTION_LOST())
+    if (this._req) this._req.destroy(errors.CONNECTION_LOST())
   }
 
   _ondata(data) {
@@ -73,68 +85,77 @@ module.exports = class HTTPClientConnection {
       for (const op of this._parser.push(data)) {
         switch (op.type) {
           case RESPONSE:
-            this.req.on('close', () => {
-              this.req = null
+            this._req.on('close', () => {
+              this._req = null
             })
 
-            this.res = new this._IncomingMessage(this.socket, op.headers, {
+            this._res = new this._IncomingMessage(this._socket, op.headers, {
               statusCode: op.code,
               statusMessage: op.reason
             })
 
-            this.res.on('close', () => {
-              this.res = null
-
+            this._res.on('close', () => {
+              this._res = null
               this._idle = true
 
-              this.socket.emit('free')
+              this._socket.emit('free')
             })
 
             if (op.headers.connection && op.headers.connection.toLowerCase() === 'upgrade') {
               return this._onupgrade(this._parser.end())
             }
 
-            this.req.emit('response', this.res)
+            this._req.emit('response', this._res)
             break
 
           case DATA:
-            this.res.push(op.data)
+            this._res.push(op.data)
             break
 
           case END:
-            if (this.res) this.res.push(null)
-            if (this.req) this.req._continueFinal()
+            if (this._res) {
+              this._res._socket = null
+              this._res.push(null)
+            }
+
+            if (this._req) {
+              this._req._socket = null
+              this._req.destroy()
+            }
             break
         }
       }
     } catch (err) {
-      this.socket.destroy(err)
+      this._socket.destroy(err)
     }
   }
 
   _onupgrade(data) {
-    this._ondetach()
+    this._detach()
 
-    const req = this.req
+    const res = this._res
+    const req = this._req
 
-    req.upgrade = true
-    req.destroy()
+    res._upgrade = req._upgrade = true
+
+    const upgraded = req.emit('upgrade', res, this._socket, data || EMPTY)
 
-    if (req.emit('upgrade', this.res, this.socket, data || EMPTY)) return
+    res.push(null)
+    req.destroy()
 
-    this.socket.destroy()
+    if (!upgraded) this._socket.destroy()
   }
 
   _ontimeout() {
-    if (this.req) this.req.emit('timeout')
+    if (this._req) this._req.emit('timeout')
   }
 
   _ondrain() {
-    if (this.req) this.req._continueWrite()
+    if (this._req) this._req._continueWrite()
   }
 
-  _ondetach() {
-    this.socket
+  _detach() {
+    this._socket
       .off('error', this._onerror)
       .off('close', this._onclose)
       .off('end', this._onend)
@@ -142,6 +163,6 @@ module.exports = class HTTPClientConnection {
       .off('drain', this._ondrain)
       .off('timeout', this._ontimeout)
 
-    HTTPClientConnection._connections.delete(this.socket)
+    HTTPClientConnection._connections.delete(this._socket)
   }
 }

package/lib/client-request.js

@@ -16,38 +16,48 @@ module.exports = class HTTPClientRequest extends HTTPOutgoingMessage {
     const agent = opts.agent === false ? new HTTPAgent() : opts.agent || HTTPAgent.global
     const method = opts.method || 'GET'
     const path = opts.path || '/'
+    const defaultPort = opts.defaultPort || (agent && agent.defaultPort) || 80
     const host = (opts.host = opts.host || 'localhost')
-    const port = (opts.port = opts.port || 80)
-    const headers = { host: host + (port === 80 ? '' : ':' + port), ...opts.headers }
+    const port = (opts.port = opts.port || defaultPort)
+    const headers = { host: hostHeader(host, port, defaultPort), ...opts.headers }
 
     super()
 
     agent.addRequest(this, opts)
 
-    this.method = method
-    this.path = path
-    this.headers = headers
+    this._headers = headers
+    this._method = method
+    this._path = path
 
     this._chunked = method !== 'GET' && method !== 'HEAD'
 
+    this._pendingWrite = null
     this._pendingFinal = null
 
     if (onresponse) this.once('response', onresponse)
   }
 
+  get method() {
+    return this._method
+  }
+
+  get path() {
+    return this._path
+  }
+
   // For Node.js compatibility
   abort() {
     return this.destroy()
   }
 
   _header() {
-    let h = `${this.method} ${this.path} HTTP/1.1\r\n`
+    let h = `${this._method} ${this._path} HTTP/1.1\r\n`
 
     let upgrade = false
 
-    for (const name of Object.keys(this.headers)) {
+    for (const name of Object.keys(this._headers)) {
       const n = name.toLowerCase()
-      const v = this.headers[name]
+      const v = this._headers[name]
 
       if (n === 'content-length') this._chunked = false
       if (n === 'connection' && v && v.toLowerCase() === 'upgrade') upgrade = true
@@ -65,33 +75,34 @@ module.exports = class HTTPClientRequest extends HTTPOutgoingMessage {
   }
 
   _write(data, encoding, cb) {
-    if (this.headersSent === false) this.flushHeaders()
+    if (this._headersSent === false) this.flushHeaders()
 
     if (this._chunked) {
-      this.socket.write(Buffer.from(data.byteLength.toString(16)))
-      this.socket.write(CHUNK_DELIMITER)
+      this._socket.write(Buffer.from(data.byteLength.toString(16)))
+      this._socket.write(CHUNK_DELIMITER)
     }
 
-    let flushed = this.socket.write(data)
+    let flushed = this._socket.write(data)
 
-    if (this._chunked) flushed = this.socket.write(CHUNK_DELIMITER)
+    if (this._chunked) flushed = this._socket.write(CHUNK_DELIMITER)
 
     if (flushed) cb(null)
     else this._pendingWrite = cb
   }
 
   _final(cb) {
-    if (this.headersSent === false) this.flushHeaders()
+    if (this._headersSent === false) this.flushHeaders()
 
-    if (this._chunked) this.socket.write(CHUNK_TERMINATOR)
+    if (this._chunked) this._socket.write(CHUNK_TERMINATOR)
 
     this._pendingFinal = cb
   }
 
   _predestroy() {
-    if (this.upgrade) return this._continueFinal()
+    super._predestroy()
 
-    this.socket.destroy()
+    this._continueWrite()
+    this._continueFinal()
   }
 
   _continueWrite() {
@@ -116,3 +127,17 @@ function httpCase(n) {
   }
   return s
 }
+
+function hostHeader(host, port, defaultPort) {
+  const i = host.indexOf(':')
+
+  if (i !== -1 && host.includes(':', i + 1) && host.charCodeAt(0) !== 91 /* [ */) {
+    host = `[${host}]`
+  }
+
+  if (port && +port !== defaultPort) {
+    host += ':' + port
+  }
+
+  return host
+}

package/lib/errors.d.ts

@@ -1,8 +1,5 @@
 declare class HTTPError extends Error {
-  private constructor()
-
-  static NOT_IMPLEMENTED(msg?: string): HTTPError
-  static CONNECTION_LOST(msg?: string): HTTPError
+  readonly code: string
 }
 
 export = HTTPError

package/lib/errors.js

@@ -19,4 +19,8 @@ module.exports = class HTTPError extends Error {
   static CONNECTION_LOST(msg = 'Socket hung up') {
     return new HTTPError(msg, HTTPError.CONNECTION_LOST)
   }
+
+  static AGENT_SUSPENDED(msg = 'Agent is suspended') {
+    return new HTTPError(msg, HTTPError.AGENT_SUSPENDED)
+  }
 }

package/lib/incoming-message.js

@@ -4,17 +4,45 @@ module.exports = class HTTPIncomingMessage extends Readable {
   constructor(socket = null, headers = {}, opts = {}) {
     super()
 
-    this.socket = socket
-    this.headers = headers
-    this.upgrade = false
+    this._socket = socket
+    this._headers = headers
+    this._upgrade = false
 
     // Server options
-    this.method = opts.method || ''
-    this.url = opts.url || ''
+    this._method = opts.method || ''
+    this._url = opts.url || ''
 
     // Client options
-    this.statusCode = opts.statusCode || 0
-    this.statusMessage = opts.statusMessage || ''
+    this._statusCode = opts.statusCode || 0
+    this._statusMessage = opts.statusMessage || ''
+  }
+
+  get socket() {
+    return this._socket
+  }
+
+  get headers() {
+    return this._headers
+  }
+
+  get upgrade() {
+    return this._upgrade
+  }
+
+  get method() {
+    return this._method
+  }
+
+  get url() {
+    return this._url
+  }
+
+  get statusCode() {
+    return this._statusCode
+  }
+
+  get statusMessage() {
+    return this._statusMessage
   }
 
   get httpVersion() {
@@ -22,26 +50,26 @@ module.exports = class HTTPIncomingMessage extends Readable {
   }
 
   getHeader(name) {
-    return this.headers[name.toLowerCase()]
+    return this._headers[name.toLowerCase()]
   }
 
   getHeaders() {
-    return { ...this.headers }
+    return { ...this._headers }
   }
 
   hasHeader(name) {
-    return name.toLowerCase() in this.headers
+    return name.toLowerCase() in this._headers
   }
 
   setTimeout(ms, ontimeout) {
     if (ontimeout) this.once('timeout', ontimeout)
 
-    this.socket.setTimeout(ms)
+    this._socket.setTimeout(ms)
 
     return this
   }
 
   _predestroy() {
-    if (this.upgrade === false && this.socket !== null) this.socket.destroy()
+    if (this._upgrade === false && this._socket !== null) this._socket.destroy()
   }
 }

package/lib/outgoing-message.js

@@ -5,39 +5,55 @@ module.exports = class HTTPOutgoingMessage extends Writable {
   constructor(socket = null) {
     super()
 
-    this.socket = socket
-    this.headers = {}
-    this.headersSent = false
-    this.upgrade = false
+    this._socket = socket
+    this._headers = {}
+    this._headersSent = false
+    this._upgrade = false
+  }
+
+  get socket() {
+    return this._socket
+  }
+
+  get headers() {
+    return this._headers
+  }
+
+  get headersSent() {
+    return this._headersSent
+  }
+
+  get upgrade() {
+    return this._upgrade
   }
 
   getHeader(name) {
-    return this.headers[name.toLowerCase()]
+    return this._headers[name.toLowerCase()]
   }
 
   getHeaders() {
-    return { ...this.headers }
+    return { ...this._headers }
   }
 
   hasHeader(name) {
-    return name.toLowerCase() in this.headers
+    return name.toLowerCase() in this._headers
   }
 
   setHeader(name, value) {
-    this.headers[name.toLowerCase()] = value
+    this._headers[name.toLowerCase()] = value
   }
 
   flushHeaders() {
-    if (this.headersSent === true || this.socket === null) return
+    if (this._headersSent === true || this._socket === null) return
 
-    this.socket.write(Buffer.from(this._header()))
-    this.headersSent = true
+    this._socket.write(Buffer.from(this._header()))
+    this._headersSent = true
   }
 
   setTimeout(ms, ontimeout) {
     if (ontimeout) this.once('timeout', ontimeout)
 
-    this.socket.setTimeout(ms)
+    this._socket.setTimeout(ms)
 
     return this
   }
@@ -47,6 +63,6 @@ module.exports = class HTTPOutgoingMessage extends Writable {
   }
 
   _predestroy() {
-    if (this.upgrade === false && this.socket !== null) this.socket.destroy()
+    if (this._upgrade === false && this._socket !== null) this._socket.destroy()
   }
 }

package/lib/server-connection.js

@@ -19,11 +19,11 @@ module.exports = class HTTPServerConnection {
   constructor(server, socket, opts = {}) {
     const { IncomingMessage = HTTPIncomingMessage, ServerResponse = HTTPServerResponse } = opts
 
-    this.server = server
-    this.socket = socket
+    this._server = server
+    this._socket = socket
 
-    this.req = null
-    this.res = null
+    this._req = null
+    this._res = null
 
     this._IncomingMessage = IncomingMessage
     this._ServerResponse = ServerResponse
@@ -45,7 +45,23 @@ module.exports = class HTTPServerConnection {
 
     HTTPServerConnection._connections.set(socket, this)
 
-    if (this.server.timeout) socket.setTimeout(this.server.timeout)
+    if (this._server.timeout) socket.setTimeout(this._server.timeout)
+  }
+
+  get server() {
+    return this._server
+  }
+
+  get socket() {
+    return this._socket
+  }
+
+  get req() {
+    return this._req
+  }
+
+  get res() {
+    return this._res
   }
 
   get idle() {
@@ -53,10 +69,11 @@ module.exports = class HTTPServerConnection {
   }
 
   _onclose() {
-    if (this.req && !isEnded(this.req)) this.req.destroy()
-    if (this.res && !isFinished(this.res)) this.res.destroy()
-    const err = getStreamError(this.socket)
-    if (err) this.socket.destroy(err)
+    if (this._req && !isEnded(this._req)) this._req.destroy()
+    if (this._res && !isFinished(this._res)) this._res.destroy()
+
+    const err = getStreamError(this._socket)
+    if (err) this._socket.destroy(err)
   }
 
   _ondata(data) {
@@ -66,86 +83,92 @@ module.exports = class HTTPServerConnection {
       for (const op of this._parser.push(data)) {
         switch (op.type) {
           case REQUEST:
-            this.req = new this._IncomingMessage(this.socket, op.headers, {
+            this._req = new this._IncomingMessage(this._socket, op.headers, {
               method: op.method,
               url: op.url
             })
 
-            this.req.on('close', () => {
-              this.req = null
+            this._req.on('close', () => {
+              this._req = null
 
               this._idle = true
 
-              if (this.server.closing) this.socket.destroy()
+              if (this._server.closing) this._socket.destroy()
             })
 
             // Eagerly open the request stream
-            this.req.resume()
-            this.req.pause()
+            this._req.resume()
+            this._req.pause()
 
             if (op.headers.connection && op.headers.connection.toLowerCase() === 'upgrade') {
               return this._onupgrade(this._parser.end())
             }
 
-            this.res = new this._ServerResponse(
-              this.socket,
-              this.req,
+            this._res = new this._ServerResponse(
+              this._socket,
+              this._req,
               op.headers.connection === 'close'
             )
 
-            this.res.on('close', () => {
-              this.res = null
+            this._res.on('close', () => {
+              this._res = null
             })
 
-            this.server.emit('request', this.req, this.res)
+            this._server.emit('request', this._req, this._res)
             break
 
           case DATA:
-            this.req.push(op.data)
+            this._req.push(op.data)
             break
 
           case END:
-            if (this.req) this.req.push(null)
+            if (this._req) {
+              this._req._socket = null
+              this._req.push(null)
+            }
             break
         }
       }
     } catch (err) {
-      this.socket.destroy(err)
+      this._socket.destroy(err)
     }
   }
 
   _onupgrade(data) {
-    this._ondetach()
+    this._detach()
+
+    const req = this._req
+
+    req._upgrade = true
 
-    const req = this.req
+    const upgraded = this._server.emit('upgrade', req, this._socket, data || EMPTY)
 
-    req.upgrade = true
-    req.destroy()
+    req.push(null)
 
-    this.server.emit('upgrade', req, this.socket, data || EMPTY)
+    if (!upgraded) this._socket.destroy()
   }
 
   _ontimeout() {
-    const reqTimeout = this.req && this.req.emit('timeout')
-    const resTimeout = this.res && this.res.emit('timeout')
-    const serverTimeout = this.server.emit('timeout', this.socket)
+    const reqTimeout = this._req && this._req.emit('timeout')
+    const resTimeout = this._res && this._res.emit('timeout')
+    const serverTimeout = this._server.emit('timeout', this._socket)
 
-    if (!reqTimeout && !resTimeout && !serverTimeout) this.socket.destroy()
+    if (!reqTimeout && !resTimeout && !serverTimeout) this._socket.destroy()
   }
 
   _ondrain() {
-    if (this.res) this.res._continueWrite()
+    if (this._res) this._res._continueWrite()
   }
 
-  _ondetach() {
-    this.socket
+  _detach() {
+    this._socket
       .off('error', noop)
       .off('close', this._onclose)
       .off('data', this._ondata)
       .off('drain', this._ondrain)
       .off('timeout', this._ontimeout)
 
-    HTTPServerConnection._connections.delete(this.socket)
+    HTTPServerConnection._connections.delete(this._socket)
   }
 }
 

package/lib/server-response.js

@@ -8,10 +8,10 @@ module.exports = class HTTPServerResponse extends HTTPOutgoingMessage {
   constructor(socket, req, close) {
     super(socket)
 
-    this.req = req
+    this._req = req
 
-    this.statusCode = 200
-    this.statusMessage = null
+    this._statusCode = 200
+    this._statusMessage = null
 
     this._chunked = true
     this._close = close
@@ -21,8 +21,21 @@ module.exports = class HTTPServerResponse extends HTTPOutgoingMessage {
     this._pendingWrite = null
   }
 
+  get req() {
+    return this._req
+  }
+
+  get statusCode() {
+    return this._statusCode
+  }
+
+  get statusMessage() {
+    return this._statusMessage
+  }
+
   end(data) {
     this._finishing = true
+
     return super.end(data)
   }
 
@@ -32,22 +45,23 @@ module.exports = class HTTPServerResponse extends HTTPOutgoingMessage {
       statusMessage = null
     }
 
-    this.statusCode = statusCode
-    this.statusMessage = statusMessage || null
-    if (headers) this.headers = { ...this.headers, ...headers }
+    this._statusCode = statusCode
+    this._statusMessage = statusMessage || null
+
+    if (headers) this._headers = { ...this._headers, ...headers }
   }
 
   _header() {
     let h =
       'HTTP/1.1 ' +
-      this.statusCode +
+      this._statusCode +
       ' ' +
-      (this.statusMessage === null ? constants.status[this.statusCode] : this.statusMessage) +
+      (this._statusMessage === null ? constants.status[this._statusCode] : this._statusMessage) +
       '\r\n'
 
-    for (const name of Object.keys(this.headers)) {
+    for (const name of Object.keys(this._headers)) {
       const n = name.toLowerCase()
-      const v = this.headers[name]
+      const v = this._headers[name]
 
       if (n === 'content-length') this._chunked = false
       if (n === 'connection' && v && v.toLowerCase() === 'close') this._close = true
@@ -63,7 +77,7 @@ module.exports = class HTTPServerResponse extends HTTPOutgoingMessage {
   }
 
   _write(data, encoding, cb) {
-    if (this.headersSent === false) {
+    if (this._headersSent === false) {
       if (this._finishing) {
         this.setHeader(
           'Content-Length',
@@ -77,36 +91,36 @@ module.exports = class HTTPServerResponse extends HTTPOutgoingMessage {
     if (this._onlyHeaders === true) return cb(null)
 
     if (this._chunked) {
-      this.socket.write(Buffer.from(data.byteLength.toString(16)))
-      this.socket.write(CHUNK_DELIMITER)
+      this._socket.write(Buffer.from(data.byteLength.toString(16)))
+      this._socket.write(CHUNK_DELIMITER)
     }
 
-    let flushed = this.socket.write(data)
+    let flushed = this._socket.write(data)
 
-    if (this._chunked) flushed = this.socket.write(CHUNK_DELIMITER)
+    if (this._chunked) flushed = this._socket.write(CHUNK_DELIMITER)
 
     if (flushed) cb(null)
     else this._pendingWrite = cb
   }
 
   _final(cb) {
-    if (this.headersSent === false) {
+    if (this._headersSent === false) {
       this.setHeader('Content-Length', '0')
       this.flushHeaders()
     }
 
-    if (this._chunked && this._onlyHeaders === false) {
-      this.socket.write(CHUNK_TERMINATOR)
-    }
+    if (this._chunked && this._onlyHeaders === false) this._socket.write(CHUNK_TERMINATOR)
 
-    if (this._close) this.socket.end()
+    if (this._close) this._socket.end()
 
     cb(null)
   }
 
   _predestroy() {
     super._predestroy()
-    this.req.destroy()
+
+    this._req.destroy()
+
     this._continueWrite()
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bare-http1",
-  "version": "4.3.1",
+  "version": "4.5.1",
   "description": "Native HTTP/1 library for JavaScript",
   "exports": {
     "./package": "./package.json",
@@ -37,7 +37,7 @@
   "homepage": "https://github.com/holepunchto/bare-http1#readme",
   "dependencies": {
     "bare-events": "^2.6.0",
-    "bare-http-parser": "^1.0.0",
+    "bare-http-parser": "^1.1.1",
     "bare-stream": "^2.3.0",
     "bare-tcp": "^2.2.0"
   },