@fails-components/webtransport 0.3.1 → 1.0.1

package/lib/webtransport.browser.js

@@ -0,0 +1,284 @@
+import { WebTransportBase } from './webtransportbase.js'
+import { HttpWTSession } from './session.js'
+import { HttpClient } from './client.js'
+import { Http2WebTransportBrowser } from './http2/browser/browser.js'
+
+/**
+ * @typedef {import('./dom').WebTransport} WebTransport
+ * @typedef {import('./dom').WebTransportCloseInfo} WebTransportCloseInfo
+ * @typedef {import('./dom').WebTransportBidirectionalStream} WebTransportBidirectionalStream
+ * @typedef {import('./dom').WebTransportReceiveStream} WebTransportReceiveStream
+ * @typedef {import('./error').WebTransportError} WebTransportError
+ */
+
+/**
+ * @template T
+ * @typedef {import('node:stream/web').ReadableStream<T>} ReadableStream<T>
+ */
+
+/**
+ * @typedef {import('./dom').WebTransport} WebTransportInterface
+ *
+ * @implements {WebTransportInterface}
+ */
+export class WebTransportPonyfill extends WebTransportBase {
+  /**
+   * @param{{client: HttpClient, sessionint: HttpWTSession, ourl: URL}} args
+   */
+  startUpConnection({ client, sessionint, ourl }) {
+    client
+      .handleConnection({ createTransport: true, path: ourl.pathname })
+      .then(() => client.createWTSession(sessionint, ourl.pathname))
+      .catch((error) => {
+        client.closeHookSession()
+        sessionint.readyReject(error)
+        sessionint.closedReject(error)
+      })
+  }
+
+  get supportsReliableOnly() {
+    return true
+  }
+
+  /**
+   * @param{import('./types.js').HttpWebTransportInit} args
+   * @return {{sessionint: HttpWTSession, client: HttpClient}}
+   */
+  createClient(args) {
+    this.curtype = 'websocket'
+    const client = new HttpClient({
+      createReliableClient: (client) => {
+        // @ts-ignore
+        return new Http2WebTransportBrowser({ ...args })
+      },
+      ...args
+    })
+    const sessionint = new HttpWTSession({
+      /* object: args.session, */
+      parentobj: client
+    })
+    return { client, sessionint }
+  }
+}
+
+export class WebTransportPolyfill {
+  /**
+   * @param {string} url
+   * @param {import('./dom.js').WebTransportOptions} [args]
+   */
+  constructor(url, args) {
+    this.curtype = 'native'
+    this.closeset = false
+    this.allowFallback = true
+    this.initiatedFallback = false
+    this.args = args
+
+    this.closed = new Promise((resolve, reject) => {
+      this.closeRes = resolve
+      this.closeRej = reject
+    })
+
+    this.ready = new Promise((resolve, reject) => {
+      this.readyRes = resolve
+      this.readyRej = reject
+    })
+
+    this.draining = new Promise((resolve, reject) => {
+      this.drainingRes = resolve
+      this.drainingRej = reject
+    })
+
+    const initiateFallback = () => {
+      this.initiatedFallback = true
+      this.curtype = 'websocket'
+      this.curtransport = new WebTransportPonyfill(url, args)
+      this.curtransport.ready
+        .then((val) => this.readyRes(val))
+        .catch((error) => this.readyRej(error))
+      this.curtransport.closed
+        .then((val) => this.closeRes(val))
+        .catch((error) => this.closeRej(error))
+      this.curtransport.draining
+        .then((val) => this.drainingRes(val))
+        .catch((error) => this.drainingRej(error))
+    }
+    // @ts-ignore
+    if (globalThis.WebTransport) {
+      /** @type {WebTransport|WebTransportPonyfill} */
+      // @ts-ignore
+      // eslint-disable-next-line no-undef
+      this.curtransport = new WebTransport(url, args)
+      // if browser takes too long for waiting for client, we use the ponyfill
+      setTimeout(() => {
+        if (this.allowFallback && !this.closeset) {
+          if (
+            !this.initiatedFallback &&
+            !this.curtransport?.supportsReliableOnly // way how browser signals support for http/2, no polyfill needed in this cases
+          ) {
+            const oldtransport = this.curtransport
+            if (oldtransport)
+              oldtransport.ready
+                .then(async () => {
+                  oldtransport.close()
+                })
+                .catch(() => {})
+            initiateFallback()
+          }
+        }
+      }, 2000)
+
+      this.curtransport.ready
+        .then((val) => {
+          this.allowFallback = false
+          this.readyRes(val)
+        })
+        .catch((error) => {
+          if (this.allowFallback && !this.closeset) {
+            if (
+              !this.initiatedFallback &&
+              !this.curtransport?.supportsReliableOnly // way how browser signals support for http/2, no polyfill needed in this cases
+            ) {
+              initiateFallback()
+            }
+          } else {
+            this.readyRej(error)
+          }
+        })
+      this.curtransport.closed
+        .then((val) => {
+          if (this.curtype === 'native') this.closeRes(val)
+        })
+        .catch((error) => {
+          if (this.allowFallback && !this.closeset) {
+            if (
+              !this.initiatedFallback &&
+              !this.curtransport?.supportsReliableOnly // way how browser signals support for http/2, no polyfill needed in this cases
+            ) {
+              initiateFallback()
+            }
+          } else {
+            this.closeRej(error)
+          }
+        })
+      if (this.curtransport.draining) {
+        // @ts-ignore
+        this.curtransport.draining
+          .then((/** @type {any} */ val) => {
+            if (this.curtype === 'native') this.drainingRes(val)
+          })
+          .catch((/** @type {WebTransportError} */ error) => {
+            if (this.curtype === 'native') this.drainingRej(error)
+          })
+      }
+    } else {
+      initiateFallback()
+    }
+    /** @type {import('./dom').WebTransportDatagramDuplexStream} */
+    // @ts-ignore
+    this.datagrams = {}
+    // @ts-ignore
+    // eslint-disable-next-line no-undef
+    this.datagrams.readable = new ReadableStream({
+      start: async (controller) => {
+        await this.ready
+        this.datagramsReader = this.curtransport.datagrams.readable.getReader()
+      },
+      pull: async (controller) => {
+        const { value, done } = await this.datagramsReader.read()
+        if (value) controller.enqueue(value)
+        if (done) controller.close()
+      },
+      cancel: async (reason) => {
+        await this.datagramsReader.cancel(reason)
+      }
+    })
+    // @ts-ignore
+    // eslint-disable-next-line no-undef
+    this.datagrams.writable = new WritableStream({
+      start: async (controller) => {
+        await this.ready
+        this.datagramsWriter = this.curtransport.datagrams.writable.getWriter()
+      },
+      write: async (chunk, controller) => {
+        await this.datagramsWriter.write(chunk)
+      },
+      abort: async (reason) => {
+        await this.datagramsWriter.abort(reason)
+      },
+      close: async () => {
+        await this.datagramsWriter.close()
+      }
+    })
+    // eslint-disable-next-line no-undef
+    this.incomingBidirectionalStreams = new ReadableStream({
+      start: async (controller) => {
+        await this.ready
+        this.incomingBidirectionalStreamsReader =
+          this.curtransport.incomingBidirectionalStreams.getReader()
+      },
+      pull: async (controller) => {
+        const { value, done } =
+          await this.incomingBidirectionalStreamsReader.read()
+        if (value) controller.enqueue(value)
+        if (done) controller.close()
+      },
+      cancel: async (reason) => {
+        await this.incomingBidirectionalStreamsReader.cancel(reason)
+      }
+    })
+    // eslint-disable-next-line no-undef
+    this.incomingUnidirectionalStreams = new ReadableStream({
+      start: async (controller) => {
+        await this.ready
+        this.incomingUnidirectionalStreamsReader =
+          this.curtransport.incomingUnidirectionalStreams.getReader()
+      },
+      pull: async (controller) => {
+        const { value, done } =
+          await this.incomingUnidirectionalStreamsReader.read()
+        if (value) controller.enqueue(value)
+        if (done) controller.close()
+      },
+      cancel: async (reason) => {
+        await this.incomingUnidirectionalStreamsReader.cancel(reason)
+      }
+    })
+  }
+
+  get congestionControl() {
+    // @ts-ignore
+    return this.curtransport?.congestionControl || undefined
+  }
+
+  get reliability() {
+    // @ts-ignore
+    return this.curtransport?.reliability || undefined
+  }
+
+  get supportsReliableOnly() {
+    return true
+  }
+
+  getStats() {
+    // @ts-ignore
+    return this.curtransport.getStats()
+  }
+
+  /**
+   * @param {WebTransportCloseInfo} [closeinfo]
+   */
+  close(closeinfo) {
+    this.closeset = true
+    this.curtransport.close(closeinfo)
+  }
+
+  async createBidirectionalStream() {
+    await this.ready
+    return await this.curtransport.createBidirectionalStream()
+  }
+
+  async createUnidirectionalStream() {
+    await this.ready
+    return await this.curtransport.createUnidirectionalStream()
+  }
+}

package/lib/webtransport.node.js

@@ -0,0 +1,137 @@
+import { HttpWTSession } from './session.js'
+import { WebTransportBase } from './webtransportbase.js'
+import { HttpClient } from './client.js'
+import { Http2WebTransportClient } from './http2/node/index.js'
+import { logger } from './utils.js'
+
+const log = logger(`webtransportnode(${process?.pid})`)
+
+/**
+ * @type {(arg0: import("./types").HttpWebTransportInit) => void}
+ */
+let checkQuicheInit
+/**
+ * @type {new (arg0: import("./types").HttpWebTransportInit) => any}
+ */
+let Http3WebTransportClientSocket
+/**
+ * @type {new (arg0: import("./types").HttpWebTransportInit) => any}
+ */
+let Http3WebTransportClient
+// @ts-ignore
+// eslint-disable-next-line no-unused-vars
+const quicheLoaded = new Promise((resolve, reject) => {
+  // @ts-ignore
+  import('@fails-components/webtransport-transport-http3-quiche')
+    .then(
+      /**
+       * @type {import("./types").TransportHttp3Quiche}
+       */
+      (http3lib) => {
+        /**
+         * @type {import("./types").TransportHttp3Quiche}
+         */
+        ;({
+          checkQuicheInit,
+          Http3WebTransportClientSocket,
+          Http3WebTransportClient
+        } = http3lib)
+        resolve(undefined)
+      }
+    )
+    .catch((error) => {
+      log('Problem loading http3-quiche transport', error)
+      reject(error)
+    })
+}).catch((error) => {
+  console.log('http3 loader:', error)
+})
+
+/**
+ * @typedef {import('./dom').WebTransportCloseInfo} WebTransportCloseInfo
+ * @typedef {import('./dom').WebTransportBidirectionalStream} WebTransportBidirectionalStream
+ * @typedef {import('./dom').WebTransportReceiveStream} WebTransportReceiveStream
+ */
+
+/**
+ * @template T
+ * @typedef {import('node:stream/web').ReadableStream<T>} ReadableStream<T>
+ */
+
+/**
+ * @typedef {import('./dom').WebTransport} WebTransportInterface
+ *
+ * @implements {WebTransportInterface}
+ */
+export class WebTransport extends WebTransportBase {
+  /**
+   * @param{{client: HttpClient, sessionint: HttpWTSession, ourl: URL}} args
+   */
+  startUpConnection({ client, sessionint, ourl }) {
+    client
+      .handleConnection({ createTransport: true, path: ourl.pathname })
+      .then(() => client.createWTSession(sessionint, ourl.pathname))
+      .catch((error) => {
+        if (client.transportIntSwitchToReliable) {
+          log('Connecting to unreliable failed:', error)
+          log('Now switching to reliable')
+          client.transportIntSwitchToReliable()
+          client
+            .handleConnection({ createTransport: false, path: ourl.pathname })
+            .then(() => client.createWTSession(sessionint, ourl.pathname))
+            .catch((error) => {
+              client.closeHookSession()
+              sessionint.readyReject(error)
+              sessionint.closedReject(error)
+            })
+        } else {
+          client.closeHookSession()
+          sessionint.readyReject(error)
+          sessionint.closedReject(error)
+        }
+      })
+  }
+
+  get supportsReliableOnly() {
+    return true
+  }
+
+  /**
+   * @param{import('./types.js').HttpWebTransportInit} args
+   * @return {{sessionint: HttpWTSession, client: HttpClient}}
+   */
+  createClient(args) {
+    let createUnreliableClient
+    if (checkQuicheInit) {
+      createUnreliableClient = function (/** @type {any} */ _client) {
+        if (
+          // @ts-ignore
+          !args?.forceReliable
+        ) {
+          checkQuicheInit(args)
+        }
+        const socket = new Http3WebTransportClientSocket(args)
+        const uclient = new Http3WebTransportClient(args)
+        uclient.closeClientInt = uclient.closeClient
+        uclient.closeClient = socket.closeClient.bind(socket)
+        socket.init()
+        socket.cobj = uclient
+        uclient.socket = socket
+        return uclient
+      }
+    }
+    const client = new HttpClient({
+      createReliableClient: function (client) {
+        // @ts-ignore
+        return new Http2WebTransportClient({ ...args })
+      },
+      createUnreliableClient,
+      ...args
+    })
+    const sessionint = new HttpWTSession({
+      /* object: args.session, */
+      parentobj: client
+    })
+    return { client, sessionint }
+  }
+}

package/lib/{webtransport.js → webtransportbase.js}

@@ -1,13 +1,11 @@
-import { Http3Client } from './client.js'
-import { Http3WTSession } from './session.js'
-
-/** @type {WeakMap<WebTransport, Http3WTSession>} */
-const sessions = new WeakMap()
+/** @type {WeakMap<WebTransportBase, import('./session.js').HttpWTSession>} */
 
 /**
- * @typedef {import('./dom').WebTransportCloseInfo} WebTransportCloseInfo
- * @typedef {import('./dom').WebTransportBidirectionalStream} WebTransportBidirectionalStream
- * @typedef {import('./dom').WebTransportReceiveStream} WebTransportReceiveStream
+ * @typedef {import('./dom.js').WebTransportCloseInfo} WebTransportCloseInfo
+ * @typedef {import('./dom.js').WebTransportBidirectionalStream} WebTransportBidirectionalStream
+ * @typedef {import('./dom.js').WebTransportReceiveStream} WebTransportReceiveStream
+ * @typedef {import('./session.js').HttpWTSession} HttpWTSession
+ * @typedef { import('./session.js').HttpClient} HttpClient
  */
 
 /**
@@ -16,14 +14,14 @@ const sessions = new WeakMap()
  */
 
 /**
- * @typedef {import('./dom').WebTransport} WebTransportInterface
+ * @typedef {import('./dom.js').WebTransport} WebTransportInterface
  *
  * @implements {WebTransportInterface}
  */
-export class WebTransport {
+export class WebTransportBase {
   /**
    * @param {string} url
-   * @param {import('./dom').WebTransportOptions} [args]
+   * @param {import('./dom.js').WebTransportOptions} [args]
    */
   constructor(url, args) {
     if (!url) throw new Error('no URL supplied')
@@ -37,42 +35,44 @@ export class WebTransport {
     const host = ourl.hostname
     let port = ourl.port
     if (port === '') port = '443'
-
-    const client = new Http3Client({ host, port, ...args })
-
-    const sessionint = new Http3WTSession({
-      /* object: args.session, */
-      parentobj: client
-    })
-
+    const { sessionint, client } = this.createClient({ host, port, ...args })
     this.ready = sessionint.ready
     this.closed = sessionint.closed
     this.draining = sessionint.draining
 
     this.datagrams = sessionint.datagrams
 
-    /** @type {ReadableStream<WebTransportBidirectionalStream>} */
     this.incomingBidirectionalStreams = sessionint.incomingBidirectionalStreams
 
     this.incomingUnidirectionalStreams =
       sessionint.incomingUnidirectionalStreams
 
-    sessions.set(this, sessionint)
+    this.sessionint = sessionint
+
+    this.startUpConnection({ client, sessionint, ourl })
+  }
+
+  /**
+   * @param{import('./types.js').HttpWebTransportInit} args
+   * @return {{sessionint: HttpWTSession, client: HttpClient}}
+   * @abstract
+   */
+  createClient(args) {
+    throw new Error('Implement createClient')
+  }
 
-    client
-      .handleConnection()
-      .then(() => client.createWTSession(sessionint, ourl.pathname))
-      .catch((error) => {
-        client.closeHookSession()
-        sessionint.readyReject(error)
-        sessionint.closedReject(error)
-      })
+  /**
+   * @param{{client: HttpClient, sessionint: HttpWTSession, ourl: URL}} args
+   * @abstract
+   */
+  startUpConnection({ client, sessionint, ourl }) {
+    throw new Error('Implement createClient')
   }
 
   get reliability() {
-    const session = sessions.get(this)
+    const session = this.sessionint
 
-    if (session == null) {
+    if (!session) {
       // should never happen as session is only removed when this instance is garbage collected
       throw new Error('Http3WTSession was undefined')
     }
@@ -80,19 +80,25 @@ export class WebTransport {
   }
 
   get congestionControl() {
-    const session = sessions.get(this)
+    const session = this.sessionint
 
-    if (session == null) {
+    if (!session) {
       // should never happen as session is only removed when this instance is garbage collected
       throw new Error('Http3WTSession was undefined')
     }
     return session.congestionControl
   }
 
+  get supportsReliableOnly() {
+    throw new Error('Implement supportsReliableOnly')
+    // eslint-disable-next-line no-unreachable
+    return false
+  }
+
   getStats() {
-    const session = sessions.get(this)
+    const session = this.sessionint
 
-    if (session == null) {
+    if (!session) {
       // should never happen as session is only removed when this instance is garbage collected
       throw new Error('Http3WTSession was undefined')
     }
@@ -103,9 +109,9 @@ export class WebTransport {
    * @param {WebTransportCloseInfo} [closeinfo]
    */
   close(closeinfo) {
-    const session = sessions.get(this)
+    const session = this.sessionint
 
-    if (session == null) {
+    if (!session) {
       // should never happen as session is only removed when this instance is garbage collected
       throw new Error('Http3WTSession was undefined')
     }
@@ -114,9 +120,9 @@ export class WebTransport {
   }
 
   createBidirectionalStream() {
-    const session = sessions.get(this)
+    const session = this.sessionint
 
-    if (session == null) {
+    if (!session) {
       // should never happen as session is only removed when this instance is garbage collected
       throw new Error('Http3WTSession was undefined')
     }
@@ -125,9 +131,9 @@ export class WebTransport {
   }
 
   createUnidirectionalStream() {
-    const session = sessions.get(this)
+    const session = this.sessionint
 
-    if (session == null) {
+    if (!session) {
       // should never happen as session is only removed when this instance is garbage collected
       throw new Error('Http3WTSession was undefined')
     }

package/old_test/test.js

@@ -5,19 +5,16 @@
 // this file runs various tests
 
 import { generateWebTransportCertificate } from '../test/fixtures/certificate.js'
-import { Http3Server, WebTransport, testcheck } from '../lib/index.js'
+import { Http3Server, Http2Server, WebTransport } from '../lib/index.node.js'
 import { echoTestsConnection, runEchoServer } from './testsuite.js'
 
+let http2 = false
+
+if (process.argv.some((el) => el === 'http2')) {
+  http2 = true
+}
+
 async function run() {
-  setTimeout(() => {
-    if (!testcheck()) {
-      console.log('tests took too long, probably hanging')
-      process.exit(1)
-    } else {
-      console.log('global event loop gone, everything alright')
-      process.exit(0)
-    }
-  }, 50 * 1000)
   console.log('try connecting to server that does not exist')
   const badClient = new WebTransport('https://127.0.0.1:49823/echo', {
     serverCertificateHashes: [
@@ -57,18 +54,29 @@ async function run() {
     throw new Error('Certificate generation failed')
   }
 
-  console.log('start Http3Server and startup echo tests')
+  console.log('start HttpServer and startup echo tests')
   // now ramp up the server
-  const http3server = new Http3Server({
-    port: 8080,
-    host: '127.0.0.1',
-    secret: 'mysecret',
-    cert: certificate.cert, // unclear if it is the correct format
-    privKey: certificate.private
-  })
+  let httpserver
+  if (!http2) {
+    httpserver = new Http3Server({
+      port: 8080,
+      host: '127.0.0.1',
+      secret: 'mysecret',
+      cert: certificate.cert, // unclear if it is the correct format
+      privKey: certificate.private
+    })
+  } else {
+    httpserver = new Http2Server({
+      port: 8080,
+      host: '127.0.0.1',
+      secret: 'mysecret',
+      cert: certificate.cert, // unclear if it is the correct format
+      privKey: certificate.private
+    })
+  }
 
-  http3server.startServer() // you can call destroy to remove the server
-  runEchoServer(http3server)
+  httpserver.startServer() // you can call destroy to remove the server
+  runEchoServer(httpserver)
 
   console.log('server started now wait 2 seconds')
 
@@ -83,16 +91,10 @@ async function run() {
   })
   client.closed
     .then(() => {
-      console.log('The HTTP/3 connection to ', url, 'closed gracefully.')
+      console.log('The HTTP connection to ', url, 'closed gracefully.')
     })
     .catch((error) => {
-      console.error(
-        'The HTTP/3 connection to',
-        url,
-        'closed due to ',
-        error,
-        '.'
-      )
+      console.error('The HTTP connection to', url, 'closed due to ', error, '.')
     })
   console.log('wait for client to be ready')
   await client.ready
@@ -114,7 +116,7 @@ async function run() {
 
   console.log('now stop server')
 
-  http3server.stopServer()
+  httpserver.stopServer()
   console.log('tests finished!')
 }
 run()

package/old_test/testsuite.js

@@ -77,7 +77,7 @@ export async function datagramEchoTest(session) {
 }
 
 /**
- * @param {import('../lib').Http3Server} server
+ * @param {import('../lib').Http3Server|import('../lib').Http2Server} server
  */
 export async function runEchoServer(server) {
   try {