@lix-js/sdk 0.6.0-preview.2 → 0.6.0-preview.4

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

@@ -1,4 +1,37 @@
-#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+use std::sync::Arc;
+
+use crate::LixError;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct NormalizedJson(Arc<str>);
+
+impl NormalizedJson {
+    pub(crate) fn from_arc_unchecked(normalized: Arc<str>) -> Self {
+        Self(normalized)
+    }
+
+    pub(crate) fn from_value(value: &serde_json::Value, context: &str) -> Result<Self, LixError> {
+        let normalized: Arc<str> = serde_json::to_string(value)
+            .map_err(|error| {
+                LixError::new(
+                    LixError::CODE_UNKNOWN,
+                    format!("{context} failed to serialize as normalized JSON: {error}"),
+                )
+            })?
+            .into();
+        Ok(Self(normalized))
+    }
+
+    pub(crate) fn as_str(&self) -> &str {
+        self.0.as_ref()
+    }
+
+    pub(crate) fn as_bytes(&self) -> &[u8] {
+        self.as_str().as_bytes()
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 pub(crate) struct JsonRef {
     hash: [u8; 32],
 }
@@ -14,15 +47,128 @@ impl JsonRef {
         Self { hash }
     }
 
+    pub(crate) fn for_content(bytes: &[u8]) -> Self {
+        Self::from_hash(blake3::hash(bytes))
+    }
+
     pub(crate) fn as_hash_bytes(&self) -> &[u8] {
         &self.hash
     }
 
+    pub(crate) fn as_hash_array(&self) -> &[u8; 32] {
+        &self.hash
+    }
+
     pub(crate) fn to_hex(&self) -> String {
         self.hash.iter().map(|byte| format!("{byte:02x}")).collect()
     }
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) struct NormalizedJsonRef<'a> {
+    normalized: &'a str,
+    trusted_json_ref: Option<JsonRef>,
+}
+
+impl<'a> NormalizedJsonRef<'a> {
+    pub(crate) fn new(normalized: &'a str) -> Self {
+        Self {
+            normalized,
+            trusted_json_ref: None,
+        }
+    }
+
+    /// Uses a caller-owned invariant that `json_ref` was computed from
+    /// `normalized`. This avoids rehashing JSON already normalized by the
+    /// transaction staging boundary.
+    pub(crate) fn trusted_prehashed(normalized: &'a str, json_ref: JsonRef) -> Self {
+        Self {
+            normalized,
+            trusted_json_ref: Some(json_ref),
+        }
+    }
+
+    pub(crate) fn normalized(&self) -> &'a str {
+        self.normalized
+    }
+
+    pub(crate) fn trusted_json_ref(&self) -> Option<JsonRef> {
+        self.trusted_json_ref
+    }
+}
+
+impl<'a> From<&'a NormalizedJson> for NormalizedJsonRef<'a> {
+    fn from(value: &'a NormalizedJson) -> Self {
+        Self::new(value.as_str())
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum JsonWritePlacementRef<'a> {
+    CommitPack { commit_id: &'a str, pack_id: u32 },
+    OutOfBand,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum JsonReadScopeRef<'a> {
+    OutOfBand,
+    CommitPacks {
+        commit_id: &'a str,
+        pack_ids: &'a [u32],
+    },
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) struct JsonLoadRequestRef<'a> {
+    pub(crate) refs: &'a [JsonRef],
+    pub(crate) scope: JsonReadScopeRef<'a>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) struct JsonProjectionLoadRequestRef<'a> {
+    pub(crate) refs: &'a [JsonRef],
+    pub(crate) scope: JsonReadScopeRef<'a>,
+    pub(crate) paths: &'a [JsonProjectionPath],
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct JsonLoadBatch {
+    values: Vec<Option<Vec<u8>>>,
+}
+
+impl JsonLoadBatch {
+    pub(crate) fn new(values: Vec<Option<Vec<u8>>>) -> Self {
+        Self { values }
+    }
+
+    pub(crate) fn values(&self) -> &[Option<Vec<u8>>] {
+        &self.values
+    }
+
+    pub(crate) fn into_values(self) -> Vec<Option<Vec<u8>>> {
+        self.values
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub(crate) struct JsonValueBatch {
+    values: Vec<Option<serde_json::Value>>,
+}
+
+impl JsonValueBatch {
+    pub(crate) fn new(values: Vec<Option<serde_json::Value>>) -> Self {
+        Self { values }
+    }
+
+    pub(crate) fn values(&self) -> &[Option<serde_json::Value>] {
+        &self.values
+    }
+
+    pub(crate) fn into_values(self) -> Vec<Option<serde_json::Value>> {
+        self.values
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) struct JsonProjectionPath(String);
 
@@ -50,3 +196,22 @@ impl JsonProjection {
         &self.values
     }
 }
+
+#[derive(Debug, Clone, PartialEq)]
+pub(crate) struct JsonProjectionBatch {
+    values: Vec<Option<JsonProjection>>,
+}
+
+impl JsonProjectionBatch {
+    pub(crate) fn new(values: Vec<Option<JsonProjection>>) -> Self {
+        Self { values }
+    }
+
+    pub(crate) fn values(&self) -> &[Option<JsonProjection>] {
+        &self.values
+    }
+
+    pub(crate) fn into_values(self) -> Vec<Option<JsonProjection>> {
+        self.values
+    }
+}

package/dist-engine-src/src/lib.rs

@@ -1,9 +1,12 @@
 mod backend;
 mod binary_cas;
+pub(crate) mod catalog;
 pub(crate) mod cel;
-pub(crate) mod changelog;
 pub(crate) mod commit_graph;
+#[allow(dead_code, unused_imports)]
+pub(crate) mod commit_store;
 mod common;
+pub(crate) mod domain;
 pub mod engine;
 pub(crate) mod entity_identity;
 pub(crate) mod functions;
@@ -12,14 +15,14 @@ pub(crate) mod init;
 pub(crate) mod json_store;
 pub(crate) mod live_state;
 mod schema;
-pub(crate) mod schema_registry;
 pub mod session;
 pub(crate) mod sql2;
 #[allow(dead_code, unused_imports)]
 pub(crate) mod storage;
 #[cfg(feature = "storage-benches")]
 pub mod storage_bench;
-#[cfg(test)]
+#[cfg_attr(feature = "storage-benches", allow(dead_code))]
+#[cfg(any(test, feature = "storage-benches"))]
 pub(crate) mod test_support;
 pub(crate) mod tracked_state;
 pub mod transaction;
@@ -40,21 +43,19 @@ pub use backend::{
     BytePage, BytePageBuilder,
 };
 pub use common::LixError;
-pub(crate) use common::{
-    parse_row_metadata, serialize_row_metadata, validate_row_metadata, RowMetadata,
-};
-pub use common::{
-    CanonicalPluginKey, CanonicalSchemaKey, CanonicalSchemaVersion, EntityId, FileId, VersionId,
-};
+pub(crate) use common::{parse_row_metadata, parse_row_metadata_value, serialize_row_metadata};
+pub use common::{CanonicalPluginKey, CanonicalSchemaKey, EntityId, FileId, VersionId};
 pub use common::{LixNotice, NullableKeyFilter, SqlQueryResult, Value, WriteReceipt};
 pub use common::{WireQueryResult, WireValue};
 pub use engine::Engine;
 pub use init::InitReceipt;
+#[cfg(feature = "storage-benches")]
+pub use session::optimization9_sql2_bench;
 pub use session::{
     CreateVersionOptions, CreateVersionReceipt, MergeChangeStats, MergeConflict,
     MergeConflictChangeKind, MergeConflictKind, MergeConflictSide, MergeVersionOptions,
     MergeVersionOutcome, MergeVersionPreview, MergeVersionPreviewOptions, MergeVersionReceipt,
-    SessionContext, SwitchVersionOptions, SwitchVersionReceipt,
+    SessionContext, SessionTransaction, SwitchVersionOptions, SwitchVersionReceipt,
 };
 pub use session::{ExecuteResult, Row, RowRef, TryFromValue};