braid-text 0.2.75 → 0.2.76

package/index.js

@@ -464,7 +464,9 @@ function create_braid_text() {
     }
 
     braid_text.delete = async (key) => {
-        await braid_text.put(key, {body: ''})
+        // Accept either a key string or a resource object
+        let resource = (typeof key == 'string') ? await get_resource(key) : key
+        await resource.delete()
     }
 
     braid_text.get = async (key, options) => {
@@ -1029,6 +1031,42 @@ function create_braid_text() {
 
             resource.length_cache = createSimpleCache(braid_text.length_cache_size)
 
+            // Add delete method to resource
+            resource.delete = async () => {
+                // Free the diamond-types document
+                if (resource.doc) resource.doc.free()
+
+                // Remove from in-memory cache
+                delete braid_text.cache[key]
+
+                // Remove all files for this key from db_folder
+                if (braid_text.db_folder) {
+                    var files = await get_files_for_key(key)
+                    for (var file of files) {
+                        try {
+                            await fs.promises.unlink(file)
+                        } catch (e) {
+                            // File might not exist, that's ok
+                        }
+                    }
+
+                    // Remove meta file if it exists
+                    try {
+                        var encoded = encode_filename(key)
+                        await fs.promises.unlink(`${braid_text.db_folder}/.meta/${encoded}`)
+                    } catch (e) {
+                        // Meta file might not exist, that's ok
+                    }
+                }
+
+                // Remove from filename mapping
+                if (key_to_filename.has(key)) {
+                    var encoded = key_to_filename.get(key)
+                    ifilenames.delete(encoded.toLowerCase())
+                    key_to_filename.delete(key)
+                }
+            }
+
             done(resource)
         })
         return await cache[key]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "braid-text",
-  "version": "0.2.75",
+  "version": "0.2.76",
   "description": "Library for collaborative text over http using braid.",
   "author": "Braid Working Group",
   "repository": "braid-org/braid-text",

package/test/tests.js

@@ -1840,6 +1840,62 @@ runTest(
     ''
 )
 
+runTest(
+    "test deleting a resource completely removes all traces",
+    async () => {
+        let key = 'test-delete-complete-' + Math.random().toString(36).slice(2)
+
+        // Create a resource with some content
+        // "hello world" is 11 characters, so version should be alice-10 (positions 0-10 inclusive)
+        await braid_fetch(`/${key}`, {
+            method: 'PUT',
+            version: ['alice-10'],
+            parents: [],
+            body: 'hello world'
+        })
+
+        // Verify it exists in cache using eval endpoint
+        let r1 = await braid_fetch(`/eval`, {
+            method: 'PUT',
+            body: `res.end(braid_text.cache['/${key}'] ? 'exists' : 'missing')`
+        })
+        if ((await r1.text()) !== 'exists') return 'Resource not in cache after creation'
+
+        // Delete the resource
+        await braid_fetch(`/${key}`, {method: 'DELETE'})
+
+        // Verify it's removed from cache
+        let r2 = await braid_fetch(`/eval`, {
+            method: 'PUT',
+            body: `res.end(braid_text.cache['/${key}'] ? 'exists' : 'missing')`
+        })
+        if ((await r2.text()) !== 'missing') return 'Resource still in cache after deletion'
+
+        // Verify we can create it again from scratch with same key
+        // "new content" is 11 characters, so version should be bob-10 (positions 0-10 inclusive)
+        await braid_fetch(`/${key}`, {
+            method: 'PUT',
+            version: ['bob-10'],
+            parents: [],
+            body: 'new content'
+        })
+
+        // Get the new resource and verify it's fresh (not the old one)
+        let r = await braid_fetch(`/${key}`)
+        let body = await r.text()
+
+        if (body !== 'new content') return `Expected 'new content', got '${body}'`
+
+        // Verify the version is from scratch (bob-10, not alice-10)
+        let version = r.headers.get('version')
+        if (!version.includes('bob-10')) return `Expected version to include bob-10, got: ${version}`
+        if (version.includes('alice-')) return `Old version alice-10 should not be present, got: ${version}`
+
+        return 'ok'
+    },
+    'ok'
+)
+
 runTest(
     "test getting a binary update from a subscription",
     async () => {