braid-text 0.2.75 → 0.2.77

package/.claude/settings.local.json

@@ -4,7 +4,9 @@
       "Bash(node test/test.js:*)",
       "Bash(node:*)",
       "Bash(git add:*)",
-      "Bash(git commit -m \"$(cat <<''EOF''\n0.2.74 - updates url-file-db to 0.0.19\n\n🤖 Generated with [Claude Code](https://claude.com/claude-code)\n\nCo-Authored-By: Claude <noreply@anthropic.com>\nEOF\n)\")"
+      "Bash(git commit -m \"$(cat <<''EOF''\n0.2.74 - updates url-file-db to 0.0.19\n\n🤖 Generated with [Claude Code](https://claude.com/claude-code)\n\nCo-Authored-By: Claude <noreply@anthropic.com>\nEOF\n)\")",
+      "Bash(git push)",
+      "Bash(npm publish:*)"
     ],
     "deny": [],
     "ask": []

package/index.js

@@ -463,8 +463,30 @@ function create_braid_text() {
         throw new Error("unknown")
     }
 
-    braid_text.delete = async (key) => {
-        await braid_text.put(key, {body: ''})
+    braid_text.delete = async (key, options) => {
+        if (!options) options = {}
+
+        // Handle URL - make a DELETE request
+        if (key instanceof URL) {
+            options.my_abort = new AbortController()
+            if (options.signal)
+                options.signal.addEventListener('abort', () =>
+                    options.my_abort.abort())
+
+            var params = {
+                method: 'DELETE',
+                signal: options.my_abort.signal,
+                retry: () => true,
+            }
+            for (var x of ['headers', 'peer'])
+                if (options[x] != null) params[x] = options[x]
+
+            return await braid_fetch(key.href, params)
+        }
+
+        // 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 +1051,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.77",
   "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,95 @@ 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 braid_text.delete(url)",
+    async () => {
+        var key = 'test-' + Math.random().toString(36).slice(2)
+
+        // Create a resource first
+        await braid_fetch(`/${key}`, {
+            method: 'PUT',
+            body: 'hello there'
+        })
+
+        // Verify it exists
+        let r1 = await braid_fetch(`/${key}`)
+        if ((await r1.text()) !== 'hello there') return 'Resource not created properly'
+
+        // Delete using braid_text.delete(url)
+        var r = await braid_fetch(`/eval`, {
+            method: 'PUT',
+            body: `void (async () => {
+                await braid_text.delete(new URL('http://localhost:8889/${key}'))
+                res.end('deleted')
+            })()`
+        })
+        if (!r.ok) return 'delete failed: ' + r.status
+        if ((await r.text()) !== 'deleted') return 'delete did not complete'
+
+        // Verify it's deleted (should be empty)
+        let r2 = await braid_fetch(`/${key}`)
+        return 'got: ' + (await r2.text())
+    },
+    'got: '
+)
+
 runTest(
     "test getting a binary update from a subscription",
     async () => {