chore(keystore): clean up dead code

Author: coriolinus

keystore/src/entities/mls.rs

@@ -1,8 +1,8 @@
-use zeroize::{Zeroize, ZeroizeOnDrop};
+use zeroize::Zeroize;
 
 use crate::{
     CryptoKeystoreResult,
-    traits::{EntityBase, EntityGetBorrowed as _, KeyType, OwnedKeyType, PrimaryKey, SearchableEntity as _},
+    traits::{EntityBase, EntityGetBorrowed as _, KeyType, PrimaryKey, SearchableEntity as _},
 };
 
 /// This type exists so that we can efficiently search for the children of a given group.
@@ -88,77 +88,6 @@ impl<'a> KeyType for ConversationId<'a> {
     }
 }
 
-/// [`MlsPendingMessage`]s have no distinct primary key;
-/// they must always be accessed via [`MlsPendingMessage::find_all_by_conversation_id`] and
-/// cleaned up with [`MlsPendingMessage::delete_by_conversation_id`]
-///
-/// However, we have to fake a primary key type in order to support
-/// `KeystoreTransaction::remove_pending_messages_by_conversation_id`. Additionally we need the same one in WASM, where
-/// it's necessary for item-level encryption.
-///
-/// This implementation is fairly inefficient and hopefully temporary. But it at least implements the correct semantics.
-#[derive(ZeroizeOnDrop)]
-pub struct MlsPendingMessagePrimaryKey {
-    pub(crate) foreign_id: Vec<u8>,
-    message: Vec<u8>,
-}
-
-impl MlsPendingMessagePrimaryKey {
-    /// Construct a partial mls pending message primary key from only the conversation id.
-    ///
-    /// This does not in fact uniquely identify a single pending message--it should always uniquely
-    /// identify exactly 0 pending messages--but we have to have it so that we can search and delete
-    /// by conversation id within transactions.
-    pub(crate) fn from_conversation_id(conversation_id: impl AsRef<[u8]>) -> Self {
-        Self {
-            foreign_id: conversation_id.as_ref().to_owned(),
-            message: Vec::new(),
-        }
-    }
-}
-
-impl From<&MlsPendingMessage> for MlsPendingMessagePrimaryKey {
-    fn from(value: &MlsPendingMessage) -> Self {
-        Self {
-            foreign_id: value.foreign_id.clone(),
-            message: value.message.clone(),
-        }
-    }
-}
-
-impl KeyType for MlsPendingMessagePrimaryKey {
-    fn bytes(&self) -> std::borrow::Cow<'_, [u8]> {
-        // run-length encoding: 32 bits of size for each field, followed by the field
-        let fields = [&self.foreign_id, &self.message];
-        let mut key = Vec::with_capacity(
-            ((u32::BITS / u8::BITS) as usize * fields.len()) + self.foreign_id.len() + self.message.len(),
-        );
-        for field in fields {
-            key.extend((field.len() as u32).to_le_bytes());
-            key.extend(field.as_slice());
-        }
-        key.into()
-    }
-}
-
-impl OwnedKeyType for MlsPendingMessagePrimaryKey {
-    fn from_bytes(bytes: &[u8]) -> Option<Self> {
-        // run-length decoding: 32 bits of size for each field, followed by the field
-        let (len, bytes) = bytes.split_at_checked(4)?;
-        let len = u32::from_le_bytes(len.try_into().ok()?);
-        let (foreign_id, bytes) = bytes.split_at_checked(len as _)?;
-
-        let (len, bytes) = bytes.split_at_checked(4)?;
-        let len = u32::from_le_bytes(len.try_into().ok()?);
-        let (message, bytes) = bytes.split_at_checked(len as _)?;
-
-        bytes.is_empty().then(|| Self {
-            foreign_id: foreign_id.to_owned(),
-            message: message.to_owned(),
-        })
-    }
-}
-
 /// Entity representing a buffered message
 #[derive(core_crypto_macros::Debug, Clone, PartialEq, Eq, Zeroize, serde::Serialize, serde::Deserialize)]
 #[zeroize(drop)]
@@ -168,11 +97,11 @@ pub struct MlsPendingMessage {
     pub message: Vec<u8>,
 }
 
+/// [`MlsPendingMessage`] has no real primary key, but we have to fake it for the trait hierarchy,
+/// so here we are.
 impl PrimaryKey for MlsPendingMessage {
-    type PrimaryKey = MlsPendingMessagePrimaryKey;
-    fn primary_key(&self) -> Self::PrimaryKey {
-        self.into()
-    }
+    type PrimaryKey = ();
+    fn primary_key(&self) -> Self::PrimaryKey {}
 }
 
 /// Entity representing a buffered commit.

keystore/src/entities/platform/generic/mls/pending_message.rs

@@ -21,27 +21,6 @@ impl MlsPendingMessage {
         let message = row.get("message")?;
         Ok(Self { foreign_id, message })
     }
-
-    pub async fn find_all_by_conversation_id(
-        conn: &mut <Self as EntityBase>::ConnectionType,
-        conversation_id: &[u8],
-    ) -> CryptoKeystoreResult<Vec<Self>> {
-        let conn = conn.conn().await;
-        let mut stmt = conn.prepare_cached("SELECT * FROM mls_pending_messages WHERE id = ?")?;
-        let values = stmt
-            .query_map([conversation_id], Self::from_row)?
-            .collect::<Result<_, _>>()?;
-        Ok(values)
-    }
-
-    pub async fn delete_by_conversation_id(
-        tx: &TransactionWrapper<'_>,
-        conversation_id: &[u8],
-    ) -> CryptoKeystoreResult<bool> {
-        // a slight misuse of this helper, but SQL doesn't care if we end up deleting N rows instead of 1
-        // with this query
-        delete_helper::<Self>(tx, "id", conversation_id).await
-    }
 }
 
 impl EntityBase for MlsPendingMessage {

keystore/src/entities/platform/wasm/mls/pending_message.rs

@@ -14,24 +14,6 @@ use crate::{
     },
 };
 
-impl MlsPendingMessage {
-    pub async fn find_all_by_conversation_id(
-        conn: &mut <Self as EntityBase>::ConnectionType,
-        conversation_id: &[u8],
-    ) -> crate::CryptoKeystoreResult<Vec<Self>> {
-        let storage = conn.storage();
-        let id = JsValue::from(Uint8Array::from(conversation_id));
-        storage.get_all_with_query(Some(id.into())).await
-    }
-
-    pub async fn delete_by_conversation_id(
-        tx: &<Self as EntityDatabaseMutation<'_>>::Transaction,
-        conversation_id: &[u8],
-    ) -> crate::CryptoKeystoreResult<bool> {
-        tx.delete::<Self>(conversation_id).await
-    }
-}
-
 impl EntityBase for MlsPendingMessage {
     type ConnectionType = KeystoreDatabaseConnection;
     type AutoGeneratedFields = ();