braid-http 1.3.49 → 1.3.51

package/braid-http-client.js

@@ -266,9 +266,13 @@ async function braid_fetch (url, params = {}) {
                 // see if we should retry..
                 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 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
+                    !e.dont_retry &&           // some errors are unlikely to be fixed by retrying
+                    !cb_running                // if an error is thrown in the callback,
+                                               // then it may not be good to reconnect, and generate more errors
+
+                // some errors can be fixed by changing something, and retrying right away,
+                // for instance, for a duplicate multiplexer request id
+                if (e.dont_wait) waitTime = 0
 
                 if (retry && !original_signal?.aborted) {
                     // retry after some time..
@@ -278,7 +282,7 @@ async function braid_fetch (url, params = {}) {
                 } else {
                     // if we would have retried except that original_signal?.aborted,
                     // then we want to return that as the error..
-                    if (retry && original_signal?.aborted) e = create_abort_error('already aborted')
+                    if (retry && original_signal?.aborted) e = create_error('already aborted', {name: 'AbortError'})
 
                     // let people know things are shutting down..
                     subscription_counts_on_close?.()
@@ -288,7 +292,7 @@ async function braid_fetch (url, params = {}) {
             }
 
             try {
-                if (original_signal?.aborted) throw create_abort_error('already aborted')
+                if (original_signal?.aborted) throw create_error('already aborted', {name: 'AbortError'})
 
                 // We need a fresh underlying abort controller each time we connect
                 underlying_aborter = new AbortController()
@@ -304,7 +308,7 @@ async function braid_fetch (url, params = {}) {
                 // undocumented feature used by braid-chrome
                 // to see the fetch args as they are right before it is actually called,
                 // to display them for the user in the dev panel
-                params.onFetch?.(url, params)
+                params.onFetch?.(url, params, underlying_aborter)
 
                 // Now we run the original fetch....
 
@@ -315,7 +319,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)
 
@@ -363,7 +367,7 @@ async function braid_fetch (url, params = {}) {
                             if (!err) {
                                 // check whether we aborted
                                 if (original_signal?.aborted)
-                                    throw create_abort_error('already aborted')
+                                    throw create_error('already aborted', {name: 'AbortError'})
 
                                 // Yay!  We got a new version!  Tell the callback!
                                 cb_running = true
@@ -442,19 +446,16 @@ async function braid_fetch (url, params = {}) {
                             give_up = false
                     }
                     if (give_up) {
-                        let e = new Error(`giving up because of http status: ${res.status}${(res.status === 401 || res.status === 403) ? ` (access denied)` : ''}`)
-                        subscription_error?.(e)
-                        return fail(e)
-                    }
-                    if (!res.ok) throw new Error(`status not ok: ${res.status}`)
+                        if (subscription_cb) subscription_error?.(new Error(`giving up because of http status: ${res.status}${(res.status === 401 || res.status === 403) ? ` (access denied)` : ''}`))
+                    } else if (!res.ok) throw new Error(`status not ok: ${res.status}`)
                 }
 
-                if (subscription_cb) start_subscription(subscription_cb, subscription_error)
-
-                done(res)
+                if (subscription_cb && res.ok) start_subscription(subscription_cb, subscription_error)
 
                 params?.retry?.onRes?.(res)
                 waitTime = 1
+
+                done(res)
             } catch (e) { on_error(e) }
         }
     })
@@ -566,7 +567,7 @@ var subscription_parser = (cb) => ({
 
             // Or maybe there's an error to report upstream
             else if (this.state.result === 'error') {
-                await this.cb(null, this.state.message)
+                await this.cb(null, create_error(this.state.message, {dont_retry: true}))
                 return
             }
 
@@ -830,9 +831,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_error(msg, override) {
+    var e = new Error(msg)
+    if (override) Object.assign(e, override)
+    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 +958,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(create_error(e.error, {dont_wait: true}))
                     }
                     if (!r.ok || r.headers.get('Multiplex-Version') !== multiplex_version)
                         throw 'bad'
@@ -908,7 +973,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(create_error(e.error, {dont_wait: true}))
                         }
                         if (!r.ok) throw new Error('status not ok: ' + r.status)
                         if (r.headers.get('Multiplex-Version') !== multiplex_version)
@@ -938,7 +1004,9 @@ async function multiplex_fetch(url, params, mux_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'))
+                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)
@@ -972,8 +1040,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()
                 })
 
@@ -991,13 +1061,20 @@ async function multiplex_fetch(url, params, mux_params) {
                     var res = await normal_fetch(url, params)
 
                     if (res.status === 409) {
-                        var e = await r.json()
-                        if (e.error === 'Request already multiplexed') throw new Error(e.error)
+                        var e = await res.json()
+                        if (e.error === 'Request already multiplexed') {
+                            // the id is already in use,
+                            // so we want to retry right away with a different id
+                            throw create_error(e.error, {dont_wait: true})
+                        }
                     }
 
                     if (res.status === 424) {
-                        // this error will trigger a retry if the user is using that option
-                        throw new Error('multiplexer not yet connected')
+                        // the multiplexer isn't there,
+                        // could be we arrived before the multiplexer,
+                        // or after it was shutdown;
+                        // in either case we want to retry right away
+                        throw create_error('multiplexer not connected', {dont_wait: true})
                     }
 
                     // if the response says it's ok,
@@ -1006,21 +1083,23 @@ async function multiplex_fetch(url, params, mux_params) {
                     if (res.ok && res.status !== 293) return res
 
                     if (res.status !== 293)
-                        throw new Error('Could not establish multiplexed request '
-                                        + params.headers.get('multiplex-through')
-                                        + ', got status: ' + res.status)
+                        throw create_error('Could not establish multiplexed request '
+                                           + params.headers.get('multiplex-through')
+                                           + ', got status: ' + res.status,
+                                           { dont_retry: true })
 
                     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'))
+                        throw create_error('Could not establish multiplexed request '
+                                           + params.headers.get('multiplex-through')
+                                           + ', got unknown version: '
+                                           + res.headers.get('Multiplex-Version'),
+                                           { dont_retry: true })
 
                     // 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 request
-                    params.signal?.addEventListener('abort', () =>
-                        unset(create_abort_error('request aborted')))
+                    params.signal.addEventListener('abort', () =>
+                        unset(create_error('request aborted', {name: 'AbortError'})))
 
                     // first, we need to listen for the headers..
                     var headers_buffer = new Uint8Array()
@@ -1069,6 +1148,8 @@ async function multiplex_fetch(url, params, mux_params) {
                                     if (!b) return true
                                     controller.enqueue(b)
                                 })
+                            } catch (e) {
+                                controller.error(e)
                             } finally { controller.close() }
                         }
                     }), {
@@ -1085,7 +1166,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
                 }
             }
         })()
@@ -1173,62 +1254,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.49",
+  "version": "1.3.51",
   "description": "An implementation of Braid-HTTP for Node.js and Browsers",
   "scripts": {
     "test": "node test/server.js"