@fails-components/webtransport 0.3.1 → 1.0.1

package/lib/types.ts

@@ -1,27 +1,37 @@
-import type { WebTransport, WebTransportOptions } from './dom'
+import type {
+  WebTransportSession,
+  WebTransportHash,
+  WebTransportOptions
+} from './dom'
+import type { IncomingHttpHeaders, Http2Stream } from 'http2'
+import { ParserBase } from './http2/parserbase'
+import { Http2WebTransportSession } from './http2/session'
+import { HttpClient } from './client'
 
 /**
- * Native Http3WTSession counterpart
+ * Native HttpWTSession counterpart
  */
- export interface NativeHttp3WTSession {
+export interface NativeHttpWTSession {
   jsobj: WebTransportSessionEventHandler
+  sendInitialParameters?: () => void
   writeDatagram: (chunk: Uint8Array) => void
   orderUnidiStream: () => void
   orderBidiStream: () => void
   orderSessionStats: () => void
   orderDatagramStats: () => void
-  notifySessionDraining(): () => void
-  close: (arg: { code: number, reason: string }) => void
+  notifySessionDraining: () => void
+  close: (arg: { code: number; reason: string }) => void
 }
 
 /**
- * Native Http3WTStream counterpart
+ * Native HttpWTStream counterpart
  */
-export interface NativeHttp3WTStream {
-  updateReadPos(bytesread: Number, pos: Number): unknown
+export interface NativeHttpWTStream {
   jsobj: WebTransportStreamEventHandler
-  readbuffer: Uint8Array | undefined
+  readbuffer: ArrayBuffer | undefined
+  sendInitialParameters?: () => void
   startReading: () => void
+  drainReads: () => void
   stopReading: () => void
   stopSending: (code: number) => void
   resetStream: (code: number) => void
@@ -29,63 +39,106 @@ export interface NativeHttp3WTStream {
   streamFinal: () => void
 }
 
-export type Purpose = 'StreamRecvSignal' | 'StreamRead' | 'StreamWrite' | 'StreamReset' | 'StreamNetworkFinish'
+export interface NativeServerOptions {
+  port: number | 443
+  secret?: string
+  host: string
+  cert: string
+  certhttp2?: string // if http2 has a different cert
+  privKey: string
+  privKeyhttp2?: string // if http2 has a different cert
+  initialStreamFlowControlWindow?: number
+  streamShouldAutoTuneReceiveWindow?: boolean
+  streamFlowControlWindowSizeLimit?: number
+  initialSessionFlowControlWindow?: number
+  sessionShouldAutoTuneReceiveWindow?: boolean
+  sessionFlowControlWindowSizeLimit?: number
+}
+
+export interface NativeClientOptions {
+  port: number
+  host: string
+  serverCertificateHashes: WebTransportHash[]
+  localPort: number
+  allowPooling: boolean
+  forceIpv6: boolean
+  initialStreamFlowControlWindow?: number
+  streamShouldAutoTuneReceiveWindow?: boolean
+  streamFlowControlWindowSizeLimit?: number
+  initialSessionFlowControlWindow?: number
+  sessionShouldAutoTuneReceiveWindow?: boolean
+  sessionFlowControlWindowSizeLimit?: number
+}
+
+export interface FlowControlable {
+  sendWindowUpdate: (windowOffset: bigint) => void
+  sendBlocked: (windowOffSet: bigint) => void
+  connected: () => boolean
+  closeConnection: (arg: { code: number; reason: string }) => void
+  smoothedRtt: () => number
+}
+
+export interface ReadBuffer {
+  buffer?: Uint8Array
+  readBytes?: number
+  byob?: ReadableStreamBYOBRequest
+  drained?: boolean
+  fin: boolean
+}
+
+export interface NativeFinishSessionRequest {
+  header: IncomingHttpHeaders
+  session: Http2Stream
+  status: number
+  protocol: 'capsule' | 'websocket' | 'websocketoverhttp1' | 'http3'
+  head?: Buffer
+}
+
+export type Purpose =
+  | 'StreamRecvSignal'
+  | 'StreamRead'
+  | 'StreamWrite'
+  | 'StreamReset'
+  | 'StreamNetworkFinish'
 export type NetTask = 'stopSending' | 'resetStream' | 'streamFinal'
 
 export interface StreamRecvSignalEvent {
-  object: NativeHttp3WTStream
-  purpose: 'StreamRecvSignal'
   code: number
   nettask: NetTask
 }
 
 export interface StreamReadEvent {
-  object: NativeHttp3WTStream
-  purpose: 'StreamRead'
   buffergrow?: number
   fin?: boolean
   success?: boolean
 }
 
 export interface StreamWriteEvent {
-  object: NativeHttp3WTStream
-  purpose: 'StreamWrite'
+  success?: boolean
 }
 
-export interface StreamResetEvent {
-  object: NativeHttp3WTStream
-  purpose: 'StreamReset'
-}
+export interface StreamResetEvent {}
 
 export interface StreamNetworkFinishEvent {
-  object: NativeHttp3WTStream
-  purpose: 'StreamNetworkFinish'
   nettask: NetTask
 }
 
 export interface WebTransportStreamEventHandler {
   onStreamRecvSignal: (evt: StreamRecvSignalEvent) => void
-  onStreamRead: (evt: StreamReadEvent) => void
   onStreamWrite: (evt: StreamWriteEvent) => void
-  onStreamReset: (evt: StreamResetEvent) => void
   onStreamNetworkFinish: (evt: StreamNetworkFinishEvent) => void
 }
 
 export interface SessionReadyEvent {
-  object: NativeHttp3WTSession
-  purpose: 'SessionReady'
+  object: NativeHttpWTSession
 }
 
 export interface SessionCloseEvent {
-  object: NativeHttp3WTSession
-  purpose: 'SessionClose'
   errorcode: number
   error: string
 }
 
 export interface SessionStatsEvent {
-  object: NativeHttp3WTSession
-  purpose: 'SessionStats'
   timestamp: number
   expiredOutgoing: bigint
   lostOutgoing: bigint
@@ -98,34 +151,21 @@ export interface SessionStatsEvent {
 }
 
 export interface DatagramStatsEvent {
-  object: NativeHttp3WTSession
-  purpose: 'DatagramStats'
   timestamp: number
   expiredOutgoing: bigint
   lostOutgoing: bigint
 }
 
 export interface DatagramReceivedEvent {
-  object: NativeHttp3WTSession
-  purpose: 'DatagramReceived'
   datagram: Uint8Array
 }
 
-export interface DatagramSendEvent {
-  object: NativeHttp3WTSession
-  purpose: 'DatagramSend'
-}
+export interface DatagramSendEvent {}
 
-export interface GoawayReceivedEvent {
-  object: NativeHttp3WTSession
-  purpose: 'GoawayReceived'
-}
+export interface GoawayReceivedEvent {}
 
 export interface NewStreamEvent {
-  object: NativeHttp3WTSession
-  purpose: 'Http3WTStreamVisitor'
-  stream: NativeHttp3WTStream
-  transport: object
+  stream: NativeHttpWTStream
   bidirectional: boolean
   incoming: boolean
 }
@@ -143,62 +183,50 @@ export interface WebTransportSessionEventHandler {
 }
 
 export interface ClientConnectedEvent {
-  purpose: 'ClientConnected'
   success: boolean
 }
 
-export interface ClientWebtransportSupportEvent {
-  purpose: 'ClientWebtransportSupport'
-}
+export interface ClientWebtransportSupportEvent {}
 
-export interface Http3WTSessionVisitorEvent {
-  purpose: 'Http3WTSessionVisitor'
-  session: NativeHttp3WTSession
+export interface HttpWTSessionVisitorEvent {
+  session: NativeHttpWTSession
+  reliable?: boolean
 }
 
-export interface Http3ClientEventHandler {
+export interface HttpClientEventHandler {
   onClientConnected: (evt: ClientConnectedEvent) => void
   onClientWebTransportSupport: (evt: ClientWebtransportSupportEvent) => void
-  onHttp3WTSessionVisitor: (evt: Http3WTSessionVisitorEvent) => void
+  onHttpWTSessionVisitor: (evt: HttpWTSessionVisitorEvent) => void
 }
 
-export interface Http3WTServerSessionVisitorEvent extends Http3WTSessionVisitorEvent {
+export interface HttpWTServerSessionVisitorEvent
+  extends HttpWTSessionVisitorEvent {
   path: string
-  object: any
-  header?: any
+  header: Object
 }
 
 export interface ServerSessionRequestEvent {
-  purpose: 'SessionRequest'
   header: Object
-  promise: any
+  head?: Buffer | undefined
+  promise?: any
   session: any
+  object?: any // the actual transport object itself, actually present on all messages, but required here
+  protocol: string //'capsule' | 'websocket' | 'http3'
 }
 
 /**
- * The Http3 server is listening on the specified port
+ * The Http server is listening on the specified port
  */
-export interface Http3ServerListeningEvent {
-  purpose: 'Http3ServerListening'
+export interface HttpServerListeningEvent {
+  port: number | undefined
+  host: string | undefined
 }
 
-/**
- * The Http3 server has stopped listening on the specified port
- */
- export interface ServerStatusEvent {
-  port: number | null
-  host: string | null
-  purpose: 'ServerStatus',
-  status: 'error' | 'listening' | 'close'
-}
-
-
-export interface Http3ServerEventHandler {
-  onHttp3WTSessionVisitor: (evt: Http3WTServerSessionVisitorEvent) => void
-  onServerError: () => void
-  onServerListening: () => void
+export interface HttpServerEventHandler {
+  onHttpWTSessionVisitor: (evt: HttpWTServerSessionVisitorEvent) => void
+  onServerError: (error?: Error) => void
+  onServerListening: (evt: HttpServerListeningEvent) => void
   onServerClose: () => void
-  onServerStatus: (evt: ServerStatusEvent) => void
 }
 
 /**
@@ -211,20 +239,32 @@ export interface Deferred<T = unknown> {
 }
 
 // https://www.w3.org/TR/webtransport/#dom-webtransport-state-slot
-export type WebTransportSessionState =  'connecting' | 'connected' | 'draining' | 'closed' | 'failed'
-
-export interface WebTransportSession extends WebTransport {
+export type WebTransportSessionState =
+  | 'connecting'
+  | 'connected'
+  | 'draining'
+  | 'closed'
+  | 'failed'
+
+export interface WebTransportSessionImpl extends WebTransportSession {
   state: WebTransportSessionState
 }
 
-export interface Http3WebTransportInit extends WebTransportOptions {
+export interface HttpWebTransportInit extends WebTransportOptions {
   host: string
   port: string | number
   quicheLogVerbose?: number
+  forceIpv6?: boolean
+  localPort?: number
 }
 
-// see Http3ServerJS C++ type
-export interface Http3ServerInit extends Http3WebTransportInit {
+export type WebTransportServerReliability =
+  | 'unreliableOnly'
+  | 'reliableOnly'
+  | 'both'
+
+// see HttpServerJS C++ type
+export interface HttpServerInit extends HttpWebTransportInit {
   port: string | number
   host: string
   secret: string
@@ -232,13 +272,34 @@ export interface Http3ServerInit extends Http3WebTransportInit {
   privKey: string
   maxConnections?: number
   initialStreamFlowControlWindow?: number
+  streamShouldAutoTuneReceiveWindow?: boolean
+  streamFlowControlWindowSizeLimit?: number
   initialSessionFlowControlWindow?: number
+  sessionShouldAutoTuneReceiveWindow?: boolean
+  sessionFlowControlWindowSizeLimit?: number
+  reliability?: WebTransportServerReliability
 }
 
-// see Http3ClientJS C++ type
-export interface Http3ClientInit extends Http3WebTransportInit {
+// see HttpClientJS C++ type
+export interface HttpClientInit extends HttpWebTransportInit {
+  forceReliable?: any
   forceIpv6?: boolean
   localPort?: number
+  initialStreamFlowControlWindow?: number
+  streamShouldAutoTuneReceiveWindow?: boolean
+  streamFlowControlWindowSizeLimit?: number
+  initialSessionFlowControlWindow?: number
+  sessionShouldAutoTuneReceiveWindow?: boolean
+  sessionFlowControlWindowSizeLimit?: number
+  createReliableClient?: (cklient: HttpClient) => any
+  createUnreliableClient?: (client: HttpClient) => any
+}
+
+export interface TransportHttp3Quiche {
+  checkQuicheInit: () => void
+
+  Http3WebTransportServer: new (init: HttpServerInit) => any
+  Http3WebTransportServerSocket: new (init: HttpServerInit) => any
 }
 
 export interface Logger {
@@ -246,3 +307,29 @@ export interface Logger {
   error: (formatter: any, ...args: any[]) => void
   trace: (formatter: any, ...args: any[]) => void
 }
+
+export type CreateParserFunction = (
+  nativesession: Http2WebTransportSession
+) => ParserBase
+
+export interface ParserInit {
+  isclient: boolean
+  nativesession: any
+  initialStreamSendWindowOffset: number
+  initialStreamReceiveWindowOffset: number
+  streamShouldAutoTuneReceiveWindow: boolean
+  streamReceiveWindowSizeLimit: number
+}
+
+export interface ParserHttp2Init extends ParserInit {
+  stream: Http2Stream
+}
+
+export interface ParserWebsocketInit extends ParserInit {
+  ws: WebSocket
+}
+
+export interface ReadDataInt {
+  data: Uint8Array
+  fin: boolean
+}

package/lib/utils.js

@@ -28,8 +28,9 @@ export function defer() {
  * @returns {import('./types').Logger}
  */
 export function logger(name) {
+  const dtrace = !!(typeof process === 'undefined' || process.env.DEBUG_TRACE)
   return Object.assign(debug(name), {
     error: debug(`${name}:error`),
-    trace: process.env.DEBUG_TRACE ? debug(`${name}:trace`) : () => {}
+    trace: dtrace ? debug(`${name}:trace`) : () => {}
   })
 }

package/lib/webstreams.browser.js

@@ -0,0 +1,6 @@
+/** @type {ReadableStream} */
+// @ts-ignore
+export const ReadableStream = globalThis.ReadableStream
+/** @type {WritableStream} */
+// @ts-ignore
+export const WritableStream = globalThis.WritableStream

package/lib/webstreams.js

@@ -0,0 +1,7 @@
+import {
+  ReadableStream as ReadableStreamNode,
+  WritableStream as WritableStreamNode
+} from 'node:stream/web'
+
+export const ReadableStream = ReadableStreamNode
+export const WritableStream = WritableStreamNode