braid-http 1.1.1 → 1.3.0

package/braid-http-client.js

@@ -189,18 +189,31 @@ async function braid_fetch (url, params = {}) {
         if (params.patches.length === 1) {
             let patch = params.patches[0]
             params.headers.set('Content-Range', `${patch.unit} ${patch.range}`)
-            params.headers.set('Content-Length', `${(new TextEncoder().encode(patch.content)).length}`)
+
+            if (typeof patch.content === 'string')
+                patch.content = new TextEncoder().encode(patch.content)
+
             params.body = patch.content
         }
 
         // Multiple patches get sent within a Patches: N block
         else {
             params.headers.set('Patches', params.patches.length)
-            params.body = (params.patches).map(patch => {
-                var length = `content-length: ${(new TextEncoder().encode(patch.content)).length}`
+            let bufs = []
+            let te = new TextEncoder()
+            for (let patch of params.patches) {
+                if (bufs.length) bufs.push(te.encode(`\r\n`))
+
+                if (typeof patch.content === 'string')
+                    patch.content = te.encode(patch.content)
+
+                var length = `content-length: ${get_binary_length(patch.content)}`
                 var range = `content-range: ${patch.unit} ${patch.range}`
-                return `${length}\r\n${range}\r\n\r\n${patch.content}\r\n`
-            }).join('\r\n')
+                bufs.push(te.encode(`${length}\r\n${range}\r\n\r\n`))
+                bufs.push(patch.content)
+                bufs.push(te.encode(`\r\n`))
+            }
+            params.body = new Blob(bufs)
         }
     }
 
@@ -306,10 +319,13 @@ async function braid_fetch (url, params = {}) {
                         // Each time something happens, we'll either get a new
                         // version back, or an error.
                         (result, err) => {
-                            if (!err)
+                            if (!err) {
+                                // check whether we aborted
+                                if (original_signal?.aborted) throw new DOMException('already aborted', 'AbortError')
+
                                 // Yay!  We got a new version!  Tell the callback!
                                 cb(result)
-                            else
+                            } else
                                 // This error handling code runs if the connection
                                 // closes, or if there is unparseable stuff in the
                                 // streamed response.
@@ -486,7 +502,18 @@ var subscription_parser = (cb) => ({
                     }
                 })
 
-                this.cb(update)
+                for (let p of update.patches ?? []) {
+                    Object.defineProperty(p, 'content_text', {
+                        get: () => new TextDecoder('utf-8').decode(p.content)
+                    })
+                }
+
+                try {
+                    this.cb(update)
+                } catch (e) {
+                    this.cb(null, e)
+                    return
+                }
 
                 // Reset the parser for the next version!
                 this.state = {input: this.state.input}
@@ -551,6 +578,15 @@ function parse_headers (input) {
     var h = extractHeader(input)
     if (!h) return {result: 'waiting'}
 
+    // Skip "HTTP 104 Multiresponse"
+    if (h.header_string.startsWith('HTTP 104')) {
+        h = extractHeader(h.remaining_bytes)
+        if (!h) return {result: 'waiting'}
+    }
+
+    // Skip "HTTP 200 OK"
+    h.header_string = h.header_string.replace(/^HTTP 200.*\r?\n/, '')
+
     var headers_source = h.header_string
     var headers_length = headers_source.length
     
@@ -629,7 +665,7 @@ function parse_body (state) {
             state.patches = [{
                 unit: match.unit,
                 range: match.range,
-                content: (new TextDecoder('utf-8')).decode(new Uint8Array(state.input.slice(0, content_length))),
+                content: new Uint8Array(state.input.slice(0, content_length)),
 
                 // Question: Perhaps we should include headers here, like we do for
                 // the Patches: N headers below?
@@ -715,7 +751,7 @@ function parse_body (state) {
 
                 last_patch.unit = match.unit
                 last_patch.range = match.range
-                last_patch.content = (new TextDecoder('utf-8')).decode(new Uint8Array(state.input.slice(0, content_length)))
+                last_patch.content = new Uint8Array(state.input.slice(0, content_length))
                 last_patch.extra_headers = extra_headers(last_patch.headers)
                 delete last_patch.headers  // We only keep the extra headers ^^
 
@@ -811,6 +847,12 @@ function extractHeader(input) {
     };
 }
 
+function get_binary_length(x) {
+    return  x instanceof ArrayBuffer ? x.byteLength :
+            x instanceof Uint8Array ? x.length :
+            x instanceof Blob ? x.size : undefined
+}
+
 // ****************************
 // Exports
 // ****************************

package/braid-http-server.js

@@ -1,6 +1,6 @@
 var assert = require('assert')
 
-// Return a string of patches in pseudoheader format.
+// Writes patches in pseudoheader format.
 //
 //   The `patches` argument can be:
 //     - Array of patches
@@ -25,9 +25,7 @@ var assert = require('assert')
 //
 //       {"some": "json object"}
 //
-function generate_patches(res, patches) {
-    var result = ''
-
+function write_patches(res, patches) {
     // `patches` must be a patch object or an array of patch objects
     //  - Object:  {unit, range, content}
     //  - Array:  [{unit, range, content}, ...]
@@ -38,7 +36,7 @@ function generate_patches(res, patches) {
     if (Array.isArray(patches)) {
 
         // Add `Patches: N` header if array
-        result += `Patches: ${patches.length}\r\n\r\n`
+        res.write(`Patches: ${patches.length}\r\n\r\n`)
     } else
         // Else, we'll out put a single patch
         patches = [patches]
@@ -47,29 +45,35 @@ function generate_patches(res, patches) {
     patches.forEach((patch, i) => {
         assert(typeof patch.unit    === 'string')
         assert(typeof patch.range   === 'string')
-        assert(typeof patch.content === 'string')
+
+        if (typeof patch.content === 'string')
+            patch.content = new TextEncoder().encode(patch.content)
 
         if (i > 0)
-            result += '\r\n\r\n'
+            res.write('\r\n\r\n')
 
         let extra_headers = Object.fromEntries(Object.entries(patch).filter(([k, v]) => k != 'unit' && k != 'range' && k != 'content'))
 
-        result += `Content-Length: ${(new TextEncoder().encode(patch.content)).length}\r
+        res.write(`Content-Length: ${get_binary_length(patch.content)}\r
 Content-Range: ${patch.unit} ${patch.range}\r
 ${Object.entries(extra_headers).map(([k, v]) => `${k}: ${v}\r\n`).join('')}\r
-${patch.content}`
+`)
+        write_binary(res, patch.content)
     })
-    return result
 }
 
 
 // Deprecated method for legacy support
 function parse_patches (req, cb) {
     parse_update(req, update => {
-        if (typeof update.body === 'string')
+        if (update.body != null) {
             // Return body as an "everything" patch
-            cb([{unit: 'everything', range: '', content: update.body}])
-        else
+            let patch = {unit: 'everything', range: '', content: update.body}
+            Object.defineProperty(patch, 'content_text', {
+                get: () => new TextDecoder('utf-8').decode(patch.content)
+            })
+            cb([patch])
+        } else
             cb(update.patches)
     })
 }
@@ -80,16 +84,20 @@ function parse_update (req, cb) {
     var num_patches = req.headers.patches
 
     if (!num_patches && !req.headers['content-range']) {
-        var body = ''
-        req.on('data', chunk => {body += chunk.toString()})
+        var buffer = []
+        req.on('data', chunk => buffer.push(chunk))
         req.on('end', () => {
-            cb({ body, patches: undefined })
+            let body = new Uint8Array(Buffer.concat(buffer))
+            let update = { body, patches: undefined }
+            Object.defineProperty(update, 'body_text', {
+                get: () => new TextDecoder('utf-8').decode(update.body)
+            })
+            cb(update)
         })
     }
 
     // Parse a single patch, lacking Patches: N
     else if (num_patches === undefined && req.headers['content-range']) {
-
         // We only support range patches right now, so there must be a
         // Content-Range header.
         assert(req.headers['content-range'], 'No patches to parse: need `Patches: N` or `Content-Range:` header in ' + JSON.stringify(req.headers))
@@ -104,8 +112,11 @@ function parse_update (req, cb) {
         req.on('data', chunk => buffer.push(chunk))
         // Then return it
         req.on('end', () => {
-            patches = [{unit, range, content: Buffer.concat(buffer).toString('utf8')}]
-            cb({ patches, body: undefined })
+            let patch = {unit, range, content: new Uint8Array(Buffer.concat(buffer))}
+            Object.defineProperty(patch, 'content_text', {
+                get: () => new TextDecoder('utf-8').decode(patch.content)
+            })
+            cb({ patches: [patch], body: undefined })
         })
     }
 
@@ -136,7 +147,7 @@ function parse_update (req, cb) {
                 if (!('content-length' in headers)) {
                     // Print a nice error if it's missing
                     console.error('No content-length in', JSON.stringify(headers),
-                                  'from', {buffer})
+                                  'from', new TextDecoder().decode(new Uint8Array(buffer)), {buffer})
                     process.exit(1)
                 }
 
@@ -150,10 +161,14 @@ function parse_update (req, cb) {
 
                 // Content-range is of the form '<unit> <range>' e.g. 'json .index'
                 var [unit, range] = parse_content_range(headers['content-range'])
-                var patch_content = new TextDecoder('utf-8').decode(new Uint8Array(h.remaining_bytes.slice(0, body_length)))
+                var patch_content = new Uint8Array(h.remaining_bytes.slice(0, body_length))
 
                 // We've got our patch!
-                patches.push({unit, range, content: patch_content})
+                let patch = {unit, range, content: patch_content}
+                Object.defineProperty(patch, 'content_text', {
+                    get: () => new TextDecoder('utf-8').decode(patch.content)
+                })
+                patches.push(patch)
 
                 buffer = h.remaining_bytes.slice(body_length)
             }
@@ -215,7 +230,7 @@ function braidify (req, res, next) {
         (done, err) => parse_patches(
             req,
             (patches) => done(patches.map(
-                p => ({...p, content: JSON.parse(p.content)})
+                p => ({...p, content: JSON.parse(p.content_text)})
             ))
         )
     )
@@ -297,7 +312,7 @@ function braidify (req, res, next) {
     next && next()
 }
 
-function send_update(res, data, url, peer) {
+async function send_update(res, data, url, peer) {
     var {version, parents, patches, patch, body} = data
 
     function set_header (key, val) {
@@ -308,7 +323,7 @@ function send_update(res, data, url, peer) {
     }
     function write_body (body) {
         if (res.isSubscription) res.write('\r\n')
-        res.write(body)
+        write_binary(res, body)
     }
 
     // console.log('sending version', {url, peer, version, parents, patches, body,
@@ -316,14 +331,10 @@ function send_update(res, data, url, peer) {
 
     // Validate that the body and patches are strings,
     // or in the case of body, it could be binary
-    if (body !== undefined)
-        assert(typeof body === 'string' ||
-            body instanceof ArrayBuffer ||
-            body instanceof Uint8Array ||
-            body instanceof Blob ||
-            body instanceof Buffer
-        )
-    else {
+    if (body !== undefined) {
+        assert(typeof body === 'string' || get_binary_length(body) != null)
+        if (body instanceof Blob) body = await body.arrayBuffer()
+    } else {
         // Only one of patch or patches can be set
         assert(!(patch && patches))
         assert((patch || patches) !== undefined)
@@ -339,23 +350,31 @@ function send_update(res, data, url, peer) {
 
         // Now `patches` will be an array of patches or a single patch object.
         //
-        // This distinction is used in generate_patches() to determine whether
+        // This distinction is used in write_patches() to determine whether
         // to inline a single patch in the update body vs. writing out a
         // Patches: N block.
         assert(typeof patches === 'object')
-        if (Array.isArray(patches))
-            patches.forEach(p => {
-                assert('unit' in p)
-                assert('range' in p)
-                assert('content' in p)
-                assert(typeof p.content === 'string')
-            })
+        for (let p of Array.isArray(patches) ? patches : [patch]) {
+            assert('unit' in p)
+            assert('range' in p)
+            assert('content' in p)
+            assert(typeof p.content === 'string' || get_binary_length(p.content) != null)
+            if (p.content instanceof Blob) p.content = await p.content.arrayBuffer()
+        }
     }
 
     var body_exists = body || body === ''
     assert(body_exists || patches, 'Missing body or patches')
     assert(!(body_exists && patches), 'Cannot send both body and patches')
 
+    // Write the beginning of a new multiresponse response
+    if (!res.wrote_104_multiresponse) {
+        res.write(`HTTP 104 Multiresponse\r\n\r\n`)
+        res.wrote_104_multiresponse = true
+    }
+
+    res.write(`HTTP 200 OK\r\n`)
+
     // Write the headers or virtual headers
     for (var [header, value] of Object.entries(data)) {
         header = header.toLowerCase()
@@ -384,14 +403,10 @@ function send_update(res, data, url, peer) {
     // Write the patches or body
     if (body_exists) {
         let x = typeof body === 'string' ? new TextEncoder().encode(body) : body
-        set_header('Content-Length',
-            x instanceof ArrayBuffer ? x.byteLength :
-            x instanceof Uint8Array ? x.length :
-            x instanceof Blob ? x.size :
-            x instanceof Buffer ? x.length : null)
+        set_header('Content-Length', get_binary_length(x))
         write_body(x)
     } else
-        res.write(generate_patches(res, patches))
+        write_patches(res, patches)
 
     // Add a newline to prepare for the next version
     // See also https://github.com/braid-org/braid-spec/issues/73
@@ -461,4 +476,16 @@ function extractHeader(input) {
     };
 }
 
+function get_binary_length(x) {
+    return  x instanceof ArrayBuffer ? x.byteLength :
+            x instanceof Uint8Array ? x.length :
+            x instanceof Blob ? x.size :
+            x instanceof Buffer ? x.length : undefined
+}
+
+function write_binary(res, body) {
+    if (body instanceof ArrayBuffer) body = new Uint8Array(body)
+    res.write(body)
+}
+
 module.exports = braidify

package/package.json

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