braid-http 1.3.35 → 1.3.37

package/braid-http-client.js

@@ -306,14 +306,14 @@ async function braid_fetch (url, params = {}) {
 
                 // Now we run the original fetch....
 
-                // try multiplexing if either of these is true:
-                // - they explicitly want multiplexing
-                // - this is not the first subscription to the same origin
-                if (braid_fetch.use_multiplexing &&
+                // try multiplexing if the multiplex flag is set, and conditions are met
+                var mux_params = params.multiplex ?? braid_fetch.multiplex
+                if (mux_params !== false &&
                     (params.headers.has('multiplexer') ||
-                        (params.headers.has('subscribe') &&
-                            braid_fetch.subscription_counts?.[origin] > 1))) {
-                    res = await multiplex_fetch(url, params)
+                    (params.headers.has('subscribe') &&
+                        braid_fetch.subscription_counts?.[origin] >
+                            (!mux_params ? 1 : (mux_params.after ?? 0))))) {
+                    res = await multiplex_fetch(url, params, mux_params?.via === 'POST')
                 } else {
                     res = await normal_fetch(url, params)
                 }
@@ -827,24 +827,18 @@ 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.
-//
-// This function assumes a header in params called 'multiplexer' with a value
-// that looks like /multiplexer_id/stream_id. It creates a multiplexer if it
-// doesn't exist already, then performs a fetch providing the multiplexer header.
-// This tells the server to send the results to the given multiplexer.
-//
-async function multiplex_fetch(url, params) {
+async function multiplex_fetch(url, params, skip_multiplex_method) {
     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
+    var mux_key = params.headers.get('multiplexer')?.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('/')[1] ?? Math.random().toString(36).slice(2)
+        var multiplexer = params.headers.get('multiplexer')?.split('/')[3] ?? Math.random().toString(36).slice(2)
 
         var streams = new Map()
         var mux_error = null
@@ -852,14 +846,14 @@ async function multiplex_fetch(url, params) {
         var mux_promise = (async () => {
             // attempt to establish a multiplexed connection
             try {
-                if (params.use_multiplex_well_known_url) throw 'skip to trying header'
+                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'
             } 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}`, {headers: {'Multiplex-Version': '0.0.1'}, retry: true})
+                    r = await braid_fetch(`${origin}/.well-known/multiplex/${multiplexer}`, {method: 'POST', headers: {'Multiplex-Version': '0.0.1'}, 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')
@@ -892,11 +886,11 @@ async function multiplex_fetch(url, params) {
                 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)
+            var stream = params.headers.get('multiplexer')?.split('/')[4] ?? 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}`)
+            mux_headers.set('Multiplexer', `/.well-known/multiplex/${multiplexer}/${stream}`)
             mux_headers.set('Multiplex-Version', '0.0.1')
             params = {...params, headers: mux_headers}
 
@@ -935,7 +929,7 @@ async function multiplex_fetch(url, params) {
                 stream_error = e
                 bytes_available()
                 try {
-                    var r = await braid_fetch(`${origin}/.well-known/multiplex${params.headers.get('multiplexer')}`, {
+                    var r = await braid_fetch(`${origin}${params.headers.get('multiplexer')}`, {
                         method: 'DELETE',
                         headers: { 'Multiplex-Version': '0.0.1' }, retry: true
                     })

package/braid-http-server.js

@@ -247,6 +247,14 @@ function braidify (req, res, next) {
         (req.method === 'MULTIPLEX' || req.url.startsWith('/.well-known/multiplex/')) &&
         req.headers['multiplex-version'] === '0.0.1') {
 
+        // let the caller know we're handling things
+        req.is_multiplexer = res.is_multiplexer = true
+
+        // free the cors
+        res.setHeader("Access-Control-Allow-Origin", "*")
+        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)
 
@@ -265,7 +273,7 @@ function braidify (req, res, next) {
 
             // keep the connection open,
             // so people can send multiplexed data to it
-            res.writeHead(200, {
+            res.writeHead(200, 'OK', {
                 'Multiplex-Version': '0.0.1',
                 'Incremental': '?1',
                 'Cache-Control': 'no-cache',
@@ -282,15 +290,15 @@ function braidify (req, res, next) {
             // if the multiplexer doesn't exist, send an error
             var m = braidify.multiplexers?.get(multiplexer)
             if (!m) {
-                res.writeHead(400, {'Content-Type': 'text/plain'})
-                return res.end(`multiplexer /${multiplexer} does not exist`)
+                res.writeHead(422, 'Multiplexer no exist', {'Bad-Multiplexer': multiplexer})
+                return res.end(`multiplexer ${multiplexer} does not exist`)
             }
 
             // if the stream doesn't exist, send an error
             let s = m.streams.get(stream)
             if (!s) {
-                res.writeHead(400, {'Content-Type': 'text/plain'})
-                return res.end(`stream /${multiplexer}/${stream} does not exist`)
+                res.writeHead(422, 'Stream no exist', {'Bad-Stream': stream})
+                return res.end(`stream ${stream} does not exist`)
             }
 
             // remove this stream, and notify it
@@ -298,7 +306,7 @@ function braidify (req, res, next) {
             s()
 
             // let the requester know we succeeded
-            res.writeHead(200, { 'Multiplex-Version': '0.0.1' })
+            res.writeHead(200, 'OK', { 'Multiplex-Version': '0.0.1' })
             return res.end(``)
         }
     }
@@ -310,23 +318,54 @@ function braidify (req, res, next) {
         req.headers.multiplexer &&
         req.headers['multiplex-version'] === '0.0.1') {
 
-        // parse the multiplexer id and stream id from the url
-        var [multiplexer, stream] = req.headers.multiplexer.slice(1).split('/')
+        // parse the multiplexer id and stream id from the header
+        var [multiplexer, stream] = req.headers.multiplexer.split('/').slice(3)
 
         // find the multiplexer object (contains a response object)
         var m = braidify.multiplexers?.get(multiplexer)
         if (!m) {
-            // 422 = Unprocessable Entity (but good syntax!)
-            res.writeHead(422, {Multiplexer: `/${multiplexer}`})
-            res.end(`multiplexer ${multiplexer} does not exist`)
+            res.writeHead(422, 'Multiplexer no exist', {'Bad-Multiplexer': multiplexer})
+            return res.end(`multiplexer ${multiplexer} does not exist`)
         }
 
         // let the requester know we've multiplexed their response
-        res.writeHead(293, {
-            multiplexer: req.headers.multiplexer,
-            'Multiplex-Version': '0.0.1'
-        })
-        res.end('Ok.')
+        var og_stream = res.stream
+        var og_socket = res.socket
+        var og_res_end = () => {
+            og_res_end = null
+            if (!braidify.cors_headers) braidify.cors_headers = new Set([
+                'Access-Control-Allow-Origin',
+                'Access-Control-Allow-Methods',
+                'Access-Control-Allow-Headers',
+                'Access-Control-Allow-Credentials',
+                'Access-Control-Expose-Headers',
+                'Access-Control-Max-Age'
+            ].map(x => x.toLowerCase()))
+
+            // copy any CORS headers from the user
+            var cors_headers = Object.entries(res.getHeaders()).
+                filter(x => braidify.cors_headers.has(x.key))
+
+            if (og_stream) {
+                og_stream.respond({
+                    ':status': 293,
+                    Multiplexer: req.headers.multiplexer,
+                    'Multiplex-Version': '0.0.1',
+                    ...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`)
+                cors_headers.forEach(([key, value]) =>
+                    og_socket.write(`${key}: ${value}\r\n`))
+                og_socket.write('\r\n')
+                og_socket.write('Ok.')
+                og_socket.end()
+            }
+        }
 
         // and now set things up so that future use of the
         // response object forwards stuff into the multiplexer
@@ -340,6 +379,8 @@ function braidify (req, res, next) {
             }
 
             _write(chunk, encoding, callback) {
+                og_res_end?.()
+
                 try {
                     var len = Buffer.isBuffer(chunk) ? chunk.length : Buffer.byteLength(chunk, encoding)
                     this.multiplexer.res.write(`${len} bytes for stream ${this.stream}\r\n`)
@@ -365,7 +406,10 @@ function braidify (req, res, next) {
 
         // register a handler for when the multiplexer closes,
         // to close our fake response stream
-        m.streams.set(stream, () => res2.destroy())
+        m.streams.set(stream, () => {
+            og_res_end?.()
+            res2.destroy()
+        })
 
         // when our fake response is done,
         // we want to send a special message to the multiplexer saying so
@@ -384,22 +428,6 @@ function braidify (req, res, next) {
                 // 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
@@ -418,21 +446,8 @@ 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
+        res.multiplexer = m.res
     }
 
     // Add the braidly request/response helper methods

package/package.json

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