braid-blob 0.0.23 → 0.0.25

package/.claude/settings.local.json

@@ -0,0 +1,9 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npm test:*)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

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,21 +107,21 @@ 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 (res.status === 404) return null
+
             if (options.subscribe) {
                 if (options.dont_retry) {
                     var error_happened
@@ -154,6 +152,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 +163,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 +181,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 ||
@@ -209,6 +209,32 @@ function create_braid_blob() {
         return result
     }
 
+    braid_blob.delete = async (key, options = {}) => {
+        // Handle URL case - make a remote DELETE request
+        if (key instanceof URL) {
+
+            var params = {
+                method: 'DELETE',
+                signal: options.signal
+            }
+            for (var x of ['headers', 'peer'])
+                if (options[x] != null) params[x] = options[x]
+
+            return await braid_fetch(key.href, params)
+        }
+
+        await braid_blob.init()
+        if (options.signal?.aborted) return
+
+        // Delete the file from the database
+        await braid_blob.db.delete(key)
+
+        // TODO: notify subscribers of deletion once we have a protocol for that
+        // For now, just clean up the subscriptions
+        if (braid_blob.key_to_subs[key])
+            delete braid_blob.key_to_subs[key]
+    }
+
     braid_blob.serve = async (req, res, options = {}) => {
         await braid_blob.init()
 
@@ -292,34 +318,47 @@ function create_braid_blob() {
                 res.setHeader("Version", version_to_header(event != null ? [event] : []))
                 res.end('')
             } else if (req.method === 'DELETE') {
-                await braid_blob.db.delete(options.key)
+                await braid_blob.delete(options.key)
                 res.statusCode = 204 // No Content
                 res.end('')
             }
         })
     }
 
-    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) {
@@ -327,17 +366,23 @@ 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)
+
             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
 
@@ -353,12 +398,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
@@ -370,24 +416,36 @@ 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
                     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']
                             })
+                            remote_first_put()
                         },
                     }
                     // Use fork-point (parents) to avoid receiving data we already have
                     if (local_version) {
                         b_ops.parents = local_version
                     }
+
+                    // 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)))
+
                     // NOTE: this should not return, but it might throw
                     await braid_blob.get(b, b_ops)
+
+                    // this will only return if it couldn't find the key
+                    await local_first_put_promise
+                    disconnect()
+                    connect()
                 } catch (e) {
                     if (closed) {
                         return

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "braid-blob",
-  "version": "0.0.23",
+  "version": "0.0.25",
   "description": "Library for collaborative blobs over http using braid.",
   "author": "Braid Working Group",
   "repository": "braid-org/braid-blob",

package/test/tests.js

@@ -381,6 +381,102 @@ runTest(
     '204'
 )
 
+runTest(
+    "test braid_blob.delete() directly",
+    async () => {
+        var r1 = await braid_fetch(`/eval`, {
+            method: 'POST',
+            body: `void (async () => {
+                var test_id = 'test-db-' + 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
+
+                try {
+                    // Put a file
+                    await bb.put('/test-file', Buffer.from('hello'))
+
+                    // Verify it exists
+                    var result = await bb.get('/test-file')
+                    if (!result || !result.body) {
+                        res.end('error: file not found after put')
+                        return
+                    }
+
+                    // Delete it
+                    await bb.delete('/test-file')
+
+                    // Verify it's gone
+                    var result2 = await bb.get('/test-file')
+                    if (result2) {
+                        res.end('error: file still exists after delete')
+                        return
+                    }
+
+                    res.end('true')
+                } catch (e) {
+                    res.end('error: ' + e.message)
+                } finally {
+                    await require('fs').promises.rm(db_folder, { recursive: true, force: true })
+                    await require('fs').promises.rm(meta_folder, { recursive: true, force: true })
+                }
+            })()`
+        })
+        return await r1.text()
+    },
+    'true'
+)
+
+runTest(
+    "test braid_blob.delete() cleans up subscriptions",
+    async () => {
+        var r1 = await braid_fetch(`/eval`, {
+            method: 'POST',
+            body: `void (async () => {
+                var test_id = 'test-db-' + 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
+
+                try {
+                    // Put a file
+                    await bb.put('/test-file', Buffer.from('hello'))
+
+                    // Subscribe to it
+                    var got_update = false
+                    await bb.get('/test-file', {
+                        subscribe: (update) => { got_update = true }
+                    })
+
+                    // Verify subscription exists
+                    var has_sub_before = !!bb.key_to_subs['/test-file']
+
+                    // Delete it
+                    await bb.delete('/test-file')
+
+                    // Verify subscription is cleaned up
+                    var has_sub_after = !!bb.key_to_subs['/test-file']
+
+                    res.end('' + (has_sub_before && !has_sub_after))
+                } catch (e) {
+                    res.end('error: ' + e.message)
+                } finally {
+                    await require('fs').promises.rm(db_folder, { recursive: true, force: true })
+                    await require('fs').promises.rm(meta_folder, { recursive: true, force: true })
+                }
+            })()`
+        })
+        return await r1.text()
+    },
+    'true'
+)
+
 runTest(
     "test that subscribe returns current-version header",
     async () => {
@@ -1066,12 +1162,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) {
@@ -1105,15 +1203,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) {
@@ -1398,6 +1498,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)