braid-text 0.2.66 → 0.2.68

package/index.js

@@ -1,6 +1,6 @@
 
 let { Doc, OpLog, Branch } = require("@braid.org/diamond-types-node")
-let braidify = require("braid-http").http_server
+let {http_server: braidify, fetch: braid_fetch} = require("braid-http")
 let fs = require("fs")
 
 function create_braid_text() {
@@ -16,6 +16,15 @@ function create_braid_text() {
 
     let max_encoded_key_size = 240
 
+    braid_text.sync = async (a, b, options) => {
+        braid_text.get(a, {
+            subscribe: update => braid_text.put(b, update)
+        })
+        braid_text.get(b, {
+            subscribe: update => braid_text.put(a, update)
+        })
+    }
+
     braid_text.serve = async (req, res, options = {}) => {
         options = {
             key: req.url.split('?')[0], // Default key
@@ -237,7 +246,7 @@ function create_braid_text() {
                         req.parents,
                         resource.actor_seqs,
                         // approximation of memory usage for this update
-                        body ? body.length :
+                        body != null ? body.length :
                             patches.reduce((a, b) => a + b.range.length + b.content.length, 0),
                         options.recv_buffer_max_time,
                         options.recv_buffer_max_space)
@@ -270,7 +279,8 @@ function create_braid_text() {
                     return done_my_turn(550, "repr-digest mismatch!")
                 }
 
-                if (req.version) got_event(options.key, req.version[0], change_count)
+                if (req.version?.length)
+                    got_event(options.key, req.version[0], change_count)
             
                 res.setHeader("Version", get_current_version())
 
@@ -291,6 +301,33 @@ function create_braid_text() {
     }
 
     braid_text.get = async (key, options) => {
+        if (key instanceof URL) {
+            if (!options) options = {}
+
+            options.my_abort = new AbortController()
+
+            var params = {
+                signal: options.my_abort.signal,
+                retry: () => true,
+                subscribe: !!options.subscribe,
+                heartbeats: 120,
+            }
+            for (var x of ['headers', 'parents', 'version', 'peer'])
+                if (options[x] != null) params[x] = options[x]
+
+            var res = await braid_fetch(key.href, params)
+
+            if (options.subscribe) {
+                res.subscribe(update => {
+                    update.body = update.body_text
+                    if (update.patches)
+                        for (var p of update.patches) p.content = p.content_text
+                    options.subscribe(update)
+                })
+                return res
+            } else return await res.text()
+        }
+
         if (!options) {
             // if it doesn't exist already, don't create it in this case
             if (!braid_text.cache[key]) return
@@ -412,6 +449,8 @@ function create_braid_text() {
     braid_text.forget = async (key, options) => {
         if (!options) throw new Error('options is required')
 
+        if (key instanceof URL) return options.my_abort.abort()
+
         let resource = (typeof key == 'string') ? await get_resource(key) : key
 
         if (options.merge_type != "dt")
@@ -420,6 +459,20 @@ function create_braid_text() {
     }
 
     braid_text.put = async (key, options) => {
+        if (key instanceof URL) {
+            options.my_abort = new AbortController()
+
+            var params = {
+                method: 'PUT',
+                signal: options.my_abort.signal,
+                retry: () => true,
+            }
+            for (var x of ['headers', 'parents', 'version', 'peer', 'body', 'patches'])
+                if (options[x] != null) params[x] = options[x]
+
+            return await braid_fetch(key.href, params)
+        }
+
         let { version, patches, body, peer } = options
 
         // support for json patch puts..
@@ -456,6 +509,12 @@ function create_braid_text() {
         }
 
         if (version) validate_version_array(version)
+        if (version && !version.length) {
+            console.log(`warning: ignoring put with empty version`)
+            return { change_count: 0 }
+        }
+        if (version && version.length > 1)
+            throw new Error(`cannot put a version with multiple ids`)
 
         // translate a single parent of "root" to the empty array (same meaning)
         let options_parents = options.parents
@@ -894,11 +953,11 @@ function create_braid_text() {
         var meta_filename = `${braid_text.db_folder}/.meta/${encoded}`
         var meta_dirty = null
         var meta_saving = null
+        var meta_file_content = '{}'
         try {
-            set_meta(JSON.parse(await fs.promises.readFile(meta_filename)))
-        } catch (e) {
-            console.error(`Error processing meta file: ${meta_filename}`)
-        }
+            var meta_file_content = await fs.promises.readFile(meta_filename)
+        } catch (e) {}
+        set_meta(JSON.parse(meta_file_content))
 
         let chain = Promise.resolve()
         return {

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "braid-text",
-  "version": "0.2.66",
+  "version": "0.2.68",
   "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.80"
+    "braid-http": "~1.3.83"
   }
 }

package/test/test.html

@@ -96,6 +96,398 @@ async function runTest(testName, testFunction, expectedResult) {
     }
 }
 
+runTest(
+    "test subscribe update with body_text",
+    async () => {
+        var key = 'test' + Math.random().toString(36).slice(2)
+
+        var r = await braid_fetch(`/${key}`, {
+            method: 'PUT',
+            body: 'hi'
+        })
+        if (!r.ok) return 'got: ' + r.status
+
+        var r1p = braid_fetch(`/eval`, {
+            method: 'PUT',
+            body: `void (async () => {
+                var x = await new Promise(done => {
+                    braid_text.get(new URL('http://localhost:8889/${key}'), {
+                        subscribe: update => {
+                            if (update.body_text) done(update.body_text)
+                        }
+                    })
+                })
+                res.end(x)
+            })()`
+        })
+
+        var r2 = await braid_fetch(`/${key}`, {
+            method: 'PUT',
+            body: 'yo'
+        })
+
+        var r1 = await r1p
+        if (!r1.ok) return 'got: ' + r.status
+
+        return await r1.text()
+    },
+    'yo'
+)
+
+runTest(
+    "test braid_text.sync, url to key",
+    async () => {
+        var key_a = 'test-a-' + Math.random().toString(36).slice(2)
+        var key_b = 'test-b-' + Math.random().toString(36).slice(2)
+
+        var r = await braid_fetch(`/${key_a}`, {
+            method: 'PUT',
+            body: 'hi'
+        })
+        if (!r.ok) return 'got: ' + r.status
+
+        var r = await braid_fetch(`/eval`, {
+            method: 'PUT',
+            body: `void (async () => {
+                braid_text.sync(new URL('http://localhost:8889/${key_a}'), '/${key_b}')
+                res.end('')
+            })()`
+        })
+        if (!r.ok) return 'got: ' + r.status
+
+        await new Promise(done => setTimeout(done, 100))
+
+        var r = await braid_fetch(`/${key_b}`)
+        return 'got: ' + (await r.text())
+    },
+    'got: hi'
+)
+
+runTest(
+    "test braid_text.sync, with two urls",
+    async () => {
+        var key_a = 'test-a-' + Math.random().toString(36).slice(2)
+        var key_b = 'test-b-' + Math.random().toString(36).slice(2)
+
+        var r = await braid_fetch(`/${key_a}`, {
+            method: 'PUT',
+            body: 'hi'
+        })
+        if (!r.ok) return 'got: ' + r.status
+
+        var r = await braid_fetch(`/eval`, {
+            method: 'PUT',
+            body: `void (async () => {
+                braid_text.sync(new URL('http://localhost:8889/${key_a}'),
+                    new URL('http://localhost:8889/${key_b}'))
+                res.end('')
+            })()`
+        })
+        if (!r.ok) return 'got: ' + r.status
+
+        await new Promise(done => setTimeout(done, 100))
+
+        var r = await braid_fetch(`/${key_b}`)
+        return 'got: ' + (await r.text())
+    },
+    'got: hi'
+)
+
+runTest(
+    "test braid_text.sync, key to url",
+    async () => {
+        var key_a = 'test-a-' + Math.random().toString(36).slice(2)
+        var key_b = 'test-b-' + Math.random().toString(36).slice(2)
+
+        var r = await braid_fetch(`/${key_a}`, {
+            method: 'PUT',
+            body: 'hi'
+        })
+        if (!r.ok) return 'got: ' + r.status
+
+        var r = await braid_fetch(`/eval`, {
+            method: 'PUT',
+            body: `void (async () => {
+                braid_text.sync('/${key_a}', new URL('http://localhost:8889/${key_b}'))
+                res.end('')
+            })()`
+        })
+        if (!r.ok) return 'got: ' + r.status
+
+        await new Promise(done => setTimeout(done, 100))
+
+        var r = await braid_fetch(`/${key_b}`)
+        return 'got: ' + (await r.text())
+    },
+    'got: hi'
+)
+
+runTest(
+    "test braid_text.sync, with two keys",
+    async () => {
+        var key_a = 'test-a-' + Math.random().toString(36).slice(2)
+        var key_b = 'test-b-' + Math.random().toString(36).slice(2)
+
+        var r = await braid_fetch(`/${key_a}`, {
+            method: 'PUT',
+            body: 'hi'
+        })
+        if (!r.ok) return 'got: ' + r.status
+
+        var r = await braid_fetch(`/eval`, {
+            method: 'PUT',
+            body: `void (async () => {
+                braid_text.sync('/${key_a}', '/${key_b}')
+                res.end('')
+            })()`
+        })
+        if (!r.ok) return 'got: ' + r.status
+
+        await new Promise(done => setTimeout(done, 100))
+
+        var r = await braid_fetch(`/${key_b}`)
+        return 'got: ' + (await r.text())
+    },
+    'got: hi'
+)
+
+runTest(
+    "test putting version with multiple event ids, should have error",
+    async () => {
+        var key_a = 'test-a-' + Math.random().toString(36).slice(2)
+
+        var r = await braid_fetch(`/${key_a}`, {
+            method: 'PUT',
+            version: ['abc-1', 'xyz-2'],
+            body: 'hi'
+        })
+        return '' + (await r.text()).includes('cannot put a version with multiple ids')
+    },
+    'true'
+)
+
+runTest(
+    "test braid_text.get(url), with no options",
+    async () => {
+        var key = 'test-' + Math.random().toString(36).slice(2)
+        let r = await braid_fetch(`/${key}`, {
+            method: 'PUT',
+            body: 'hi'
+        })
+        if (!r.ok) return 'got: ' + r.status
+
+        var r1 = await braid_fetch(`/eval`, {
+            method: 'PUT',
+            body: `void (async () => {
+                res.end(await braid_text.get(new URL('http://localhost:8889/${key}')))
+            })()`
+        })
+
+        return 'got: ' + (await r1.text())
+    },
+    'got: hi'
+)
+
+runTest(
+    "test braid_text.get(url), with headers",
+    async () => {
+        var key = 'test-' + Math.random().toString(36).slice(2)
+        let r = await braid_fetch(`/${key}`, {
+            method: 'PUT',
+            version: ['xyz-1'],
+            body: 'hi'
+        })
+        if (!r.ok) return 'got: ' + r.status
+
+        var r1 = await braid_fetch(`/eval`, {
+            method: 'PUT',
+            body: `void (async () => {
+                res.end(await braid_text.get(new URL('http://localhost:8889/${key}'), {
+                    headers: {
+                        version: '"xyz-0"'
+                    }
+                }))
+            })()`
+        })
+
+        return 'got: ' + (await r1.text())
+    },
+    'got: h'
+)
+
+runTest(
+    "test braid_text.get(url), with parents",
+    async () => {
+        var key = 'test-' + Math.random().toString(36).slice(2)
+        let r = await braid_fetch(`/${key}`, {
+            method: 'PUT',
+            version: ['xyz-1'],
+            body: 'hi'
+        })
+        if (!r.ok) return 'got: ' + r.status
+
+        var r1 = await braid_fetch(`/eval`, {
+            method: 'PUT',
+            body: `void (async () => {
+                res.end(await braid_text.get(new URL('http://localhost:8889/${key}'), {
+                    parents: ['xyz-0']
+                }))
+            })()`
+        })
+
+        return 'got: ' + (await r1.text())
+    },
+    'got: h'
+)
+
+runTest(
+    "test braid_text.get(url), with version and peer",
+    async () => {
+        var key = 'test-' + Math.random().toString(36).slice(2)
+        let r = await braid_fetch(`/${key}`, {
+            method: 'PUT',
+            version: ['xyz-1'],
+            body: 'hi'
+        })
+        if (!r.ok) return 'got: ' + r.status
+
+        var r1 = await braid_fetch(`/eval`, {
+            method: 'PUT',
+            body: `void (async () => {
+                res.end(await braid_text.get(new URL('http://localhost:8889/${key}'), {
+                    version: ['xyz-0'],
+                    peer: 'xyz'
+                }))
+            })()`
+        })
+
+        return 'got: ' + (await r1.text())
+    },
+    'got: h'
+)
+
+runTest(
+    "test braid_text.get(url) with subscription",
+    async () => {
+        var key = 'test-' + Math.random().toString(36).slice(2)
+        let r = await braid_fetch(`/${key}`, {
+            method: 'PUT',
+            version: ['xyz-1'],
+            body: 'hi'
+        })
+        if (!r.ok) return 'got: ' + r.status
+
+        var r1 = await braid_fetch(`/eval`, {
+            method: 'PUT',
+            body: `void (async () => {
+                var url = new URL('http://localhost:8889/${key}')
+                var update = await new Promise(done => {
+                    var o = {
+                        subscribe: update => {
+                            braid_text.forget(url, o)
+                            done(update)
+                        }
+                    }
+                    braid_text.get(url, o)
+                })
+                res.end(update.body)
+            })()`
+        })
+
+        return 'got: ' + (await r1.text())
+    },
+    'got: hi'
+)
+
+runTest(
+    "test braid_text.put(url), with body",
+    async () => {
+        var key = 'test-' + Math.random().toString(36).slice(2)
+
+        var r = await braid_fetch(`/eval`, {
+            method: 'PUT',
+            body: `void (async () => {
+                var r = await braid_text.put(new URL('http://localhost:8889/${key}'),
+                    {body: 'yo'})
+                res.end('')
+            })()`
+        })
+        if (!r.ok) return 'got: ' + r.status
+
+        let r1 = await braid_fetch(`/${key}`)
+        return 'got: ' + (await r1.text())
+    },
+    'got: yo'
+)
+
+runTest(
+    "test braid_text.put(url), with body and headers",
+    async () => {
+        var key = 'test-' + Math.random().toString(36).slice(2)
+
+        var r = await braid_fetch(`/eval`, {
+            method: 'PUT',
+            body: `void (async () => {
+                var r = await braid_text.put(new URL('http://localhost:8889/${key}'),
+                    {body: 'yo', headers: {version: '"abc123-1"'}})
+                res.end('')
+            })()`
+        })
+        if (!r.ok) return 'got: ' + r.status
+
+        let r2 = await braid_fetch(`/${key}`)
+        return 'got: ' + (await r2.text()) + ' -- version: ' + r2.headers.get('version')
+    },
+    'got: yo -- version: "abc123-1"'
+)
+
+runTest(
+    "test braid_text.put(url), with body and version and parents",
+    async () => {
+        var key = 'test-' + Math.random().toString(36).slice(2)
+        let r = await braid_fetch(`/${key}`, {
+            method: 'PUT',
+            body: 'hi',
+            version: ['abc-1']
+        })
+
+        var r1 = await braid_fetch(`/eval`, {
+            method: 'PUT',
+            body: `void (async () => {
+                var r = await braid_text.put(new URL('http://localhost:8889/${key}'),
+                    {body: 'yo', version: ['xyz-3'], parents: ['abc-1']})
+                res.end('')
+            })()`
+        })
+        if (!r1.ok) return 'got: ' + r1.status
+
+        let r2 = await braid_fetch(`/${key}`)
+        return 'got: ' + (await r2.text()) + ' -- version: ' + r2.headers.get('version')
+    },
+    'got: yo -- version: "xyz-3"'
+)
+
+runTest(
+    "test braid_text.put(url), with peer",
+    async () => {
+        var key = 'test-' + Math.random().toString(36).slice(2)
+
+        var r1 = await braid_fetch(`/eval`, {
+            method: 'PUT',
+            body: `void (async () => {
+                var r = await braid_text.put(new URL('http://localhost:8889/${key}'),
+                    {body: 'yo', peer: 'xyz', parents: []})
+                res.end('')
+            })()`
+        })
+        if (!r1.ok) return 'got: ' + r1.status
+
+        let r2 = await braid_fetch(`/${key}`)
+        return 'got: ' + (await r2.text()) + ' -- version: ' + r2.headers.get('version')
+    },
+    'got: yo -- version: "xyz-1"'
+)
+
 runTest(
     "test updating meta data",
     async () => {