braid-text 0.2.44 → 0.2.46

package/index.js

@@ -291,11 +291,6 @@ braid_text.get = async (key, options) => {
             options.my_last_sent_version = x.version
             resource.simpleton_clients.add(options)
         } else {
-            if (resource.need_defrag) {
-                if (braid_text.verbose) console.log(`doing defrag..`)
-                resource.need_defrag = false
-                resource.doc = defrag_dt(resource.doc)
-            }
 
             if (options.accept_encoding?.match(/updates\s*\((.*)\)/)?.[1].split(',').map(x=>x.trim()).includes('dt')) {
                 var bytes = resource.doc.toBytes()
@@ -431,7 +426,7 @@ braid_text.put = async (key, options) => {
     // validate version: make sure we haven't seen it already
     if (resource.actor_seqs[v[0]]?.has(v[1])) {
 
-        if (!options.validate_already_seen_versions) return
+        if (!options.validate_already_seen_versions) return { change_count }
 
         // if we have seen it already, make sure it's the same as before
         let updates = dt_get_patches(resource.doc, og_parents)
@@ -488,7 +483,7 @@ braid_text.put = async (key, options) => {
         }
 
         // we already have this version, so nothing left to do
-        return
+        return { change_count: change_count }
     }
     if (!resource.actor_seqs[v[0]]) resource.actor_seqs[v[0]] = new RangeSet()
     resource.actor_seqs[v[0]].add_range(v[1] + 1 - change_count, v[1])
@@ -526,8 +521,6 @@ braid_text.put = async (key, options) => {
     for (let b of bytes) resource.doc.mergeBytes(b)
     resource.val = resource.doc.get()
 
-    resource.need_defrag = true
-
     var post_commit_updates = []
 
     if (options.merge_type != "dt") {
@@ -674,17 +667,12 @@ async function get_resource(key) {
 
         resource.db_delta = change
 
-        resource.doc = defrag_dt(resource.doc)
-        resource.need_defrag = false
-
         resource.actor_seqs = {}
 
-        let max_version = resource.doc.getLocalVersion().reduce((a, b) => Math.max(a, b), -1)
-        for (let i = 0; i <= max_version; i++) {
-            let v = resource.doc.localToRemoteVersion([i])[0]
-            if (!resource.actor_seqs[v[0]]) resource.actor_seqs[v[0]] = new RangeSet()
-            resource.actor_seqs[v[0]].add_range(v[1], v[1])
-        }
+        dt_get_actor_seq_runs([...resource.doc.toBytes()], (actor, base, len) => {
+            if (!resource.actor_seqs[actor]) resource.actor_seqs[actor] = new RangeSet()
+            resource.actor_seqs[actor].add_range(base, base + len - 1)
+        })
 
         resource.val = resource.doc.get()
 
@@ -1069,16 +1057,19 @@ function dt_get(doc, version, agent = null, anti_version = null) {
 }
 
 function dt_get_patches(doc, version = null) {
+    if (version && v_eq(version,
+        doc.getRemoteVersion().map((x) => x.join("-")).sort())) {
+        // they want everything past the end, which is nothing
+        return []
+    }
+
     let bytes = doc.toBytes()
     doc = Doc.fromBytes(bytes)
 
     let [_agents, versions, parentss] = dt_parse([...bytes])
 
     let op_runs = []
-    if (version && v_eq(version,
-        doc.getRemoteVersion().map((x) => x.join("-")).sort())) {
-        // they want everything past the end, which is nothing
-    } else if (version?.length) {
+    if (version?.length) {
         let frontier = {}
         version.forEach((x) => frontier[x] = true)
         let local_version = []
@@ -1223,6 +1214,48 @@ function dt_parse(byte_array) {
     return [agents, versions, parentss]
 }
 
+function dt_get_actor_seq_runs(byte_array, cb) {
+    if (new TextDecoder().decode(new Uint8Array(byte_array.splice(0, 8))) !== "DMNDTYPS") throw new Error("dt parse error, expected DMNDTYPS")
+
+    if (byte_array.shift() != 0) throw new Error("dt parse error, expected version 0")
+
+    let agents = []
+
+    while (byte_array.length) {
+        let id = byte_array.shift()
+        let len = dt_read_varint(byte_array)
+        if (id == 1) {
+        } else if (id == 3) {
+            let goal = byte_array.length - len
+            while (byte_array.length > goal) {
+                agents.push(dt_read_string(byte_array))
+            }
+        } else if (id == 20) {
+        } else if (id == 21) {
+            let seqs = {}
+            let goal = byte_array.length - len
+            while (byte_array.length > goal) {
+                let part0 = dt_read_varint(byte_array)
+                let has_jump = part0 & 1
+                let agent_i = (part0 >> 1) - 1
+                let run_length = dt_read_varint(byte_array)
+                let jump = 0
+                if (has_jump) {
+                    let part2 = dt_read_varint(byte_array)
+                    jump = part2 >> 1
+                    if (part2 & 1) jump *= -1
+                }
+                let base = (seqs[agent_i] || 0) + jump
+
+                cb(agents[agent_i], base, run_length)
+                seqs[agent_i] = base + run_length
+            }
+        } else {
+            byte_array.splice(0, len)
+        }
+    }
+}
+
 function dt_get_local_version(bytes, version) {
     var looking_for = new Map()
     for (var event of version) {
@@ -1492,11 +1525,6 @@ function dt_create_bytes(version, parents, pos, del, ins) {
     return bytes
 }
 
-function defrag_dt(doc) {
-    let bytes = doc.toBytes()
-    doc.free()
-    return Doc.fromBytes(bytes, 'server')
-}
 
 function OpLog_remote_to_local(doc, frontier) {
     let map = Object.fromEntries(frontier.map((x) => [x, true]))

package/package.json

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

package/test/test.html

@@ -96,6 +96,157 @@ async function runTest(testName, testFunction, expectedResult) {
     }
 }
 
+runTest(
+    "test PUTing a version that the server already has",
+    async () => {
+        var key = 'test-' + Math.random().toString(36).slice(2)
+
+        var r1 = await braid_fetch(`/${key}`, {
+            method: 'PUT',
+            version: ['hi-0'],
+            parents: [],
+            body: 'x'
+        })
+
+        var r2 = await braid_fetch(`/${key}`, {
+            method: 'PUT',
+            version: ['hi-0'],
+            parents: [],
+            body: 'x'
+        })
+
+        return r1.status + " " + r2.status
+    },
+    '200 200'
+)
+
+runTest(
+    "test validate_already_seen_versions with same version",
+    async () => {
+        var key = 'test-' + Math.random().toString(36).slice(2)
+
+        var r1 = await braid_fetch(`/eval`, {
+            method: 'PUT',
+            body: `void (async () => {
+                var resource = await braid_text.get_resource('/${key}')
+
+                var {change_count} = await braid_text.put(resource, { peer: "abc", version: ["hi-2"], parents: [], patches: [{unit: "text", range: "[0:0]", content: "XYZ"}], merge_type: "dt" })
+
+                res.end('' + change_count)
+            })()`
+        })
+
+        var r2 = await braid_fetch(`/eval`, {
+            method: 'PUT',
+            body: `void (async () => {
+                var resource = await braid_text.get_resource('/${key}')
+
+                var {change_count} = await braid_text.put(resource, { peer: "abc", version: ["hi-2"], parents: [], patches: [{unit: "text", range: "[0:0]", content: "XYZ"}], merge_type: "dt", validate_already_seen_versions: true })
+
+                res.end('' + change_count)
+            })()`
+        })
+
+        return (await r1.text()) + " " + (await r2.text())
+    },
+    '3 3'
+)
+
+runTest(
+    "test validate_already_seen_versions with modified version",
+    async () => {
+        var key = 'test-' + Math.random().toString(36).slice(2)
+
+        var r1 = await braid_fetch(`/eval`, {
+            method: 'PUT',
+            body: `void (async () => {
+                var resource = await braid_text.get_resource('/${key}')
+
+                var {change_count} = await braid_text.put(resource, { peer: "abc", version: ["hi-2"], parents: [], patches: [{unit: "text", range: "[0:0]", content: "XYZ"}], merge_type: "dt" })
+
+                res.end('' + change_count)
+            })()`
+        })
+
+        var r2 = await braid_fetch(`/eval`, {
+            method: 'PUT',
+            body: `void (async () => {
+                var resource = await braid_text.get_resource('/${key}')
+
+                try {
+                    var {change_count} = await braid_text.put(resource, { peer: "abc", version: ["hi-2"], parents: [], patches: [{unit: "text", range: "[0:0]", content: "ABC"}], merge_type: "dt", validate_already_seen_versions: true })
+
+                    res.end('' + change_count)
+                } catch (e) {
+                    res.end(e.message)
+                }
+            })()`
+        })
+
+        return await r2.text()
+    },
+    'invalid update: different from previous update with same version'
+)
+
+runTest(
+    "test loading a previously saved resource",
+    async () => {
+        var key = 'test-' + Math.random().toString(36).slice(2)
+
+        var f1 = await braid_fetch(`/${key}`, {
+            method: 'PUT',
+            version: ['hi-2'],
+            parents: [],
+            body: 'abc'
+        })
+
+        var f1 = await braid_fetch(`/eval`, {
+            method: 'PUT',
+            body: `
+                delete braid_text.cache['/${key}']
+                res.end()
+            `
+        })
+
+        var r = await braid_fetch(`/${key}`)
+        return await r.text()
+    },
+    'abc'
+)
+
+runTest(
+    "test non-contigous ids",
+    async () => {
+        var key = 'test-' + Math.random().toString(36).slice(2)
+
+        var r = await braid_fetch(`/${key}`, {
+            method: 'PUT',
+            version: ['hi-10'],
+            parents: [],
+            body: 'abc'
+        })
+
+        var r = await braid_fetch(`/${key}`, {
+            method: 'PUT',
+            version: ['hi-20'],
+            parents: ['hi-10'],
+            body: 'ABC'
+        })
+
+        var f1 = await braid_fetch(`/eval`, {
+            method: 'PUT',
+            body: `
+                delete braid_text.cache['/${key}']
+                res.end()
+            `
+        })
+
+        var r = await braid_fetch(`/${key}`)
+        return await r.text()
+    },
+    'ABC'
+)
+
 runTest(
     "test when PUT cache/buffer size fails",
     async () => {