braid-blob 0.0.25 → 0.0.26

package/index.js

@@ -123,18 +123,9 @@ function create_braid_blob() {
             if (res.status === 404) return null
 
             if (options.subscribe) {
-                if (options.dont_retry) {
-                    var error_happened
-                    var error_promise = new Promise((_, fail) => error_happened = fail)
-                }
-
                 res.subscribe(async update => {
                     await options.subscribe(update)
-                }, e => options.dont_retry && error_happened(e))
-
-                if (options.dont_retry) {
-                    return await error_promise
-                }
+                }, e => options.on_error?.(e))
                 return res
             } else {
                 return await res.arrayBuffer()
@@ -374,6 +365,13 @@ function create_braid_blob() {
             var local_first_put_promise = new Promise(done => local_first_put = done)
             var remote_first_put_promise = new Promise(done => remote_first_put = done)
 
+            function handle_error(e) {
+                if (closed) return
+                disconnect()
+                console.log(`disconnected, retrying in 1 second`)
+                setTimeout(connect, 1000)
+            }
+
             async function connect() {
                 var ac = new AbortController()
                 disconnect = () => ac.abort()
@@ -418,16 +416,28 @@ function create_braid_blob() {
                     }
 
                     // Remote -> local: subscribe to remote updates
+                    // We need both: remote_res (for Editable header) and local file exists
+                    var got_remote_res, got_local_file
+                    var remote_res_promise = new Promise(done => got_remote_res = done)
+                    var local_file_promise = new Promise(done => got_local_file = done)
+
+                    // Apply read-only once we have both remote response and local file
+                    Promise.all([remote_res_promise, local_file_promise]).then(async () => {
+                        var read_only = remote_res.headers?.get('editable') === 'false'
+                        await braid_blob.db.set_read_only(a, read_only)
+                    })
+
                     var b_ops = {
                         signal: ac.signal,
-                        dont_retry: true,
                         subscribe: async update => {
                             await braid_blob.put(a, update.body, {
                                 version: update.version,
                                 content_type: update.headers?.['content-type']
                             })
+                            got_local_file()
                             remote_first_put()
                         },
+                        on_error: handle_error
                     }
                     // Use fork-point (parents) to avoid receiving data we already have
                     if (local_version) {
@@ -435,25 +445,25 @@ function create_braid_blob() {
                     }
 
                     // Set up both subscriptions, handling cases where one doesn't exist yet
-                    braid_blob.get(a, a_ops).then(x =>
-                        x || remote_first_put_promise.then(() =>
-                            braid_blob.get(a, a_ops)))
+                    braid_blob.get(a, a_ops).then(x => {
+                        if (x) got_local_file()
+                        else remote_first_put_promise.then(() =>
+                            braid_blob.get(a, a_ops))
+                    })
 
-                    // NOTE: this should not return, but it might throw
-                    await braid_blob.get(b, b_ops)
+                    // Get the response to check Editable header
+                    var remote_res = await braid_blob.get(b, b_ops)
+                    if (remote_res) got_remote_res()
 
-                    // this will only return if it couldn't find the key
-                    await local_first_put_promise
-                    disconnect()
-                    connect()
-                } catch (e) {
-                    if (closed) {
-                        return
+                    // If remote doesn't exist yet, wait for it to be created then reconnect
+                    if (!remote_res) {
+                        await local_first_put_promise
+                        disconnect()
+                        connect()
                     }
-
-                    disconnect()
-                    console.log(`disconnected, retrying in 1 second`)
-                    setTimeout(connect, 1000)
+                    // Otherwise, on_error will call handle_error when connection drops
+                } catch (e) {
+                    handle_error(e)
                 }
             }
             connect()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "braid-blob",
-  "version": "0.0.25",
+  "version": "0.0.26",
   "description": "Library for collaborative blobs over http using braid.",
   "author": "Braid Working Group",
   "repository": "braid-org/braid-blob",
@@ -11,6 +11,6 @@
   },
   "dependencies": {
     "braid-http": "~1.3.82",
-    "url-file-db": "^0.0.21"
+    "url-file-db": "^0.0.22"
   }
 }

package/test/tests.js

@@ -1147,6 +1147,153 @@ runTest(
     'shared content'
 )
 
+runTest(
+    "test sync readonly remote to nonexistent local",
+    async () => {
+        var local_key = 'test-sync-readonly-local-' + Math.random().toString(36).slice(2)
+        var remote_key = 'test-sync-readonly-remote-' + Math.random().toString(36).slice(2)
+
+        // Put something on the server first with Editable: false
+        var r1 = await braid_fetch(`/eval`, {
+            method: 'POST',
+            body: `void (async () => {
+                try {
+                    // Create a custom handler that sets Editable: false
+                    req.method = 'PUT'
+                    req.version = ['100']
+                    req.body = Buffer.from('readonly content')
+                    await braid_blob.put('${remote_key}', req.body, { version: req.version })
+                    res.end('created')
+                } catch (e) {
+                    res.end('error: ' + e.message + ' ' + e.stack)
+                }
+            })()`
+        })
+        var result = await r1.text()
+        if (result.startsWith('error:')) return result
+
+        // Now sync to a local key that doesn't exist, with a readonly remote
+        var r2 = await braid_fetch(`/eval`, {
+            method: 'POST',
+            body: `void (async () => {
+                try {
+                    var fs = require('fs').promises
+                    var test_id = 'test-sync-readonly-' + Math.random().toString(36).slice(2)
+                    var db_folder = __dirname + '/' + test_id + '-db'
+                    var meta_folder = __dirname + '/' + test_id + '-meta'
+
+                    var bb = braid_blob.create_braid_blob()
+                    bb.db_folder = db_folder
+                    bb.meta_folder = meta_folder
+
+                    // Create a mock server URL that returns Editable: false
+                    var http = require('http')
+                    var {http_server: braidify} = require('braid-http')
+
+                    var mock_server = http.createServer((req2, res2) => {
+                        braidify(req2, res2)
+                        res2.setHeader('Editable', 'false')
+                        braid_blob.serve(req2, res2, { key: '${remote_key}' })
+                    })
+
+                    await new Promise(resolve => mock_server.listen(0, resolve))
+                    var port = mock_server.address().port
+
+                    var remote_url = new URL('http://localhost:' + port + '/${remote_key}')
+                    var ac = new AbortController()
+
+                    // Start sync - local key doesn't exist yet
+                    bb.sync('${local_key}', remote_url, { signal: ac.signal })
+
+                    // Wait for sync to happen
+                    await new Promise(done => setTimeout(done, 500))
+
+                    // Stop sync
+                    ac.abort()
+                    mock_server.close()
+
+                    // Check if local file exists and has the content
+                    var result = await bb.get('${local_key}')
+
+                    var response
+                    if (!result) {
+                        response = 'file not created'
+                    } else if (result.body.toString() !== 'readonly content') {
+                        response = 'wrong content: ' + result.body.toString()
+                    } else {
+                        // Check if the file is actually read-only
+                        await bb.init()
+                        var is_readonly = await bb.db.is_read_only('${local_key}')
+                        response = is_readonly ? 'synced and readonly' : 'synced but NOT readonly'
+                    }
+
+                    // Clean up
+                    await fs.rm(db_folder, { recursive: true, force: true })
+                    await fs.rm(meta_folder, { recursive: true, force: true })
+
+                    res.end(response)
+                } catch (e) {
+                    res.end('error: ' + e.message + ' ' + e.stack)
+                }
+            })()`
+        })
+        return await r2.text()
+    },
+    'synced and readonly'
+)
+
+runTest(
+    "test sync does not disconnect unnecessarily",
+    async () => {
+        var local_key = 'test-sync-no-disconnect-local-' + Math.random().toString(36).slice(2)
+        var remote_key = 'test-sync-no-disconnect-remote-' + Math.random().toString(36).slice(2)
+
+        var r1 = await braid_fetch(`/eval`, {
+            method: 'POST',
+            body: `void (async () => {
+                try {
+                    var braid_blob = require(\`\${__dirname}/../index.js\`)
+
+                    // Put something locally first
+                    await braid_blob.put('${local_key}', Buffer.from('local content'), { version: ['600'] })
+
+                    var remote_url = new URL('http://localhost:' + req.socket.localPort + '/${remote_key}')
+
+                    // Capture console.log to count disconnects
+                    var disconnect_count = 0
+                    var original_log = console.log
+                    console.log = function(...args) {
+                        if (args[0]?.includes?.('disconnected')) disconnect_count++
+                        original_log.apply(console, args)
+                    }
+
+                    // Create an AbortController to stop the sync
+                    var ac = new AbortController()
+
+                    // Start sync
+                    braid_blob.sync('${local_key}', remote_url, { signal: ac.signal })
+
+                    // Wait for sync to establish and stabilize
+                    await new Promise(done => setTimeout(done, 500))
+
+                    // Stop sync
+                    ac.abort()
+
+                    // Restore console.log
+                    console.log = original_log
+
+                    // Should have zero disconnects during normal operation
+                    res.end(disconnect_count === 0 ? 'no disconnects' : 'disconnects: ' + disconnect_count)
+                } catch (e) {
+                    res.end('error: ' + e.message + ' ' + e.stack)
+                }
+            })()`
+        })
+        return await r1.text()
+    },
+    'no disconnects'
+)
+
 runTest(
     "test sync closed during error",
     async () => {