braid-text 0.2.34 → 0.2.36

package/index.js

@@ -72,6 +72,10 @@ braid_text.serve = async (req, res, options = {}) => {
         return my_end(200)
     }
 
+    var get_current_version = () => ascii_ify(
+        resource.doc.getRemoteVersion().map(x => x.join("-")).sort()
+            .map(x => JSON.stringify(x)).join(", "))
+
     if (req.method == "GET" || req.method == "HEAD") {
         if (!req.subscribe) {
             res.setHeader("Accept-Subscribe", "true")
@@ -88,20 +92,29 @@ braid_text.serve = async (req, res, options = {}) => {
 
             let x = null
             try {
-                x = await braid_text.get(resource, { version: req.version, parents: req.parents })
+                x = await braid_text.get(resource, {
+                    version: req.version,
+                    parents: req.parents,
+                    transfer_encoding: req.headers['accept-transfer-encoding']
+                })
             } catch (e) {
                 return my_end(500, "The server failed to get something. The error generated was: " + e)
             }
 
-            res.setHeader("Version", x.version.map((x) => JSON.stringify(x)).join(", "))
-
-            const buffer = Buffer.from(x.body, "utf8")
-            res.setHeader("Repr-Digest", `sha-256=:${require('crypto').createHash('sha256').update(buffer).digest('base64')}:`)
-            res.setHeader("Content-Length", buffer.length)
-
-            if (req.method === "HEAD") return my_end(200)
-
-            return my_end(200, buffer)
+            if (req.headers['accept-transfer-encoding'] === 'dt') {
+                res.setHeader("Current-Version", get_current_version())
+                res.setHeader("X-Transfer-Encoding", 'dt')
+                res.setHeader("Content-Length", x.body.length)
+                return my_end(209, req.method === "HEAD" ? null : x.body, 'Multiresponse')
+            } else {
+                if (req.version || req.parents)
+                    res.setHeader("Current-Version", get_current_version())
+                res.setHeader("Version", ascii_ify(x.version.map((x) => JSON.stringify(x)).join(", ")))
+                var buffer = Buffer.from(x.body, "utf8")
+                res.setHeader("Repr-Digest", `sha-256=:${require('crypto').createHash('sha256').update(buffer).digest('base64')}:`)
+                res.setHeader("Content-Length", buffer.length)
+                return my_end(200, req.method === "HEAD" ? null : buffer)
+            }
         } else {
             if (!res.hasHeader("editable")) res.setHeader("Editable", "true")
             res.setHeader("Merge-Type", merge_type)
@@ -112,7 +125,6 @@ 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)
             }
@@ -171,7 +183,7 @@ braid_text.serve = async (req, res, options = {}) => {
 
             await braid_text.put(resource, { peer, version: req.version, parents: req.parents, patches, body, merge_type })
             
-            res.setHeader("Version", resource.doc.getRemoteVersion().map((x) => x.join("-")).sort())
+            res.setHeader("Version", get_current_version())
 
             options.put_cb(options.key, resource.val)
         } catch (e) {
@@ -213,12 +225,38 @@ braid_text.get = async (key, options) => {
     let resource = (typeof key == 'string') ? await get_resource(key) : key
 
     if (!options.subscribe) {
-        return options.version || options.parents ?
-            {
+        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,
+            // and let it be handled as the default
+            var op_v = options.version
+            if (op_v && v_eq(op_v, version)) op_v = null
+
+            var bytes = null
+            if (op_v || options.parents) {
+                if (op_v) {
+                    var doc = dt_get(resource.doc, op_v)
+                    bytes = doc.toBytes()
+                } else {
+                    bytes = resource.doc.toBytes()
+                    var doc = Doc.fromBytes(bytes)
+                }
+                if (options.parents) {
+                    bytes = doc.getPatchSince(
+                    dt_get_local_version(bytes, options.parents))
+                }
+                doc.free()
+            } else bytes = resource.doc.toBytes()
+            return { body: bytes }
+        }
+
+        return options.version || options.parents ? {
                 version: options.version || options.parents,
                 body: dt_get_string(resource.doc, options.version || options.parents)
             } : {
-                version: resource.doc.getRemoteVersion().map((x) => x.join("-")).sort(),
+                version,
                 body: resource.doc.get()
             }
     } else {
@@ -251,52 +289,33 @@ braid_text.get = async (key, options) => {
                 resource.doc = defrag_dt(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 {
-                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)
-                }
+            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 }],
-                    })
-
-                // 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")
+                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")
+
             resource.clients.add(options)
         }
     }

package/package.json

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

package/test/test.html

@@ -69,7 +69,7 @@ async function runTest(testName, testFunction, expectedResult) {
 }
 
 runTest(
-    "test transfer-encoding dt",
+    "test transfer-encoding dt (with parents)",
     async () => {
         await dt_p
         let key = 'test-' + Math.random().toString(36).slice(2)
@@ -85,25 +85,210 @@ runTest(
         if (!r.ok) throw 'got: ' + r.statusCode
 
         let r2 = await braid_fetch(`/${key}`, {
-            version: ['hi-0'],
-            subscribe: true,
+            parents: ['hi-0'],
             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)
+
+        doc.mergeBytes([...new Uint8Array(await r2.arrayBuffer())])
+        var text = doc.get()
+        doc.free()
+
+        return r2.headers.get('current-version') + ' ' + r2.headers.get('x-transfer-encoding') + ' ' + text + ' ' + r2.statusText
+    },
+    '"hi-1" dt xy Multiresponse'
+)
+
+runTest(
+    "test transfer-encoding 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
+
+        let r2 = await braid_fetch(`/${key}`, {
+            headers: {
+                'Accept-Transfer-Encoding': 'dt'
+            }
         })
+
+        var doc = new Doc('yo')
+        doc.mergeBytes([...new Uint8Array(await r2.arrayBuffer())])
+        var text = doc.get()
+        doc.free()
+
+        return r2.headers.get('current-version') + ' ' + r2.headers.get('x-transfer-encoding') + ' ' + text
     },
     '"hi-1" dt xy'
 )
 
+runTest(
+    "test GETing old version explicitly with transfer-encoding 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
+
+        let r2 = await braid_fetch(`/${key}`, {
+            version: ['hi∑-0'],
+            headers: {
+                'Accept-Transfer-Encoding': 'dt'
+            }
+        })
+
+        var doc = new Doc('yo')
+        doc.mergeBytes([...new Uint8Array(await r2.arrayBuffer())])
+        var text = doc.get()
+        doc.free()
+
+        return r2.headers.get('current-version') + ' ' + text + ' ' + JSON.parse(r2.headers.get('current-version'))
+    },
+    '"hi\\u2211-1" x hi∑-1'
+)
+
+runTest(
+    "test GETing current version explicitly with transfer-encoding 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
+
+        let r2 = await braid_fetch(`/${key}`, {
+            version: ['hi∑-1'],
+            headers: {
+                'Accept-Transfer-Encoding': 'dt'
+            }
+        })
+
+        var doc = new Doc('yo')
+        doc.mergeBytes([...new Uint8Array(await r2.arrayBuffer())])
+        var text = doc.get()
+        doc.free()
+
+        return r2.headers.get('current-version') + ' ' + text + ' ' + JSON.parse(r2.headers.get('current-version'))
+    },
+    '"hi\\u2211-1" xy hi∑-1'
+)
+
+runTest(
+    "test for Current-Version when GETing old version",
+    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
+
+        let r2 = await braid_fetch(`/${key}`, {
+            version: ['hi∑-0']
+        })
+
+        var text = await r2.text()
+
+        return r2.headers.get('current-version') + ' ' + r2.headers.get('version') + ' ' + text + ' ' + JSON.parse(r2.headers.get('current-version'))
+    },
+    '"hi\\u2211-1" "hi\\u2211-0" x hi∑-1'
+)
+
+runTest(
+    "test HEAD for GET without subscribe",
+    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
+
+        let r2 = await braid_fetch(`/${key}`, {
+            method: 'HEAD'
+        })
+
+        var text = await r2.text()
+
+        return r2.headers.get('version') + ' ' + JSON.parse(r2.headers.get('version')) + ` text:[${text}]`
+    },
+    '"hi\\u2211-1" hi∑-1 text:[]'
+)
+
+runTest(
+    "test HEAD for GET without subscribe (with transfer-encoding)",
+    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
+
+        let r2 = await braid_fetch(`/${key}`, {
+            method: 'HEAD',
+            headers: {
+                'accept-transfer-encoding': 'dt'
+            }
+        })
+
+        var buf = await r2.arrayBuffer()
+
+        return r2.headers.get('current-version') + ' ' + JSON.parse(r2.headers.get('current-version')) + ` buf.byteLength:${buf.byteLength}`
+    },
+    '"hi\\u2211-1" hi∑-1 buf.byteLength:0'
+)
+
+runTest(
+    "test Version we get from PUTing",
+    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
+
+        return r.headers.get('version')
+    },
+    '"hi\\u2211-1"'
+)
+
 runTest(
     "test error code when missing parents",
     async () => {