bare-http1 4.5.3 → 4.5.5

package/index.d.ts

@@ -28,25 +28,23 @@ export interface HTTPIncomingMessageEvents extends ReadableEvents {
 }
 
 export interface HTTPIncomingMessageOptions {
+  headers?: Record<string, string | number>
   method?: HTTPMethod
-  url?: URL | string
+  url?: string
   statusCode?: HTTPStatusCode
   statusMessage?: HTTPStatusMessage
 }
 
-export interface HTTPIncomingMessage<
+interface HTTPIncomingMessage<
   M extends HTTPIncomingMessageEvents = HTTPIncomingMessageEvents
 > extends Readable<M> {
   readonly socket: TCPSocket
-  readonly headers: Record<string, string | number>
   readonly upgrade: boolean
-
-  readonly method: HTTPMethod
-  readonly url: URL | string
-
-  readonly statusCode: HTTPStatusCode
-  readonly statusMessage: HTTPStatusMessage
-
+  headers: Record<string, string | number>
+  method: HTTPMethod
+  url: string
+  statusCode: HTTPStatusCode
+  statusMessage: HTTPStatusMessage
   readonly httpVersion: '1.1'
 
   getHeader(name: string): string | number | undefined
@@ -56,27 +54,25 @@ export interface HTTPIncomingMessage<
   setTimeout(ms: number, ontimeout?: () => void): this
 }
 
-class HTTPIncomingMessage extends Readable {
-  constructor(
-    socket?: TCPSocket,
-    headers?: Record<string, string | number>,
-    opts?: HTTPIncomingMessageOptions
-  )
+declare class HTTPIncomingMessage<
+  M extends HTTPIncomingMessageEvents = HTTPIncomingMessageEvents
+> extends Readable<M> {
+  constructor(socket?: TCPSocket, opts?: HTTPIncomingMessageOptions)
 }
 
-export { HTTPIncomingMessage as IncomingMessage }
+export { type HTTPIncomingMessage, HTTPIncomingMessage as IncomingMessage }
 
 export interface HTTPOutgoingMessageEvents extends WritableEvents {
   timeout: []
 }
 
-export interface HTTPOutgoingMessage<
+interface HTTPOutgoingMessage<
   M extends HTTPOutgoingMessageEvents = HTTPOutgoingMessageEvents
 > extends Writable<M> {
   readonly socket: TCPSocket
-  readonly headers: Record<string, string | number>
-  readonly headersSent: boolean
   readonly upgrade: boolean
+  readonly headersSent: boolean
+  headers: Record<string, string | number>
 
   getHeader(name: string): string | number | undefined
   getHeaders(): Record<string, string | number>
@@ -87,31 +83,29 @@ export interface HTTPOutgoingMessage<
   setTimeout(ms: number, ontimeout?: () => void): this
 }
 
-class HTTPOutgoingMessage extends Writable {
+declare class HTTPOutgoingMessage<
+  M extends HTTPOutgoingMessageEvents = HTTPOutgoingMessageEvents
+> extends Writable<M> {
   constructor(socket?: TCPSocket)
 }
 
-export { HTTPOutgoingMessage as OutgoingMessage }
+export { type HTTPOutgoingMessage, HTTPOutgoingMessage as OutgoingMessage }
 
 export interface HTTPAgentOptions {
   keepAlive?: boolean
   keepAliveMsecs?: number
 }
 
-export interface HTTPAgent {
+interface HTTPAgent {
   readonly suspended: boolean
   readonly resumed: Promise<void> | null
   readonly sockets: IterableIterator<TCPSocket>
   readonly freeSockets: IterableIterator<TCPSocket>
 
   createConnection(opts?: TCPSocketOptions & TCPSocketConnectOptions): TCPSocket
-
   reuseSocket(socket: TCPSocket, req?: HTTPClientRequest): void
-
   keepSocketAlive(socket: TCPSocket): boolean
-
   getName(opts: { host: string; port: number }): string
-
   addRequest(req: HTTPClientRequest, opts: TCPSocketOptions & TCPSocketConnectOptions): void
 
   suspend(): void
@@ -119,15 +113,17 @@ export interface HTTPAgent {
   destroy(): void
 }
 
-class HTTPAgent {
+declare class HTTPAgent {
   constructor(opts?: HTTPAgentOptions & TCPSocketOptions & TCPSocketConnectOptions)
+}
 
-  static readonly global: HTTPAgent
+declare namespace HTTPAgent {
+  export const global: HTTPAgent
 }
 
 export const globalAgent: HTTPAgent
 
-export { HTTPAgent as Agent }
+export { type HTTPAgent, HTTPAgent as Agent }
 
 export interface HTTPServerEvents extends TCPServerEvents {
   request: [req: HTTPIncomingMessage, res: HTTPServerResponse]
@@ -135,13 +131,13 @@ export interface HTTPServerEvents extends TCPServerEvents {
   timeout: [socket: TCPSocket]
 }
 
-export interface HTTPServer<M extends HTTPServerEvents = HTTPServerEvents> extends TCPServer<M> {
+interface HTTPServer<M extends HTTPServerEvents = HTTPServerEvents> extends TCPServer<M> {
   readonly timeout: number | undefined
 
   setTimeout(ms: number, ontimeout?: () => void): this
 }
 
-class HTTPServer extends TCPServer {
+declare class HTTPServer<M extends HTTPServerEvents = HTTPServerEvents> extends TCPServer<M> {
   constructor(
     opts?: HTTPServerConnectionOptions,
     onrequest?: (req: HTTPIncomingMessage, res: HTTPServerResponse) => void
@@ -150,12 +146,12 @@ class HTTPServer extends TCPServer {
   constructor(onrequest: (req: HTTPIncomingMessage, res: HTTPServerResponse) => void)
 }
 
-export { HTTPServer as Server }
+export { type HTTPServer, HTTPServer as Server }
 
-export interface HTTPServerResponse extends HTTPOutgoingMessage {
+interface HTTPServerResponse extends HTTPOutgoingMessage {
   readonly req: HTTPIncomingMessage
-  readonly statusCode: HTTPStatusCode
-  readonly statusMessage: HTTPStatusMessage | null
+  statusCode: HTTPStatusCode
+  statusMessage: HTTPStatusMessage | null
 
   writeHead(
     statusCode: HTTPStatusCode,
@@ -166,34 +162,32 @@ export interface HTTPServerResponse extends HTTPOutgoingMessage {
   writeHead(statusCode: HTTPStatusCode, headers?: Record<string, string | number>): void
 }
 
-class HTTPServerResponse extends HTTPOutgoingMessage {
-  constructor(socket: TCPSocket, req: HTTPIncomingMessage, close: boolean)
+declare class HTTPServerResponse extends HTTPOutgoingMessage {
+  constructor(socket: TCPSocket, req: HTTPIncomingMessage)
 }
 
-export { HTTPServerResponse as ServerResponse }
+export { type HTTPServerResponse, HTTPServerResponse as ServerResponse }
 
 export interface HTTPServerConnectionOptions {
   IncomingMessage?: typeof HTTPIncomingMessage
   ServerResponse?: typeof HTTPServerResponse
 }
 
-export interface HTTPServerConnection {
+interface HTTPServerConnection {
   readonly server: HTTPServer
   readonly socket: TCPSocket | null
-
   readonly req: HTTPIncomingMessage | null
   readonly res: HTTPServerResponse | null
-
   readonly idle: boolean
 }
 
-class HTTPServerConnection {
+declare class HTTPServerConnection {
   constructor(server: HTTPServer, socket: TCPSocket, opts?: HTTPServerConnectionOptions)
 
   static for(socket: TCPSocket): HTTPServerConnection
 }
 
-export { HTTPServerConnection as ServerConnection }
+export { type HTTPServerConnection, HTTPServerConnection as ServerConnection }
 
 export interface HTTPClientRequestEvents extends HTTPOutgoingMessageEvents {
   response: [res: HTTPIncomingMessage]
@@ -207,7 +201,7 @@ export interface HTTPClientRequestOptions extends TCPSocketConnectOptions {
   path?: string
 }
 
-export interface HTTPClientRequest<
+interface HTTPClientRequest<
   M extends HTTPClientRequestEvents = HTTPClientRequestEvents
 > extends HTTPOutgoingMessage<M> {
   readonly method: HTTPMethod
@@ -215,28 +209,28 @@ export interface HTTPClientRequest<
   readonly headers: Record<string, string | number>
 }
 
-class HTTPClientRequest extends HTTPOutgoingMessage {
+declare class HTTPClientRequest<
+  M extends HTTPClientRequestEvents = HTTPClientRequestEvents
+> extends HTTPOutgoingMessage<M> {
   constructor(opts?: HTTPClientRequestOptions, onresponse?: () => void)
 
   constructor(onresponse: () => void)
 }
 
-export { HTTPClientRequest as ClientRequest }
+export { type HTTPClientRequest, HTTPClientRequest as ClientRequest }
 
 export interface HTTPClientConnectionOptions {
   IncomingMessage?: typeof HTTPIncomingMessage
 }
 
-export interface HTTPClientConnection {
+interface HTTPClientConnection {
   readonly socket: TCPSocket | null
-
   readonly req: HTTPClientRequest | null
   readonly res: HTTPIncomingMessage | null
-
   readonly idle: boolean
 }
 
-class HTTPClientConnection {
+declare class HTTPClientConnection {
   constructor(socket: TCPSocket, opts?: HTTPClientConnectionOptions)
 
   static for(socket: TCPSocket): HTTPClientConnection | null
@@ -244,7 +238,7 @@ class HTTPClientConnection {
   static from(socket: TCPSocket, opts?: HTTPClientConnectionOptions): HTTPClientConnection
 }
 
-export { HTTPClientConnection as ClientConnection }
+export { type HTTPClientConnection, HTTPClientConnection as ClientConnection }
 
 export function createServer(
   opts?: HTTPServerConnectionOptions,

package/lib/client-connection.js

@@ -89,7 +89,8 @@ module.exports = class HTTPClientConnection {
               this._req = null
             })
 
-            this._res = new this._IncomingMessage(this._socket, op.headers, {
+            this._res = new this._IncomingMessage(this._socket, {
+              headers: op.headers,
               statusCode: op.code,
               statusMessage: op.reason
             })

package/lib/incoming-message.js

@@ -1,12 +1,12 @@
 const { Readable } = require('bare-stream')
 
 module.exports = class HTTPIncomingMessage extends Readable {
-  constructor(socket = null, headers = {}, opts = {}) {
+  constructor(socket = null, opts = {}) {
     super()
 
     this._socket = socket
-    this._headers = headers
     this._upgrade = false
+    this._headers = opts.headers || {}
 
     // Server options
     this._method = opts.method || ''
@@ -21,30 +21,50 @@ module.exports = class HTTPIncomingMessage extends Readable {
     return this._socket
   }
 
+  get upgrade() {
+    return this._upgrade
+  }
+
   get headers() {
     return this._headers
   }
 
-  get upgrade() {
-    return this._upgrade
+  set headers(value) {
+    this._headers = value
   }
 
   get method() {
     return this._method
   }
 
+  set method(value) {
+    this._method = value
+  }
+
   get url() {
     return this._url
   }
 
+  set url(value) {
+    this._url = value
+  }
+
   get statusCode() {
     return this._statusCode
   }
 
+  set statusCode(value) {
+    this._statusCode = value
+  }
+
   get statusMessage() {
     return this._statusMessage
   }
 
+  set statusMessage(value) {
+    this._statusMessage = value
+  }
+
   get httpVersion() {
     return '1.1'
   }

package/lib/outgoing-message.js

@@ -6,25 +6,29 @@ module.exports = class HTTPOutgoingMessage extends Writable {
     super()
 
     this._socket = socket
-    this._headers = {}
-    this._headersSent = false
     this._upgrade = false
+    this._headersSent = false
+    this._headers = {}
   }
 
   get socket() {
     return this._socket
   }
 
-  get headers() {
-    return this._headers
+  get upgrade() {
+    return this._upgrade
   }
 
   get headersSent() {
     return this._headersSent
   }
 
-  get upgrade() {
-    return this._upgrade
+  get headers() {
+    return this._headers
+  }
+
+  set headers(value) {
+    this._headers = value
   }
 
   getHeader(name) {

package/lib/server-connection.js

@@ -83,7 +83,8 @@ 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, {
+              headers: op.headers,
               method: op.method,
               url: op.url
             })
@@ -104,11 +105,7 @@ module.exports = class HTTPServerConnection {
               return this._onupgrade(this._parser.end())
             }
 
-            this._res = new this._ServerResponse(
-              this._socket,
-              this._req,
-              op.headers.connection === 'close'
-            )
+            this._res = new this._ServerResponse(this._socket, this._req)
 
             this._res.on('close', () => {
               this._res = null

package/lib/server-response.js

@@ -6,7 +6,7 @@ const CHUNK_DELIMITER = Buffer.from('\r\n')
 const CHUNK_TERMINATOR = Buffer.from('0\r\n\r\n')
 
 module.exports = class HTTPServerResponse extends HTTPOutgoingMessage {
-  constructor(socket, req, close) {
+  constructor(socket, req) {
     super(socket)
 
     this._req = req
@@ -15,7 +15,7 @@ module.exports = class HTTPServerResponse extends HTTPOutgoingMessage {
     this._statusMessage = null
 
     this._chunked = true
-    this._close = close
+    this._close = req.headers.connection === 'close'
     this._onlyHeaders = req.method === 'HEAD'
 
     this._pendingWrite = null
@@ -29,10 +29,18 @@ module.exports = class HTTPServerResponse extends HTTPOutgoingMessage {
     return this._statusCode
   }
 
+  set statusCode(value) {
+    this._statusCode = value
+  }
+
   get statusMessage() {
     return this._statusMessage
   }
 
+  set statusMessage(value) {
+    this._statusMessage = value
+  }
+
   writeHead(statusCode, statusMessage = null, headers = {}) {
     if (typeof statusMessage === 'object' && statusMessage !== null) {
       headers = statusMessage

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bare-http1",
-  "version": "4.5.3",
+  "version": "4.5.5",
   "description": "Native HTTP/1 library for JavaScript",
   "exports": {
     "./package": "./package.json",