@lix-js/sdk 0.6.0-preview.5 → 0.6.1

package/dist-engine-src/src/json_store/compression.rs

@@ -1,77 +0,0 @@
-use crate::LixError;
-
-#[cfg(not(target_arch = "wasm32"))]
-pub(crate) fn compress_json_payload(json_data: &[u8]) -> Result<Vec<u8>, LixError> {
-    zstd::bulk::compress(json_data, 1).map_err(|error| LixError {
-        code: "LIX_ERROR_UNKNOWN".to_string(),
-        message: format!("json compression failed: {error}"),
-        hint: None,
-        details: None,
-    })
-}
-
-#[cfg(target_arch = "wasm32")]
-pub(crate) fn compress_json_payload(json_data: &[u8]) -> Result<Vec<u8>, LixError> {
-    Ok(ruzstd::encoding::compress_to_vec(
-        json_data,
-        ruzstd::encoding::CompressionLevel::Fastest,
-    ))
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-pub(crate) fn decode_json_zstd_payload(
-    compressed_payload: &[u8],
-    uncompressed_len: usize,
-    hash_hex: &str,
-) -> Result<Vec<u8>, LixError> {
-    zstd::bulk::decompress(compressed_payload, uncompressed_len).map_err(|error| LixError {
-        code: "LIX_ERROR_UNKNOWN".to_string(),
-        message: format!("json decompression failed for ref '{hash_hex}': {error}"),
-        hint: None,
-        details: None,
-    })
-}
-
-#[cfg(target_arch = "wasm32")]
-pub(crate) fn decode_json_zstd_payload(
-    compressed_payload: &[u8],
-    _uncompressed_len: usize,
-    _hash_hex: &str,
-) -> Result<Vec<u8>, LixError> {
-    use std::io::Read as _;
-
-    let mut decoder =
-        ruzstd::decoding::StreamingDecoder::new(compressed_payload).map_err(|error| LixError {
-            code: "LIX_ERROR_UNKNOWN".to_string(),
-            message: format!("json decompression failed: {error}"),
-            hint: None,
-            details: None,
-        })?;
-
-    let mut output = Vec::new();
-    decoder.read_to_end(&mut output).map_err(|error| LixError {
-        code: "LIX_ERROR_UNKNOWN".to_string(),
-        message: format!("json decompression failed: {error}"),
-        hint: None,
-        details: None,
-    })?;
-    Ok(output)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn zstd_payload_roundtrips() {
-        let json = "zstd-friendly text ".repeat(2048);
-        let compressed = compress_json_payload(json.as_bytes()).expect("should compress");
-        assert!(compressed.len() < json.len());
-
-        let hash_hex = blake3::hash(json.as_bytes()).to_hex().to_string();
-        let decoded =
-            decode_json_zstd_payload(&compressed, json.len(), &hash_hex).expect("should decode");
-
-        assert_eq!(decoded, json.as_bytes());
-    }
-}

package/dist-engine-src/src/json_store/context.rs

@@ -1,172 +0,0 @@
-use crate::json_store::store;
-use crate::json_store::types::{
-    JsonLoadBatch, JsonLoadRequestRef, JsonProjection, JsonProjectionBatch,
-    JsonProjectionLoadRequestRef, JsonRef, JsonValueBatch, JsonWritePlacementRef,
-    NormalizedJsonRef,
-};
-use crate::storage::{StorageKey, StorageRead, StorageValue, StorageWriteSet};
-use crate::LixError;
-use bytes::Bytes;
-use std::collections::HashSet;
-
-#[derive(Debug, Clone, Copy)]
-pub(crate) struct JsonStoreContext;
-
-impl JsonStoreContext {
-    pub(crate) fn new() -> Self {
-        Self
-    }
-
-    pub(crate) fn reader<S>(&self, store: S) -> JsonStoreReader<S>
-    where
-        S: StorageRead,
-    {
-        JsonStoreReader { store }
-    }
-
-    pub(crate) fn writer(&self) -> JsonStoreWriter {
-        JsonStoreWriter::new()
-    }
-
-    pub(crate) async fn load_bytes_many(
-        &self,
-        store: &(impl StorageRead + ?Sized),
-        request: JsonLoadRequestRef<'_>,
-    ) -> Result<JsonLoadBatch, LixError> {
-        store::load_json_bytes_many_in_scope(store, request.refs, request.scope)
-            .await
-            .map(JsonLoadBatch::new)
-    }
-}
-
-pub(crate) struct JsonStoreReader<S> {
-    store: S,
-}
-
-impl<S> Clone for JsonStoreReader<S>
-where
-    S: Clone,
-{
-    fn clone(&self) -> Self {
-        Self {
-            store: self.store.clone(),
-        }
-    }
-}
-
-impl<S> JsonStoreReader<S>
-where
-    S: StorageRead,
-{
-    pub(crate) async fn load_bytes_many(
-        &mut self,
-        request: JsonLoadRequestRef<'_>,
-    ) -> Result<JsonLoadBatch, LixError> {
-        store::load_json_bytes_many_in_scope(&self.store, request.refs, request.scope)
-            .await
-            .map(JsonLoadBatch::new)
-    }
-
-    pub(crate) async fn load_values_many(
-        &mut self,
-        request: JsonLoadRequestRef<'_>,
-    ) -> Result<JsonValueBatch, LixError> {
-        let refs = request.refs;
-        let values = self
-            .load_bytes_many(request)
-            .await?
-            .into_values()
-            .into_iter()
-            .enumerate()
-            .map(|(index, bytes)| match bytes {
-                Some(bytes) => serde_json::from_slice(&bytes).map(Some).map_err(|error| {
-                    LixError::new(
-                        "LIX_ERROR_UNKNOWN",
-                        format!(
-                            "json ref '{}' is invalid JSON: {error}",
-                            refs[index].to_hex()
-                        ),
-                    )
-                }),
-                None => Ok(None),
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-        Ok(JsonValueBatch::new(values))
-    }
-
-    pub(crate) async fn load_projections_many(
-        &mut self,
-        request: JsonProjectionLoadRequestRef<'_>,
-    ) -> Result<JsonProjectionBatch, LixError> {
-        let values = self
-            .load_values_many(JsonLoadRequestRef {
-                refs: request.refs,
-                scope: request.scope,
-            })
-            .await?
-            .into_values()
-            .into_iter()
-            .map(|value| {
-                value.map(|value| {
-                    JsonProjection::new(
-                        request
-                            .paths
-                            .iter()
-                            .map(|path| value.pointer(path.as_str()).cloned())
-                            .collect(),
-                    )
-                })
-            })
-            .collect();
-        Ok(JsonProjectionBatch::new(values))
-    }
-}
-
-pub(crate) struct JsonStoreWriter;
-
-impl JsonStoreWriter {
-    fn new() -> Self {
-        Self
-    }
-
-    pub(crate) fn stage_batch<'a>(
-        &mut self,
-        writes: &mut StorageWriteSet,
-        placement: JsonWritePlacementRef,
-        payloads: impl IntoIterator<Item = NormalizedJsonRef<'a>>,
-    ) -> Result<Vec<JsonRef>, LixError> {
-        let JsonWritePlacementRef::OutOfBand = placement;
-        let mut unique_encoded = Vec::new();
-        let mut order = Vec::new();
-        let mut seen = HashSet::new();
-        for payload in payloads {
-            let encoded = match payload.trusted_json_ref() {
-                Some(json_ref) => store::encode_json_str_with_ref(payload.normalized(), json_ref)?,
-                None => store::encode_json_str(payload.normalized())?,
-            };
-            let hash: [u8; 32] = encoded
-                .json_ref
-                .as_hash_bytes()
-                .try_into()
-                .expect("json ref hash is fixed size");
-            #[cfg(feature = "storage-benches")]
-            crate::storage_bench::record_json_store_stage_bytes(hash);
-            order.push(encoded.json_ref);
-            if seen.insert(hash) {
-                unique_encoded.push(encoded);
-            }
-        }
-
-        for encoded in &unique_encoded {
-            writes.put(
-                store::JSON_SPACE,
-                StorageKey(Bytes::copy_from_slice(encoded.json_ref.as_hash_bytes())),
-                StorageValue {
-                    bytes: Bytes::from(store::encode_direct_json_payload(encoded)),
-                },
-            );
-        }
-
-        Ok(order)
-    }
-}

package/dist-engine-src/src/json_store/encoded.rs

@@ -1,15 +0,0 @@
-use crate::json_store::types::JsonRef;
-use std::borrow::Cow;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub(crate) enum JsonCodec {
-    Raw,
-    Zstd,
-}
-
-pub(crate) struct EncodedJson<'a> {
-    pub(crate) json_ref: JsonRef,
-    pub(crate) codec: JsonCodec,
-    pub(crate) uncompressed_len: usize,
-    pub(crate) data: Cow<'a, [u8]>,
-}

package/dist-engine-src/src/json_store/mod.rs

@@ -1,38 +0,0 @@
-pub(crate) mod compression;
-pub(crate) mod context;
-mod encoded;
-pub(crate) mod store;
-pub(crate) mod types;
-
-use crate::storage::StorageWriteSet;
-use crate::LixError;
-
-#[allow(unused_imports)]
-pub(crate) use context::{JsonStoreContext, JsonStoreReader, JsonStoreWriter};
-pub(crate) use types::{
-    JsonLoadRequestRef, JsonReadScopeRef, JsonRef, JsonWritePlacementRef, NormalizedJson,
-    NormalizedJsonRef,
-};
-
-pub(crate) fn direct_json_payload_ref_from_key(key: &[u8]) -> Result<JsonRef, LixError> {
-    let hash: [u8; 32] = key.try_into().map_err(|_| {
-        LixError::unknown(format!(
-            "json_store direct payload key has {} bytes, expected 32",
-            key.len()
-        ))
-    })?;
-    Ok(JsonRef::from_hash_bytes(hash))
-}
-
-pub(crate) fn stage_direct_json_payload_delete(writes: &mut StorageWriteSet, json_ref: &JsonRef) {
-    writes.delete(store::JSON_SPACE, json_ref.as_hash_bytes().to_vec());
-}
-
-#[cfg(any(test, feature = "storage-benches"))]
-pub(crate) fn stage_direct_json_payload_put(
-    writes: &mut StorageWriteSet,
-    json_ref: &JsonRef,
-    bytes: Vec<u8>,
-) {
-    writes.put(store::JSON_SPACE, json_ref.as_hash_bytes().to_vec(), bytes);
-}