braid-text 0.2.41 → 0.2.43

package/index.js

@@ -129,6 +129,9 @@ braid_text.serve = async (req, res, options = {}) => {
                 version: req.version,
                 parents: req.parents,
                 merge_type,
+                accept_encoding:
+                    req.headers['x-accept-encoding'] ??
+                    req.headers['accept-encoding'],
                 subscribe: x => res.sendVersion(x),
                 write: (x) => res.write(x)
             }
@@ -180,8 +183,8 @@ braid_text.serve = async (req, res, options = {}) => {
                     // approximation of memory usage for this update
                     body ? body.length :
                         patches.reduce((a, b) => a + b.range.length + b.content.length, 0),
-                    options.put_buffer_max_time,
-                    options.put_buffer_max_space)
+                    options.recv_buffer_max_time,
+                    options.recv_buffer_max_space)
 
                 // make sure we have the necessary parents now
                 var unknowns = []
@@ -229,10 +232,9 @@ braid_text.get = async (key, options) => {
     if (options.parents) validate_version_array(options.parents)
 
     let resource = (typeof key == 'string') ? await get_resource(key) : key
+    var version = resource.doc.getRemoteVersion().map((x) => x.join("-")).sort()
 
     if (!options.subscribe) {
-        var version = resource.doc.getRemoteVersion().map((x) => x.join("-")).sort()
-
         if (options.transfer_encoding === 'dt') {
             // optimization: if requesting current version
             // pretend as if they didn't set a version,
@@ -251,7 +253,7 @@ braid_text.get = async (key, options) => {
                 }
                 if (options.parents) {
                     bytes = doc.getPatchSince(
-                    dt_get_local_version(bytes, options.parents))
+                        dt_get_local_version(bytes, options.parents))
                 }
                 doc.free()
             } else bytes = resource.doc.toBytes()
@@ -267,7 +269,6 @@ braid_text.get = async (key, options) => {
             }
     } else {
         if (options.merge_type != "dt") {
-            let version = resource.doc.getRemoteVersion().map((x) => x.join("-")).sort()
             let x = { version }
 
             if (!options.parents && !options.version) {
@@ -295,32 +296,43 @@ braid_text.get = async (key, options) => {
                 resource.doc = defrag_dt(resource.doc)
             }
 
-            var updates = null
-            if (!options.parents && !options.version) {
-                options.subscribe({
-                    version: [],
-                    parents: [],
-                    body: "",
-                })
-
-                updates = dt_get_patches(resource.doc)
+            if (options.accept_encoding?.match(/updates\s*\((.*)\)/)?.[1].split(',').map(x=>x.trim()).includes('dt')) {
+                var bytes = resource.doc.toBytes()
+                if (options.parents) {
+                    var doc = Doc.fromBytes(bytes)
+                    bytes = doc.getPatchSince(
+                        dt_get_local_version(bytes, options.parents))
+                    doc.free()
+                }
+                options.subscribe({ encoding: 'dt', body: bytes })
             } else {
-                // Then start the subscription from the parents in options
-                updates = dt_get_patches(resource.doc, options.parents || options.version)
-            }
+                var updates = null
+                if (!options.parents && !options.version) {
+                    options.subscribe({
+                        version: [],
+                        parents: [],
+                        body: "",
+                    })
 
-            for (let u of updates)
-                options.subscribe({
-                    version: [u.version],
-                    parents: u.parents,
-                    patches: [{ unit: u.unit, range: u.range, content: u.content }],
-                })
+                    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)
+                }
+
+                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")
+                // 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)
         }

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "braid-text",
-  "version": "0.2.41",
+  "version": "0.2.43",
   "description": "Library for collaborative text over http using braid.",
   "author": "Braid Working Group",
   "repository": "braid-org/braid-text",
   "homepage": "https://braid.org",
   "dependencies": {
     "@braid.org/diamond-types-node": "^2.0.0",
-    "braid-http": "~1.3.77"
+    "braid-http": "~1.3.79"
   }
 }

package/test/test.html

@@ -18,8 +18,20 @@
     .failed {
         background-color: #ffebee;
     }
+    #summaryContainer {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 5px;
+        margin-bottom: 20px;
+    }
+    .summaryBox {
+        width: 25px;
+        height: 25px;
+        border: 1px solid #ddd;
+    }    
 </style>
 <script src="https://unpkg.com/braid-http@~1.3/braid-http-client.js"></script>
+<div id="summaryContainer"></div>
 <div id="testContainer"></div>
 <script type=module>
 
@@ -51,20 +63,36 @@ function updateTestResult(div, passed, message, got, expected) {
     }
 }
 
+function createSummaryBox() {
+    var summaryContainer = document.getElementById('summaryContainer')
+    const box = document.createElement('div');
+    box.className = 'summaryBox running';
+    summaryContainer.appendChild(box);
+    return box;
+}
+
+function updateSummaryBox(box, passed) {
+    box.className = `summaryBox ${passed ? 'passed' : passed === false ? 'failed' : 'other'}`;
+}
+
 async function runTest(testName, testFunction, expectedResult) {
     delay += 70
 
     await new Promise(done => setTimeout(done, delay))
     const div = createTestDiv(testName)
+    const summaryBox = createSummaryBox()
     try {
         let x = await testFunction()
         if (x == expectedResult) {
             updateTestResult(div, true, x)
+            updateSummaryBox(summaryBox, true)
         } else {
             updateTestResult(div, false, "Mismatch:", x, expectedResult)
+            updateSummaryBox(summaryBox, false)
         }
     } catch (error) {
         updateTestResult(div, false, "Error:", error.message || error, expectedResult)
+        updateSummaryBox(summaryBox, false)
     }
 }
 
@@ -456,6 +484,135 @@ runTest(
     '"hi\\u2211-1" hi∑-1 buf.byteLength:0'
 )
 
+runTest(
+    "test accept-encoding updates(dt) (with parents)",
+    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
+
+        var a = new AbortController()
+        let r2 = await braid_fetch(`/${key}`, {
+            signal: a.signal,
+            parents: ['hi-0'],
+            subscribe: true,
+            headers: {
+                'merge-type': 'dt',
+                'X-Accept-Encoding': 'updates(dt)'
+            }
+        })
+
+        return await new Promise(done => {
+            r2.subscribe(u => {
+                doc.mergeBytes(u.body)
+                done(doc.get())
+                doc.free()
+                a.abort()
+            })
+        })
+    },
+    'xy'
+)
+
+runTest(
+    "test accept-encoding updates(dt)",
+    async () => {
+        await dt_p
+        let key = 'test-' + Math.random().toString(36).slice(2)
+
+        let r = await braid_fetch(`/${key}`, {
+            method: 'PUT',
+            version: ['hi-1'],
+            parents: [],
+            body: 'xy'
+        })
+        if (!r.ok) throw 'got: ' + r.statusCode
+
+        var a = new AbortController()
+        let r2 = await braid_fetch(`/${key}`, {
+            signal: a.signal,
+            subscribe: true,
+            headers: {
+                'merge-type': 'dt',
+                'X-Accept-Encoding': 'updates(dt)'
+            }
+        })
+
+        var doc = new Doc('yo')
+        return await new Promise(done => {
+            r2.subscribe(u => {
+                doc.mergeBytes(u.body)
+                done(doc.get())
+                doc.free()
+                a.abort()
+            })
+        })
+    },
+    'xy'
+)
+
+runTest(
+    "test accept-encoding updates(dt), getting non-encoded update",
+    async () => {
+        await dt_p
+        let key = 'test-' + Math.random().toString(36).slice(2)
+
+        let r = await braid_fetch(`/${key}`, {
+            method: 'PUT',
+            version: ['hi-1'],
+            parents: [],
+            body: 'xy'
+        })
+        if (!r.ok) throw 'got: ' + r.statusCode
+
+        var a = new AbortController()
+        let r2 = await braid_fetch(`/${key}`, {
+            signal: a.signal,
+            subscribe: true,
+            headers: {
+                'merge-type': 'dt',
+                'X-Accept-Encoding': 'updates(dt)'
+            }
+        })
+
+        setTimeout(async () => {
+            await braid_fetch(`/${key}`, {
+                method: 'PUT',
+                version: ['yo-0'],
+                parents: ['hi-1'],
+                patches: [{unit: 'text', range: '[2:2]', content: 'z'}]
+            })
+        }, 200)
+
+        var results = []
+
+        var doc = new Doc('yo')
+        return await new Promise(done => {
+            r2.subscribe(u => {
+                if (!u.status) {
+                    doc.mergeBytes(u.body)
+                    results.push(doc.get())
+                    doc.free()
+                } else {
+                    results.push(u.patches[0].content_text)
+                    done(results.join(''))
+                    a.abort()
+                }
+            })
+        })
+    },
+    'xyz'
+)
+
 runTest(
     "test Version we get from PUTing",
     async () => {