braid-http 1.3.21 → 1.3.23

package/braid-http-client.js

@@ -236,7 +236,7 @@ async function braid_fetch (url, params = {}) {
     // then we want to multiplex
     var subscription_counts_on_close = null
     if (params.headers.has('subscribe')) {
-        var origin = url[0] === '/' ? location.origin : new URL(url).origin
+        var origin = new URL(url, typeof document !== 'undefined' ? document.baseURI : undefined).origin
         if (!braid_fetch.subscription_counts)
             braid_fetch.subscription_counts = {}
         braid_fetch.subscription_counts[origin] =
@@ -845,30 +845,51 @@ async function multiplex_fetch(url, params) {
         // make up a new multiplexer id (unless it is being overriden)
         var multiplexer = params.headers.get('multiplexer')?.split('/')[1] ?? Math.random().toString(36).slice(2)
 
-        // attempt to establish a multiplexed connection
-        try {
-            var r = await braid_fetch(`${origin}/${multiplexer}`, {method: 'MULTIPLEX', retry: true})
-        } catch (e) {
-            // fallback to normal fetch if multiplexed connection fails
-            console.error(`Could not establish multiplexed connection.\nGot error: ${e}.\nFalling back to normal connection.`)
-            return (url, params) => normal_fetch(url, params)
-        }
-
-        // parse the multiplexed stream,
-        // and send messages to the appropriate streams
         var streams = new Map()
         var mux_error = null
-        parse_multiplex_stream(r.body.getReader(), (stream, bytes) => {
-            streams.get(stream)?.(bytes)
-        }, e => {
-            // the multiplexer stream has died.. let everyone know..
-            mux_error = e
-            for (var f of streams.values()) f()
-            delete multiplex_fetch.multiplexers[mux_key]
-        })
+        var using_multiplex_header = false
+
+        var mux_promise = (async () => {
+            // attempt to establish a multiplexed connection
+            try {
+                if (params.use_multiplex_header) throw 'skip to trying header'
+                var r = await braid_fetch(`${origin}/${multiplexer}`, {method: 'MULTIPLEX', retry: true})
+            } catch (e) {
+                // some servers don't like custom methods,
+                // so let's try with a custom header
+                try {
+                    using_multiplex_header = true
+                    r = await braid_fetch(`${origin}/${multiplexer}`, {headers: {MULTIPLEX: true}, retry: true})
+                } catch (e) {
+                    // fallback to normal fetch if multiplexed connection fails
+                    console.error(`Could not establish multiplexed connection.\nGot error: ${e}.\nFalling back to normal connection.`)
+                    return false
+                }
+            }
+
+            // parse the multiplexed stream,
+            // and send messages to the appropriate streams
+            parse_multiplex_stream(r.body.getReader(), (stream, bytes) => {
+                streams.get(stream)?.(bytes)
+            }, e => {
+                // the multiplexer stream has died.. let everyone know..
+                mux_error = e
+                for (var f of streams.values()) f()
+                delete multiplex_fetch.multiplexers[mux_key]
+            })
+        })()
 
         // return a "fetch" for this multiplexer
         return async (url, params) => {
+            // maybe wait for multiplexer to be connected..
+            if (!params.experimental_do_not_wait_for_multiplexer) {
+                if ((await mux_promise) === false) {
+                    // it failed to connect the multiplexer,
+                    // so fallback to normal fetch
+                    return await normal_fetch(url, params)
+                }
+            }
+
             // make up a new stream id (unless it is being overriden)
             var stream = params.headers.get('multiplexer')?.split('/')[2] ?? Math.random().toString(36).slice(2)
 
@@ -912,7 +933,7 @@ async function multiplex_fetch(url, params) {
                 stream_error = e
                 bytes_available()
                 try {
-                    await braid_fetch(`${origin}${params.headers.get('multiplexer')}`, {method: 'MULTIPLEX', retry: true})
+                    await braid_fetch(`${origin}${params.headers.get('multiplexer')}`, {...using_multiplex_header ? {headers: {MULTIPLEX: true}} : {method: 'MULTIPLEX'}, retry: true})
                 } catch (e) {
                     console.error(`Could not cancel multiplexed connection:`, e)
                     throw e
@@ -922,6 +943,14 @@ async function multiplex_fetch(url, params) {
             // do the underlying fetch
             try {
                 var res = await normal_fetch(url, params)
+
+                if (params.experimental_do_not_wait_for_multiplexer &&
+                    res.status === 422 &&
+                    !(await promise_done(mux_promise))) {
+                    // this error will trigger a retry if the user is using that
+                    throw new Error('multiplexer not yet connected')
+                }
+
                 if (res.status !== 293) throw new Error('Could not establish multiplexed stream ' + params.headers.get('multiplexer') + ' got status: ' + res.status)
 
                 // we want to present the illusion that the connection is still open,
@@ -1126,6 +1155,12 @@ function create_abort_error(msg) {
     return e
 }
 
+async function promise_done(promise) {
+    var pending = {}
+    var ret = await Promise.race([promise, Promise.resolve(pending)])
+    return ret !== pending
+}
+
 // ****************************
 // Exports
 // ****************************

package/braid-http-server.js

@@ -243,7 +243,7 @@ function braidify (req, res, next) {
     req.subscribe = subscribe
 
     // Multiplexer stuff
-    if (braidify.use_multiplexing && req.method === 'MULTIPLEX') {
+    if (braidify.use_multiplexing && (req.method === 'MULTIPLEX' || req.headers.multiplex)) {
         // parse the multiplexer id and stream id from the url
         var [multiplexer, stream] = req.url.slice(1).split('/')
 
@@ -304,7 +304,7 @@ function braidify (req, res, next) {
         var [multiplexer, stream] = req.headers.multiplexer.slice(1).split('/')
 
         var end_things = (msg) => {
-            res.statusCode = 400
+            res.statusCode = 422 // Unprocessable Entity (but good syntax!)
             res.end(msg)
         }
 
@@ -334,14 +334,19 @@ function braidify (req, res, next) {
             }
 
             _write(chunk, encoding, callback) {
-                var len = Buffer.isBuffer(chunk) ? chunk.length : Buffer.byteLength(chunk, encoding)
-                this.multiplexer.res.write(`${len} bytes for stream ${this.stream}\r\n`)
-                this.multiplexer.res.write(chunk, encoding, callback)
-
-                // console.log(`wrote:`)
-                // console.log(`${len} bytes for stream /${this.stream}\r\n`)
-                // if (Buffer.isBuffer(chunk)) console.log(new TextDecoder().decode(chunk))
-                // else console.log('STRING?: ' + chunk)
+                try {
+                    var len = Buffer.isBuffer(chunk) ? chunk.length : Buffer.byteLength(chunk, encoding)
+                    this.multiplexer.res.write(`${len} bytes for stream ${this.stream}\r\n`)
+                    this.multiplexer.res.write(chunk, encoding, callback)
+
+                    // console.log(`wrote:`)
+                    // console.log(`${len} bytes for stream /${this.stream}\r\n`)
+                    // if (Buffer.isBuffer(chunk)) console.log(new TextDecoder().decode(chunk))
+                    // else console.log('STRING?: ' + chunk)
+
+                } catch (e) {
+                    callback(e)
+                }
             }
         }
         var mw = new MultiplexedWritable(m, stream)
@@ -368,7 +373,31 @@ function braidify (req, res, next) {
             } while (obj = Object.getPrototypeOf(obj))
         }
         for (let key of get_props(res)) {
-            if (key === '_events' || key === 'emit') continue
+            // skip keys that break stuff for some reason
+            if (
+                // just touching these seems to cause issues
+                key === '_events' || key === 'emit'
+
+                // because we called res.end above,
+                // in http 1, node is going to wait
+                // for the event loop to fire again,
+                // and then call these keys:
+                // "socket" to set it to null,
+                // "detachSocket" to do that,
+                // "_closed" to determine if the socket is closed;
+                // we're going to override that to say true,
+                // we do that below..
+                // we do it so we don't need to add "destroyed" here,
+                // because if _closed was false,
+                // it would try to set destroyed to true
+                || key === 'socket'
+                || key === 'detachSocket'
+                || key === '_closed'
+
+                // adding these lines gets rid of some deprecation warnings.. keep?
+                || key === '_headers'
+                || key === '_headerNames') continue
+
             if (res2[key] === undefined) continue
             var value = res[key]
             if (typeof value === 'function') {
@@ -383,6 +412,19 @@ function braidify (req, res, next) {
             }
         }
 
+        // node http 1 has the issue that when we call res.end,
+        // which we do above, not everything happens right away..
+        // in the next js event loop tick, it is going to
+        // try to tear down the stream,
+        // but we have proxied all the properties,
+        // so it would tear down our new res2 stream..
+        // to prevent that, we sacrafice this property
+        // (which the end-user hopefully won't be accessing anyway)
+        // to make the http 1 tear down code think its job is complete already,
+        // otherwise it would want to set "destroyed",
+        // and we would need to not proxy that key as well
+        res._closed = true
+
         // this is provided so code can know if the response has been multiplexed
         res.multiplexer = res2
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "braid-http",
-  "version": "1.3.21",
+  "version": "1.3.23",
   "description": "An implementation of Braid-HTTP for Node.js and Browsers",
   "scripts": {
     "test": "node test/server.js"