braid-text 0.2.66 → 0.2.67

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() {
@@ -291,6 +291,28 @@ 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(options.subscribe)
+                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 +434,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 +444,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'])
+                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..
@@ -894,11 +932,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,6 +1,6 @@
 {
   "name": "braid-text",
-  "version": "0.2.66",
+  "version": "0.2.67",
   "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,228 @@ async function runTest(testName, testFunction, expectedResult) {
     }
 }
 
+// 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_text)
+            })()`
+        })
+
+        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 () => {