braid-http 1.3.10 → 1.3.12

package/braid-http-client.js

@@ -592,10 +592,11 @@ function parse_headers (input) {
     }
 
     // Extract the header string
-    var headers_source = new TextDecoder('utf-8').decode(new Uint8Array(input.slice(start, end)))
+    var headers_source = input.slice(start, end).map(x => String.fromCharCode(x)).join('')
 
     // Convert "HTTP 200 OK" to a :status: 200 header
-    headers_source = headers_source.replace(/^HTTP\/?\d*\.?\d* (\d\d\d).*\r?\n/, ':status: $1\r\n')
+    headers_source = headers_source.replace(/^HTTP\/?\d*\.?\d* (\d\d\d).*\r?\n/,
+                                            ':status: $1\r\n')
 
     var headers_length = headers_source.length
     
@@ -728,18 +729,21 @@ function parse_body (state) {
 
             // Parse Range Patch format
             {
+                var to_text = (bytes) =>
+                    new TextDecoder('utf-8').decode(new Uint8Array(bytes))
+
                 if (!('content-length' in last_patch.headers))
                     return {
                         result: 'error',
                         message: 'no content-length in patch',
-                        patch: last_patch, input: (new TextDecoder('utf-8')).decode(new Uint8Array(state.input))
+                        patch: last_patch, input: to_text(state.input)
                     }
 
                 if (!('content-range' in last_patch.headers))
                     return {
                         result: 'error',
                         message: 'no content-range in patch',
-                        patch: last_patch, input: (new TextDecoder('utf-8')).decode(new Uint8Array(state.input))
+                        patch: last_patch, input: to_text(state.input)
                     }
 
                 var content_length = parseInt(last_patch.headers['content-length'])
@@ -755,7 +759,7 @@ function parse_body (state) {
                     return {
                         result: 'error',
                         message: 'cannot parse content-range in patch',
-                        patch: last_patch, input: (new TextDecoder('utf-8')).decode(new Uint8Array(state.input))
+                        patch: last_patch, input: to_text(state.input)
                     }
 
                 last_patch.unit = match.unit

package/braid-http-server.js

@@ -25,11 +25,15 @@ var assert = require('assert')
 //
 //       {"some": "json object"}
 //
-function write_patches(res, patches) {
+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}, ...]
 
+    if (typeof patches !== 'object')
+        console.error('We got bad patches!', {patches})
+
+    assert(patches)
     assert(typeof patches === 'object')  // An array is also an object
 
     // An array of one patch behaves like a single patch
@@ -46,19 +50,29 @@ function write_patches(res, patches) {
         assert(typeof patch.unit    === 'string')
         assert(typeof patch.range   === 'string')
 
-        if (typeof patch.content === 'string')
-            patch.content = new TextEncoder().encode(patch.content)
-
         if (i > 0)
             res.write('\r\n\r\n')
 
-        let extra_headers = Object.fromEntries(Object.entries(patch).filter(([k, v]) => k != 'unit' && k != 'range' && k != 'content'))
+        // Use a slick object_destructuring line to extract the extra_headers
+        var {unit, range, content, ...extra_headers} = patch
+
+        // Binarize the patch content
+        var binary_content = (typeof patch.content === 'string'
+                              ? new TextEncoder().encode(patch.content)
+                              : patch.content)
+
+        // Write the basic headers
+        res.write('Content-Length: ' + get_binary_length(binary_content) + '\r\n'
+                  + 'Content-Range: ' + patch.unit + ' ' + patch.range + '\r\n')
+
+        // Write the extra headers:
+        for (var header in extra_headers)
+            res.write(`${header}: ${extra_headers[header]}\r\n`)
+
+        res.write('\r\n')
 
-        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
-`)
-        write_binary(res, patch.content)
+        // Write the patch content
+        write_binary(res, binary_content)
     })
 }
 
@@ -150,7 +164,7 @@ function parse_update (req, cb) {
                 }
 
                 // Extract the header string
-                let headers_source = new TextDecoder('utf-8').decode(new Uint8Array(buffer.slice(s, e)))
+                let headers_source = buffer.slice(s, e).map(x => String.fromCharCode(x)).join('')
 
                 // Now let's parse those headers.
                 var headers = require('parse-headers')(headers_source)
@@ -345,29 +359,27 @@ async function send_update(res, data, url, peer) {
         write_binary(res, body)
     }
 
-    // console.log('sending version', {url, peer, version, parents, patches, body,
-    //                                 subscription: res.isSubscription})
+    // console.log('Sending Update', {url, peer, data, subscription: res.isSubscription})
 
-    // Validate that the body and patches are strings,
-    // or in the case of body, it could be binary
+    // Validate the body and patches
+    assert(!(patch && patches),
+           'sendUpdate: cannot have both `update.patch` and `update.patches` set')
+    if (patch)
+        patches = [patch]
+    assert(!(body && patches),
+           'sendUpdate: cannot have both `update.body` and `update.patch(es)')
+    assert(!patches || Array.isArray(patches),
+           'sendUpdate: `patches` provided is not array')
+
+    // Validate body format
     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)
-        assert((patch || patches) !== null)
-
-        // Patches must be an array
-        if (patches)
-            assert(Array.isArray(patches))
-
-        // But if using `patch`, then we set `patches` to just that object
-        if (patch)
-            patches = patch
+    }
 
-        // Now `patches` will be an array of patches or a single patch object.
+    // Validate patches format
+    if (patches !== undefined) {
+        // Now `patches` will be an array of patches
         //
         // This distinction is used in write_patches() to determine whether
         // to inline a single patch in the update body vs. writing out a
@@ -377,16 +389,21 @@ async function send_update(res, data, url, peer) {
             assert('unit' in p)
             assert('range' in p)
             assert('content' in p)
-            assert(typeof p.content === 'string' || get_binary_length(p.content) != null)
+            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')
+    // To send a response without a body, we just send an empty body
+    if (!patches && !body)
+        body = ''
 
-    if (res.isSubscription) res.write(`HTTP ${status} OK\r\n`)
+    var reason =
+        status === 200 ? 'OK'
+        : 404 ? 'Not Found'
+        : 'Unknown'
+    if (res.isSubscription) res.write(`HTTP ${status} ${reason}\r\n`)
 
     // Write the headers or virtual headers
     for (var [header, value] of Object.entries(data)) {
@@ -396,6 +413,10 @@ async function send_update(res, data, url, peer) {
         if (value === undefined)
             continue
 
+        // Status headers are set in the status line (above)
+        if (header === 'status')
+            continue
+
         // Version and Parents get output in the Structured Headers format,
         // so we convert `value` from array to comma-separated strings.
         if (header === 'version') {
@@ -414,10 +435,12 @@ async 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', get_binary_length(x))
-        write_body(x)
+    if (body || body === '') {
+        let binary = typeof body === 'string' ? new TextEncoder().encode(body) : body,
+            length = get_binary_length(binary)
+        assert(length !== undefined && length !== 'undefined')
+        set_header('Content-Length', length)
+        write_body(binary)
     } else
         write_patches(res, patches)
 

package/package.json

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