braid-blob 0.0.21 → 0.0.23

package/index.js

@@ -1,6 +1,5 @@
 var {http_server: braidify, fetch: braid_fetch} = require('braid-http'),
     {url_file_db} = require('url-file-db'),
-    fs = require('fs'),
     path = require('path')
 
 function create_braid_blob() {
@@ -9,9 +8,8 @@ function create_braid_blob() {
         meta_folder: './braid-blob-meta',
         cache: {},
         key_to_subs: {},
-        peer: null, // we'll try to load this from a file, if not set by the user
-        db: null, // url-file-db instance for blob storage
-        meta_db: null // url-file-db instance for meta storage
+        peer: null, // will be auto-generated if not set by the user
+        db: null // url-file-db instance with integrated meta storage
     }
 
     braid_blob.init = async () => {
@@ -21,25 +19,21 @@ function create_braid_blob() {
         await braid_blob.init()
 
         async function real_init() {
-            // Create url-file-db instance for blob storage
-            braid_blob.db = await url_file_db.create(braid_blob.db_folder, async (key) => {
-                // File changed externally, notify subscriptions
-                var body = await braid_blob.db.read(key)
-                await braid_blob.put(key, body, { skip_write: true })
-            })
-
-            // Create url-file-db instance for meta storage (in a subfolder)
-            // This will create both meta_folder and the db subfolder with recursive: true
-            braid_blob.meta_db = await url_file_db.create(`${braid_blob.meta_folder}/db`)
+            // Create url-file-db instance with integrated meta storage
+            braid_blob.db = await url_file_db.create(
+                braid_blob.db_folder,
+                braid_blob.meta_folder,
+                async (db, key) => {
+                    // File changed externally, notify subscriptions
+                    // 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 })
+                }
+            )
 
-            // establish a peer id (stored at root of meta_folder, sibling to db subfolder)
-            if (!braid_blob.peer)
-                try {
-                    braid_blob.peer = await fs.promises.readFile(`${braid_blob.meta_folder}/peer.txt`, 'utf8')
-                } catch (e) {}
+            // establish a peer id if not already set
             if (!braid_blob.peer)
                 braid_blob.peer = Math.random().toString(36).slice(2)
-            await fs.promises.writeFile(`${braid_blob.meta_folder}/peer.txt`, braid_blob.peer)
         }
     }
 
@@ -69,11 +63,8 @@ function create_braid_blob() {
 
         await braid_blob.init()
 
-        // Read the meta data from meta_db
-        var meta = {}
-        var meta_content = await braid_blob.meta_db.read(key)
-        if (meta_content)
-            meta = JSON.parse(meta_content.toString('utf8'))
+        // Read the meta data using new meta API
+        var meta = braid_blob.db.get_meta(key) || {}
 
         var their_e =
             !options.version ?
@@ -93,11 +84,12 @@ function create_braid_blob() {
             if (!options.skip_write)
                 await braid_blob.db.write(key, body)
 
-            // Write the meta data
+            // Update only the fields we want to change in metadata
+            var meta_updates = { event: their_e }
             if (options.content_type)
-                meta.content_type = options.content_type
+                meta_updates.content_type = options.content_type
 
-            await braid_blob.meta_db.write(key, JSON.stringify(meta))
+            await braid_blob.db.update_meta(key, meta_updates)
 
             // Notify all subscriptions of the update
             // (except the peer which made the PUT request itself)
@@ -153,11 +145,8 @@ function create_braid_blob() {
 
         await braid_blob.init()
 
-        // Read the meta data from meta_db
-        var meta = {}
-        var meta_content = await braid_blob.meta_db.read(key)
-        if (meta_content)
-            meta = JSON.parse(meta_content.toString('utf8'))
+        // Read the meta data using new meta API
+        var meta = braid_blob.db.get_meta(key) || {}
         if (meta.event == null) return null
 
         var result = {
@@ -238,12 +227,6 @@ function create_braid_blob() {
         var body = req.method === 'PUT' && await slurp(req)
 
         await within_fiber(options.key, async () => {
-            // Read the meta data from meta_db
-            var meta = {}
-            var meta_content = await braid_blob.meta_db.read(options.key)
-            if (meta_content)
-                meta = JSON.parse(meta_content.toString('utf8'))
-
             if (req.method === 'GET' || req.method === 'HEAD') {
                 if (!res.hasHeader("editable")) res.setHeader("Editable", "true")
                 if (!req.subscribe) res.setHeader("Accept-Subscribe", "true")
@@ -301,16 +284,15 @@ function create_braid_blob() {
                 }
             } else if (req.method === 'PUT') {
                 // Handle PUT request to update binary files
-                meta.event = await braid_blob.put(options.key, body, {
+                var event = await braid_blob.put(options.key, body, {
                     version: req.version,
                     content_type: req.headers['content-type'],
                     peer: req.peer
                 })
-                res.setHeader("Version", version_to_header(meta.event != null ? [meta.event] : []))
+                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.meta_db.delete(options.key)
                 res.statusCode = 204 // No Content
                 res.end('')
             }

package/package.json

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

package/test/tests.js

@@ -34,7 +34,7 @@ runTest(
 )
 
 runTest(
-    "test that peer is same the second time we run from same db folder",
+    "test that peer is different each time we create a new instance",
     async () => {
         var r1 = await braid_fetch(`/eval`, {
             method: 'POST',
@@ -62,7 +62,7 @@ runTest(
                 await require('fs').promises.rm(db, { recursive: true, force: true })
                 await require('fs').promises.rm(meta, { recursive: true, force: true })
 
-                res.end('' + (bb1.peer === bb2.peer))
+                res.end('' + (bb1.peer !== bb2.peer))
             })()`
         })
         return await r1.text()
@@ -100,6 +100,39 @@ runTest(
     'test_peer'
 )
 
+runTest(
+    "test that manually set peer persists through initialization",
+    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 = __dirname + '/' + test_id + '-db'
+                var meta = __dirname + '/' + test_id + '-meta'
+
+                // Create instance with manually set peer
+                var bb1 = braid_blob.create_braid_blob()
+                bb1.db_folder = db
+                bb1.meta_folder = meta
+                bb1.peer = 'custom-peer-id-123'
+
+                // Initialize (should keep our custom peer)
+                await bb1.init()
+
+                var peer_after_init = bb1.peer
+
+                // Clean up
+                await require('fs').promises.rm(db, { recursive: true, force: true })
+                await require('fs').promises.rm(meta, { recursive: true, force: true })
+
+                res.end(peer_after_init === 'custom-peer-id-123' ? 'true' : 'false: ' + peer_after_init)
+            })()`
+        })
+        return await r1.text()
+    },
+    'true'
+)
+
 runTest(
     "test that PUTing with shorter event id doesn't do anything.",
     async () => {
@@ -1142,6 +1175,229 @@ runTest(
     '309'
 )
 
+runTest(
+    "test multiple writes preserve correct mtime across restarts",
+    async () => {
+        var r1 = await braid_fetch(`/eval`, {
+            method: 'POST',
+            body: `void (async () => {
+                var fs = require('fs').promises
+                var test_id = 'test-multi-write-' + Math.random().toString(36).slice(2)
+                var db_folder = __dirname + '/' + test_id + '-db'
+                var meta_folder = __dirname + '/' + test_id + '-meta'
+                var test_key = 'test-file'
+
+                try {
+                    // Create first braid_blob instance
+                    var bb1 = braid_blob.create_braid_blob()
+                    bb1.db_folder = db_folder
+                    bb1.meta_folder = meta_folder
+
+                    // First write
+                    await bb1.put(test_key, Buffer.from('content1'), {
+                        version: ['version-1']
+                    })
+
+                    // Wait a bit to ensure different mtime
+                    await new Promise(resolve => setTimeout(resolve, 50))
+
+                    // Second write to same file (this is where the bug would occur)
+                    await bb1.put(test_key, Buffer.from('content2'), {
+                        version: ['version-2']
+                    })
+
+                    var result1 = await bb1.get(test_key)
+
+                    // Now restart and check
+                    var bb2 = braid_blob.create_braid_blob()
+                    bb2.db_folder = db_folder
+                    bb2.meta_folder = meta_folder
+
+                    // This should NOT trigger a file change callback
+                    var result2 = await bb2.get(test_key)
+
+                    // Version should still be version-2, not regenerated
+                    var correct_version = (result2.version[0] === 'version-2')
+                    var content_correct = (result2.body.toString() === 'content2')
+
+                    // Clean up
+                    await fs.rm(db_folder, { recursive: true, force: true })
+                    await fs.rm(meta_folder, { recursive: true, force: true })
+
+                    res.end(correct_version && content_correct ? 'true' :
+                            'false: version=' + result2.version[0] + ', content=' + result2.body.toString())
+                } catch (e) {
+                    // Clean up even on error
+                    await fs.rm(db_folder, { recursive: true, force: true })
+                    await fs.rm(meta_folder, { recursive: true, force: true })
+                    res.end('error: ' + e.message)
+                }
+            })()`
+        })
+        return await r1.text()
+    },
+    'true'
+)
+
+runTest(
+    "test that files keep same event ID across restarts when not edited",
+    async () => {
+        var r1 = await braid_fetch(`/eval`, {
+            method: 'POST',
+            body: `void (async () => {
+                var fs = require('fs').promises
+                var test_id = 'test-persist-event-' + Math.random().toString(36).slice(2)
+                var db_folder = __dirname + '/' + test_id + '-db'
+                var meta_folder = __dirname + '/' + test_id + '-meta'
+                var test_key = 'test-file'
+                var test_content = 'test content that should not change'
+
+                try {
+                    // Create first braid_blob instance
+                    var bb1 = braid_blob.create_braid_blob()
+                    bb1.db_folder = db_folder
+                    bb1.meta_folder = meta_folder
+
+                    // Put a file with specific version
+                    var version1 = await bb1.put(test_key, Buffer.from(test_content), {
+                        version: ['test-peer-123456']
+                    })
+
+                    // Get the file to verify it has the expected version
+                    var result1 = await bb1.get(test_key)
+
+                    // Check what metadata was saved
+                    var meta1 = bb1.db.get_meta(test_key)
+                    var debug_info = 'meta1: ' + JSON.stringify(meta1) + '; '
+
+                    // Wait a bit to ensure file system has settled
+                    await new Promise(resolve => setTimeout(resolve, 100))
+
+                    // Now create a second braid_blob instance with the same folders
+                    // This simulates a restart
+                    var bb2 = braid_blob.create_braid_blob()
+                    bb2.db_folder = db_folder
+                    bb2.meta_folder = meta_folder
+
+                    // Initialize bb2 by doing a get (this triggers init)
+                    var result2 = await bb2.get(test_key)
+
+                    // Check what metadata bb2 sees
+                    var meta2 = bb2.db.get_meta(test_key)
+                    debug_info += 'meta2: ' + JSON.stringify(meta2) + '; '
+
+                    // The version should be the same - no new event ID generated
+                    var versions_match = (result1.version[0] === result2.version[0])
+                    var both_have_expected = (result1.version[0] === 'test-peer-123456')
+
+                    // Clean up
+                    await fs.rm(db_folder, { recursive: true, force: true })
+                    await fs.rm(meta_folder, { recursive: true, force: true })
+
+                    res.end(versions_match && both_have_expected ? 'true' :
+                            'false: v1=' + result1.version[0] + ', v2=' + result2.version[0] + ' | ' + debug_info)
+                } catch (e) {
+                    // Clean up even on error
+                    await fs.rm(db_folder, { recursive: true, force: true })
+                    await fs.rm(meta_folder, { recursive: true, force: true })
+                    res.end('error: ' + e.message)
+                }
+            })()`
+        })
+        return await r1.text()
+    },
+    '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)

package/.claude/settings.local.json

@@ -1,20 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(node test/test.js:*)",
-      "Bash(lsof:*)",
-      "Bash(xargs kill -9)",
-      "Bash(curl:*)",
-      "Bash(cat:*)",
-      "Bash(node test.js:*)",
-      "Bash(timeout 5 node:*)",
-      "Bash(git checkout:*)",
-      "Bash(npm show:*)",
-      "Bash(npm install:*)",
-      "Bash(node:*)",
-      "Bash(git add:*)"
-    ],
-    "deny": [],
-    "ask": []
-  }
-}