Move fn prepare_record from Preparable trait to struct PreparedRecord

Author: Nicklas Warming Jacobsen

src/encrypted_table/mod.rs

@@ -8,7 +8,7 @@ pub use self::{
 use crate::{
     crypto::*,
     errors::*,
-    traits::{Decryptable, Preparable, PrimaryKeyParts, Searchable},
+    traits::{Decryptable, PrimaryKey, PrimaryKeyParts, Searchable},
     Identifiable, IndexType,
 };
 use aws_sdk_dynamodb::types::{AttributeValue, Delete, Put, TransactWriteItem};
@@ -115,6 +115,55 @@ impl PreparedRecord {
             sealer,
         }
     }
+
+    pub fn prepare_record<R>(record: R) -> Result<Self, SealError>
+    where
+        R: Searchable + Identifiable,
+    {
+        let type_name = R::type_name();
+
+        let PrimaryKeyParts { pk, sk } = record
+            .get_primary_key()
+            .into_parts(&type_name, R::sort_key_prefix().as_deref());
+
+        let protected_indexes = R::protected_indexes();
+        let protected_attributes = R::protected_attributes();
+
+        let unsealed_indexes = protected_indexes
+            .iter()
+            .map(|(index_name, index_type)| {
+                record
+                    .attribute_for_index(index_name, *index_type)
+                    .and_then(|attr| {
+                        R::index_by_name(index_name, *index_type)
+                            .map(|index| (attr, index, index_name.clone(), *index_type))
+                    })
+                    .ok_or(SealError::MissingAttribute(index_name.to_string()))
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        let unsealed = record.into_unsealed();
+
+        let sealer = Sealer {
+            pk,
+            sk,
+
+            is_sk_encrypted: R::is_sk_encrypted(),
+            is_pk_encrypted: R::is_pk_encrypted(),
+
+            type_name,
+
+            unsealed_indexes,
+
+            unsealed,
+        };
+
+        Ok(PreparedRecord::new(
+            protected_indexes,
+            protected_attributes,
+            sealer,
+        ))
+    }
 }
 
 impl DynamoRecordPatch {
@@ -366,7 +415,7 @@ impl EncryptedTable<Dynamo> {
     where
         T: Searchable + Identifiable,
     {
-        let record = record.prepare_record()?;
+        let record = PreparedRecord::prepare_record(record)?;
 
         let transact_items = self
             .create_put_patch(

src/traits/mod.rs

@@ -1,8 +1,5 @@
+use crate::crypto::{SealError, Unsealed};
 pub use crate::encrypted_table::{TableAttribute, TryFromTableAttr};
-use crate::{
-    crypto::{SealError, Sealer, Unsealed},
-    encrypted_table::PreparedRecord,
-};
 use cipherstash_client::encryption::EncryptionError;
 pub use cipherstash_client::{
     credentials::{service_credentials::ServiceToken, Credentials},
@@ -151,57 +148,3 @@ pub trait Decryptable: Sized {
     /// Must be equal to or a subset of protected_attributes on the [`Encryptable`] type.
     fn plaintext_attributes() -> Cow<'static, [Cow<'static, str>]>;
 }
-
-pub trait Preparable {
-    fn prepare_record(self) -> Result<PreparedRecord, SealError>;
-}
-
-impl<R> Preparable for R
-where
-    R: Searchable + Identifiable,
-{
-    fn prepare_record(self) -> Result<PreparedRecord, SealError> {
-        let type_name = Self::type_name();
-
-        let PrimaryKeyParts { pk, sk } = self
-            .get_primary_key()
-            .into_parts(&type_name, Self::sort_key_prefix().as_deref());
-
-        let protected_indexes = Self::protected_indexes();
-        let protected_attributes = Self::protected_attributes();
-
-        let unsealed_indexes = protected_indexes
-            .iter()
-            .map(|(index_name, index_type)| {
-                self.attribute_for_index(index_name, *index_type)
-                    .and_then(|attr| {
-                        Self::index_by_name(index_name, *index_type)
-                            .map(|index| (attr, index, index_name.clone(), *index_type))
-                    })
-                    .ok_or(SealError::MissingAttribute(index_name.to_string()))
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-
-        let unsealed = self.into_unsealed();
-
-        let sealer = Sealer {
-            pk,
-            sk,
-
-            is_sk_encrypted: Self::is_sk_encrypted(),
-            is_pk_encrypted: Self::is_pk_encrypted(),
-
-            type_name,
-
-            unsealed_indexes,
-
-            unsealed,
-        };
-
-        Ok(PreparedRecord::new(
-            protected_indexes,
-            protected_attributes,
-            sealer,
-        ))
-    }
-}

tests/headless_tests.rs

@@ -1,6 +1,7 @@
 use aws_sdk_dynamodb::Client;
 use cipherstash_dynamodb::{
-    traits::Preparable, Decryptable, Encryptable, EncryptedTable, Identifiable, Searchable,
+    encrypted_table::PreparedRecord, Decryptable, Encryptable, EncryptedTable, Identifiable,
+    Searchable,
 };
 use serial_test::serial;
 use std::future::Future;
@@ -60,10 +61,8 @@ async fn test_headless_roundtrip() {
             .await
             .expect("failed to init table");
 
-        let user_record = user
-            .clone()
-            .prepare_record()
-            .expect("failed to prepare record");
+        let user_record =
+            PreparedRecord::prepare_record(user.clone()).expect("failed to prepare record");
 
         let patch = table
             .create_put_patch(user_record, |_, _| true)