braid-blob 0.0.34 → 0.0.36

package/index.js

@@ -1,5 +1,4 @@
 var {http_server: braidify, fetch: braid_fetch} = require('braid-http'),
-    {url_file_db} = require('url-file-db'),
     fs = require('fs'),
     path = require('path')
 
@@ -11,7 +10,7 @@ function create_braid_blob() {
         meta_cache: {},
         key_to_subs: {},
         peer: null, // will be auto-generated if not set by the user
-        db: null // url-file-db instance
+        db: null // object with read/write/delete methods
     }
 
     braid_blob.init = async () => {
@@ -24,15 +23,36 @@ function create_braid_blob() {
             // Ensure our meta folder exists
             await fs.promises.mkdir(braid_blob.meta_folder, { recursive: true })
 
-            // Create a fake meta folder for url-file-db (we manage our own meta)
-            var fake_meta_folder = braid_blob.meta_folder + '-fake'
-            await fs.promises.mkdir(fake_meta_folder, { recursive: true })
-
-            // Create url-file-db instance (with fake meta folder - we manage our own)
-            braid_blob.db = await url_file_db.create(
-                braid_blob.db_folder,
-                fake_meta_folder
-            )
+            // Set up db - either use provided object or create file-based storage
+            if (typeof braid_blob.db_folder === 'string') {
+                await fs.promises.mkdir(braid_blob.db_folder, { recursive: true })
+                braid_blob.db = {
+                    read: async (key) => {
+                        var file_path = path.join(braid_blob.db_folder, encode_filename(key))
+                        try {
+                            return await fs.promises.readFile(file_path)
+                        } catch (e) {
+                            if (e.code === 'ENOENT') return null
+                            throw e
+                        }
+                    },
+                    write: async (key, data) => {
+                        var file_path = path.join(braid_blob.db_folder, encode_filename(key))
+                        await fs.promises.writeFile(file_path, data)
+                    },
+                    delete: async (key) => {
+                        var file_path = path.join(braid_blob.db_folder, encode_filename(key))
+                        try {
+                            await fs.promises.unlink(file_path)
+                        } catch (e) {
+                            if (e.code !== 'ENOENT') throw e
+                        }
+                    }
+                }
+            } else {
+                // db_folder is already an object with read/write/delete
+                braid_blob.db = braid_blob.db_folder
+            }
 
             // establish a peer id if not already set
             if (!braid_blob.peer)
@@ -181,7 +201,7 @@ function create_braid_blob() {
             throw new Error('unkown version: ' + options.version)
         if (options.parents && options.parents.length && compare_events(options.parents[0], meta.event) > 0)
             throw new Error('unkown version: ' + options.parents)
-        if (options.head) return
+        if (options.head) return result
 
         if (options.subscribe) {
             var subscribe_chain = Promise.resolve()
@@ -264,7 +284,7 @@ function create_braid_blob() {
 
         if (!options.key) {
             var url = new URL(req.url, 'http://localhost')
-            options.key = url_file_db.get_canonical_path(url.pathname)
+            options.key = url.pathname
         }
 
         braidify(req, res)
@@ -412,7 +432,8 @@ function create_braid_blob() {
                 try {
                     // Check if remote has our current version (simple fork-point check)
                     var local_result = await braid_blob.get(a, {
-                        signal: ac.signal
+                        signal: ac.signal,
+                        head: true
                     })
                     var local_version = local_result ? local_result.version : null
                     var server_has_our_version = false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "braid-blob",
-  "version": "0.0.34",
+  "version": "0.0.36",
   "description": "Library for collaborative blobs over http using braid.",
   "author": "Braid Working Group",
   "repository": "braid-org/braid-blob",
@@ -10,7 +10,6 @@
     "test:browser": "node test/test.js --browser"
   },
   "dependencies": {
-    "braid-http": "~1.3.83",
-    "url-file-db": "^0.0.25"
+    "braid-http": "~1.3.83"
   }
 }

package/test/tests.js

@@ -1199,6 +1199,68 @@ runTest(
     'no disconnects'
 )
 
+runTest(
+    "test sync connect does not read file body for version check",
+    async () => {
+        var local_key = '/test-sync-no-read-' + Math.random().toString(36).slice(2)
+        var remote_key = 'test-sync-no-read-remote-' + Math.random().toString(36).slice(2)
+
+        // Put something on remote with SAME version as local, so no data needs to flow
+        var put_result = await braid_fetch(`/${remote_key}`, {
+            method: 'PUT',
+            version: ['same-version-123'],
+            body: 'same content'
+        })
+        if (!put_result.ok) return 'PUT status: ' + put_result.status
+
+        var r1 = await braid_fetch(`/eval`, {
+            method: 'POST',
+            body: `void (async () => {
+                try {
+                    var braid_blob = require(\`\${__dirname}/../index.js\`)
+
+                    // Put locally with SAME version - so when sync connects, no updates need to flow
+                    await braid_blob.put('${local_key}', Buffer.from('same content'), { version: ['same-version-123'] })
+
+                    // Wrap db.read to count calls for our specific key
+                    var read_count = 0
+                    var original_read = braid_blob.db.read
+                    braid_blob.db.read = async function(key) {
+                        if (key === '${local_key}') read_count++
+                        return original_read.call(this, key)
+                    }
+
+                    var remote_url = new URL('http://localhost:' + req.socket.localPort + '/${remote_key}')
+
+                    // Create an AbortController to stop the sync
+                    var ac = new AbortController()
+
+                    // Start sync - since both have same version, no updates should flow
+                    braid_blob.sync('${local_key}', remote_url, { signal: ac.signal })
+
+                    // Wait for sync to establish connection
+                    await new Promise(done => setTimeout(done, 300))
+
+                    // Stop sync
+                    ac.abort()
+
+                    // Restore original read
+                    braid_blob.db.read = original_read
+
+                    // db.read should not have been called since:
+                    // 1. Initial version check uses head:true (no body read)
+                    // 2. Both have same version so no updates flow
+                    res.end(read_count === 0 ? 'no reads' : 'reads: ' + read_count)
+                } catch (e) {
+                    res.end('error: ' + e.message + ' ' + e.stack)
+                }
+            })()`
+        })
+        return await r1.text()
+    },
+    'no reads'
+)
+
 runTest(
     "test sync closed during error",
     async () => {
@@ -1419,7 +1481,7 @@ runTest(
                     var result1 = await bb1.get(test_key)
 
                     // Check what metadata was saved
-                    var meta1 = bb1.db.get_meta(test_key)
+                    var meta1 = bb1.meta_cache[test_key]
                     var debug_info = 'meta1: ' + JSON.stringify(meta1) + '; '
 
                     // Wait a bit to ensure file system has settled
@@ -1435,7 +1497,7 @@ runTest(
                     var result2 = await bb2.get(test_key)
 
                     // Check what metadata bb2 sees
-                    var meta2 = bb2.db.get_meta(test_key)
+                    var meta2 = bb2.meta_cache[test_key]
                     debug_info += 'meta2: ' + JSON.stringify(meta2) + '; '
 
                     // The version should be the same - no new event ID generated