braid-blob 0.0.22 → 0.0.24

package/.claude/settings.local.json

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

package/index.js

@@ -23,9 +23,10 @@ function create_braid_blob() {
             braid_blob.db = await url_file_db.create(
                 braid_blob.db_folder,
                 braid_blob.meta_folder,
-                async (key) => {
+                async (db, key) => {
                     // File changed externally, notify subscriptions
-                    var body = await braid_blob.db.read(key)
+                    // Use db parameter instead of braid_blob.db to avoid race condition
+                    var body = await db.read(key)
                     await braid_blob.put(key, body, { skip_write: true })
                 }
             )
@@ -208,6 +209,36 @@ function create_braid_blob() {
         return result
     }
 
+    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
+            }
+            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()
+
+        // 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()
 
@@ -291,7 +322,7 @@ 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('')
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "braid-blob",
-  "version": "0.0.22",
+  "version": "0.0.24",
   "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.19"
+    "url-file-db": "^0.0.21"
   }
 }

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 () => {
@@ -1309,6 +1405,95 @@ runTest(
     'true'
 )
 
+runTest(
+    "test that callback receives db parameter for use before assignment",
+    async () => {
+        var r1 = await braid_fetch(`/eval`, {
+            method: 'POST',
+            body: `void (async () => {
+                var fs = require('fs').promises
+                var test_id = 'test-callback-' + Math.random().toString(36).slice(2)
+                var db_folder = __dirname + '/' + test_id + '-db'
+                var meta_folder = __dirname + '/' + test_id + '-meta'
+
+                try {
+                    // Pre-create files that will trigger callback during init
+                    await fs.mkdir(db_folder, { recursive: true })
+                    await fs.mkdir(meta_folder, { recursive: true })
+
+                    // Write a file that exists before init
+                    await fs.writeFile(db_folder + '/pre-existing', 'old content')
+
+                    // Create metadata for it with old timestamp to trigger callback
+                    await fs.writeFile(meta_folder + '/!pre-existing', JSON.stringify({
+                        canonical_path: '/pre-existing',
+                        event: 'old-version',
+                        last_seen: Date.now() - 10000,
+                        mtime_ns: '1000000000000000'
+                    }))
+
+                    // Wait for files to be written
+                    await new Promise(resolve => setTimeout(resolve, 100))
+
+                    var callback_error = null
+                    var callback_called = false
+                    var db_was_null = false
+
+                    // Monkey-patch url_file_db.create to intercept callback
+                    var url_file_db_module = require('url-file-db').url_file_db
+                    var original_create = url_file_db_module.create
+
+                    url_file_db_module.create = async function(db_dir, meta_dir, callback) {
+                        var wrapped_callback = async function(db, key) {
+                            callback_called = true
+                            // Check if bb.db is null during callback
+                            if (!bb.db) {
+                                db_was_null = true
+                            }
+                            try {
+                                await callback(db, key)
+                            } catch (e) {
+                                callback_error = e.message
+                            }
+                        }
+                        return await original_create.call(this, db_dir, meta_dir, wrapped_callback)
+                    }
+
+                    var bb = braid_blob.create_braid_blob()
+                    bb.db_folder = db_folder
+                    bb.meta_folder = meta_folder
+
+                    // Init will trigger callback for pre-existing file
+                    // Callback tries to use braid_blob.db.read() but db not assigned yet
+                    await bb.init()
+
+                    // Restore
+                    url_file_db_module.create = original_create
+
+                    // Clean up
+                    await fs.rm(db_folder, { recursive: true, force: true })
+                    await fs.rm(meta_folder, { recursive: true, force: true })
+
+                    if (!callback_called) {
+                        res.end('callback was not called')
+                    } else if (callback_error) {
+                        res.end('callback error: ' + callback_error)
+                    } else {
+                        // Success: callback worked even if bb.db was null (using db param)
+                        res.end('true')
+                    }
+                } catch (e) {
+                    await fs.rm(db_folder, { recursive: true, force: true }).catch(() => {})
+                    await fs.rm(meta_folder, { recursive: true, force: true }).catch(() => {})
+                    res.end('error: ' + e.message)
+                }
+            })()`
+        })
+        return await r1.text()
+    },
+    'true'
+)
+
 }
 
 // Export for Node.js (CommonJS)