braid-http 1.3.48 → 1.3.50

package/braid-http-client.js

@@ -315,7 +315,7 @@ async function braid_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)
+                    res = await multiplex_fetch(url, params, mux_params, underlying_aborter)
                 } else
                     res = await normal_fetch(url, params)
 
@@ -830,9 +830,72 @@ function parse_body (state) {
     }
 }
 
+
+// The "extra_headers" field is returned to the client on any *update* or
+// *patch* to include any headers that we've received, but don't have braid
+// semantics for.
+//
+// This function creates that hash from a headers object, by filtering out all
+// known headers.
+function extra_headers (headers) {
+    // Clone headers
+    var result = Object.assign({}, headers)
+
+    // Remove the non-extra parts
+    var known_headers = ['version', 'parents', 'patches',
+                         'content-length', 'content-range', ':status']
+    for (var i = 0; i < known_headers.length; i++)
+        delete result[known_headers[i]]
+
+    // Return undefined if we deleted them all
+    if (Object.keys(result).length === 0)
+        return undefined
+
+    return result
+}
+
+function get_binary_length(x) {
+    return  x instanceof ArrayBuffer ? x.byteLength :
+            x instanceof Uint8Array ? x.length :
+            x instanceof Blob ? x.size : undefined
+}
+
+function deep_copy(x) {
+    if (x === null || typeof x !== 'object') return x
+    if (Array.isArray(x)) return x.map(x => deep_copy(x))
+    if (Object.prototype.toString.call(x) === '[object Object]')
+        return Object.fromEntries(Object.entries(x).map(([k, x]) => [k, deep_copy(x)]))
+    return x
+}
+
+function ascii_ify(s) {
+    return s.replace(/[^\x20-\x7E]/g, c => '\\u' + c.charCodeAt(0).toString(16).padStart(4, '0'))
+}
+
+function create_abort_error(msg) {
+    var e = new Error(msg)
+    e.name = 'AbortError'
+    return e
+}
+
+async function promise_done(promise) {
+    var pending = {}
+    var ret = await Promise.race([promise, Promise.resolve(pending)])
+    return ret !== pending
+}
+
+function random_base64url(n) {
+    return [...crypto.getRandomValues(new Uint8Array(n))].map(x => 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'[x % 64]).join('')
+}
+
+
+// ****************************
+// Multiplexing
+// ****************************
+
 // 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, mux_params) {
+async function multiplex_fetch(url, params, mux_params, aborter) {
     var multiplex_version = '1.0'
 
     var origin = new URL(url, typeof document !== 'undefined' ? document.baseURI : undefined).origin
@@ -894,7 +957,8 @@ async function multiplex_fetch(url, params, mux_params) {
                     })
                     if (r.status === 409) {
                         var e = await r.json()
-                        if (e.error === 'Multiplexer already exists') return cleanup(new Error(e.error))
+                        if (e.error === 'Multiplexer already exists')
+                            return cleanup(new Error(e.error))
                     }
                     if (!r.ok || r.headers.get('Multiplex-Version') !== multiplex_version)
                         throw 'bad'
@@ -908,7 +972,8 @@ async function multiplex_fetch(url, params, mux_params) {
                                                retry: true})
                         if (r.status === 409) {
                             var e = await r.json()
-                            if (e.error === 'Multiplexer already exists') return cleanup(new Error(e.error))
+                            if (e.error === 'Multiplexer already exists')
+                                return cleanup(new Error(e.error))
                         }
                         if (!r.ok) throw new Error('status not ok: ' + r.status)
                         if (r.headers.get('Multiplex-Version') !== multiplex_version)
@@ -919,13 +984,13 @@ async function multiplex_fetch(url, params, mux_params) {
                         // fallback to normal fetch if multiplexed connection fails
                         console.error(`Could not establish multiplexer.\n`
                                       + `Got error: ${e}.\nFalling back to normal connection.`)
-                        return cleanup(e, true)
+                        cleanup(e, true)
+                        return false
                     }
                 }
 
                 // parse the multiplexed stream,
                 // and send messages to the appropriate requests
-                var try_deleting = new Set()
                 parse_multiplex_stream(r.body.getReader(), async (request, bytes) => {
                     if (requests.has(request)) requests.get(request)(bytes)
                     else try_deleting_request(request)
@@ -935,6 +1000,14 @@ async function multiplex_fetch(url, params, mux_params) {
             // return a "fetch" for this multiplexer
             return async (url, params) => {
 
+                // 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-through'))
+                    return await normal_fetch(url, params)
+
                 // make up a new request id (unless it is being overriden)
                 var request = params.headers.get('multiplex-through')?.split('/')[4]
                     ?? random_base64url(Math.ceil((mux_params?.id_bits ?? 72) / 6))
@@ -966,8 +1039,10 @@ async function multiplex_fetch(url, params, mux_params) {
 
                 // 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)
+                    if (!bytes) {
+                        buffers.push(bytes)
+                        if (mux_error || request_error) aborter.abort()
+                    } else if (!mux_error) buffers.push(bytes)
                     bytes_available()
                 })
 
@@ -982,8 +1057,6 @@ async function multiplex_fetch(url, params, mux_params) {
 
                 // do the underlying fetch
                 try {
-                    var mux_was_done = await promise_done(mux_promise)
-
                     var res = await normal_fetch(url, params)
 
                     if (res.status === 409) {
@@ -991,7 +1064,7 @@ async function multiplex_fetch(url, params, mux_params) {
                         if (e.error === 'Request already multiplexed') throw new Error(e.error)
                     }
 
-                    if (res.status === 424 && !mux_was_done) {
+                    if (res.status === 424) {
                         // this error will trigger a retry if the user is using that option
                         throw new Error('multiplexer not yet connected')
                     }
@@ -1062,7 +1135,10 @@ async function multiplex_fetch(url, params, mux_params) {
                             try {
                                 await process_buffers(() => {
                                     var b = buffers.shift()
-                                    if (!b) return true
+                                    if (!b) {
+                                        if (mux_error || request_error) controller.error(mux_error || request_error)
+                                        return true
+                                    }
                                     controller.enqueue(b)
                                 })
                             } finally { controller.close() }
@@ -1081,7 +1157,7 @@ async function multiplex_fetch(url, params, mux_params) {
                 } catch (e) {
                     // if we had an error, be sure to unregister ourselves
                     unset(e)
-                    throw e
+                    throw mux_error || e
                 }
             }
         })()
@@ -1169,62 +1245,6 @@ function concat_buffers(buffers) {
     return x
 }
 
-// The "extra_headers" field is returned to the client on any *update* or
-// *patch* to include any headers that we've received, but don't have braid
-// semantics for.
-//
-// This function creates that hash from a headers object, by filtering out all
-// known headers.
-function extra_headers (headers) {
-    // Clone headers
-    var result = Object.assign({}, headers)
-
-    // Remove the non-extra parts
-    var known_headers = ['version', 'parents', 'patches',
-                         'content-length', 'content-range', ':status']
-    for (var i = 0; i < known_headers.length; i++)
-        delete result[known_headers[i]]
-
-    // Return undefined if we deleted them all
-    if (Object.keys(result).length === 0)
-        return undefined
-
-    return result
-}
-
-function get_binary_length(x) {
-    return  x instanceof ArrayBuffer ? x.byteLength :
-            x instanceof Uint8Array ? x.length :
-            x instanceof Blob ? x.size : undefined
-}
-
-function deep_copy(x) {
-    if (x === null || typeof x !== 'object') return x
-    if (Array.isArray(x)) return x.map(x => deep_copy(x))
-    if (Object.prototype.toString.call(x) === '[object Object]')
-        return Object.fromEntries(Object.entries(x).map(([k, x]) => [k, deep_copy(x)]))
-    return x
-}
-
-function ascii_ify(s) {
-    return s.replace(/[^\x20-\x7E]/g, c => '\\u' + c.charCodeAt(0).toString(16).padStart(4, '0'))
-}
-
-function create_abort_error(msg) {
-    var e = new Error(msg)
-    e.name = 'AbortError'
-    return e
-}
-
-async function promise_done(promise) {
-    var pending = {}
-    var ret = await Promise.race([promise, Promise.resolve(pending)])
-    return ret !== pending
-}
-
-function random_base64url(n) {
-    return [...crypto.getRandomValues(new Uint8Array(n))].map(x => 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'[x % 64]).join('')
-}
 
 // ****************************
 // Exports

package/package.json

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