braid-text 0.2.32 → 0.2.34

package/index.js

@@ -112,6 +112,7 @@ braid_text.serve = async (req, res, options = {}) => {
                 version: req.version,
                 parents: req.parents,
                 merge_type,
+                transfer_encoding: req.headers['accept-transfer-encoding'],
                 subscribe: x => res.sendVersion(x),
                 write: (x) => res.write(x)
             }
@@ -180,7 +181,10 @@ braid_text.serve = async (req, res, options = {}) => {
                 // we want to send some kind of error that gives the client faith,
                 // that resending this request later may work,
                 // hopefully after we've received the necessary parents.
-                return done_my_turn(309, e.message, 'Missing Parents', { 'Retry-After': '1' })
+                return done_my_turn(309, e.message, 'Version Unknown', {
+                    Parents: req.headers.parents,
+                    'Retry-After': '1'
+                })
             } else {
                 return done_my_turn(500, "The server failed to apply this version. The error generated was: " + e)
             }
@@ -241,39 +245,57 @@ braid_text.get = async (key, options) => {
             options.my_last_sent_version = x.version
             resource.simpleton_clients.add(options)
         } else {
-            let updates = null
-
             if (resource.need_defrag) {
                 if (braid_text.verbose) console.log(`doing defrag..`)
                 resource.need_defrag = false
                 resource.doc = defrag_dt(resource.doc)
             }
 
-            if (!options.parents && !options.version) {
-                options.subscribe({
-                    version: [],
-                    parents: [],
-                    body: "",
-                })
-
-                updates = dt_get_patches(resource.doc)
+            if (options.transfer_encoding === 'dt') {
+                var o = {
+                    'Transfer-Encoding': 'dt',
+                    'Current-Version': resource.doc.getRemoteVersion().
+                        map(x => x.join("-")).
+                        map(JSON.stringify).map(ascii_ify).join(", "),
+                }
+                var bytes = resource.doc.toBytes()
+                if (!options.parents && !options.version) o.body = bytes
+                else {
+                    var doc = Doc.fromBytes(bytes)
+                    o.body = doc.getPatchSince(
+                        dt_get_local_version(bytes,
+                            options.parents || options.version))
+                    doc.free()
+                }
+                options.subscribe(o)
             } else {
-                // Then start the subscription from the parents in options
-                updates = dt_get_patches(resource.doc, options.parents || options.version)
-            }
-
-            for (let u of updates)
-                options.subscribe({
-                    version: [u.version],
-                    parents: u.parents,
-                    patches: [{ unit: u.unit, range: u.range, content: u.content }],
-                })
+                var updates = null
+                if (!options.parents && !options.version) {
+                    options.subscribe({
+                        version: [],
+                        parents: [],
+                        body: "",
+                    })
+
+                    updates = dt_get_patches(resource.doc)
+                } else {
+                    // Then start the subscription from the parents in options
+                    updates = dt_get_patches(resource.doc, options.parents || options.version)
+                }
 
-            // Output at least *some* data, or else chrome gets confused and
-            // thinks the connection failed.  This isn't strictly necessary,
-            // but it makes fewer scary errors get printed out in the JS
-            // console.
-            if (updates.length === 0) options.write?.("\r\n")
+                for (let u of updates)
+                    options.subscribe({
+                        version: [u.version],
+                        parents: u.parents,
+                        patches: [{ unit: u.unit, range: u.range, content: u.content }],
+                    })
+
+                // Output at least *some* data, or else chrome gets confused and
+                // thinks the connection failed.  This isn't strictly necessary,
+                // but it makes fewer scary errors get printed out in the JS
+                // console.
+                if (updates.length === 0) options.write?.("\r\n")
+            }
 
             resource.clients.add(options)
         }
@@ -1863,6 +1885,10 @@ class RangeSet {
     }
 }
 
+function ascii_ify(s) {
+    return s.replace(/[^\x20-\x7E]/g, c => '\\u' + c.charCodeAt(0).toString(16).padStart(4, '0'))
+}
+
 braid_text.get_resource = get_resource
 
 braid_text.encode_filename = encode_filename

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "braid-text",
-  "version": "0.2.32",
+  "version": "0.2.34",
   "description": "Library for collaborative text over http using braid.",
   "author": "Braid Working Group",
   "repository": "braid-org/braid-text",

package/test/test.html

@@ -23,6 +23,13 @@
 <div id="testContainer"></div>
 <script type=module>
 
+import {
+    default as init,
+    Doc,
+    OpLog,
+} from "https://unpkg.com/diamond-types-web";
+var dt_p = init()
+
 let delay = 0
 
 function createTestDiv(testName) {
@@ -61,6 +68,42 @@ async function runTest(testName, testFunction, expectedResult) {
     }
 }
 
+runTest(
+    "test transfer-encoding dt",
+    async () => {
+        await dt_p
+        let key = 'test-' + Math.random().toString(36).slice(2)
+        var doc = new Doc('hi')
+        doc.ins(0, 'x')
+
+        let r = await braid_fetch(`/${key}`, {
+            method: 'PUT',
+            version: ['hi-1'],
+            parents: [],
+            body: 'xy'
+        })
+        if (!r.ok) throw 'got: ' + r.statusCode
+
+        let r2 = await braid_fetch(`/${key}`, {
+            version: ['hi-0'],
+            subscribe: true,
+            headers: {
+                'Merge-Type': 'dt',
+                'Accept-Transfer-Encoding': 'dt'
+            }
+        })
+        return await new Promise(async (done, fail) => {
+            r2.subscribe(async update => {
+                doc.mergeBytes(update.body)
+                done(update.extra_headers['current-version'] + ' ' +
+                    update.extra_headers['transfer-encoding'] + ' ' + 
+                    doc.get())
+            }, fail)
+        })
+    },
+    '"hi-1" dt xy'
+)
+
 runTest(
     "test error code when missing parents",
     async () => {
@@ -68,12 +111,12 @@ runTest(
         let r = await braid_fetch(`/${key}`, {
             method: 'PUT',
             version: ['hi-1'],
-            parents: ['missing-0'],
+            parents: ['missing-0', 'y😀-0'],
             body: 'xx'
         })
-        return r.status + ' ' + r.ok
+        return r.status + ' ' + r.ok + ' ' + r.statusText +  ' ' + r.headers.get('Parents')
     },
-    '309 false'
+    '309 false Version Unknown "missing-0", "y\\ud83d\\ude00-0"'
 )
 
 runTest(