various: rename Store delete into remove

delete is a cpp keyword

Author: RCasatta

lwk_bindings/src/store.rs

@@ -19,7 +19,7 @@ pub trait ForeignStore: Send + Sync {
     /// Remove a value by key.
     ///
     /// Returns `Ok(())` even if the key did not exist.
-    fn delete(&self, key: String) -> Result<(), LwkError>;
+    fn remove(&self, key: String) -> Result<(), LwkError>;
 }
 
 /// Error type for the store bridge.
@@ -69,10 +69,10 @@ impl lwk_common::Store for ForeignStoreLink {
             .map_err(|e| StoreError::Foreign(format!("{e:?}")))
     }
 
-    fn delete<K: AsRef<[u8]>>(&self, key: K) -> Result<(), Self::Error> {
+    fn remove<K: AsRef<[u8]>>(&self, key: K) -> Result<(), Self::Error> {
         let key_str = String::from_utf8_lossy(key.as_ref()).into_owned();
         self.inner
-            .delete(key_str)
+            .remove(key_str)
             .map_err(|e| StoreError::Foreign(format!("{e:?}")))
     }
 }
@@ -106,7 +106,7 @@ mod test {
             Ok(())
         }
 
-        fn delete(&self, key: String) -> Result<(), LwkError> {
+        fn remove(&self, key: String) -> Result<(), LwkError> {
             self.data.lock().unwrap().remove(&key);
             Ok(())
         }
@@ -123,7 +123,7 @@ mod test {
         link.put("key", b"value").unwrap();
         assert_eq!(link.get("key").unwrap(), Some(b"value".to_vec()));
 
-        link.delete("key").unwrap();
+        link.remove("key").unwrap();
         assert_eq!(link.get("key").unwrap(), None);
     }
 }

lwk_bindings/src/test_env.rs

@@ -109,9 +109,9 @@ impl LwkTestStore {
         })
     }
 
-    /// Delete a key from the store.
-    pub fn delete(&self, key: String) -> Result<(), LwkError> {
-        self.store.delete(key).map_err(|e| LwkError::Generic {
+    /// Remove a key from the store.
+    pub fn remove(&self, key: String) -> Result<(), LwkError> {
+        self.store.remove(key).map_err(|e| LwkError::Generic {
             msg: format!("{e}"),
         })
     }

lwk_bindings/tests/bindings/custom_store.py

@@ -13,7 +13,7 @@ def get(self, key):
     def put(self, key, value):
         self.data[key] = value
 
-    def delete(self, key):
+    def remove(self, key):
         self.data.pop(key, None)
 
 
@@ -39,13 +39,13 @@ def delete(self, key):
 result = test.read("key")
 assert result == b"new_value", "Rust should read updated value"
 
-# Test Rust deleting
-test.delete("key")
+# Test Rust removing
+test.remove("key")
 result = test.read("key")
-assert result is None, "Deleted key should return None"
+assert result is None, "Removed key should return None"
 
-# Test delete non-existent key (should not raise)
-test.delete("key")
+# Test remove non-existent key (should not raise)
+test.remove("key")
 
 # Test with namespaced keys (as intended for LWK usage)
 test.write("Liquid:Tx:abc123", b"tx_data")

lwk_common/src/store.rs

@@ -32,7 +32,7 @@ pub trait Store: Send + Sync + Debug {
     /// Remove a value by key.
     ///
     /// Returns `Ok(())` even if the key did not exist.
-    fn delete<K: AsRef<[u8]>>(&self, key: K) -> Result<(), Self::Error>;
+    fn remove<K: AsRef<[u8]>>(&self, key: K) -> Result<(), Self::Error>;
 }
 
 /// A simple in-memory implementation of [`Store`].
@@ -70,7 +70,7 @@ impl Store for MemoryStore {
         Ok(())
     }
 
-    fn delete<K: AsRef<[u8]>>(&self, key: K) -> Result<(), Self::Error> {
+    fn remove<K: AsRef<[u8]>>(&self, key: K) -> Result<(), Self::Error> {
         self.data
             .lock()
             .expect("lock poisoned")
@@ -98,11 +98,11 @@ mod test {
         store.put("key", b"new_value").unwrap();
         assert_eq!(store.get("key").unwrap(), Some(b"new_value".to_vec()));
 
-        // Delete
-        store.delete("key").unwrap();
+        // Remove
+        store.remove("key").unwrap();
         assert_eq!(store.get("key").unwrap(), None);
 
-        // Delete non-existent key is ok
-        store.delete("key").unwrap();
+        // Remove non-existent key is ok
+        store.remove("key").unwrap();
     }
 }

lwk_wasm/src/store.rs

@@ -1,7 +1,7 @@
 //! Duck-typed JavaScript storage interface for WASM.
 //!
 //! JavaScript doesn't have traits, so we use duck typing: any JS object with
-//! `get`, `put`, and `delete` methods can be used as storage.
+//! `get`, `put`, and `remove` methods can be used as storage.
 
 use wasm_bindgen::prelude::*;
 
@@ -14,15 +14,15 @@ extern "C" {
     /// A duck-typed JavaScript storage object.
     ///
     /// Any JS object with `get(key) -> Uint8Array|null`, `put(key, value)`,
-    /// and `delete(key)` methods can be used.
+    /// and `remove(key)` methods can be used.
     ///
     /// Example JS implementation:
     /// ```js
     /// const storage = {
     ///     _data: new Map(),
     ///     get(key) { return this._data.get(key) || null; },
     ///     put(key, value) { this._data.set(key, value); },
-    ///     delete(key) { this._data.delete(key); }
+    ///     remove(key) { this._data.delete(key); }
     /// };
     /// ```
     pub type JsStorage;
@@ -35,9 +35,9 @@ extern "C" {
     #[wasm_bindgen(method, catch)]
     fn put(this: &JsStorage, key: &str, value: &[u8]) -> Result<(), JsValue>;
 
-    /// Delete a key.
+    /// Remove a key.
     #[wasm_bindgen(method, catch)]
-    fn delete(this: &JsStorage, key: &str) -> Result<(), JsValue>;
+    fn remove(this: &JsStorage, key: &str) -> Result<(), JsValue>;
 }
 
 /// Error type for the JS store bridge.
@@ -64,7 +64,7 @@ impl std::fmt::Debug for JsStoreLink {
 impl JsStoreLink {
     /// Create a new `JsStoreLink` from a JavaScript storage object.
     ///
-    /// The JS object must have `get(key)`, `put(key, value)`, and `delete(key)` methods.
+    /// The JS object must have `get(key)`, `put(key, value)`, and `remove(key)` methods.
     #[wasm_bindgen(constructor)]
     pub fn new(storage: JsStorage) -> Self {
         Self { inner: storage }
@@ -88,10 +88,10 @@ impl lwk_common::Store for JsStoreLink {
             .map_err(|e| JsStoreError::Js(format!("{e:?}")))
     }
 
-    fn delete<K: AsRef<[u8]>>(&self, key: K) -> Result<(), Self::Error> {
+    fn remove<K: AsRef<[u8]>>(&self, key: K) -> Result<(), Self::Error> {
         let key_str = String::from_utf8_lossy(key.as_ref());
         self.inner
-            .delete(&key_str)
+            .remove(&key_str)
             .map_err(|e| JsStoreError::Js(format!("{e:?}")))
     }
 }
@@ -133,11 +133,11 @@ impl JsTestStore {
             .map_err(|e| Error::Generic(format!("{e}")))
     }
 
-    /// Delete a key from the store.
-    pub fn delete(&self, key: &str) -> Result<(), Error> {
+    /// Remove a key from the store.
+    pub fn remove(&self, key: &str) -> Result<(), Error> {
         use lwk_common::Store;
         self.store
-            .delete(key)
+            .remove(key)
             .map_err(|e| Error::Generic(format!("{e}")))
     }
 }
@@ -162,7 +162,7 @@ mod tests {
                     // Copy the value - WASM may reuse memory buffer
                     store.set(key, value ? new Uint8Array(value) : null);
                 },
-                delete: function(key) {
+                remove: function(key) {
                     store.delete(key);
                 }
             };
@@ -189,12 +189,12 @@ mod tests {
         link.put("key", b"new_value").unwrap();
         assert_eq!(link.get("key").unwrap(), Some(b"new_value".to_vec()));
 
-        // Test delete
-        link.delete("key").unwrap();
+        // Test remove
+        link.remove("key").unwrap();
         assert_eq!(link.get("key").unwrap(), None);
 
-        // Test delete non-existent key
-        link.delete("key").unwrap();
+        // Test remove non-existent key
+        link.remove("key").unwrap();
 
         // Test with namespaced keys
         link.put("Liquid:Tx:abc123", b"tx_data").unwrap();
@@ -213,7 +213,7 @@ mod tests {
         test.write("key", b"value").unwrap();
         assert_eq!(test.read("key").unwrap(), Some(b"value".to_vec()));
 
-        test.delete("key").unwrap();
+        test.remove("key").unwrap();
         assert_eq!(test.read("key").unwrap(), None);
     }
 }

lwk_wasm/tests/node/custom_store.js

@@ -16,7 +16,7 @@ function createStorage() {
             const valueCopy = value ? new Uint8Array(value) : null;
             store.set(key, valueCopy);
         },
-        delete(key) {
+        remove(key) {
             store.delete(key);
         },
         // Helper for testing - not required by the interface
@@ -57,13 +57,13 @@ async function runCustomStoreTest() {
         "Rust should read updated value"
     );
 
-    // Test Rust deleting
-    test.delete("key");
+    // Test Rust removing
+    test.remove("key");
     result = test.read("key");
-    assert(result === null || result === undefined, "Deleted key should return null/undefined");
+    assert(result === null || result === undefined, "Removed key should return null/undefined");
 
-    // Test delete non-existent key (should not throw)
-    test.delete("key");
+    // Test remove non-existent key (should not throw)
+    test.remove("key");
 
     // Test with namespaced keys (as intended for LWK usage)
     test.write("Liquid:Tx:abc123", new Uint8Array([1, 2, 3]));