braid-http 1.3.39 → 1.3.41

package/braid-http-client.js

@@ -265,7 +265,7 @@ async function braid_fetch (url, params = {}) {
                 var retry = params.retry && // only try to reconnect if the user has chosen to
                     e.name !== "AbortError" && // don't retry if the user has chosen to abort
                     !e.startsWith?.('Parse error in headers') && // in this case, the server is spewing garbage, so reconnecting might be bad
-                    !e.message?.startsWith?.('Could not establish multiplexed stream') && // the server has told us no, or is using a different version of multiplexing
+                    !e.message?.startsWith?.('Could not establish multiplexed request') && // the server has told us no, or is using a different version of multiplexing
                     !cb_running // if an error is thrown in the callback, then it may not be good to reconnect, and generate more errors
 
                 if (retry && !original_signal?.aborted) {
@@ -307,9 +307,9 @@ async function braid_fetch (url, params = {}) {
                 // Now we run the original fetch....
 
                 // try multiplexing if the multiplex flag is set, and conditions are met
-                var mux_params = params.multiplex ?? braid_fetch.multiplex
+                var mux_params = params.multiplex ?? braid_fetch.enable_multiplex
                 if (mux_params !== false &&
-                    (params.headers.has('multiplexer') ||
+                    (params.headers.has('multiplex-at') ||
                     (params.headers.has('subscribe') &&
                         braid_fetch.subscription_counts?.[origin] >
                             (!mux_params ? 1 : (mux_params.after ?? 0))))) {
@@ -828,50 +828,52 @@ function parse_body (state) {
 // multiplex_fetch provides a fetch-like experience for HTTP requests
 // where the result is actually being sent over a separate multiplexed connection.
 async function multiplex_fetch(url, params, skip_multiplex_method) {
+    var multiplex_version = '1.0'
+
     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('/')[3] ?? origin
+    var mux_key = params.headers.get('multiplex-at')?.split('/')[3] ?? origin
 
     // create a new multiplexer if it doesn't exist for this origin
     if (!multiplex_fetch.multiplexers) multiplex_fetch.multiplexers = {}
     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('/')[3] ?? Math.random().toString(36).slice(2)
+        var multiplexer = params.headers.get('multiplex-at')?.split('/')[3] ?? Math.random().toString(36).slice(2)
 
-        var streams = new Map()
+        var requests = new Map()
         var mux_error = null
 
         var mux_promise = (async () => {
             // attempt to establish a multiplexed connection
             try {
                 if (skip_multiplex_method) throw 'skip multiplex method'
-                var r = await braid_fetch(`${origin}/${multiplexer}`, {method: 'MULTIPLEX', headers: {'Multiplex-Version': '0.0.1'}, retry: true})
-                if (!r.ok || r.headers.get('Multiplex-Version') !== '0.0.1') throw 'bad'
+                var r = await braid_fetch(`${origin}/${multiplexer}`, {method: 'MULTIPLEX', headers: {'Multiplex-Version': multiplex_version}, retry: true})
+                if (!r.ok || r.headers.get('Multiplex-Version') !== multiplex_version) throw 'bad'
             } catch (e) {
                 // some servers don't like custom methods,
                 // so let's try with a custom header
                 try {
-                    r = await braid_fetch(`${origin}/.well-known/multiplex/${multiplexer}`, {method: 'POST', headers: {'Multiplex-Version': '0.0.1'}, retry: true})
+                    r = await braid_fetch(`${origin}/.well-known/multiplex/${multiplexer}`, {method: 'POST', headers: {'Multiplex-Version': multiplex_version}, retry: true})
 
                     if (!r.ok) throw new Error('status not ok: ' + r.status)
-                    if (r.headers.get('Multiplex-Version') !== '0.0.1') throw new Error('wrong multiplex version: ' + r.headers.get('Multiplex-Version') + ', expected 0.0.1')
+                    if (r.headers.get('Multiplex-Version') !== multiplex_version) throw new Error('wrong multiplex version: ' + r.headers.get('Multiplex-Version') + ', expected ' + multiplex_version)
                 } 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.`)
+                    console.error(`Could not establish multiplexer.\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)
+            // and send messages to the appropriate requests
+            parse_multiplex_stream(r.body.getReader(), (reqest, bytes) => {
+                requests.get(reqest)?.(bytes)
             }, e => {
                 // the multiplexer stream has died.. let everyone know..
                 mux_error = e
-                for (var f of streams.values()) f()
+                for (var f of requests.values()) f()
                 delete multiplex_fetch.multiplexers[mux_key]
             })
         })()
@@ -882,30 +884,30 @@ async function multiplex_fetch(url, params, skip_multiplex_method) {
             // if we already know the multiplexer is not working,
             // then fallback to normal fetch
             // (unless the user is specifically asking for multiplexing)
-            if ((await promise_done(mux_promise)) && (await mux_promise) === false && !params.headers.get('multiplexer'))
+            if ((await promise_done(mux_promise)) && (await mux_promise) === false && !params.headers.get('multiplex-at'))
                 return await normal_fetch(url, params)
 
-            // make up a new stream id (unless it is being overriden)
-            var stream = params.headers.get('multiplexer')?.split('/')[4] ?? Math.random().toString(36).slice(2)
+            // make up a new request id (unless it is being overriden)
+            var request = params.headers.get('multiplex-at')?.split('/')[4] ?? Math.random().toString(36).slice(2)
 
-            // add the multiplexer header without affecting the underlying params
+            // add the Multiplex-At header without affecting the underlying params
             var mux_headers = new Headers(params.headers)
-            mux_headers.set('Multiplexer', `/.well-known/multiplex/${multiplexer}/${stream}`)
-            mux_headers.set('Multiplex-Version', '0.0.1')
+            mux_headers.set('Multiplex-At', `/.well-known/multiplex/${multiplexer}/${request}`)
+            mux_headers.set('Multiplex-Version', multiplex_version)
             params = {...params, headers: mux_headers}
 
             // setup a way to receive incoming data from the multiplexer
             var buffers = []
             var bytes_available = () => {}
-            var stream_error = null
+            var request_error = null
 
             // this utility calls the callback whenever new data is available to process
             async function process_buffers(cb) {
                 while (true) {
                     // wait for data if none is available
-                    if (!mux_error && !stream_error && !buffers.length)
+                    if (!mux_error && !request_error && !buffers.length)
                         await new Promise(done => bytes_available = done)
-                    if (mux_error || stream_error) throw (mux_error || stream_error)
+                    if (mux_error || request_error) throw (mux_error || request_error)
 
                     // process the data
                     let ret = cb()
@@ -913,31 +915,29 @@ async function multiplex_fetch(url, params, skip_multiplex_method) {
                 }
             }
 
-            // tell the multiplexer to send bytes for this stream to us
-            streams.set(stream, bytes => {
-                if (!bytes) {
-                    streams.delete(stream)
-                    buffers.push(bytes)
-                } else if (!mux_error) buffers.push(bytes)
+            // tell the multiplexer to send bytes for this request to us
+            requests.set(request, bytes => {
+                if (!bytes) buffers.push(bytes)
+                else if (!mux_error) buffers.push(bytes)
                 bytes_available()
             })
 
             // prepare a function that we'll call to cleanly tear things down
             var unset = async e => {
                 unset = () => {}
-                streams.delete(stream)
-                stream_error = e
+                requests.delete(request)
+                request_error = e
                 bytes_available()
                 try {
-                    var r = await braid_fetch(`${origin}${params.headers.get('multiplexer')}`, {
+                    var r = await braid_fetch(`${origin}${params.headers.get('multiplex-at')}`, {
                         method: 'DELETE',
-                        headers: { 'Multiplex-Version': '0.0.1' }, retry: true
+                        headers: { 'Multiplex-Version': multiplex_version }, retry: true
                     })
 
                     if (!r.ok) throw new Error('status not ok: ' + r.status)
-                    if (r.headers.get('Multiplex-Version') !== '0.0.1') throw new Error('wrong multiplex version: ' + r.headers.get('Multiplex-Version') + ', expected 0.0.1')
+                    if (r.headers.get('Multiplex-Version') !== multiplex_version) throw new Error('wrong multiplex version: ' + r.headers.get('Multiplex-Version') + ', expected ' + multiplex_version)
                 } catch (e) {
-                    e = new Error(`Could not cancel multiplexed connection: ${e}`)
+                    e = new Error(`Could not cancel multiplexed request: ${e}`)
                     console.error('' + e)
                     throw e
                 }
@@ -945,9 +945,11 @@ async function multiplex_fetch(url, params, skip_multiplex_method) {
 
             // do the underlying fetch
             try {
+                var mux_was_done = await promise_done(mux_promise)
+
                 var res = await normal_fetch(url, params)
 
-                if (res.status === 424 && !(await promise_done(mux_promise))) {
+                if (res.status === 424 && !mux_was_done) {
                     // this error will trigger a retry if the user is using that option
                     throw new Error('multiplexer not yet connected')
                 }
@@ -957,29 +959,29 @@ async function multiplex_fetch(url, params, skip_multiplex_method) {
                 // fall back to as if it was a normal fetch
                 if (res.ok && res.status !== 293) return res
 
-                if (res.status !== 293) throw new Error('Could not establish multiplexed stream ' + params.headers.get('multiplexer') + ', got status: ' + res.status)
+                if (res.status !== 293) throw new Error('Could not establish multiplexed request ' + params.headers.get('multiplex-at') + ', got status: ' + res.status)
 
-                if (res.headers.get('Multiplex-Version') !== '0.0.1') throw new Error('Could not establish multiplexed stream ' + params.headers.get('multiplexer') + ', got unknown version: ' + res.headers.get('Multiplex-Version'))
+                if (res.headers.get('Multiplex-Version') !== multiplex_version) throw new Error('Could not establish multiplexed request ' + params.headers.get('multiplex-at') + ', got unknown version: ' + res.headers.get('Multiplex-Version'))
 
                 // we want to present the illusion that the connection is still open,
                 // and therefor closable with "abort",
-                // so we handle the abort ourselves to close the multiplexed stream
+                // so we handle the abort ourselves to close the multiplexed request
                 params.signal?.addEventListener('abort', () =>
-                    unset(create_abort_error('stream aborted')))
+                    unset(create_abort_error('request aborted')))
 
                 // first, we need to listen for the headers..
                 var headers_buffer = new Uint8Array()
                 var parsed_headers = await process_buffers(() => {
-                    // check if the stream has been closed
-                    var stream_ended = !buffers[buffers.length - 1]
-                    if (stream_ended) buffers.pop()
+                    // check if the request has been closed
+                    var request_ended = !buffers[buffers.length - 1]
+                    if (request_ended) buffers.pop()
 
                     // aggregate all the new buffers into our big headers_buffer
                     headers_buffer = concat_buffers([headers_buffer, ...buffers])
                     buffers = []
 
-                    // and if the stream had ended, put that information back
-                    if (stream_ended) buffers.push(null)
+                    // and if the request had ended, put that information back
+                    if (request_ended) buffers.push(null)
 
                     // try parsing what we got so far as headers..
                     var x = parse_headers(headers_buffer)
@@ -990,7 +992,7 @@ async function multiplex_fetch(url, params, skip_multiplex_method) {
                         console.log(`headers_buffer: ` + new TextDecoder().decode(headers_buffer))
                         throw new Error('error parsing headers')
                     } else if (x.result === 'waiting') {
-                        if (stream_ended) throw new Error('Multiplexed stream ended before headers received.')
+                        if (request_ended) throw new Error('Multiplexed request ended before headers received.')
                     } else return x
                 })
 
@@ -1004,7 +1006,7 @@ async function multiplex_fetch(url, params, skip_multiplex_method) {
 
                 // create our own fake response object,
                 // to mimik fetch's response object,
-                // feeding the user our stream data from the multiplexer
+                // feeding the user our request data from the multiplexer
                 var res = new Response(new ReadableStream({
                     async start(controller) {
                         try {
@@ -1022,7 +1024,7 @@ async function multiplex_fetch(url, params, skip_multiplex_method) {
 
                 // add a convenience property for the user to know if
                 // this response is being multiplexed
-                res.multiplexer = params.headers.get('multiplexer')
+                res.is_multiplexed = true
 
                 // return the fake response object
                 return res
@@ -1038,14 +1040,14 @@ async function multiplex_fetch(url, params, skip_multiplex_method) {
     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..
+// waits on reader for chunks like: 123 bytes for request ABC\r\n..123 bytes..
 // which would trigger cb("ABC", bytes)
 async function parse_multiplex_stream(reader, cb, on_error) {
     try {
         var buffers = [new Uint8Array(0)]
         var buffers_size = 0
         var chunk_size = null
-        var stream_id = null
+        var request_id = null
         var header_length = 0
         var header_started = false
 
@@ -1072,15 +1074,15 @@ async function parse_multiplex_stream(reader, cb, on_error) {
                     }
                     if (headerComplete) {
                         var headerStr = new TextDecoder().decode(buffers[0].slice(0, header_length))
-                        var m = headerStr.match(/^[\r\n]*((\d+) bytes for|close) stream ([A-Za-z0-9_-]+)\r\n$/)
+                        var m = headerStr.match(/^[\r\n]*((\d+) bytes for|close) request ([A-Za-z0-9_-]+)\r\n$/)
                         if (!m) throw new Error('invalid multiplex header')
-                        stream_id = m[3]
+                        request_id = m[3]
 
                         buffers[0] = buffers[0].slice(header_length)
                         buffers_size -= header_length
 
                         if (m[1] === 'close') {
-                            cb(stream_id)
+                            cb(request_id)
                             break
                         } else chunk_size = 1 * m[2]
                     } else break
@@ -1091,12 +1093,12 @@ async function parse_multiplex_stream(reader, cb, on_error) {
                     buffers[0] = buffers[0].slice(chunk_size)
                     buffers_size -= chunk_size
 
-                    // console.log(`stream_id: ${stream_id}, ${new TextDecoder().decode(chunk)}`)
+                    // console.log(`request_id: ${request_id}, ${new TextDecoder().decode(chunk)}`)
 
-                    cb(stream_id, chunk)
+                    cb(request_id, chunk)
 
                     chunk_size = null
-                    stream_id = null
+                    request_id = null
                     header_length = 0
                     header_started = false
                 } else break

package/braid-http-server.js

@@ -243,9 +243,10 @@ function braidify (req, res, next) {
     req.subscribe = subscribe
 
     // Multiplexer stuff
-    if (braidify.use_multiplexing &&
+    var multiplex_version = '1.0'
+    if ((braidify.enable_multiplex ?? true) &&
         (req.method === 'MULTIPLEX' || req.url.startsWith('/.well-known/multiplex/')) &&
-        req.headers['multiplex-version'] === '0.0.1') {
+        req.headers['multiplex-version'] === multiplex_version) {
 
         // let the caller know we're handling things
         req.is_multiplexer = res.is_multiplexer = true
@@ -255,37 +256,48 @@ function braidify (req, res, next) {
         res.setHeader("Access-Control-Allow-Methods", "*")
         res.setHeader("Access-Control-Allow-Headers", "*")
 
-        // parse the multiplexer id and stream id from the url
-        var [multiplexer, stream] = req.url.split('/').slice(req.method === 'MULTIPLEX' ? 1 : 3)
+        // parse the multiplexer id and request id from the url
+        var [multiplexer, request] = req.url.split('/').slice(req.method === 'MULTIPLEX' ? 1 : 3)
 
         // if there's just a multiplexer, then we're creating a multiplexer..
-        if (!stream) {
+        if (!request) {
             // maintain a Map of all the multiplexers
             if (!braidify.multiplexers) braidify.multiplexers = new Map()
-            braidify.multiplexers.set(multiplexer, {streams: new Map(), res})
+
+            // if this multiplexer already exists, respond with an error
+            if (braidify.multiplexers.has(multiplexer)) {
+                res.writeHead(409, 'Conflict', {'Content-Type': 'application/json'})
+                return res.end(JSON.stringify({
+                    error: 'Multiplexer already exists',
+                    message: `Cannot create duplicate multiplexer with ID '${multiplexer}'`,
+                    details: 'This multiplexer ID must be unique'
+                }))
+            }
+
+            braidify.multiplexers.set(multiplexer, {requests: new Map(), res})
 
             // when the response closes,
             // let everyone know the multiplexer has died
             res.on('close', () => {
-                for (var f of braidify.multiplexers.get(multiplexer).streams.values()) f()
+                for (var f of braidify.multiplexers.get(multiplexer).requests.values()) f()
                 braidify.multiplexers.delete(multiplexer)
             })
 
             // keep the connection open,
             // so people can send multiplexed data to it
             res.writeHead(200, 'OK', {
-                'Multiplex-Version': '0.0.1',
+                'Multiplex-Version': multiplex_version,
                 'Incremental': '?1',
                 'Cache-Control': 'no-cache',
                 'X-Accel-Buffering': 'no',
                 ...req.httpVersion !== '2.0' && {'Connection': 'keep-alive'}
             })
 
-            // but write something.. won't interfere with stream,
+            // but write something.. won't interfere with multiplexer,
             // and helps flush the headers
             return res.write(`\r\n`)
         } else {
-            // in this case, we're closing the given stream
+            // in this case, we're closing the given request
 
             // if the multiplexer doesn't exist, send an error
             var m = braidify.multiplexers?.get(multiplexer)
@@ -294,32 +306,32 @@ function braidify (req, res, next) {
                 return res.end(`multiplexer ${multiplexer} does not exist`)
             }
 
-            // if the stream doesn't exist, send an error
-            let s = m.streams.get(stream)
+            // if the request doesn't exist, send an error
+            let s = m.requests.get(request)
             if (!s) {
-                res.writeHead(404, 'Stream no exist', {'Bad-Stream': stream})
-                return res.end(`stream ${stream} does not exist`)
+                res.writeHead(404, 'Multiplexed request not found', {'Bad-Request': request})
+                return res.end(`request ${request} does not exist`)
             }
 
-            // remove this stream, and notify it
-            m.streams.delete(stream)
+            // remove this request, and notify it
+            m.requests.delete(request)
             s()
 
             // let the requester know we succeeded
-            res.writeHead(200, 'OK', { 'Multiplex-Version': '0.0.1' })
+            res.writeHead(200, 'OK', { 'Multiplex-Version': multiplex_version })
             return res.end(``)
         }
     }
 
-    // a multiplexer header means the user wants to send the
+    // a Multiplex-At header means the user wants to send the
     // results of this request to the provided multiplexer,
-    // tagged with the given stream id
-    if (braidify.use_multiplexing &&
-        req.headers.multiplexer &&
-        req.headers['multiplex-version'] === '0.0.1') {
+    // tagged with the given request id
+    if ((braidify.enable_multiplex ?? true) &&
+        req.headers['multiplex-at'] &&
+        req.headers['multiplex-version'] === multiplex_version) {
 
-        // parse the multiplexer id and stream id from the header
-        var [multiplexer, stream] = req.headers.multiplexer.split('/').slice(3)
+        // parse the multiplexer id and request id from the header
+        var [multiplexer, request] = req.headers['multiplex-at'].split('/').slice(3)
 
         // find the multiplexer object (contains a response object)
         var m = braidify.multiplexers?.get(multiplexer)
@@ -349,16 +361,16 @@ function braidify (req, res, next) {
             if (og_stream) {
                 og_stream.respond({
                     ':status': 293,
-                    Multiplexer: req.headers.multiplexer,
-                    'Multiplex-Version': '0.0.1',
+                    'Multiplex-At': req.headers['multiplex-at'],
+                    'Multiplex-Version': multiplex_version,
                     ...Object.fromEntries(cors_headers)
                 })
                 og_stream.write('Ok.')
                 og_stream.end()
             } else {
                 og_socket.write('HTTP/1.1 293 Responded via multiplexer\r\n')
-                og_socket.write(`Multiplexer: ${req.headers.multiplexer}\r\n`)
-                og_socket.write(`Multiplex-Version: 0.0.1\r\n`)
+                og_socket.write(`Multiplex-At: ${req.headers['multiplex-at']}\r\n`)
+                og_socket.write(`Multiplex-Version: ${multiplex_version}\r\n`)
                 cors_headers.forEach(([key, value]) =>
                     og_socket.write(`${key}: ${value}\r\n`))
                 og_socket.write('\r\n')
@@ -372,10 +384,10 @@ function braidify (req, res, next) {
 
         // first we create a kind of fake socket
         class MultiplexedWritable extends require('stream').Writable {
-            constructor(multiplexer, stream) {
+            constructor(multiplexer, request) {
                 super()
                 this.multiplexer = multiplexer
-                this.stream = stream
+                this.request = request
             }
 
             _write(chunk, encoding, callback) {
@@ -383,11 +395,11 @@ function braidify (req, res, next) {
 
                 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(`${len} bytes for request ${this.request}\r\n`)
                     this.multiplexer.res.write(chunk, encoding, callback)
 
                     // console.log(`wrote:`)
-                    // console.log(`${len} bytes for stream /${this.stream}\r\n`)
+                    // console.log(`${len} bytes for request /${this.request}\r\n`)
                     // if (Buffer.isBuffer(chunk)) console.log(new TextDecoder().decode(chunk))
                     // else console.log('STRING?: ' + chunk)
 
@@ -396,7 +408,7 @@ function braidify (req, res, next) {
                 }
             }
         }
-        var mw = new MultiplexedWritable(m, stream)
+        var mw = new MultiplexedWritable(m, request)
 
         // then we create a fake server response,
         // that pipes data to our fake socket
@@ -405,15 +417,15 @@ function braidify (req, res, next) {
         res2.assignSocket(mw)
 
         // register a handler for when the multiplexer closes,
-        // to close our fake response stream
-        m.streams.set(stream, () => {
+        // to close our fake response
+        m.requests.set(request, () => {
             og_res_end?.()
             res2.destroy()
         })
 
         // when our fake response is done,
         // we want to send a special message to the multiplexer saying so
-        res2.on('finish', () => m.res.write(`close stream ${stream}\r\n`))
+        res2.on('finish', () => m.res.write(`close request ${request}\r\n`))
 
         // we want access to "res" to be forwarded to our fake "res2",
         // so that it goes into the multiplexer

package/package.json

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