bare-http1 4.0.2 → 4.0.3

package/index.d.ts

@@ -0,0 +1,286 @@
+import { Readable, ReadableEvents, Writable, WritableEvents } from 'bare-stream'
+import {
+  TCPSocket,
+  TCPSocketOptions,
+  TCPSocketConnectOptions,
+  TCPServer,
+  TCPServerEvents
+} from 'bare-tcp'
+import Buffer from 'bare-buffer'
+import URL from 'bare-url'
+import constants, {
+  HTTPMethod,
+  HTTPStatusCode,
+  HTTPStatusMessage
+} from './lib/constants'
+import HTTPError from './lib/errors'
+
+export {
+  constants,
+  type HTTPMethod,
+  type HTTPStatusCode,
+  type HTTPStatusMessage,
+  type HTTPError,
+  HTTPError as errors
+}
+
+export const STATUS_CODES: typeof constants.status
+
+export interface HTTPIncomingMessageEvents extends ReadableEvents {
+  timeout: []
+}
+
+export interface HTTPIncomingMessageOptions {
+  method?: HTTPMethod
+  url?: URL | string
+  statusCode?: HTTPStatusCode
+  statusMessage?: HTTPStatusMessage
+}
+
+export 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
+
+  readonly httpVersion: '1.1'
+
+  getHeader(name: string): string | number | undefined
+  getHeaders(): Record<string, string | number>
+  hasHeader(name: string): boolean
+
+  setTimeout(ms: number, ontimeout?: () => void): this
+}
+
+export class HTTPIncomingMessage {
+  constructor(
+    socket?: TCPSocket,
+    headers?: Record<string, string | number>,
+    opts?: HTTPIncomingMessageOptions
+  )
+}
+
+export { HTTPIncomingMessage as IncomingMessage }
+
+export interface HTTPOutgoingMessageEvents extends WritableEvents {
+  timeout: []
+}
+
+export interface HTTPOutgoingMessage<
+  M extends HTTPOutgoingMessageEvents = HTTPOutgoingMessageEvents
+> extends Writable<M> {
+  readonly socket: TCPSocket
+  readonly headers: Record<string, string | number>
+  readonly headersSent: boolean
+  readonly upgrade: boolean
+
+  getHeader(name: string): string | number | undefined
+  getHeaders(): Record<string, string | number>
+  hasHeader(name: string): boolean
+  setHeader(name: string, value: string | number): void
+  flushHeaders(): void
+
+  setTimeout(ms: number, ontimeout?: () => void): this
+}
+
+export class HTTPOutgoingMessage {
+  constructor(socket?: TCPSocket)
+}
+
+export { HTTPOutgoingMessage as OutgoingMessage }
+
+export interface HTTPAgentOptions {
+  keepAlive?: boolean
+  keepAliveMsecs?: number
+}
+
+export interface HTTPAgent {
+  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
+
+  destroy(): void
+}
+
+export class HTTPAgent {
+  constructor(
+    opts?: HTTPAgentOptions & TCPSocketOptions & TCPSocketConnectOptions
+  )
+
+  static global: HTTPAgent
+}
+
+export const globalAgent: HTTPAgent
+
+export { HTTPAgent as Agent }
+
+export interface HTTPServerEvents extends TCPServerEvents {
+  request: [req: HTTPIncomingMessage, res: HTTPServerResponse]
+  upgrade: [req: HTTPIncomingMessage, socket: TCPSocket, head: Buffer]
+  timeout: [socket: TCPSocket]
+}
+
+export interface HTTPServer<M extends HTTPServerEvents = HTTPServerEvents>
+  extends TCPServer<M> {
+  readonly timeout: number | undefined
+
+  setTimeout(ms: number, ontimeout?: () => void): this
+}
+
+export class HTTPServer {
+  constructor(
+    opts?: HTTPServerConnectionOptions,
+    onrequest?: (req: HTTPIncomingMessage, res: HTTPServerResponse) => void
+  )
+
+  constructor(
+    onrequest: (req: HTTPIncomingMessage, res: HTTPServerResponse) => void
+  )
+}
+
+export { HTTPServer as Server }
+
+export interface HTTPServerResponse extends HTTPOutgoingMessage {
+  readonly req: HTTPIncomingMessage
+  readonly statusCode: HTTPStatusCode
+  readonly statusMessage: HTTPStatusMessage | null
+
+  writeHead(
+    statusCode: HTTPStatusCode,
+    statusMessage?: HTTPStatusMessage,
+    headers?: Record<string, string | number>
+  ): void
+
+  writeHead(
+    statusCode: HTTPStatusCode,
+    headers?: Record<string, string | number>
+  ): void
+}
+
+export class HTTPServerResponse {
+  constructor(socket: TCPSocket, req: HTTPIncomingMessage, close: boolean)
+}
+
+export { HTTPServerResponse as ServerResponse }
+
+export interface HTTPServerConnectionOptions {
+  IncomingMessage?: typeof HTTPIncomingMessage
+  ServerResponse?: typeof HTTPServerResponse
+}
+
+export interface HTTPServerConnection {
+  readonly server: HTTPServer
+  readonly socket: TCPSocket
+
+  readonly req: HTTPIncomingMessage | null
+  readonly res: HTTPServerResponse | null
+
+  readonly idle: boolean
+}
+
+export class HTTPServerConnection {
+  constructor(
+    server: HTTPServer,
+    socket: TCPSocket,
+    opts?: HTTPServerConnectionOptions
+  )
+
+  static for(socket: TCPSocket): HTTPServerConnection
+}
+
+export { HTTPServerConnection as ServerConnection }
+
+export interface HTTPClientRequestEvents extends HTTPOutgoingMessageEvents {
+  response: [res: HTTPIncomingMessage]
+  upgrade: [res: HTTPIncomingMessage, socket: TCPSocket, head: Buffer]
+}
+
+export interface HTTPClientRequestOptions extends TCPSocketConnectOptions {
+  agent?: HTTPAgent | false
+  headers?: Record<string, string | number>
+  method?: HTTPMethod
+  path?: string
+}
+
+export interface HTTPClientRequest<
+  M extends HTTPClientRequestEvents = HTTPClientRequestEvents
+> extends HTTPOutgoingMessage<M> {
+  readonly method: HTTPMethod
+  readonly path: string
+  readonly headers: Record<string, string | number>
+}
+
+export class HTTPClientRequest {
+  constructor(opts?: HTTPClientRequestOptions, onresponse?: () => void)
+
+  constructor(onresponse: () => void)
+}
+
+export { HTTPClientRequest as ClientRequest }
+
+export interface HTTPClientConnectionOptions {
+  IncomingMessage?: typeof HTTPIncomingMessage
+}
+
+export interface HTTPClientConnection {
+  readonly socket: TCPSocket
+
+  readonly req: HTTPClientRequest | null
+  readonly res: HTTPIncomingMessage | null
+
+  readonly idle: boolean
+}
+
+export class HTTPClientConnection {
+  constructor(socket: TCPSocket, opts?: HTTPClientConnectionOptions)
+
+  static for(socket: TCPSocket): HTTPClientConnection | null
+
+  static from(
+    socket: TCPSocket,
+    opts?: HTTPClientConnectionOptions
+  ): HTTPClientConnection
+}
+
+export { HTTPClientConnection as ClientConnection }
+
+export function createServer(
+  opts?: HTTPServerConnectionOptions,
+  onrequest?: (req: HTTPIncomingMessage, res: HTTPServerResponse) => void
+): HTTPServer
+
+export function createServer(
+  onrequest: (req: HTTPIncomingMessage, res: HTTPServerResponse) => void
+): HTTPServer
+
+export function request(
+  url: URL | string,
+  opts?: HTTPClientRequestOptions,
+  onresponse?: (res: HTTPIncomingMessage) => void
+): HTTPClientRequest
+
+export function request(
+  url: URL | string,
+  onresponse: (res: HTTPIncomingMessage) => void
+): HTTPClientRequest
+
+export function request(
+  opts: HTTPClientRequestOptions,
+  onresponse?: (res: HTTPIncomingMessage) => void
+): HTTPClientRequest

package/index.js

@@ -12,6 +12,7 @@ exports.ClientRequest = require('./lib/client-request')
 exports.ClientConnection = require('./lib/client-connection')
 
 exports.constants = require('./lib/constants')
+exports.errors = require('./lib/errors')
 
 exports.STATUS_CODES = exports.constants.status // For Node.js compatibility
 

package/lib/agent.js

@@ -1,9 +1,13 @@
 const tcp = require('bare-tcp')
 const HTTPClientConnection = require('./client-connection')
+const EventEmitter = require('bare-events')
 
-module.exports = class HTTPAgent {
+module.exports = class HTTPAgent extends EventEmitter {
   constructor(opts = {}) {
+    super()
+
     const { keepAlive = false, keepAliveMsecs = 1000 } = opts
+    this.options = { keepAlive, keepAliveMsecs }
 
     this._sockets = new Map()
     this._freeSockets = new Map()
@@ -99,6 +103,8 @@ module.exports = class HTTPAgent {
     } else {
       socket.end()
     }
+
+    this.emit('free', socket)
   }
 
   _onremove(socket, name, all = true) {

package/lib/constants.d.ts

@@ -0,0 +1,93 @@
+declare const constants: {
+  state: {
+    BEFORE_HEAD: number
+    IN_HEAD: number
+    IN_BODY: number
+    BEFORE_CHUNK: number
+    IN_CHUNK: number
+  }
+  method: {
+    GET: 'GET'
+    HEAD: 'HEAD'
+    POST: 'POST'
+    PUT: 'PUT'
+    DELETE: 'DELETE'
+    CONNECT: 'CONNECT'
+    OPTIONS: 'OPTIONS'
+    TRACE: 'TRACE'
+    PATCH: 'PATCH'
+  }
+  status: {
+    100: 'Continue'
+    101: 'Switching Protocols'
+    102: 'Processing'
+    103: 'Early Hints'
+    200: 'OK'
+    201: 'Created'
+    202: 'Accepted'
+    203: 'Non-Authoritative Information'
+    204: 'No Content'
+    205: 'Reset Content'
+    206: 'Partial Content'
+    207: 'Multi-Status'
+    208: 'Already Reported'
+    226: 'IM Used'
+    300: 'Multiple Choices'
+    301: 'Moved Permanently'
+    302: 'Found'
+    303: 'See Other'
+    304: 'Not Modified'
+    305: 'Use Proxy'
+    307: 'Temporary Redirect'
+    308: 'Permanent Redirect'
+    400: 'Bad Request'
+    401: 'Unauthorized'
+    402: 'Payment Required'
+    403: 'Forbidden'
+    404: 'Not Found'
+    405: 'Method Not Allowed'
+    406: 'Not Acceptable'
+    407: 'Proxy Authentication Required'
+    408: 'Request Timeout'
+    409: 'Conflict'
+    410: 'Gone'
+    411: 'Length Required'
+    412: 'Precondition Failed'
+    413: 'Payload Too Large'
+    414: 'URI Too Long'
+    415: 'Unsupported Media Type'
+    416: 'Range Not Satisfiable'
+    417: 'Expectation Failed'
+    418: "I'm a Teapot"
+    421: 'Misdirected Request'
+    422: 'Unprocessable Entity'
+    423: 'Locked'
+    424: 'Failed Dependency'
+    425: 'Too Early'
+    426: 'Upgrade Required'
+    428: 'Precondition Required'
+    429: 'Too Many Requests'
+    431: 'Request Header Fields Too Large'
+    451: 'Unavailable For Legal Reasons'
+    500: 'Internal Server Error'
+    501: 'Not Implemented'
+    502: 'Bad Gateway'
+    503: 'Service Unavailable'
+    504: 'Gateway Timeout'
+    505: 'HTTP Version Not Supported'
+    506: 'Variant Also Negotiates'
+    507: 'Insufficient Storage'
+    508: 'Loop Detected'
+    509: 'Bandwidth Limit Exceeded'
+    510: 'Not Extended'
+    511: 'Network Authentication Required'
+  }
+}
+
+declare namespace constants {
+  export type HTTPMethod = keyof typeof constants.method
+  export type HTTPStatusCode = keyof typeof constants.status
+  export type HTTPStatusMessage = (typeof constants.status)[HTTPStatusCode]
+}
+
+export = constants

package/lib/errors.d.ts

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

package/lib/server-connection.js

@@ -156,6 +156,7 @@ module.exports = class HTTPServerConnection {
       this._onreset()
     })
 
+    // Eagerly open the request stream
     this.req.resume()
     this.req.pause()
 

package/package.json

@@ -1,14 +1,25 @@
 {
   "name": "bare-http1",
-  "version": "4.0.2",
+  "version": "4.0.3",
   "description": "Native HTTP/1 library for JavaScript",
   "exports": {
-    ".": "./index.js",
     "./package": "./package.json",
-    "./constants": "./lib/constants.js"
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
+    "./constants": {
+      "types": "./lib/constants.d.ts",
+      "default": "./lib/constants.js"
+    },
+    "./errors": {
+      "types": "./lib/errors.d.ts",
+      "default": "./lib/errors.js"
+    }
   },
   "files": [
     "index.js",
+    "index.d.ts",
     "lib"
   ],
   "scripts": {
@@ -25,13 +36,27 @@
   },
   "homepage": "https://github.com/holepunchto/bare-http1#readme",
   "dependencies": {
-    "bare-events": "^2.0.0",
+    "bare-events": "^2.6.0",
     "bare-stream": "^2.3.0",
-    "bare-tcp": "^2.0.0"
+    "bare-tcp": "^2.0.3"
   },
   "devDependencies": {
+    "bare-buffer": "^3.0.2",
+    "bare-url": "^2.1.3",
     "brittle": "^3.3.0",
     "prettier": "^3.4.1",
     "prettier-config-standard": "^7.0.0"
+  },
+  "peerDependencies": {
+    "bare-buffer": "*",
+    "bare-url": "*"
+  },
+  "peerDependenciesMeta": {
+    "bare-buffer": {
+      "optional": true
+    },
+    "bare-url": {
+      "optional": true
+    }
   }
 }