braid-blob 0.0.24 → 0.0.26

package/index.js

@@ -40,15 +40,10 @@ function create_braid_blob() {
     braid_blob.put = async (key, body, options = {}) => {
         // Handle URL case - make a remote PUT request
         if (key instanceof URL) {
-            options.my_abort = new AbortController()
-            if (options.signal) {
-                options.signal.addEventListener('abort', () =>
-                    options.my_abort.abort())
-            }
 
             var params = {
                 method: 'PUT',
-                signal: options.my_abort.signal,
+                signal: options.signal,
                 retry: () => true,
                 body: body
             }
@@ -62,6 +57,7 @@ function create_braid_blob() {
         }
 
         await braid_blob.init()
+        if (options.signal?.aborted) return
 
         // Read the meta data using new meta API
         var meta = braid_blob.db.get_meta(key) || {}
@@ -83,6 +79,7 @@ function create_braid_blob() {
             // Write the file using url-file-db (unless skip_write is set)
             if (!options.skip_write)
                 await braid_blob.db.write(key, body)
+            if (options.signal?.aborted) return
 
             // Update only the fields we want to change in metadata
             var meta_updates = { event: their_e }
@@ -90,6 +87,7 @@ function create_braid_blob() {
                 meta_updates.content_type = options.content_type
 
             await braid_blob.db.update_meta(key, meta_updates)
+            if (options.signal?.aborted) return
 
             // Notify all subscriptions of the update
             // (except the peer which made the PUT request itself)
@@ -109,34 +107,25 @@ function create_braid_blob() {
     braid_blob.get = async (key, options = {}) => {
         // Handle URL case - make a remote GET request
         if (key instanceof URL) {
-            options.my_abort = new AbortController()
-
             var params = {
-                signal: options.my_abort.signal,
+                signal: options.signal,
                 subscribe: !!options.subscribe,
                 heartbeats: 120,
             }
             if (!options.dont_retry) {
-                params.retry = () => true
+                params.retry = (res) => res.status !== 404
             }
             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) {
-                if (options.dont_retry) {
-                    var error_happened
-                    var error_promise = new Promise((_, fail) => error_happened = fail)
-                }
+            if (res.status === 404) return null
 
+            if (options.subscribe) {
                 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()
@@ -154,6 +143,7 @@ function create_braid_blob() {
             content_type: meta.content_type
         }
         if (options.header_cb) await options.header_cb(result)
+        if (options.signal?.aborted) return
         // Check if requested version/parents is newer than what we have - if so, we don't have it
         if (options.version && options.version.length && compare_events(options.version[0], meta.event) > 0)
             throw new Error('unkown version: ' + options.version)
@@ -164,7 +154,8 @@ function create_braid_blob() {
         if (options.subscribe) {
             var subscribe_chain = Promise.resolve()
             options.my_subscribe = (x) => subscribe_chain =
-                subscribe_chain.then(() => options.subscribe(x))
+                subscribe_chain.then(() =>
+                    !options.signal?.aborted && options.subscribe(x))
 
             // Start a subscription for future updates
             if (!braid_blob.key_to_subs[key])
@@ -181,14 +172,14 @@ function create_braid_blob() {
                 }
             })
 
-            // Store unsubscribe function
-            result.unsubscribe = () => {
+            options.signal?.addEventListener('abort', () => {
                 braid_blob.key_to_subs[key].delete(peer)
                 if (!braid_blob.key_to_subs[key].size)
                     delete braid_blob.key_to_subs[key]
-            }
+            })
 
             if (options.before_send_cb) await options.before_send_cb(result)
+            if (options.signal?.aborted) return
 
             // Send an immediate update if needed
             if (!options.parents ||
@@ -212,15 +203,10 @@ function create_braid_blob() {
     braid_blob.delete = async (key, options = {}) => {
         // Handle URL case - make a remote DELETE request
         if (key instanceof URL) {
-            options.my_abort = new AbortController()
-            if (options.signal) {
-                options.signal.addEventListener('abort', () =>
-                    options.my_abort.abort())
-            }
 
             var params = {
                 method: 'DELETE',
-                signal: options.my_abort.signal
+                signal: options.signal
             }
             for (var x of ['headers', 'peer'])
                 if (options[x] != null) params[x] = options[x]
@@ -229,6 +215,7 @@ function create_braid_blob() {
         }
 
         await braid_blob.init()
+        if (options.signal?.aborted) return
 
         // Delete the file from the database
         await braid_blob.db.delete(key)
@@ -329,27 +316,40 @@ function create_braid_blob() {
         })
     }
 
-    braid_blob.sync = async (a, b, options = {}) => {
-        var unsync_cbs = []
-        options.my_unsync = () => unsync_cbs.forEach(cb => cb())
-
+    braid_blob.sync = (a, b, options = {}) => {
         if ((a instanceof URL) === (b instanceof URL)) {
             // Both are URLs or both are local keys
+            var a_first_put, b_first_put
+            var a_first_put_promise = new Promise(done => a_first_put = done)
+            var b_first_put_promise = new Promise(done => b_first_put = done)
+
             var a_ops = {
-                subscribe: update => braid_blob.put(b, update.body, {
-                    version: update.version,
-                    content_type: update.headers?.['content-type']
-                })
+                signal: options.signal,
+                subscribe: update => {
+                    braid_blob.put(b, update.body, {
+                        signal: options.signal,
+                        version: update.version,
+                        content_type: update.headers?.['content-type']
+                    }).then(a_first_put)
+                }
             }
-            braid_blob.get(a, a_ops)
+            braid_blob.get(a, a_ops).then(x =>
+                x || b_first_put_promise.then(() =>
+                    braid_blob.get(a, a_ops)))
 
             var b_ops = {
-                subscribe: update => braid_blob.put(a, update.body, {
-                    version: update.version,
-                    content_type: update.headers?.['content-type']
-                })
+                signal: options.signal,
+                subscribe: update => {
+                    braid_blob.put(a, update.body, {
+                        signal: options.signal,
+                        version: update.version,
+                        content_type: update.headers?.['content-type']
+                    }).then(b_first_put)
+                }
             }
-            braid_blob.get(b, b_ops)
+            braid_blob.get(b, b_ops).then(x =>
+                x || a_first_put_promise.then(() =>
+                    braid_blob.get(b, b_ops)))
         } else {
             // One is local, one is remote - make a=local and b=remote (swap if not)
             if (a instanceof URL) {
@@ -357,17 +357,30 @@ function create_braid_blob() {
             }
 
             var closed = false
-            options.my_unsync = () => { closed = true; disconnect() }
-
             var disconnect = () => { }
+            options.signal?.addEventListener('abort', () =>
+                { closed = true; disconnect() })
+
+            var local_first_put, remote_first_put
+            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()
-                var disconnect_cbs = [() => ac.abort()]
-                disconnect = () => disconnect_cbs.forEach(cb => cb())
+                disconnect = () => ac.abort()
 
                 try {
                     // Check if remote has our current version (simple fork-point check)
-                    var local_result = await braid_blob.get(a)
+                    var local_result = await braid_blob.get(a, {
+                        signal: ac.signal
+                    })
                     var local_version = local_result ? local_result.version : null
                     var server_has_our_version = false
 
@@ -383,12 +396,13 @@ function create_braid_blob() {
 
                     // Local -> remote: subscribe to future local changes
                     var a_ops = {
+                        signal: ac.signal,
                         subscribe: update => {
-                            update.signal = ac.signal
                             braid_blob.put(b, update.body, {
+                                signal: ac.signal,
                                 version: update.version,
                                 content_type: update.content_type
-                            }).catch(e => {
+                            }).then(local_first_put).catch(e => {
                                 if (e.name === 'AbortError') {
                                     // ignore
                                 } else throw e
@@ -400,32 +414,56 @@ function create_braid_blob() {
                     if (server_has_our_version) {
                         a_ops.parents = local_version
                     }
-                    braid_blob.get(a, a_ops)
 
                     // 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 = {
-                        dont_retry: true,
+                        signal: ac.signal,
                         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) {
                         b_ops.parents = local_version
                     }
-                    // NOTE: this should not return, but it might throw
-                    await braid_blob.get(b, b_ops)
-                } catch (e) {
-                    if (closed) {
-                        return
-                    }
 
-                    disconnect()
-                    console.log(`disconnected, retrying in 1 second`)
-                    setTimeout(connect, 1000)
+                    // Set up both subscriptions, handling cases where one doesn't exist yet
+                    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))
+                    })
+
+                    // Get the response to check Editable header
+                    var remote_res = await braid_blob.get(b, b_ops)
+                    if (remote_res) got_remote_res()
+
+                    // If remote doesn't exist yet, wait for it to be created then reconnect
+                    if (!remote_res) {
+                        await local_first_put_promise
+                        disconnect()
+                        connect()
+                    }
+                    // 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.24",
+  "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 () => {
@@ -1162,12 +1309,14 @@ runTest(
                     // Use an invalid/unreachable URL to trigger an error
                     var remote_url = new URL('http://localhost:9999/${remote_key}')
 
-                    // Start sync
-                    var sync_options = {}
-                    braid_blob.sync('${local_key}', remote_url, sync_options)
+                    // Create an AbortController to stop the sync
+                    var ac = new AbortController()
+
+                    // Start sync with signal
+                    braid_blob.sync('${local_key}', remote_url, { signal: ac.signal })
 
                     // Close the sync immediately to trigger the closed path when error occurs
-                    sync_options.my_unsync()
+                    ac.abort()
 
                     res.end('sync started and closed')
                 } catch (e) {
@@ -1201,15 +1350,17 @@ runTest(
                     // Use an invalid/unreachable URL to trigger an error
                     var remote_url = new URL('http://localhost:9999/${remote_key}')
 
-                    // Start sync without closing it - should trigger retry
-                    var sync_options = {}
-                    braid_blob.sync('${local_key}', remote_url, sync_options)
+                    // Create an AbortController to stop the sync
+                    var ac = new AbortController()
+
+                    // Start sync with signal - should trigger retry on error
+                    braid_blob.sync('${local_key}', remote_url, { signal: ac.signal })
 
                     // Wait a bit for the error to occur and retry message to print
                     await new Promise(done => setTimeout(done, 200))
 
                     // Now close it to stop retrying
-                    sync_options.my_unsync()
+                    ac.abort()
 
                     res.end('sync error occurred')
                 } catch (e) {
@@ -1494,6 +1645,213 @@ runTest(
     'true'
 )
 
+runTest(
+    "test get with URL returns null on 404",
+    async () => {
+        var key = 'test-url-get-404-' + Math.random().toString(36).slice(2)
+
+        var r1 = await braid_fetch(`/eval`, {
+            method: 'POST',
+            body: `void (async () => {
+                var braid_blob = require(\`\${__dirname}/../index.js\`)
+                var url = new URL('http://localhost:' + req.socket.localPort + '/${key}')
+                var result = await braid_blob.get(url)
+                res.end(result === null ? 'null' : 'not null: ' + JSON.stringify(result))
+            })()`
+        })
+
+        return await r1.text()
+    },
+    'null'
+)
+
+runTest(
+    "test signal abort stops local put operation",
+    async () => {
+        var r1 = await braid_fetch(`/eval`, {
+            method: 'POST',
+            body: `void (async () => {
+                var fs = require('fs').promises
+                var test_id = 'test-abort-put-' + Math.random().toString(36).slice(2)
+                var db_folder = __dirname + '/' + test_id + '-db'
+                var meta_folder = __dirname + '/' + test_id + '-meta'
+
+                try {
+                    var bb = braid_blob.create_braid_blob()
+                    bb.db_folder = db_folder
+                    bb.meta_folder = meta_folder
+
+                    // Create an already-aborted signal
+                    var ac = new AbortController()
+                    ac.abort()
+
+                    // Try to put with aborted signal
+                    var result = await bb.put('/test-file', Buffer.from('hello'), {
+                        signal: ac.signal
+                    })
+
+                    // Result should be undefined since operation was aborted
+                    res.end(result === undefined ? 'aborted' : 'not aborted: ' + result)
+                } catch (e) {
+                    res.end('error: ' + e.message)
+                } finally {
+                    await fs.rm(db_folder, { recursive: true, force: true })
+                    await fs.rm(meta_folder, { recursive: true, force: true })
+                }
+            })()`
+        })
+        return await r1.text()
+    },
+    'aborted'
+)
+
+runTest(
+    "test signal abort stops local get operation",
+    async () => {
+        var r1 = await braid_fetch(`/eval`, {
+            method: 'POST',
+            body: `void (async () => {
+                var fs = require('fs').promises
+                var test_id = 'test-abort-get-' + Math.random().toString(36).slice(2)
+                var db_folder = __dirname + '/' + test_id + '-db'
+                var meta_folder = __dirname + '/' + test_id + '-meta'
+
+                try {
+                    var bb = braid_blob.create_braid_blob()
+                    bb.db_folder = db_folder
+                    bb.meta_folder = meta_folder
+
+                    // Put a file first
+                    await bb.put('/test-file', Buffer.from('hello'), { version: ['1'] })
+
+                    // Create an already-aborted signal
+                    var ac = new AbortController()
+                    ac.abort()
+
+                    // Try to get with aborted signal (after header_cb)
+                    var header_called = false
+                    var result = await bb.get('/test-file', {
+                        signal: ac.signal,
+                        header_cb: () => { header_called = true }
+                    })
+
+                    // Result should be undefined since operation was aborted after header_cb
+                    res.end(header_called && result === undefined ? 'aborted' : 'not aborted: header=' + header_called + ' result=' + JSON.stringify(result))
+                } catch (e) {
+                    res.end('error: ' + e.message)
+                } finally {
+                    await fs.rm(db_folder, { recursive: true, force: true })
+                    await fs.rm(meta_folder, { recursive: true, force: true })
+                }
+            })()`
+        })
+        return await r1.text()
+    },
+    'aborted'
+)
+
+runTest(
+    "test signal abort stops local delete operation",
+    async () => {
+        var r1 = await braid_fetch(`/eval`, {
+            method: 'POST',
+            body: `void (async () => {
+                var fs = require('fs').promises
+                var test_id = 'test-abort-delete-' + Math.random().toString(36).slice(2)
+                var db_folder = __dirname + '/' + test_id + '-db'
+                var meta_folder = __dirname + '/' + test_id + '-meta'
+
+                try {
+                    var bb = braid_blob.create_braid_blob()
+                    bb.db_folder = db_folder
+                    bb.meta_folder = meta_folder
+
+                    // Put a file first
+                    await bb.put('/test-file', Buffer.from('hello'), { version: ['1'] })
+
+                    // Create an already-aborted signal
+                    var ac = new AbortController()
+                    ac.abort()
+
+                    // Try to delete with aborted signal
+                    await bb.delete('/test-file', { signal: ac.signal })
+
+                    // File should still exist since delete was aborted
+                    var result = await bb.get('/test-file')
+                    res.end(result && result.body ? 'still exists' : 'deleted')
+                } catch (e) {
+                    res.end('error: ' + e.message)
+                } finally {
+                    await fs.rm(db_folder, { recursive: true, force: true })
+                    await fs.rm(meta_folder, { recursive: true, force: true })
+                }
+            })()`
+        })
+        return await r1.text()
+    },
+    'still exists'
+)
+
+runTest(
+    "test signal abort stops subscription updates",
+    async () => {
+        var r1 = await braid_fetch(`/eval`, {
+            method: 'POST',
+            body: `void (async () => {
+                var fs = require('fs').promises
+                var test_id = 'test-abort-sub-' + Math.random().toString(36).slice(2)
+                var db_folder = __dirname + '/' + test_id + '-db'
+                var meta_folder = __dirname + '/' + test_id + '-meta'
+
+                try {
+                    var bb = braid_blob.create_braid_blob()
+                    bb.db_folder = db_folder
+                    bb.meta_folder = meta_folder
+
+                    // Put a file first
+                    await bb.put('/test-file', Buffer.from('v1'), { version: ['1'] })
+
+                    // Subscribe with an AbortController
+                    var ac = new AbortController()
+                    var updates = []
+
+                    await bb.get('/test-file', {
+                        signal: ac.signal,
+                        subscribe: (update) => {
+                            updates.push(update.body.toString())
+                        }
+                    })
+
+                    // Should have received initial update
+                    if (updates.length !== 1 || updates[0] !== 'v1') {
+                        res.end('initial update wrong: ' + JSON.stringify(updates))
+                        return
+                    }
+
+                    // Abort the subscription
+                    ac.abort()
+
+                    // Put another update
+                    await bb.put('/test-file', Buffer.from('v2'), { version: ['2'] })
+
+                    // Wait a bit for any updates to propagate
+                    await new Promise(done => setTimeout(done, 50))
+
+                    // Should still only have the initial update
+                    res.end(updates.length === 1 ? 'stopped' : 'got extra: ' + JSON.stringify(updates))
+                } catch (e) {
+                    res.end('error: ' + e.message)
+                } finally {
+                    await fs.rm(db_folder, { recursive: true, force: true })
+                    await fs.rm(meta_folder, { recursive: true, force: true })
+                }
+            })()`
+        })
+        return await r1.text()
+    },
+    'stopped'
+)
+
 }
 
 // Export for Node.js (CommonJS)