braid-http 1.3.42 → 1.3.44

package/braid-http-client.js

@@ -309,7 +309,7 @@ async function braid_fetch (url, params = {}) {
                 // try multiplexing if the multiplex flag is set, and conditions are met
                 var mux_params = params.multiplex ?? braid_fetch.enable_multiplex
                 if (mux_params !== false &&
-                    (params.headers.has('multiplex-at') ||
+                    (params.headers.has('multiplex-through') ||
                     (params.headers.has('subscribe') &&
                         braid_fetch.subscription_counts?.[origin] >
                             (!mux_params ? 1 : (mux_params.after ?? 0))))) {
@@ -834,13 +834,13 @@ async function multiplex_fetch(url, params, skip_multiplex_method) {
 
     // 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('multiplex-at')?.split('/')[3] ?? origin
+    var mux_key = params.headers.get('multiplex-through')?.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('multiplex-at')?.split('/')[3] ?? Math.random().toString(36).slice(2)
+        var multiplexer = params.headers.get('multiplex-through')?.split('/')[3] ?? Math.random().toString(36).slice(2)
 
         var requests = new Map()
         var mux_error = null
@@ -855,7 +855,7 @@ async function multiplex_fetch(url, params, skip_multiplex_method) {
                 // 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': multiplex_version}, retry: true})
+                    r = await braid_fetch(`${origin}/.well-known/multiplexer/${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') !== multiplex_version) throw new Error('wrong multiplex version: ' + r.headers.get('Multiplex-Version') + ', expected ' + multiplex_version)
@@ -875,7 +875,7 @@ async function multiplex_fetch(url, params, skip_multiplex_method) {
                 } else if (!try_deleting.has(request)) {
                     try_deleting.add(request)
                     try {
-                        await braid_fetch(`${origin}/.well-known/multiplex/${multiplexer}/${request}`, {
+                        await braid_fetch(`${origin}/.well-known/multiplexer/${multiplexer}/${request}`, {
                             method: 'DELETE',
                             headers: { 'Multiplex-Version': multiplex_version }, retry: true
                         })
@@ -895,15 +895,15 @@ 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('multiplex-at'))
+            if ((await promise_done(mux_promise)) && (await mux_promise) === false && !params.headers.get('multiplex-through'))
                 return await normal_fetch(url, params)
 
             // 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)
+            var request = params.headers.get('multiplex-through')?.split('/')[4] ?? Math.random().toString(36).slice(2)
 
-            // add the Multiplex-At header without affecting the underlying params
+            // add the Multiplex-Through header without affecting the underlying params
             var mux_headers = new Headers(params.headers)
-            mux_headers.set('Multiplex-At', `/.well-known/multiplex/${multiplexer}/${request}`)
+            mux_headers.set('Multiplex-Through', `/.well-known/multiplexer/${multiplexer}/${request}`)
             mux_headers.set('Multiplex-Version', multiplex_version)
             params = {...params, headers: mux_headers}
 
@@ -940,7 +940,7 @@ async function multiplex_fetch(url, params, skip_multiplex_method) {
                 request_error = e
                 bytes_available()
                 try {
-                    var r = await braid_fetch(`${origin}${params.headers.get('multiplex-at')}`, {
+                    var r = await braid_fetch(`${origin}${params.headers.get('multiplex-through')}`, {
                         method: 'DELETE',
                         headers: { 'Multiplex-Version': multiplex_version }, retry: true
                     })
@@ -970,9 +970,9 @@ 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 request ' + params.headers.get('multiplex-at') + ', got status: ' + res.status)
+                if (res.status !== 293) throw new Error('Could not establish multiplexed request ' + params.headers.get('multiplex-through') + ', got status: ' + res.status)
 
-                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'))
+                if (res.headers.get('Multiplex-Version') !== multiplex_version) throw new Error('Could not establish multiplexed request ' + params.headers.get('multiplex-through') + ', 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",
@@ -1085,7 +1085,7 @@ 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|start) request ([A-Za-z0-9_-]+)\r\n$/)
+                        var m = headerStr.match(/^[\r\n]*((\d+) bytes for|close|start) response ([A-Za-z0-9_-]+)\r\n$/)
 
                         if (!m) throw new Error('invalid multiplex header')
                         request_id = m[3]

package/braid-http-server.js

@@ -245,7 +245,7 @@ function braidify (req, res, next) {
     // Multiplexer stuff
     var multiplex_version = '1.0'
     if ((braidify.enable_multiplex ?? true) &&
-        (req.method === 'MULTIPLEX' || req.url.startsWith('/.well-known/multiplex/')) &&
+        (req.method === 'MULTIPLEX' || req.url.startsWith('/.well-known/multiplexer/')) &&
         req.headers['multiplex-version'] === multiplex_version) {
 
         // let the caller know we're handling things
@@ -323,15 +323,15 @@ function braidify (req, res, next) {
         }
     }
 
-    // a Multiplex-At header means the user wants to send the
+    // a Multiplex-Through header means the user wants to send the
     // results of this request to the provided multiplexer,
     // tagged with the given request id
     if ((braidify.enable_multiplex ?? true) &&
-        req.headers['multiplex-at'] &&
+        req.headers['multiplex-through'] &&
         req.headers['multiplex-version'] === multiplex_version) {
 
         // parse the multiplexer id and request id from the header
-        var [multiplexer, request] = req.headers['multiplex-at'].split('/').slice(3)
+        var [multiplexer, request] = req.headers['multiplex-through'].split('/').slice(3)
 
         // find the multiplexer object (contains a response object)
         var m = braidify.multiplexers?.get(multiplexer)
@@ -340,7 +340,17 @@ function braidify (req, res, next) {
             return res.end(`multiplexer ${multiplexer} does not exist`)
         }
 
-        m.res.write(`start request ${request}\r\n`)
+        // if this request-id already exists, respond with an error
+        if (m.requests.has(request)) {
+            res.writeHead(409, 'Conflict', {'Content-Type': 'application/json'})
+            return res.end(JSON.stringify({
+                error: 'Request already exists',
+                message: `Cannot create duplicate request with ID '${request}'`,
+                details: 'This request ID must be unique'
+            }))
+        }
+
+        m.res.write(`start response ${request}\r\n`)
 
         // let the requester know we've multiplexed their response
         var og_stream = res.stream
@@ -363,7 +373,7 @@ function braidify (req, res, next) {
             if (og_stream) {
                 og_stream.respond({
                     ':status': 293,
-                    'Multiplex-At': req.headers['multiplex-at'],
+                    'Multiplex-Through': req.headers['multiplex-through'],
                     'Multiplex-Version': multiplex_version,
                     ...Object.fromEntries(cors_headers)
                 })
@@ -371,7 +381,7 @@ function braidify (req, res, next) {
                 og_stream.end()
             } else {
                 og_socket.write('HTTP/1.1 293 Responded via multiplexer\r\n')
-                og_socket.write(`Multiplex-At: ${req.headers['multiplex-at']}\r\n`)
+                og_socket.write(`Multiplex-Through: ${req.headers['multiplex-through']}\r\n`)
                 og_socket.write(`Multiplex-Version: ${multiplex_version}\r\n`)
                 cors_headers.forEach(([key, value]) =>
                     og_socket.write(`${key}: ${value}\r\n`))
@@ -397,14 +407,8 @@ function braidify (req, res, next) {
 
                 try {
                     var len = Buffer.isBuffer(chunk) ? chunk.length : Buffer.byteLength(chunk, encoding)
-                    this.multiplexer.res.write(`${len} bytes for request ${this.request}\r\n`)
+                    this.multiplexer.res.write(`${len} bytes for response ${this.request}\r\n`)
                     this.multiplexer.res.write(chunk, encoding, callback)
-
-                    // console.log(`wrote:`)
-                    // 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)
-
                 } catch (e) {
                     callback(e)
                 }
@@ -427,7 +431,7 @@ function braidify (req, res, next) {
 
         // 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 request ${request}\r\n`))
+        res2.on('finish', () => m.res.write(`close response ${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.42",
+  "version": "1.3.44",
   "description": "An implementation of Braid-HTTP for Node.js and Browsers",
   "scripts": {
     "test": "node test/server.js"