braid-blob 0.0.33 → 0.0.35

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,21 +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,
-                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 })
+            // 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)
@@ -270,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)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "braid-blob",
-  "version": "0.0.33",
+  "version": "0.0.35",
   "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

@@ -1365,7 +1365,7 @@ runTest(
                     bb2.db_folder = db_folder
                     bb2.meta_folder = meta_folder
 
-                    // This should NOT trigger a file change callback
+                    // Get the file from the new instance
                     var result2 = await bb2.get(test_key)
 
                     // Version should still be version-2, not regenerated
@@ -1419,7 +1419,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 +1435,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
@@ -1461,95 +1461,6 @@ 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'
-)
-
 runTest(
     "test get with URL returns null on 404",
     async () => {