@lix-js/sdk 0.6.0-preview.1 → 0.6.0-preview.3

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

@@ -0,0 +1,217 @@
+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],
+}
+
+impl JsonRef {
+    pub(crate) fn from_hash(hash: blake3::Hash) -> Self {
+        Self {
+            hash: *hash.as_bytes(),
+        }
+    }
+
+    pub(crate) fn from_hash_bytes(hash: [u8; 32]) -> Self {
+        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);
+
+impl JsonProjectionPath {
+    pub(crate) fn new(pointer: impl Into<String>) -> Self {
+        Self(pointer.into())
+    }
+
+    pub(crate) fn as_str(&self) -> &str {
+        &self.0
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub(crate) struct JsonProjection {
+    values: Vec<Option<serde_json::Value>>,
+}
+
+impl JsonProjection {
+    pub(crate) fn new(values: Vec<Option<serde_json::Value>>) -> Self {
+        Self { values }
+    }
+
+    pub(crate) fn values(&self) -> &[Option<serde_json::Value>] {
+        &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

@@ -0,0 +1,62 @@
+mod backend;
+mod binary_cas;
+pub(crate) mod catalog;
+pub(crate) mod cel;
+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;
+pub(crate) mod init;
+#[allow(dead_code)]
+pub(crate) mod json_store;
+pub(crate) mod live_state;
+mod schema;
+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_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;
+pub(crate) mod untracked_state;
+pub(crate) mod version;
+pub mod wasm;
+
+pub use schema::{
+    lix_schema_definition, lix_schema_definition_json, validate_lix_schema,
+    validate_lix_schema_definition,
+};
+
+pub use backend::{
+    Backend, BackendKvEntryPage, BackendKvExistsBatch, BackendKvExistsGroup, BackendKvGetGroup,
+    BackendKvGetRequest, BackendKvKeyPage, BackendKvScanRange, BackendKvScanRequest,
+    BackendKvValueBatch, BackendKvValueGroup, BackendKvValuePage, BackendKvWriteBatch,
+    BackendKvWriteGroup, BackendKvWriteStats, BackendReadTransaction, BackendWriteTransaction,
+    BytePage, BytePageBuilder,
+};
+pub use common::LixError;
+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,
+};
+pub use session::{ExecuteResult, Row, RowRef, TryFromValue};
+
+pub(crate) const GLOBAL_VERSION_ID: &str = "global";