braid-http 1.3.18 → 1.3.20

package/braid-http-client.js

@@ -312,22 +312,6 @@ async function braid_fetch (url, params = {}) {
                     (params.headers.has('multiplexer') ||
                         (params.headers.has('subscribe') &&
                             braid_fetch.subscription_counts?.[origin] > 1))) {
-
-                    // invent a new multiplexer and stream id
-                    // if not provided
-                    if (!params.headers.has('multiplexer')) {
-                        // we want to keep the same multiplexer id for each origin
-                        if (!braid_fetch.multiplexers)
-                            braid_fetch.multiplexers = {}
-                        if (!braid_fetch.multiplexers[origin])
-                            braid_fetch.multiplexers[origin] =
-                                Math.random().toString(36).slice(2)
-
-                        // the stream id is different each time
-                        var stream = Math.random().toString(36).slice(2)
-                        params.headers.set('multiplexer',
-                            `/${braid_fetch.multiplexers[origin]}/${stream}`)
-                    }
                     res = await multiplex_fetch(url, params)
                 } else {
                     res = await normal_fetch(url, params)
@@ -849,27 +833,25 @@ function parse_body (state) {
 // This tells the server to send the results to the given multiplexer.
 //
 async function multiplex_fetch(url, params) {
-    // extract multiplexer id from the header
-    var multiplexer = params.headers.get('multiplexer').split('/')[1]
+    var origin = new URL(url, typeof document !== 'undefined' ? document.baseURI : undefined).origin
+
+    // the mux_key is the same as the origin, unless it is being overriden
+    // (the overriding is done by the tests)
+    var mux_key = params.headers.get('multiplexer')?.split('/')[1] ?? origin
 
-    // create a new multiplexer if it doesn't exist
+    // create a new multiplexer if it doesn't exist for this origin
     if (!multiplex_fetch.multiplexers) multiplex_fetch.multiplexers = {}
-    if (!multiplex_fetch.multiplexers[multiplexer]) multiplex_fetch.multiplexers[multiplexer] = (async () => {
-        var origin = url[0] === '/' ? location.origin : new URL(url).origin
+    if (!multiplex_fetch.multiplexers[mux_key]) multiplex_fetch.multiplexers[mux_key] = (async () => {
+        // 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 {
-            if (braid_fetch.use_multiplexing === 'USE GET')
-                var r = await braid_fetch(`${origin}/MULTIPLEX/${multiplexer}`, {retry: true})
-            else
-                var r = await braid_fetch(`${origin}/${multiplexer}`, {method: 'MULTIPLEX', retry: true})
+            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) => {
-                params.headers.delete('multiplexer')
-                return normal_fetch(url, params)
-            }
+            return (url, params) => normal_fetch(url, params)
         }
 
         // parse the multiplexed stream,
@@ -882,13 +864,18 @@ async function multiplex_fetch(url, params) {
             // the multiplexer stream has died.. let everyone know..
             mux_error = e
             for (var f of streams.values()) f()
-            delete multiplex_fetch.multiplexers[multiplexer]
+            delete multiplex_fetch.multiplexers[mux_key]
         })
 
         // return a "fetch" for this multiplexer
         return async (url, params) => {
-            // extract stream id from the header
-            var stream = params.headers.get('multiplexer').split('/')[2]
+            // 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)
+
+            // add the multiplexer header without affecting the underlying params
+            var mux_headers = new Headers(params.headers)
+            mux_headers.set('multiplexer', `/${multiplexer}/${stream}`)
+            params = {...params, headers: mux_headers}
 
             // setup a way to receive incoming data from the multiplexer
             var buffers = []
@@ -925,10 +912,7 @@ async function multiplex_fetch(url, params) {
                 stream_error = e
                 bytes_available()
                 try {
-                    if (braid_fetch.use_multiplexing === 'USE GET')
-                        await braid_fetch(`${origin}/MULTIPLEX${params.headers.get('multiplexer')}`, {retry: true})
-                    else
-                        await braid_fetch(`${origin}${params.headers.get('multiplexer')}`, {method: 'MULTIPLEX', retry: true})
+                    await braid_fetch(`${origin}${params.headers.get('multiplexer')}`, {method: 'MULTIPLEX', retry: true})
                 } catch (e) {
                     console.error(`Could not cancel multiplexed connection:`, e)
                     throw e
@@ -1014,7 +998,7 @@ async function multiplex_fetch(url, params) {
     })()
 
     // call the special fetch function for the multiplexer
-    return await (await multiplex_fetch.multiplexers[multiplexer])(url, params)
+    return await (await multiplex_fetch.multiplexers[mux_key])(url, params)
 }
 
 // waits on reader for chunks like: 123 bytes for stream ABC\r\n..123 bytes..

package/braid-http-server.js

@@ -243,10 +243,9 @@ function braidify (req, res, next) {
     req.subscribe = subscribe
 
     // Multiplexer stuff
-    if ((braidify.use_multiplexing && req.method === 'MULTIPLEX') ||
-        (braidify.use_multiplexing === 'USE GET' && req.url.startsWith('/MULTIPLEX/'))) {
+    if (braidify.use_multiplexing && req.method === 'MULTIPLEX') {
         // parse the multiplexer id and stream id from the url
-        var [multiplexer, stream] = req.url.slice(1).replace(/^MULTIPLEX\//, '').split('/')
+        var [multiplexer, stream] = req.url.slice(1).split('/')
 
         // if there's just a multiplexer, then we're creating a multiplexer..
         if (!stream) {

package/package.json

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