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

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

@@ -1,217 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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, SessionTransaction, SwitchVersionOptions, SwitchVersionReceipt,
-};
-pub use session::{ExecuteResult, Row, RowRef, TryFromValue};
-
-pub(crate) const GLOBAL_VERSION_ID: &str = "global";