@fails-components/webtransport 1.1.4 → 1.2.0

package/lib/stream.js

@@ -20,6 +20,8 @@ const log = logger(`webtransport:http3wtstream(${pid})`)
  * @typedef {import('./dom').WebTransportReceiveStream} WebTransportReceiveStream
  * @typedef {import('./dom').WebTransportSendStream} WebTransportSendStream
  *
+ * @typedef {import('./dom').WebTransportSendGroup} WebTransportSendGroup
+ *
  * @typedef {import('./session').HttpWTSession} HttpWTSession
  *
  * @typedef {import('stream/web').WritableStreamDefaultController} WritableStreamDefaultController
@@ -33,6 +35,8 @@ export class HttpWTStream {
    * @param {object} args.transport
    * @param {boolean} args.bidirectional
    * @param {boolean} args.incoming
+   * @param {WebTransportSendGroup|undefined} args.sendGroup
+   * @param {bigint} args.sendOrder
    */
   constructor(args) {
     this.objint = args.object
@@ -43,6 +47,9 @@ export class HttpWTStream {
     this.incoming = args.incoming
     this.closed = false
 
+    this._sendGroup = args.sendGroup
+    this._sendOrder = args.sendOrder
+
     if (this.objint.sendInitialParameters) {
       this.objint.sendInitialParameters()
     }
@@ -140,18 +147,15 @@ export class HttpWTStream {
               wchunk = new Uint8Array(wchunk)
             }
             if (wchunk instanceof Uint8Array) {
+              if (wchunk.byteLength === 0) {
+                // or should we throw an error ?, Ask the W3C people!
+                return
+              }
               // eslint-disable-next-line no-unused-vars
               this.pendingoperation = new Promise((resolve, reject) => {
                 this.pendingres = resolve
               })
-              this.parentobj
-                .waitForDatagramsSend()
-                .finally(() => {
-                  this.objint.writeChunk(wchunk)
-                })
-                .catch((/** @type {any} */ err) => {
-                  log.error(err)
-                })
+              this.objint.writeChunk(wchunk)
               return this.pendingoperation
             } else {
               log.trace('chunk info:', chunk)
@@ -203,6 +207,36 @@ export class HttpWTStream {
           bytesAcknowledged: 0n
         })
       }
+      Object.defineProperties(this.writable, {
+        sendOrder: {
+          get: () => {
+            return this._sendOrder
+          },
+          /**
+           * @param {bigint} value
+           */
+          set: (value) => {
+            if (value !== this._sendOrder) {
+              this._sendOrder = args.sendOrder
+              this.updateSendOrderAndGroup()
+            }
+          }
+        },
+        sendGroup: {
+          get: () => {
+            return this._sendGroup
+          },
+          /**
+           * @param {WebTransportSendGroup} value
+           */
+          set: (value) => {
+            if (value !== this._sendGroup) {
+              this._sendGroup = value
+              this.updateSendOrderAndGroup()
+            }
+          }
+        }
+      })
       // @ts-ignore
       this.parentobj.addSendStream(this.writable, this.writableController)
     }
@@ -278,6 +312,14 @@ export class HttpWTStream {
     return retObj
   }
 
+  updateSendOrderAndGroup() {
+    this.objint.updateSendOrderAndGroup({
+      sendOrder: this._sendOrder,
+      // @ts-ignore
+      sendGroupId: this._sendGroup._sendGroupId
+    })
+  }
+
   /**
    * @param {import('./types').StreamRecvSignalEvent} args
    * @returns {void}

package/lib/types.ts

@@ -2,7 +2,7 @@ import type {
   WebTransportSession,
   WebTransportHash,
   WebTransportOptions,
-  WebTransportSendGroup
+  WebTransportSendStreamOptions
 } from './dom'
 import type { IncomingHttpHeaders, Http2Stream, ServerHttp2Stream } from 'http2'
 import { ParserBase } from './http2/parserbase'
@@ -15,12 +15,13 @@ import { HttpClient } from './client'
 export interface NativeHttpWTSession {
   jsobj: WebTransportSessionEventHandler
   sendInitialParameters?: () => void
-  writeDatagram: (chunk: Uint8Array) => void
-  orderUnidiStream: (opts:{sendGroup:  WebTransportSendGroup|null, sendOrder: number, waitUntilAvailable: boolean}) => boolean
-  orderBidiStream: (opts:{sendGroup:  WebTransportSendGroup|null, sendOrder: number, waitUntilAvailable: boolean})  => boolean
+  writeDatagram: (chunk: Uint8Array) => { code: 'success' | 'blocked' | 'internalError' | 'tooBig', message?: string}
+  orderUnidiStream: (opts: WebTransportSendStreamOptions) => boolean
+  orderBidiStream: (opts: WebTransportSendStreamOptions)  => boolean
   orderSessionStats: () => void
   orderDatagramStats: () => void
   notifySessionDraining: () => void
+  getMaxDatagramSize: () => number
   close: (arg: { code: number; reason: string }) => void
 }
 
@@ -38,6 +39,10 @@ export interface NativeHttpWTStream {
   resetStream: (code: number) => void
   writeChunk: (buf: Uint8Array) => void
   streamFinal: () => void
+  updateSendOrderAndGroup: (args :{
+    sendOrder: bigint,
+    sendGroupId: bigint
+  }) => void
 }
 
 export interface NativeServerOptions {
@@ -79,6 +84,7 @@ export interface NativeClientOptions {
   initialSessionFlowControlWindow?: number
   sessionShouldAutoTuneReceiveWindow?: boolean
   sessionFlowControlWindowSizeLimit?: number
+  protocols?: string[]
 }
 
 export interface FlowControlable {
@@ -110,7 +116,8 @@ export interface NativeFinishSessionRequest {
   protocol: 'capsule' | 'websocket' | 'websocketoverhttp1' | 'http3'
   head?: Buffer
   userData?: object
-  transportPrivate?: object
+  transportPrivate?: object,
+  selectedProtocol?: string
 }
 
 export type Purpose =
@@ -150,6 +157,7 @@ export interface WebTransportStreamEventHandler {
 
 export interface SessionReadyEvent {
   object: NativeHttpWTSession
+  protocol?: string
 }
 
 export interface SessionCloseEvent {
@@ -179,21 +187,20 @@ export interface DatagramReceivedEvent {
   datagram: Uint8Array
 }
 
-export interface DatagramSendEvent {}
-
 export interface GoawayReceivedEvent {}
 
 export interface NewStreamEvent {
   stream: NativeHttpWTStream
   bidirectional: boolean
   incoming: boolean
+  sendGroupId?: bigint;
+  sendOrder: bigint;
 }
 
 export interface WebTransportSessionEventHandler {
   onReady: (evt: SessionReadyEvent) => void
   onClose: (evt: SessionCloseEvent) => void
   onDatagramReceived: (evt: DatagramReceivedEvent) => void
-  onDatagramSend: (evt: DatagramSendEvent) => void
   onGoAwayReceived: (evt: GoawayReceivedEvent) => void
   onSessionStats: (evt: SessionStatsEvent) => void
   onDatagramStats: (evt: DatagramStatsEvent) => void

package/lib/webtransport.browser.js

@@ -3,6 +3,7 @@ import { HttpWTSession } from './session.js'
 import { HttpClient } from './client.js'
 import { Http2WebTransportBrowser } from './http2/browser/browser.js'
 import { logger } from './utils.js'
+import { WebTransportError } from './error'
 
 const log = logger(`webtransport:browser()`)
 
@@ -13,7 +14,7 @@ const log = logger(`webtransport:browser()`)
  * @typedef {import('./dom').WebTransportSendStream} WebTransportSendStream
  * @typedef {import('./dom').WebTransportSendStreamOptions} WebTransportSendStreamOptions
  * @typedef {import('./dom').WebTransportReceiveStream} WebTransportReceiveStream
- * @typedef {import('./error').WebTransportError} WebTransportError
+ * @typedef {import('./dom').WebTransportSendGroup} WebTransportSendGroup
  */
 
 /**
@@ -215,7 +216,17 @@ export class WebTransportPolyfill {
     }
     /** @type {import('./dom').WebTransportDatagramDuplexStream} */
     // @ts-ignore
-    this.datagrams = {}
+    this.datagrams = {
+      // @ts-ignore
+      get writable() {
+        // @ts-ignore
+        if (!this.datagramwritablepolyfilled_) {
+          console.warn('datagrams.writable is deprecated')
+        }
+        // @ts-ignore
+        return (this.datagramwritablepolyfilled_ ||= this.createWritable())
+      }
+    }
     // @ts-ignore
     this.datagrams.readable = new ReadableStream({
       // eslint-disable-next-line no-unused-vars
@@ -233,23 +244,67 @@ export class WebTransportPolyfill {
       }
     })
     // @ts-ignore
-    this.datagrams.writable = new WritableStream({
-      // eslint-disable-next-line no-unused-vars
-      start: async (controller) => {
-        await this.ready
-        this.datagramsWriter = this.curtransport.datagrams.writable.getWriter()
-      },
-      // eslint-disable-next-line no-unused-vars
-      write: async (chunk, controller) => {
-        await this.datagramsWriter.write(chunk)
-      },
-      abort: async (reason) => {
-        await this.datagramsWriter.abort(reason)
-      },
-      close: async () => {
-        await this.datagramsWriter.close()
+    this.datagrams.createWritable = (options) => {
+      // @ts-ignore Must not exist for older browser
+      if (this.curtransport.datagrams.createWritable) {
+        return this.curtransport.datagrams.createWritable(options)
       }
-    })
+      // we need to fallback to the old default writable
+      // @ts-ignore
+      if (!this.curtransport.datagrams.writable) {
+        throw new WebTransportError('No way to send out datagrams')
+      }
+      let sendOrder = options?.sendOrder
+      let sendGroup = options?.sendGroup
+      const retWritable = new WritableStream({
+        // eslint-disable-next-line no-unused-vars
+        start: async (controller) => {
+          await this.ready
+          if (!this.datagramsWriter) {
+            this.datagramsWriter =
+              // @ts-ignore
+              this.curtransport.datagrams.writable.getWriter()
+          }
+        },
+        // eslint-disable-next-line no-unused-vars
+        write: async (chunk, controller) => {
+          await this.datagramsWriter.write(chunk)
+        },
+        abort: async (reason) => {
+          await this.datagramsWriter.abort(reason)
+        },
+        close: async () => {
+          await this.datagramsWriter.close()
+        }
+      })
+      Object.defineProperties(retWritable, {
+        sendOrder: {
+          get: () => {
+            return sendOrder
+          },
+          /**
+           * @param {number} value
+           */
+          set: (value) => {
+            sendOrder = value
+          }
+        },
+        sendGroup: {
+          get: () => {
+            return sendGroup
+          },
+          /**
+           * @param {WebTransportSendGroup} value
+           */
+          set: (value) => {
+            if (value !== sendGroup) {
+              sendGroup = value
+            }
+          }
+        }
+      })
+      return retWritable
+    }
     this.incomingBidirectionalStreams = new ReadableStream({
       // eslint-disable-next-line no-unused-vars
       start: async (controller) => {
@@ -300,6 +355,10 @@ export class WebTransportPolyfill {
     return true
   }
 
+  get protocol() {
+    return this.curtransport?.protocol || undefined
+  }
+
   getStats() {
     // @ts-ignore
     return this.curtransport.getStats()

package/lib/webtransportbase.js

@@ -152,4 +152,11 @@ export class WebTransportBase {
 
     return session.createUnidirectionalStream(opts)
   }
+
+  get protocol() {
+    const session = this.sessionint
+    if (!session) return undefined
+
+    return session.protocol
+  }
 }

package/old_test/testsuite.js

@@ -70,7 +70,9 @@ export async function unidirectionalEchoTest(session) {
  */
 export async function datagramEchoTest(session) {
   try {
-    session.datagrams.readable.pipeTo(session.datagrams.writable)
+    const writable =
+      session.datagrams.writable || session.datagrams.createWritable()
+    session.datagrams.readable.pipeTo(writable)
   } catch (error) {
     console.log('datagram echo exited with', error)
   }
@@ -287,7 +289,9 @@ export async function echoTestsConnection(transport) {
   console.log('TEST 3: finish')
   console.log('TEST 4: start')
   console.log('finally test datagrams')
-  const datawrite = await transport.datagrams.writable.getWriter()
+  const dwritable =
+    transport.datagrams.writable || transport.datagrams.createWritable()
+  const datawrite = await dwritable.getWriter()
   const data7 = new Uint8Array([83, 84, 85])
   const data8 = new Uint8Array([86, 87, 88])
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fails-components/webtransport",
-  "version": "1.1.4",
+  "version": "1.2.0",
   "description": "A component to add webtransport support (server and client) to node.js using libquiche",
   "exports": {
     ".": {
@@ -53,13 +53,13 @@
     "@types/node": "^18.15.3",
     "eslint": "^9.3.0",
     "eslint-config-prettier": "^9.1.0",
-    "eslint-config-standard": "^16.0.2",
-    "eslint-plugin-import": "^2.25.2",
+    "eslint-plugin-import": "^2.31.0",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-prettier": "^5.1.3",
-    "eslint-plugin-promise": "^4.3.1",
-    "eslint-plugin-standard": "^4.1.0",
-    "prettier": "^3.2.5",
+    "eslint-plugin-promise": "^7.2.1",
+    "prettier": "^3.5.3",
+    "prettier-linter-helpers": "^1.0.0",
+    "synckit": "^0.11.4",
     "typescript": "^4.8.4",
     "uint8arrays": "^4.0.2"
   },

package/readme.md

@@ -109,7 +109,9 @@ Other but more expert options include:
 * `certhttp2` and `privKeyhttp2`: For providing a different certificate for the http/2 as the  http/2 implementation does not support certificate matching by fingerprints.
 * `initialStreamFlowControlWindow`, `initialSessionFlowControlWindow`, `streamShouldAutoTuneReceiveWindow`, `sessionShouldAutoTuneReceiveWindow`, `streamFlowControlWindowSizeLimit`, `sessionFlowControlWindowSizeLimit`: As expert's option for tweaking the internal flow control.
 
-The method `setRequestHandler(callback)` sets a callback, that inspects incoming headers and allows to change the incoming path header and also to throw an error if the session should not be opened. This method is considered to be experimental.
+The method `setRequestCallback(callback)` sets a callback, that inspects incoming headers and allows to change the incoming path header and also to throw an error if the session should not be opened. 
+It is also required for selecting the application level protocol.
+In order to see how it is used, look into `test/fixtures/server.js` for a working example.
 In general, the HTTP header is attached as the `header` property to the WebTransport Session object.
 
 The method `updateCert(cert, privKey, http2only)` allows to change the certificate, while the server is running (not supported by all transports).