braid-text 0.2.19 → 0.2.21

package/index.js

@@ -26,8 +26,8 @@ braid_text.serve = async (req, res, options = {}) => {
 
     braid_text.free_cors(res)
 
-    function my_end(statusCode, x) {
-        res.statusCode = statusCode
+    function my_end(statusCode, x, statusText, headers) {
+        res.writeHead(statusCode, statusText, headers)
         res.end(x ?? '')
     }
 
@@ -134,10 +134,10 @@ braid_text.serve = async (req, res, options = {}) => {
         let done_my_turn = null
         prev_put_p = new Promise(
             (done) =>
-            (done_my_turn = (statusCode, x) => {
+            (done_my_turn = (statusCode, x, statusText, headers) => {
                 waiting_puts--
                 if (braid_text.verbose) console.log(`waiting_puts(after--) = ${waiting_puts}`)
-                my_end(statusCode, x)
+                my_end(statusCode, x, statusText, headers)
                 done()
             })
         )
@@ -190,7 +190,7 @@ braid_text.serve = async (req, res, options = {}) => {
                 // - 428 Precondition Required
                 //     - pros: the name sounds right
                 //     - cons: typically implies that the request was missing an http conditional field like If-Match. that is to say, it implies that the request is missing a precondition, not that the server is missing a precondition
-                return done_my_turn(425, e.message)
+                return done_my_turn(400, e.message, 'Missing Parents', { 'Retry-After': '1' })
             } else {
                 return done_my_turn(500, "The server failed to apply this version. The error generated was: " + e)
             }
@@ -580,31 +580,22 @@ braid_text.put = async (key, options) => {
     await resource.db_delta(resource.doc.getPatchSince(v_before))
 }
 
-// currently version must be an array with exactly one element, e.g. ["abc-1"]
 braid_text.revert = async (key, version) => {
     var resource = (typeof key == 'string') ? await get_resource(key) : key
 
-    var [actor, seq] = decode_version(version[0])
-
-    // get version without actor-seq,
-    // and update actor_seqs
-    var v = []
-    for (var [a, s] of Object.entries(resource.actor_seqs)) {
-        if (a !== actor) v.push(`${a}-${s}`)
-        else {
-            if (s < seq) return // nothing to do
-            else if (seq > 0) {
-                v.push(`${a}-${seq - 1}`)
-                resource.actor_seqs[actor] = seq - 1
-            } else delete resource.actor_seqs[actor]
-        }
-    }
-
     // revert dt
     var old_doc = resource.doc
-    resource.doc = dt_get(resource.doc, v)
+    resource.doc = dt_get(resource.doc, null, null, version)
     old_doc.free()
 
+    for (let v of version) {
+        var [actor, seq] = decode_version(v)
+        if ((resource.actor_seqs[actor] ?? -1) > seq - 1) {
+            if (seq > 0) resource.actor_seqs[actor] = seq - 1
+            else delete resource.actor_seqs[actor]
+        }
+    }
+
     resource.val = resource.doc.get()
 
     // save it
@@ -852,32 +843,47 @@ function dt_get_string(doc, version) {
     return s
 }
 
-function dt_get(doc, version, agent = null) {
+function dt_get(doc, version, agent = null, anti_version = null) {
     if (dt_get.last_doc) dt_get.last_doc.free()
 
     let bytes = doc.toBytes()
     dt_get.last_doc = doc = Doc.fromBytes(bytes, agent)
 
     let [_agents, versions, parentss] = dt_parse([...bytes])
-
-    let frontier = new Set(version)
-
-    let local_version = []
-    for (let i = 0; i < versions.length; i++) {
-        var v = versions[i].join("-")
-        if (frontier.has(v)) {
-            local_version.push(i)
-            frontier.delete(v)
+    if (anti_version) {
+        var include_versions = new Set()
+        var bad_versions = new Set(anti_version)
+
+        for (let i = 0; i < versions.length; i++) {
+            var v = versions[i].join("-")
+            var ps = parentss[i].map(x => x.join('-'))
+            if (bad_versions.has(v) || ps.some(x => bad_versions.has(x)))
+                bad_versions.add(v)
+            else
+                include_versions.add(v)
         }
-    }
-
-    if (frontier.size) throw new Error(`version not found: ${version}`)
+    } else {
+        var include_versions = new Set(version)
+        var looking_for = new Set(version)
+        var local_version = []
+
+        for (let i = versions.length - 1; i >= 0; i--) {
+            var v = versions[i].join("-")
+            var ps = parentss[i].map(x => x.join('-'))
+            if (looking_for.has(v)) {
+                local_version.push(i)
+                looking_for.delete(v)
+            }
+            if (include_versions.has(v))
+                ps.forEach(x => include_versions.add(x))
+        }
+        local_version.reverse()
 
-    dt_get.last_local_version = local_version = new Uint32Array(local_version)
+        // NOTE: currently used by braid-chrome in dt.js at the bottom
+        dt_get.last_local_version = new Uint32Array(local_version)
 
-    let after_versions = {}
-    let [_, after_versions_array, __] = dt_parse([...doc.getPatchSince(local_version)])
-    for (let v of after_versions_array) after_versions[v.join("-")] = true
+        if (looking_for.size) throw new Error(`version not found: ${version}`)
+    }
 
     let new_doc = new Doc(agent)
     let op_runs = doc.getOpsSince([])
@@ -900,12 +906,12 @@ function dt_get(doc, version, agent = null) {
             ) {
                 for (; i < I; i++) {
                     let version = versions[i].join("-")
-                    if (after_versions[version]) continue
+                    if (!include_versions.has(version)) continue
                     let og_i = i
                     let content = []
                     if (op_run.content?.[i - base_i]) content.push(op_run.content[i - base_i])
                     if (!!op_run.content === op_run.fwd)
-                        while (i + 1 < I && !after_versions[versions[i + 1].join("-")]) {
+                        while (i + 1 < I && include_versions.has(versions[i + 1].join("-"))) {
                             i++
                             if (op_run.content?.[i - base_i]) content.push(op_run.content[i - base_i])
                         }

package/package.json

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

package/test/test.html

@@ -238,4 +238,32 @@ runTest(
     '19'
 )
 
+runTest(
+    "test retry when parents not there..",
+    async () => {
+        return await new Promise(done => {
+            var count = 0
+            var key = 'test-' + Math.random().toString(36).slice(2)
+            var a = new AbortController()
+            braid_fetch(`/${key}`, {
+                signal: a.signal,
+                multiplex: false,
+                method: 'PUT',
+                version: ['hi-3'],
+                parents: ['hi-1'],
+                body: 'xx',
+                onFetch: () => {
+                    count++
+                    if (count === 2) {
+                        done('retried!')
+                        a.abort()
+                    }
+                },
+                retry: true
+            })
+        })
+    },
+    'retried!'
+)
+
 </script>

package/test/test.js

@@ -4,10 +4,10 @@ let braid_text = require('../index.js')
 let {dt_get, dt_get_patches, dt_parse, dt_create_bytes} = braid_text
 
 process.on("unhandledRejection", (x) =>
-    console.log(`unhandledRejection: ${x.stack}`)
+    console.log(`unhandledRejection: ${x.stack ?? x}`)
 )
 process.on("uncaughtException", (x) =>
-    console.log(`uncaughtException: ${x.stack}`)
+    console.log(`uncaughtException: ${x.stack ?? x}`)
 )
 
 braid_text.db_folder = null
@@ -48,7 +48,7 @@ async function main() {
     for (let t = 0; t < 10000; t++) {
         let seed = base + t
     // for (let t = 0; t < 1; t++) {
-    //     let seed = 7375800
+        // let seed = 2746153
 
         og_log(`t = ${t}, seed = ${seed}, best_n = ${best_n} @ ${best_seed}`)
         Math.randomSeed(seed)
@@ -80,7 +80,6 @@ async function main() {
                 for (let x of dt_get_patches(doc)) {
                     var resource = await braid_text.get_resource(key)
                     var [actor, seq] = braid_text.decode_version(x.version)
-                    var pre_seq = resource.actor_seqs[actor]
                     var old_text = await braid_text.get(key)
 
                     console.log(`x = `, x)
@@ -99,7 +98,9 @@ async function main() {
                     await braid_text.put(key, y)
 
                     // test revert
-                    await braid_text.revert(key, [`${actor}-${(pre_seq ?? -1) + 1}`])
+                    var range = x.range.match(/\d+/g).map((x) => parseInt(x))
+                    var change_count = [...x.content].length + range[1] - range[0]
+                    await braid_text.revert(key, [`${actor}-${seq + 1 - change_count}`])
                     var new_text = await braid_text.get(key)
                     if (old_text !== new_text) throw new Error('revert failed!')
                     await braid_text.put(key, y)