braid-text 0.2.33 → 0.2.35

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("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)
@@ -170,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) {
@@ -212,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 {
@@ -244,14 +283,13 @@ 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)
             }
 
+            var updates = null
             if (!options.parents && !options.version) {
                 options.subscribe({
                     version: [],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "braid-text",
-  "version": "0.2.33",
+  "version": "0.2.35",
   "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,227 @@ async function runTest(testName, testFunction, expectedResult) {
     }
 }
 
+runTest(
+    "test transfer-encoding 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
+
+        let r2 = await braid_fetch(`/${key}`, {
+            parents: ['hi-0'],
+            headers: {
+                'Accept-Transfer-Encoding': 'dt'
+            }
+        })
+
+        doc.mergeBytes([...new Uint8Array(await r2.arrayBuffer())])
+        var text = doc.get()
+        doc.free()
+
+        return r2.headers.get('current-version') + ' ' + r2.headers.get('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('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 () => {