braid-blob 0.0.39 → 0.0.41

package/package.json

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

package/test/tests.js

@@ -378,7 +378,7 @@ runTest(
 
         return r.status
     },
-    '204'
+    '200'
 )
 
 runTest(
@@ -431,45 +431,35 @@ runTest(
 )
 
 runTest(
-    "test braid_blob.delete() cleans up subscriptions",
+    "test that aborting cleans up subscription",
     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 test_id = '/test-' + Math.random().toString(36).slice(2)
 
-                var bb = braid_blob.create_braid_blob()
-                bb.db_folder = db_folder
-                bb.meta_folder = meta_folder
+                // Put a file
+                await braid_blob.put(test_id, 'hello')
 
-                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 }
-                    })
+                // Subscribe to it
+                var got_update = false
+                var ac = new AbortController()
+                await braid_blob.get(test_id, {
+                    signal: ac.signal,
+                    subscribe: (update) => { got_update = true }
+                })
 
-                    // Verify subscription exists
-                    var has_sub_before = !!bb.key_to_subs['/test-file']
+                // Verify subscription exists
+                var has_sub_before = !!braid_blob.key_to_subs[test_id]
 
-                    // Delete it
-                    await bb.delete('/test-file')
+                await new Promise(done => setTimeout(done, 30))
+                ac.abort()
+                await new Promise(done => setTimeout(done, 30))
 
-                    // Verify subscription is cleaned up
-                    var has_sub_after = !!bb.key_to_subs['/test-file']
+                // Verify subscription is cleaned up
+                var has_sub_after = !!braid_blob.key_to_subs[test_id]
 
-                    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 })
-                }
+                res.end('' + (has_sub_before && !has_sub_after))
             })()`
         })
         return await r1.text()
@@ -640,19 +630,6 @@ runTest(
     'false'
 )
 
-runTest(
-    "test that subscribe sends 404 if there is no file.",
-    async () => {
-        var key = 'test-' + Math.random().toString(36).slice(2)
-
-        var r = await braid_fetch(`/${key}`, {
-            subscribe: true,
-        })
-        return r.status
-    },
-    '404'
-)
-
 runTest(
     "test that we get 404 when file doesn't exist, on GET without subscribe.",
     async () => {
@@ -1072,8 +1049,7 @@ runTest(
             method: 'POST',
             body: `void (async () => {
                 try {
-                    var braid_blob = require(\`\${__dirname}/../index.js\`)
-                    var remote_url = new URL('http://localhost:' + req.socket.localPort + '${remote_key}')
+                    var remote_url = new URL('http://localhost:' + port + '${remote_key}')
 
                     // Start sync with URL as first argument (should swap internally)
                     braid_blob.sync(remote_url, '${local_key}')
@@ -1165,10 +1141,8 @@ runTest(
             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'] })
+                    await braid_blob.put('${local_key}', 'same content', { version: ['same-version-123'] })
 
                     // Wrap db.read to count calls for our specific key
                     var read_count = 0
@@ -1178,7 +1152,7 @@ runTest(
                         return original_read.call(this, key)
                     }
 
-                    var remote_url = new URL('http://localhost:' + req.socket.localPort + '/${remote_key}')
+                    var remote_url = new URL('http://localhost:' + port + '/${remote_key}')
 
                     // Create an AbortController to stop the sync
                     var ac = new AbortController()
@@ -1305,7 +1279,6 @@ runTest(
         // Try to subscribe with parents 200 (newer than what server has)
         // This triggers the "unknown version" error which gets caught and returns 309
         var r = await braid_fetch(`/${key}`, {
-            subscribe: true,
             parents: ['200']
         })
 
@@ -1537,38 +1510,22 @@ runTest(
         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'
+                var test_id = '/test-abort-get-' + Math.random().toString(36).slice(2)
 
-                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'] })
+                // Put a file first
+                await braid_blob.put(test_id, 'hello', { version: ['1'] })
 
-                    // Create an already-aborted signal
-                    var ac = new AbortController()
-                    ac.abort()
+                // 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 }
-                    })
+                // Try to get with aborted signal (after header_cb)
+                var result = await braid_blob.get(test_id, {
+                    signal: ac.signal,
+                })
 
-                    // 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 })
-                }
+                // Result should be undefined since operation was aborted already
+                res.end(result === undefined ? 'aborted' : 'not aborted')
             })()`
         })
         return await r1.text()
@@ -1678,6 +1635,170 @@ runTest(
     'stopped'
 )
 
+runTest(
+    "test options.db in put writes to custom db",
+    async () => {
+        var r1 = await braid_fetch(`/eval`, {
+            method: 'POST',
+            body: `void (async () => {
+                var test_key = '/test-custom-db-put-' + Math.random().toString(36).slice(2)
+
+                // Create a simple in-memory db
+                var custom_storage = {}
+                var custom_db = {
+                    read: async (key) => custom_storage[key] || null,
+                    write: async (key, data) => { custom_storage[key] = data },
+                    delete: async (key) => { delete custom_storage[key] }
+                }
+
+                // Put using the custom db
+                await braid_blob.put(test_key, Buffer.from('custom db content'), {
+                    version: ['100'],
+                    db: custom_db
+                })
+
+                // Verify content is in custom db
+                var custom_content = await custom_db.read(test_key)
+                var custom_ok = custom_content && custom_content.toString() === 'custom db content'
+
+                // Verify content is NOT in the default db
+                var default_content = await braid_blob.db.read(test_key)
+                var default_empty = default_content === null
+
+                res.end(custom_ok && default_empty ? 'true' :
+                    'custom_ok=' + custom_ok + ', default_empty=' + default_empty)
+            })()`
+        })
+        return await r1.text()
+    },
+    'true'
+)
+
+runTest(
+    "test options.db in get reads from custom db",
+    async () => {
+        var r1 = await braid_fetch(`/eval`, {
+            method: 'POST',
+            body: `void (async () => {
+                var test_key = '/test-custom-db-get-' + Math.random().toString(36).slice(2)
+
+                // Create a simple in-memory db with some content
+                var custom_storage = {}
+                custom_storage[test_key] = Buffer.from('from custom db')
+                var custom_db = {
+                    read: async (key) => custom_storage[key] || null,
+                    write: async (key, data) => { custom_storage[key] = data },
+                    delete: async (key) => { delete custom_storage[key] }
+                }
+
+                // Put with skip_write to just create meta
+                await braid_blob.put(test_key, Buffer.from('ignored'), {
+                    version: ['200'],
+                    skip_write: true
+                })
+
+                // Get using the custom db - should read from custom db
+                var result = await braid_blob.get(test_key, { db: custom_db })
+
+                res.end(result && result.body.toString() === 'from custom db' ? 'true' :
+                    'got: ' + (result ? result.body.toString() : 'null'))
+            })()`
+        })
+        return await r1.text()
+    },
+    'true'
+)
+
+runTest(
+    "test options.db in delete deletes from custom db",
+    async () => {
+        var r1 = await braid_fetch(`/eval`, {
+            method: 'POST',
+            body: `void (async () => {
+                var test_key = '/test-custom-db-delete-' + Math.random().toString(36).slice(2)
+
+                // Create a simple in-memory db
+                var custom_storage = {}
+                custom_storage[test_key] = Buffer.from('custom content')
+                var custom_db = {
+                    read: async (key) => custom_storage[key] || null,
+                    write: async (key, data) => { custom_storage[key] = data },
+                    delete: async (key) => { delete custom_storage[key] }
+                }
+
+                // Also put to default db
+                await braid_blob.put(test_key, Buffer.from('default content'), {
+                    version: ['300']
+                })
+
+                // Delete using custom db - should only delete from custom db
+                await braid_blob.delete(test_key, { db: custom_db })
+
+                // Verify custom db content is gone
+                var custom_content = await custom_db.read(test_key)
+                var custom_deleted = custom_content === null
+
+                // Verify default db content still exists
+                var default_content = await braid_blob.db.read(test_key)
+                var default_exists = default_content && default_content.toString() === 'default content'
+
+                res.end(custom_deleted && default_exists ? 'true' :
+                    'custom_deleted=' + custom_deleted + ', default_exists=' + default_exists)
+            })()`
+        })
+        return await r1.text()
+    },
+    'true'
+)
+
+runTest(
+    "test options.db in get subscribe uses custom db for initial update",
+    async () => {
+        var r1 = await braid_fetch(`/eval`, {
+            method: 'POST',
+            body: `void (async () => {
+                var test_key = '/test-custom-db-sub-' + Math.random().toString(36).slice(2)
+
+                // Create a simple in-memory db with content
+                var custom_storage = {}
+                custom_storage[test_key] = Buffer.from('subscribe custom content')
+                var custom_db = {
+                    read: async (key) => custom_storage[key] || null,
+                    write: async (key, data) => { custom_storage[key] = data },
+                    delete: async (key) => { delete custom_storage[key] }
+                }
+
+                // Create meta with version using skip_write
+                await braid_blob.put(test_key, Buffer.from('ignored'), {
+                    version: ['400'],
+                    skip_write: true
+                })
+
+                // Subscribe using custom db - initial update should come from custom db
+                var ac = new AbortController()
+                var received_content = null
+
+                await braid_blob.get(test_key, {
+                    db: custom_db,
+                    signal: ac.signal,
+                    subscribe: (update) => {
+                        received_content = update.body.toString()
+                    }
+                })
+
+                // Wait for update
+                await new Promise(done => setTimeout(done, 50))
+                ac.abort()
+
+                res.end(received_content === 'subscribe custom content' ? 'true' :
+                    'got: ' + received_content)
+            })()`
+        })
+        return await r1.text()
+    },
+    'true'
+)
+
 }
 
 // Export for Node.js (CommonJS)