@peerbit/native-backbone 0.1.2 → 0.1.3

package/src/append_tx/storage.rs

@@ -6,6 +6,7 @@ use crate::append_tx::coordinate_plan_to_row;
 use crate::documents::{
     document_context_facts_to_row, document_index_append_commit, DocumentIndexAppendCommit,
 };
+use crate::error::BackboneError;
 use crate::js_interop::{
     array_from_value, bytes_field, string_field, strings_from_array, strings_to_array,
     trim_hashes_vec,
@@ -13,6 +14,18 @@ use crate::js_interop::{
 use crate::shared_log_plan::leader_samples_to_optional_rows;
 use crate::NativePeerbitBackbone;
 
+/// Forward a JsValue error from an untyped log-rust wrapper without altering
+/// its message. These wrappers construct every error via `JsValue::from_str`,
+/// so `as_string()` recovers the exact string the wrapper would have thrown;
+/// the fallback only guards the theoretically-non-string case.
+fn js_wrapper_error(error: JsValue) -> BackboneError {
+    BackboneError::Message(
+        error
+            .as_string()
+            .unwrap_or_else(|| "Expected string array".to_string()),
+    )
+}
+
 #[wasm_bindgen]
 impl NativePeerbitBackbone {
     #[allow(clippy::too_many_arguments)]
@@ -81,7 +94,7 @@ impl NativePeerbitBackbone {
         self_replicating: bool,
         resolve_trimmed_entries: bool,
     ) -> Result<Array, JsValue> {
-        self.prepare_plain_storage_append_transaction_inner(
+        Ok(self.prepare_plain_storage_append_transaction_inner(
             wall_time,
             logical,
             gid,
@@ -98,7 +111,7 @@ impl NativePeerbitBackbone {
             None,
             false,
             None,
-        )
+        )?)
     }
 
     #[allow(clippy::too_many_arguments)]
@@ -118,7 +131,7 @@ impl NativePeerbitBackbone {
         resolve_trimmed_entries: bool,
         trim_length_to: usize,
     ) -> Result<Array, JsValue> {
-        self.prepare_plain_storage_append_transaction_inner(
+        Ok(self.prepare_plain_storage_append_transaction_inner(
             wall_time,
             logical,
             gid,
@@ -135,7 +148,7 @@ impl NativePeerbitBackbone {
             Some(trim_length_to),
             false,
             None,
-        )
+        )?)
     }
 
     #[allow(clippy::too_many_arguments)]
@@ -162,7 +175,7 @@ impl NativePeerbitBackbone {
         document_projection_encoded_document: JsValue,
         document_projection_signer: JsValue,
     ) -> Result<Array, JsValue> {
-        self.prepare_plain_storage_append_transaction_inner(
+        Ok(self.prepare_plain_storage_append_transaction_inner(
             wall_time,
             logical,
             gid,
@@ -188,7 +201,7 @@ impl NativePeerbitBackbone {
                 document_projection_encoded_document,
                 document_projection_signer,
             )?),
-        )
+        )?)
     }
 
     #[allow(clippy::too_many_arguments)]
@@ -216,7 +229,7 @@ impl NativePeerbitBackbone {
         document_projection_signer: JsValue,
         trim_length_to: usize,
     ) -> Result<Array, JsValue> {
-        self.prepare_plain_storage_append_transaction_inner(
+        Ok(self.prepare_plain_storage_append_transaction_inner(
             wall_time,
             logical,
             gid,
@@ -242,7 +255,7 @@ impl NativePeerbitBackbone {
                 document_projection_encoded_document,
                 document_projection_signer,
             )?),
-        )
+        )?)
     }
 
     #[allow(clippy::too_many_arguments)]
@@ -262,7 +275,7 @@ impl NativePeerbitBackbone {
         self_replicating: bool,
         resolve_trimmed_entries: bool,
     ) -> Result<Array, JsValue> {
-        self.prepare_plain_storage_append_transaction_inner(
+        Ok(self.prepare_plain_storage_append_transaction_inner(
             wall_time,
             logical,
             gid,
@@ -279,7 +292,7 @@ impl NativePeerbitBackbone {
             None,
             false,
             None,
-        )
+        )?)
     }
 
     #[allow(clippy::too_many_arguments)]
@@ -300,7 +313,7 @@ impl NativePeerbitBackbone {
         resolve_trimmed_entries: bool,
         trim_length_to: usize,
     ) -> Result<Array, JsValue> {
-        self.prepare_plain_storage_append_transaction_inner(
+        Ok(self.prepare_plain_storage_append_transaction_inner(
             wall_time,
             logical,
             gid,
@@ -317,7 +330,7 @@ impl NativePeerbitBackbone {
             Some(trim_length_to),
             false,
             None,
-        )
+        )?)
     }
 
     #[allow(clippy::too_many_arguments)]
@@ -345,7 +358,7 @@ impl NativePeerbitBackbone {
         document_projection_encoded_document: JsValue,
         document_projection_signer: JsValue,
     ) -> Result<Array, JsValue> {
-        self.prepare_plain_storage_append_transaction_inner(
+        Ok(self.prepare_plain_storage_append_transaction_inner(
             wall_time,
             logical,
             gid,
@@ -371,7 +384,7 @@ impl NativePeerbitBackbone {
                 document_projection_encoded_document,
                 document_projection_signer,
             )?),
-        )
+        )?)
     }
 
     #[allow(clippy::too_many_arguments)]
@@ -400,7 +413,7 @@ impl NativePeerbitBackbone {
         document_projection_signer: JsValue,
         trim_length_to: usize,
     ) -> Result<Array, JsValue> {
-        self.prepare_plain_storage_append_transaction_inner(
+        Ok(self.prepare_plain_storage_append_transaction_inner(
             wall_time,
             logical,
             gid,
@@ -426,7 +439,7 @@ impl NativePeerbitBackbone {
                 document_projection_encoded_document,
                 document_projection_signer,
             )?),
-        )
+        )?)
     }
 }
 
@@ -450,9 +463,9 @@ impl NativePeerbitBackbone {
         trim_length_to: Option<usize>,
         commit_blocks: bool,
         document_index_commit: Option<DocumentIndexAppendCommit>,
-    ) -> Result<Array, JsValue> {
+    ) -> Result<Array, BackboneError> {
         let profile_enabled = self.append_profile_enabled;
-        let storage_append_started = profile_enabled.then(js_sys::Date::now);
+        let storage_append_started = profile_enabled.then(crate::time::now_ms);
         let payload_size = payload_data.length();
         let delete_trimmed_document_heads = document_index_commit
             .as_ref()
@@ -462,7 +475,7 @@ impl NativePeerbitBackbone {
             .and_then(|commit| commit.previous_context.clone());
         let (entry_row, trim_rows, trim_hashes, hash, digest, meta_bytes) = if commit_blocks {
             let (meta_data, payload_data) =
-                self.copy_append_inputs_profiled(meta_data, &payload_data);
+                self.copy_append_inputs_profiled(meta_data, &payload_data)?;
             let (entry_facts, trim_hashes, entry_row, trim_rows) = self
                 .prepare_committed_log_append_rows_profiled(
                     wall_time,
@@ -485,6 +498,13 @@ impl NativePeerbitBackbone {
             )
         } else if let Some(trim_length_to) = trim_length_to {
             let next_hashes_array = strings_to_array(next_hashes.clone());
+            // No typed log-rust equivalent exists for the storage-facts mode
+            // (it hands the storage bytes back to JS instead of committing
+            // them to a native block store). It is the one append path with
+            // no typed core to re-point to, so its JsValue error is forwarded
+            // verbatim through BackboneError::Message, preserving whatever
+            // string the wrapper produced (the dominant reachable case is
+            // strings_from_array over the array built just above).
             let row = self
                 .log
                 .prepare_entry_v0_plain_entry_storage_facts_trim_and_put_with_builder(
@@ -497,7 +517,8 @@ impl NativePeerbitBackbone {
                     meta_data,
                     payload_data,
                     trim_length_to,
-                )?;
+                )
+                .map_err(js_wrapper_error)?;
             let row = array_from_value(row.into(), "native storage trim append row")?;
             let entry_row = array_from_value(row.get(0), "native storage trim append entry row")?;
             let trim_rows = array_from_value(row.get(1), "native storage trim append trim rows")?;
@@ -508,6 +529,8 @@ impl NativePeerbitBackbone {
             (entry_row, trim_rows, trim_hashes, hash, digest, meta_bytes)
         } else {
             let next_hashes_array = strings_to_array(next_hashes.clone());
+            // Same untyped storage-facts wrapper seam as the trim branch
+            // above; its JsValue error is forwarded verbatim.
             let row = self
                 .log
                 .prepare_entry_v0_plain_entry_storage_facts_and_put_with_builder(
@@ -519,7 +542,8 @@ impl NativePeerbitBackbone {
                     entry_type,
                     meta_data,
                     payload_data,
-                )?;
+                )
+                .map_err(js_wrapper_error)?;
             let hash = string_field(&row, 1, "storage entry hash")?;
             let digest = bytes_field(&row, 5, "storage entry hash digest")?;
             let meta_bytes = bytes_field(&row, 4, "storage entry meta bytes")?;
@@ -529,7 +553,7 @@ impl NativePeerbitBackbone {
         let hash_number = self.hash_number_profiled(&digest)?;
         let document_hash = hash.clone();
         let document_gid = gid.clone();
-        let coordinate_plan_started = profile_enabled.then(js_sys::Date::now);
+        let coordinate_plan_started = profile_enabled.then(crate::time::now_ms);
         let coordinate_facts = commit_local_append_for_gid_compact_core(
             &mut self.shared_log,
             hash,
@@ -546,9 +570,9 @@ impl NativePeerbitBackbone {
             true,
         )?;
         if let Some(started) = coordinate_plan_started {
-            self.append_profile.coordinate_plan_ms += js_sys::Date::now() - started;
+            self.append_profile.coordinate_plan_ms += crate::time::now_ms() - started;
         }
-        let coordinate_core_started = profile_enabled.then(js_sys::Date::now);
+        let coordinate_core_started = profile_enabled.then(crate::time::now_ms);
         self.commit_coordinate_core_from_compact_facts(
             &coordinate_facts,
             &next_hashes,
@@ -557,7 +581,7 @@ impl NativePeerbitBackbone {
             meta_bytes,
         );
         if let Some(started) = coordinate_core_started {
-            self.append_profile.coordinate_core_ms += js_sys::Date::now() - started;
+            self.append_profile.coordinate_core_ms += crate::time::now_ms() - started;
         }
         let document_trimmed_heads_processed = self.commit_append_document_index_profiled(
             document_index_commit,
@@ -570,7 +594,7 @@ impl NativePeerbitBackbone {
             &trim_hashes,
         )?;
 
-        let result_row_started = profile_enabled.then(js_sys::Date::now);
+        let result_row_started = profile_enabled.then(crate::time::now_ms);
         let out = Array::new();
         out.push(&entry_row);
         out.push(&leader_samples_to_optional_rows(&coordinate_facts.leaders));
@@ -589,10 +613,10 @@ impl NativePeerbitBackbone {
                 .unwrap_or(JsValue::UNDEFINED),
         );
         if let Some(started) = result_row_started {
-            self.append_profile.result_row_ms += js_sys::Date::now() - started;
+            self.append_profile.result_row_ms += crate::time::now_ms() - started;
         }
         if let Some(started) = storage_append_started {
-            self.append_profile.storage_append_inner_ms += js_sys::Date::now() - started;
+            self.append_profile.storage_append_inner_ms += crate::time::now_ms() - started;
         }
         Ok(out)
     }

package/src/coordinates.rs

@@ -8,14 +8,16 @@ use peerbit_indexer_core::wire::{self, WireError};
 use peerbit_shared_log_rust::NativeLocalAppendCompactFacts;
 use wasm_bindgen::prelude::*;
 
+use crate::error::BackboneError;
 use crate::js_interop::{
     append_journal_delete_record, append_journal_put_record, array_from_value, bool_field,
-    clear_journal_prefix, decode_error, number_strings_to_array, parse_u64_string, string_field,
-    stringish_field, strings_from_array, usize_field, wire_error_to_js, write_bytes, write_string,
+    clear_journal_prefix, number_strings_to_array, parse_u64_string, string_field, stringish_field,
+    strings_from_array, usize_field, write_bytes, write_string,
 };
 use crate::shared_log_plan::coordinate_numbers_from_array;
 use crate::NativePeerbitBackbone;
 
+#[derive(Debug)]
 pub(crate) struct CoordinateCoreValue {
     pub(crate) hash: String,
     pub(crate) gid: String,
@@ -66,8 +68,43 @@ pub(crate) fn coordinate_core_value_to_row(value: &CoordinateCoreValue) -> Array
     row
 }
 
-pub(crate) fn decode_coordinate_value(bytes: &[u8]) -> Result<CoordinateCoreValue, JsValue> {
-    decode_coordinate_value_core(bytes).map_err(wire_error_to_js)
+pub(crate) fn decode_coordinate_value(bytes: &[u8]) -> Result<CoordinateCoreValue, BackboneError> {
+    Ok(decode_coordinate_value_core(bytes)?)
+}
+
+/// Decode a key/value snapshot and apply journal records on top, returning
+/// the merged entries in insertion order plus the number of journal
+/// operations applied.
+pub(crate) fn merged_coordinate_entries(
+    snapshot: &[u8],
+    journal: &[u8],
+) -> Result<(Vec<(String, Vec<u8>)>, usize), BackboneError> {
+    let mut entries = if snapshot.is_empty() {
+        Default::default()
+    } else {
+        decode_key_value_snapshot(snapshot)?
+    };
+    let journal_records = if journal.is_empty() {
+        Vec::new()
+    } else {
+        decode_journal(journal)?
+    };
+    let operations = journal_records.len();
+    for record in journal_records {
+        match record {
+            JournalRecord {
+                key,
+                value: Some(value),
+                ..
+            } => {
+                entries.insert(key, value);
+            }
+            JournalRecord { key, .. } => {
+                entries.shift_remove(&key);
+            }
+        }
+    }
+    Ok((entries.into_iter().collect(), operations))
 }
 
 fn decode_coordinate_value_core(bytes: &[u8]) -> Result<CoordinateCoreValue, WireError> {
@@ -178,32 +215,8 @@ impl NativePeerbitBackbone {
         snapshot: Uint8Array,
         journal: Uint8Array,
     ) -> Result<usize, JsValue> {
-        let mut entries = if snapshot.length() == 0 {
-            Default::default()
-        } else {
-            decode_key_value_snapshot(&snapshot.to_vec()).map_err(decode_error)?
-        };
-        let journal_records = if journal.length() == 0 {
-            Vec::new()
-        } else {
-            decode_journal(&journal.to_vec()).map_err(decode_error)?
-        };
-        let operations = journal_records.len();
-        for record in journal_records {
-            match record {
-                JournalRecord {
-                    key,
-                    value: Some(value),
-                    ..
-                } => {
-                    entries.insert(key, value);
-                }
-                JournalRecord { key, .. } => {
-                    entries.shift_remove(&key);
-                }
-            }
-        }
-
+        let (entries, operations) =
+            merged_coordinate_entries(&snapshot.to_vec(), &journal.to_vec())?;
         self.shared_log.clear_entry_coordinates();
         self.clear_coordinate_core();
         for (_, value) in entries {
@@ -234,7 +247,7 @@ impl NativePeerbitBackbone {
         requested_replicas: usize,
         wall_time: u64,
         meta_bytes: Vec<u8>,
-    ) -> Result<(), JsValue> {
+    ) -> Result<(), BackboneError> {
         let hash_number = parse_u64_string(hash_number, "coordinate hash number")?;
         let coordinates = coordinate_numbers_from_array(coordinates)?;
         self.put_coordinate_core(
@@ -258,7 +271,7 @@ impl NativePeerbitBackbone {
         delete_hashes: Array,
         wall_time: u64,
         meta_bytes: Vec<u8>,
-    ) -> Result<(), JsValue> {
+    ) -> Result<(), BackboneError> {
         let row = array_from_value(coordinate_row, "coordinate plan row")?;
         let hash = string_field(&row, 0, "coordinate hash")?;
         let hash_number = stringish_field(&row, 1, "coordinate hash number")?;
@@ -301,11 +314,11 @@ impl NativePeerbitBackbone {
             true,
         );
         let profile_enabled = self.append_profile_enabled;
-        let coordinate_delete_started = profile_enabled.then(js_sys::Date::now);
+        let coordinate_delete_started = profile_enabled.then(crate::time::now_ms);
         self.delete_coordinate_core_strings(next_hashes);
         self.delete_coordinate_core_strings(delete_hashes);
         if let Some(started) = coordinate_delete_started {
-            self.append_profile.coordinate_delete_ms += js_sys::Date::now() - started;
+            self.append_profile.coordinate_delete_ms += crate::time::now_ms() - started;
         }
     }
 
@@ -322,7 +335,7 @@ impl NativePeerbitBackbone {
         record_journal: bool,
     ) {
         let profile_enabled = self.append_profile_enabled;
-        let value_encode_started = profile_enabled.then(js_sys::Date::now);
+        let value_encode_started = profile_enabled.then(crate::time::now_ms);
         let value = encode_coordinate_value(
             &hash,
             gid,
@@ -334,24 +347,24 @@ impl NativePeerbitBackbone {
             &meta_bytes,
         );
         if let Some(started) = value_encode_started {
-            self.append_profile.coordinate_value_encode_ms += js_sys::Date::now() - started;
+            self.append_profile.coordinate_value_encode_ms += crate::time::now_ms() - started;
         }
         if record_journal && self.coordinate_journal_enabled {
-            let journal_started = profile_enabled.then(js_sys::Date::now);
+            let journal_started = profile_enabled.then(crate::time::now_ms);
             self.push_coordinate_journal_put(&hash, &value);
             if let Some(started) = journal_started {
-                self.append_profile.coordinate_journal_put_ms += js_sys::Date::now() - started;
+                self.append_profile.coordinate_journal_put_ms += crate::time::now_ms() - started;
             }
         }
-        let index_put_started = profile_enabled.then(js_sys::Date::now);
+        let index_put_started = profile_enabled.then(crate::time::now_ms);
         self.coordinate_index.insert(hash.clone());
         if let Some(started) = index_put_started {
-            self.append_profile.coordinate_index_put_ms += js_sys::Date::now() - started;
+            self.append_profile.coordinate_index_put_ms += crate::time::now_ms() - started;
         }
-        let value_put_started = profile_enabled.then(js_sys::Date::now);
+        let value_put_started = profile_enabled.then(crate::time::now_ms);
         self.coordinate_values.put(hash, value);
         if let Some(started) = value_put_started {
-            self.append_profile.coordinate_value_put_ms += js_sys::Date::now() - started;
+            self.append_profile.coordinate_value_put_ms += crate::time::now_ms() - started;
         }
     }
 
@@ -373,7 +386,10 @@ impl NativePeerbitBackbone {
         self.coordinate_journal_record_count += 1;
     }
 
-    pub(crate) fn delete_coordinate_core_batch(&mut self, hashes: Array) -> Result<(), JsValue> {
+    pub(crate) fn delete_coordinate_core_batch(
+        &mut self,
+        hashes: Array,
+    ) -> Result<(), BackboneError> {
         for hash in strings_from_array(hashes)? {
             self.delete_coordinate_core(&hash);
         }
@@ -389,7 +405,15 @@ impl NativePeerbitBackbone {
 
 #[cfg(test)]
 mod tests {
-    use super::{decode_coordinate_value_core, encode_coordinate_value};
+    use super::{
+        decode_coordinate_value, decode_coordinate_value_core, encode_coordinate_value,
+        merged_coordinate_entries,
+    };
+    use crate::error::BackboneError;
+    use peerbit_indexer_core::persistence::{
+        encode_journal_delete_record, encode_journal_put_record, encode_journal_record,
+        encode_key_value_snapshot, DecodeError,
+    };
     use peerbit_indexer_core::wire::WireError;
 
     #[test]
@@ -419,4 +443,71 @@ mod tests {
             Err(WireError::Truncated("coordinate values"))
         ));
     }
+
+    #[test]
+    fn decode_coordinate_value_reports_typed_wire_errors() {
+        let mut bytes = encode_coordinate_value("hash", "gid", 7, &[1, 2], true, 3, 11, &[9]);
+        bytes.truncate(4);
+
+        let error = decode_coordinate_value(&bytes).unwrap_err();
+        assert_eq!(
+            error,
+            BackboneError::Wire(WireError::Truncated("coordinate hash"))
+        );
+        assert_eq!(error.to_string(), "Truncated coordinate hash");
+    }
+
+    #[test]
+    fn merges_snapshot_entries_with_journal_records() {
+        let snapshot = encode_key_value_snapshot(
+            [
+                ("a".to_string(), vec![1u8]),
+                ("b".to_string(), vec![2u8]),
+                ("c".to_string(), vec![3u8]),
+            ]
+            .into_iter(),
+        );
+        let mut journal = encode_journal_put_record("b", &[42]);
+        journal.extend_from_slice(&encode_journal_delete_record("c"));
+        journal.extend_from_slice(&encode_journal_put_record("d", &[4]));
+
+        let (entries, operations) = merged_coordinate_entries(&snapshot, &journal).unwrap();
+        assert_eq!(operations, 3);
+        assert_eq!(
+            entries,
+            vec![
+                ("a".to_string(), vec![1u8]),
+                ("b".to_string(), vec![42u8]),
+                ("d".to_string(), vec![4u8]),
+            ]
+        );
+
+        let (entries, operations) = merged_coordinate_entries(&[], &[]).unwrap();
+        assert_eq!(operations, 0);
+        assert!(entries.is_empty());
+    }
+
+    #[test]
+    fn merged_coordinate_entries_reports_typed_decode_errors() {
+        // The rendered message must equal the `DecodeError` Display output the
+        // old `decode_error` funnel flattened into an untyped string.
+        let snapshot = encode_key_value_snapshot([("a".to_string(), vec![1u8])].into_iter());
+        let truncated = &snapshot[..snapshot.len() - 1];
+        let expected = match super::decode_key_value_snapshot(truncated) {
+            Err(error) => error,
+            Ok(_) => panic!("snapshot decode must fail"),
+        };
+
+        let error = merged_coordinate_entries(truncated, &[]).unwrap_err();
+        assert_eq!(error, BackboneError::Decode(expected.clone()));
+        assert_eq!(error.to_string(), expected.to_string());
+
+        let bad_journal = encode_journal_record(&[9]);
+        let error = merged_coordinate_entries(&[], &bad_journal).unwrap_err();
+        assert_eq!(
+            error,
+            BackboneError::Decode(DecodeError::InvalidOperation(9))
+        );
+        assert_eq!(error.to_string(), "invalid operation 9");
+    }
 }