braid-text 0.2.62 → 0.2.64

package/index.js

@@ -40,6 +40,52 @@ braid_text.serve = async (req, res, options = {}) => {
 
     let peer = req.headers["peer"]
 
+    // selection sharing prototype
+    if (req.headers['selection-sharing-prototype']) {
+        res.setHeader('Content-Type', 'application/json')
+
+        if (!resource.selections) resource.selections = {}
+        if (!resource.selection_clients) resource.selection_clients = new Set()
+
+        if (req.method === "GET" || req.method === "HEAD") {
+            if (!req.subscribe) {
+                return my_end(200, JSON.stringify(resource.selections))
+            } else {
+                var client = {peer, res}
+                resource.selection_clients.add(client)
+                res.startSubscription({
+                    onClose: () => resource.selection_clients.delete(client)
+                })
+                res.sendUpdate({ body: JSON.stringify(resource.selections) })
+                return
+            }
+        } else if (req.method == "PUT" || req.method == "POST" || req.method == "PATCH") {
+            var body = (await req.patches())[0].content_text
+            var json = JSON.parse(body)
+
+            // only keep new selections if they are newer
+            for (var [user, selection] of Object.entries(json)) {
+                if (resource.selections[user] && resource.selections[user].time > selection.time) delete json[user]
+                else resource.selections[user] = selection
+            }
+
+            // remove old selections that are too old
+            var long_ago = Date.now() - 1000 * 60 * 5
+            for (var [user, selection] of Object.entries(resource.selections))
+                if (selection.time < long_ago) {
+                    delete resource.selections[user]
+                    delete json[user]
+                }
+
+            body = JSON.stringify(json)
+            if (body.length > 2)
+                for (let client of resource.selection_clients)
+                    if (client.peer !== peer) client.res.sendUpdate({ body })
+            
+            return my_end(200)
+        }
+    }
+
     let merge_type = req.headers["merge-type"]
     if (!merge_type) merge_type = 'simpleton'
     if (merge_type !== 'simpleton' && merge_type !== 'dt') return my_end(400, `Unknown merge type: ${merge_type}`)
@@ -387,6 +433,26 @@ braid_text.put = async (key, options) => {
         })
     }
 
+    let resource = (typeof key == 'string') ? await get_resource(key) : key
+
+    if (options.transfer_encoding === 'dt') {
+        var start_i = 1 + resource.doc.getLocalVersion().reduce((a, b) => Math.max(a, b), -1)
+        
+        resource.doc.mergeBytes(body)
+
+        var end_i = resource.doc.getLocalVersion().reduce((a, b) => Math.max(a, b), -1)
+        for (var i = start_i; i <= end_i; i++) {
+            let v = resource.doc.localToRemoteVersion([i])[0]
+            if (!resource.actor_seqs[v[0]]) resource.actor_seqs[v[0]] = new braid_text.RangeSet()
+            resource.actor_seqs[v[0]].add_range(v[1], v[1])
+        }
+        resource.val = resource.doc.get()
+        resource.version = resource.doc.getRemoteVersion().map(x => x.join("-")).sort()
+
+        await resource.db_delta(body)
+        return { change_count: end_i - start_i + 1 }
+    }
+
     if (version) validate_version_array(version)
 
     // translate a single parent of "root" to the empty array (same meaning)
@@ -399,8 +465,6 @@ braid_text.put = async (key, options) => {
     if (body != null && (typeof body !== 'string')) throw new Error(`body must be a string`)
     if (patches) validate_patches(patches)
 
-    let resource = (typeof key == 'string') ? await get_resource(key) : key
-
     if (options_parents) {
         // make sure we have all these parents
         for (let p of options_parents) {

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "braid-text",
-  "version": "0.2.62",
+  "version": "0.2.64",
   "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.79"
+    "braid-http": "~1.3.80"
   }
 }

package/server-demo.js

@@ -1,6 +1,4 @@
-
 var port = process.argv[2] || 8888
-
 var braid_text = require("./index.js")
 
 // TODO: set a custom database folder

package/test/test.html

@@ -96,6 +96,174 @@ async function runTest(testName, testFunction, expectedResult) {
     }
 }
 
+runTest(
+    "test selection-sharing-prototype PUT and GET",
+    async () => {
+        let key = 'test-' + Math.random().toString(36).slice(2)
+
+        let time = Date.now()
+
+        let r = await braid_fetch(`/${key}`, {
+            method: 'PUT',
+            body: JSON.stringify({
+                hello: {
+                    yo: 'hi',
+                    time
+                }
+            }),
+            headers: {
+                'selection-sharing-prototype': 'true'
+            }
+        })
+        if (!r.ok) return 'got: ' + r.status
+
+        let r2 = await braid_fetch(`/${key}`, {
+            method: 'GET',
+            headers: {
+                'selection-sharing-prototype': 'true'
+            }
+        })
+        if (!r2.ok) return 'got: ' + r2.status
+
+        let o = await r2.json()
+        return o.hello.time === time ? 'times match' : 'bad'
+    },
+    'times match'
+)
+
+runTest(
+    "test selection-sharing-prototype GET/subscribe",
+    async () => {
+        let key = 'test-' + Math.random().toString(36).slice(2)
+
+        var a = new AbortController()
+        let r = await braid_fetch(`/${key}`, {
+            method: 'GET',
+            signal: a.signal,
+            subscribe: true,
+            peer: 'abc',
+            headers: {
+                'selection-sharing-prototype': 'true'
+            }
+        })
+        if (!r.ok) return 'got: ' + r.status
+        var p = new Promise(done => {
+            r.subscribe(update => {
+                var body = update.body_text
+                if (body.length > 2) done(body)
+            })
+        })
+
+        var time = Date.now()
+
+        let r2 = await braid_fetch(`/${key}`, {
+            method: 'PUT',
+            peer: 'xyz',
+            body: JSON.stringify({
+                hello: {
+                    yo: 'hi',
+                    time
+                }
+            }),
+            headers: {
+                'selection-sharing-prototype': 'true'
+            }
+        })
+        if (!r2.ok) return 'got: ' + r2.status
+
+        var ret_val = JSON.parse(await p).hello.time === time ? 'times match' : 'bad'
+
+        a.abort()
+
+        return ret_val
+    },
+    'times match'
+)
+
+runTest(
+    "test selection-sharing-prototype PUT old cursor",
+    async () => {
+        let key = 'test-' + Math.random().toString(36).slice(2)
+
+        let time = Date.now()
+
+        let r = await braid_fetch(`/${key}`, {
+            method: 'PUT',
+            body: JSON.stringify({
+                hello: {
+                    yo: 'hi',
+                    time
+                }
+            }),
+            headers: {
+                'selection-sharing-prototype': 'true'
+            }
+        })
+        if (!r.ok) return 'got: ' + r.status
+
+        let r3 = await braid_fetch(`/${key}`, {
+            method: 'PUT',
+            body: JSON.stringify({
+                hello: {
+                    yo: 'hoop',
+                    time: time - 5
+                }
+            }),
+            headers: {
+                'selection-sharing-prototype': 'true'
+            }
+        })
+        if (!r3.ok) return 'got: ' + r3.status
+
+        let r2 = await braid_fetch(`/${key}`, {
+            method: 'GET',
+            headers: {
+                'selection-sharing-prototype': 'true'
+            }
+        })
+        if (!r2.ok) return 'got: ' + r2.status
+
+        let o = await r2.json()
+        return o.hello.yo
+    },
+    'hi'
+)
+
+runTest(
+    "test selection-sharing-prototype PUT really old cursor",
+    async () => {
+        let key = 'test-' + Math.random().toString(36).slice(2)
+
+        let time = Date.now() - 1000 * 60 * 60 * 24
+
+        let r = await braid_fetch(`/${key}`, {
+            method: 'PUT',
+            body: JSON.stringify({
+                hello: {
+                    yo: 'hi',
+                    time
+                }
+            }),
+            headers: {
+                'selection-sharing-prototype': 'true'
+            }
+        })
+        if (!r.ok) return 'got: ' + r.status
+
+        let r2 = await braid_fetch(`/${key}`, {
+            method: 'GET',
+            headers: {
+                'selection-sharing-prototype': 'true'
+            }
+        })
+        if (!r2.ok) return 'got: ' + r2.status
+
+        let o = await r2.json()
+        return JSON.stringify(o)
+    },
+    '{}'
+)
+
 runTest(
     "test PUT digest (good)",
     async () => {
@@ -564,6 +732,35 @@ runTest(
     'xy'
 )
 
+runTest(
+    "test put with transfer-encoding: dt",
+    async () => {
+        var key = 'test-' + Math.random().toString(36).slice(2)
+        var doc = new Doc('hi')
+        doc.ins(0, 'xy')
+
+        var bytes = doc.toBytes()
+
+        var r1 = await braid_fetch(`/eval`, {
+            method: 'PUT',
+            body: `void (async () => {
+                var key = '/${key}'
+
+                var {change_count} = await braid_text.put(key, {
+                    body: new Uint8Array([${'' + bytes}]),
+                    transfer_encoding: "dt"
+                })
+                var {body, version} = await braid_text.get(key, {})
+
+                res.end('' + change_count + " " + body + " " + version)
+            })()`
+        })
+
+        return await r1.text()
+    },
+    '2 xy hi-1'
+)
+
 runTest(
     "test transfer-encoding dt (with parents)",
     async () => {