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

package/dist-engine-src/src/untracked_state/codec.rs

@@ -1,12 +1,11 @@
 use crate::entity_identity::EntityIdentity;
-use crate::json_store::JsonRef;
-use crate::untracked_state::UntrackedStateRow;
+use crate::untracked_state::{UntrackedStateRow, UntrackedStateRowRef};
 use crate::LixError;
 
 const UNTRACKED_STATE_FILE_IDENTIFIER: &str = "LXUS";
 
-pub(crate) fn encode_row(row: &UntrackedStateRow) -> Result<Vec<u8>, LixError> {
-    let entity_id = row.entity_id.as_string().map_err(|error| {
+pub(crate) fn encode_row_ref(row: UntrackedStateRowRef<'_>) -> Result<Vec<u8>, LixError> {
+    let entity_id = row.entity_id.as_json_array_text().map_err(|error| {
         LixError::unknown(format!(
             "failed to encode untracked-state entity identity: {error}"
         ))
@@ -14,23 +13,15 @@ pub(crate) fn encode_row(row: &UntrackedStateRow) -> Result<Vec<u8>, LixError> {
 
     let mut builder = flatbuffers::FlatBufferBuilder::with_capacity(256);
     let entity_id = builder.create_string(&entity_id);
-    let schema_key = builder.create_string(&row.schema_key);
-    let file_id = row
-        .file_id
-        .as_ref()
+    let schema_key = builder.create_string(row.schema_key);
+    let file_id = row.file_id.map(|value| builder.create_string(value));
+    let snapshot_content = row
+        .snapshot_content
         .map(|value| builder.create_string(value));
-    let snapshot_ref = row
-        .snapshot_ref
-        .as_ref()
-        .map(|value| builder.create_vector(value.as_hash_bytes()));
-    let metadata_ref = row
-        .metadata_ref
-        .as_ref()
-        .map(|value| builder.create_vector(value.as_hash_bytes()));
-    let schema_version = builder.create_string(&row.schema_version);
-    let created_at = builder.create_string(&row.created_at);
-    let updated_at = builder.create_string(&row.updated_at);
-    let version_id = builder.create_string(&row.version_id);
+    let metadata = row.metadata.map(|value| builder.create_string(value));
+    let created_at = builder.create_string(row.created_at);
+    let updated_at = builder.create_string(row.updated_at);
+    let version_id = builder.create_string(row.version_id);
 
     let root = flatbuffer::create_untracked_state_row(
         &mut builder,
@@ -38,9 +29,8 @@ pub(crate) fn encode_row(row: &UntrackedStateRow) -> Result<Vec<u8>, LixError> {
             entity_id,
             schema_key,
             file_id,
-            snapshot_ref,
-            metadata_ref,
-            schema_version,
+            snapshot_content,
+            metadata,
             created_at,
             updated_at,
             global: row.global,
@@ -69,7 +59,7 @@ pub(crate) fn decode_row(bytes: &[u8]) -> Result<UntrackedStateRow, LixError> {
     })?;
 
     let entity_id = required_str(row.entity_id(), "entity_id")?;
-    let entity_id = EntityIdentity::from_string(entity_id).map_err(|error| {
+    let entity_id = EntityIdentity::from_json_array_text(entity_id).map_err(|error| {
         LixError::unknown(format!(
             "failed to decode untracked-state entity identity: {error}"
         ))
@@ -79,9 +69,8 @@ pub(crate) fn decode_row(bytes: &[u8]) -> Result<UntrackedStateRow, LixError> {
         entity_id,
         schema_key: required_str(row.schema_key(), "schema_key")?.to_string(),
         file_id: row.file_id().map(ToString::to_string),
-        snapshot_ref: optional_json_ref(row.snapshot_ref(), "snapshot_ref")?,
-        metadata_ref: optional_json_ref(row.metadata_ref(), "metadata_ref")?,
-        schema_version: required_str(row.schema_version(), "schema_version")?.to_string(),
+        snapshot_content: row.snapshot_content().map(ToString::to_string),
+        metadata: row.metadata().map(ToString::to_string),
         created_at: required_str(row.created_at(), "created_at")?.to_string(),
         updated_at: required_str(row.updated_at(), "updated_at")?.to_string(),
         global: row.global(),
@@ -98,25 +87,6 @@ fn required_str<'a>(value: Option<&'a str>, field: &str) -> Result<&'a str, LixE
     })
 }
 
-fn optional_json_ref(
-    value: Option<flatbuffers::Vector<'_, u8>>,
-    field: &str,
-) -> Result<Option<JsonRef>, LixError> {
-    let Some(value) = value else {
-        return Ok(None);
-    };
-    let bytes = value.bytes();
-    let hash = <[u8; 32]>::try_from(bytes).map_err(|_| {
-        LixError::new(
-            "LIX_ERROR_UNKNOWN",
-            format!(
-                "failed to decode untracked-state row: field `{field}` must be exactly 32 bytes"
-            ),
-        )
-    })?;
-    Ok(Some(JsonRef::from_hash_bytes(hash)))
-}
-
 mod flatbuffer {
     #[derive(Copy, Clone, PartialEq)]
     pub(super) struct UntrackedStateRow<'a> {
@@ -138,13 +108,12 @@ mod flatbuffer {
         const VT_ENTITY_ID: flatbuffers::VOffsetT = 4;
         const VT_SCHEMA_KEY: flatbuffers::VOffsetT = 6;
         const VT_FILE_ID: flatbuffers::VOffsetT = 8;
-        const VT_SNAPSHOT_REF: flatbuffers::VOffsetT = 10;
-        const VT_METADATA_REF: flatbuffers::VOffsetT = 12;
-        const VT_SCHEMA_VERSION: flatbuffers::VOffsetT = 14;
-        const VT_CREATED_AT: flatbuffers::VOffsetT = 16;
-        const VT_UPDATED_AT: flatbuffers::VOffsetT = 18;
-        const VT_GLOBAL: flatbuffers::VOffsetT = 20;
-        const VT_VERSION_ID: flatbuffers::VOffsetT = 22;
+        const VT_SNAPSHOT_CONTENT: flatbuffers::VOffsetT = 10;
+        const VT_METADATA: flatbuffers::VOffsetT = 12;
+        const VT_CREATED_AT: flatbuffers::VOffsetT = 14;
+        const VT_UPDATED_AT: flatbuffers::VOffsetT = 16;
+        const VT_GLOBAL: flatbuffers::VOffsetT = 18;
+        const VT_VERSION_ID: flatbuffers::VOffsetT = 20;
 
         #[inline]
         pub(super) fn entity_id(&self) -> Option<&'a str> {
@@ -171,36 +140,21 @@ mod flatbuffer {
         }
 
         #[inline]
-        pub(super) fn snapshot_ref(&self) -> Option<flatbuffers::Vector<'a, u8>> {
-            unsafe {
-                self.table
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
-                        Self::VT_SNAPSHOT_REF,
-                        None,
-                    )
-            }
-        }
-
-        #[inline]
-        pub(super) fn metadata_ref(&self) -> Option<flatbuffers::Vector<'a, u8>> {
+        pub(super) fn snapshot_content(&self) -> Option<&'a str> {
             unsafe {
                 self.table
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
-                        Self::VT_METADATA_REF,
-                        None,
-                    )
+                    .get::<flatbuffers::ForwardsUOffset<&str>>(Self::VT_SNAPSHOT_CONTENT, None)
             }
         }
 
         #[inline]
-        pub(super) fn schema_version(&self) -> Option<&'a str> {
+        pub(super) fn metadata(&self) -> Option<&'a str> {
             unsafe {
                 self.table
-                    .get::<flatbuffers::ForwardsUOffset<&str>>(Self::VT_SCHEMA_VERSION, None)
+                    .get::<flatbuffers::ForwardsUOffset<&str>>(Self::VT_METADATA, None)
             }
         }
 
-        #[inline]
         pub(super) fn created_at(&self) -> Option<&'a str> {
             unsafe {
                 self.table
@@ -253,20 +207,15 @@ mod flatbuffer {
                     Self::VT_FILE_ID,
                     false,
                 )?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
-                    "snapshot_ref",
-                    Self::VT_SNAPSHOT_REF,
-                    false,
-                )?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
-                    "metadata_ref",
-                    Self::VT_METADATA_REF,
+                .visit_field::<flatbuffers::ForwardsUOffset<&str>>(
+                    "snapshot_content",
+                    Self::VT_SNAPSHOT_CONTENT,
                     false,
                 )?
                 .visit_field::<flatbuffers::ForwardsUOffset<&str>>(
-                    "schema_version",
-                    Self::VT_SCHEMA_VERSION,
-                    true,
+                    "metadata",
+                    Self::VT_METADATA,
+                    false,
                 )?
                 .visit_field::<flatbuffers::ForwardsUOffset<&str>>(
                     "created_at",
@@ -293,9 +242,8 @@ mod flatbuffer {
         pub(super) entity_id: flatbuffers::WIPOffset<&'a str>,
         pub(super) schema_key: flatbuffers::WIPOffset<&'a str>,
         pub(super) file_id: Option<flatbuffers::WIPOffset<&'a str>>,
-        pub(super) snapshot_ref: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
-        pub(super) metadata_ref: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
-        pub(super) schema_version: flatbuffers::WIPOffset<&'a str>,
+        pub(super) snapshot_content: Option<flatbuffers::WIPOffset<&'a str>>,
+        pub(super) metadata: Option<flatbuffers::WIPOffset<&'a str>>,
         pub(super) created_at: flatbuffers::WIPOffset<&'a str>,
         pub(super) updated_at: flatbuffers::WIPOffset<&'a str>,
         pub(super) global: bool,
@@ -320,20 +268,16 @@ mod flatbuffer {
             UntrackedStateRow::VT_CREATED_AT,
             args.created_at,
         );
-        builder.push_slot_always::<flatbuffers::WIPOffset<_>>(
-            UntrackedStateRow::VT_SCHEMA_VERSION,
-            args.schema_version,
-        );
-        if let Some(metadata_ref) = args.metadata_ref {
+        if let Some(metadata) = args.metadata {
             builder.push_slot_always::<flatbuffers::WIPOffset<_>>(
-                UntrackedStateRow::VT_METADATA_REF,
-                metadata_ref,
+                UntrackedStateRow::VT_METADATA,
+                metadata,
             );
         }
-        if let Some(snapshot_ref) = args.snapshot_ref {
+        if let Some(snapshot_content) = args.snapshot_content {
             builder.push_slot_always::<flatbuffers::WIPOffset<_>>(
-                UntrackedStateRow::VT_SNAPSHOT_REF,
-                snapshot_ref,
+                UntrackedStateRow::VT_SNAPSHOT_CONTENT,
+                snapshot_content,
             );
         }
         if let Some(file_id) = args.file_id {

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

@@ -1,7 +1,7 @@
 use crate::storage::{StorageReader, StorageWriteSet};
 use crate::untracked_state::{
-    MaterializedUntrackedStateRow, UntrackedStateIdentity, UntrackedStateRow,
-    UntrackedStateRowRequest, UntrackedStateScanRequest,
+    MaterializedUntrackedStateRow, UntrackedStateIdentity, UntrackedStateIdentityRef,
+    UntrackedStateRowRef, UntrackedStateRowRequest, UntrackedStateScanRequest,
 };
 use crate::LixError;
 
@@ -59,6 +59,16 @@ where
     ) -> Result<Option<MaterializedUntrackedStateRow>, LixError> {
         crate::untracked_state::storage::load_row(&mut self.store, request).await
     }
+
+    pub(crate) async fn existing_identities<'a, I>(
+        &mut self,
+        identities: I,
+    ) -> Result<Vec<UntrackedStateIdentity>, LixError>
+    where
+        I: IntoIterator<Item = UntrackedStateIdentityRef<'a>>,
+    {
+        crate::untracked_state::storage::existing_identities(&mut self.store, identities).await
+    }
 }
 
 /// Untracked-state writer over a transaction-local storage write set.
@@ -69,14 +79,20 @@ pub(crate) struct UntrackedStateWriter<'a> {
 impl UntrackedStateWriter<'_> {
     /// Stages the latest untracked rows for their identities.
     ///
-    /// A row with `snapshot_ref = None` is treated as removal because
+    /// A row with `snapshot_content = None` is treated as removal because
     /// untracked state keeps only the current local value, not tombstones.
-    pub(crate) fn stage_rows(&mut self, rows: &[UntrackedStateRow]) -> Result<(), LixError> {
+    pub(crate) fn stage_rows<'a, I>(&mut self, rows: I) -> Result<(), LixError>
+    where
+        I: IntoIterator<Item = UntrackedStateRowRef<'a>>,
+    {
         crate::untracked_state::storage::stage_rows(self.writes, rows)
     }
 
     /// Removes untracked rows by exact identity.
-    pub(crate) fn stage_delete_rows(&mut self, identities: &[UntrackedStateIdentity]) {
+    pub(crate) fn stage_delete_rows<'a, I>(&mut self, identities: I)
+    where
+        I: IntoIterator<Item = UntrackedStateIdentityRef<'a>>,
+    {
         crate::untracked_state::storage::stage_delete_rows(self.writes, identities)
     }
 }

package/dist-engine-src/src/untracked_state/materialization.rs

@@ -1,44 +1,18 @@
-use crate::json_store::{JsonRef, JsonStoreReader, JsonStoreWriter};
-use crate::storage::{StorageReader, StorageWriteSet};
 use crate::untracked_state::{MaterializedUntrackedStateRow, UntrackedStateRow};
-use crate::{serialize_row_metadata, validate_row_metadata, LixError, RowMetadata};
+use crate::{parse_row_metadata, LixError};
 
-pub(crate) fn canonicalize_materialized_row(
-    writes: &mut StorageWriteSet,
-    json_writer: &mut JsonStoreWriter,
-    row: &MaterializedUntrackedStateRow,
-) -> Result<UntrackedStateRow, LixError> {
-    let snapshot_ref = stage_optional_json(writes, json_writer, row.snapshot_content.as_deref())?;
-    let metadata_ref = stage_optional_metadata(writes, json_writer, row.metadata.as_ref())?;
-    Ok(UntrackedStateRow {
-        entity_id: row.entity_id.clone(),
-        schema_key: row.schema_key.clone(),
-        file_id: row.file_id.clone(),
-        snapshot_ref,
-        metadata_ref,
-        schema_version: row.schema_version.clone(),
-        created_at: row.created_at.clone(),
-        updated_at: row.updated_at.clone(),
-        global: row.global,
-        version_id: row.version_id.clone(),
-    })
-}
-
-pub(crate) async fn materialize_row<S>(
-    json_reader: &mut JsonStoreReader<S>,
+pub(crate) fn materialize_row(
     row: UntrackedStateRow,
     projection: &UntrackedMaterializationProjection,
-) -> Result<MaterializedUntrackedStateRow, LixError>
-where
-    S: StorageReader,
-{
+) -> Result<MaterializedUntrackedStateRow, LixError> {
+    let deleted = row.snapshot_content.is_none();
     let snapshot_content = if projection.snapshot_content {
-        load_optional_json(json_reader, row.snapshot_ref.as_ref(), "snapshot_ref").await?
+        row.snapshot_content
     } else {
         None
     };
     let metadata = if projection.metadata {
-        load_optional_metadata(json_reader, row.metadata_ref.as_ref()).await?
+        load_optional_metadata(row.metadata)?
     } else {
         None
     };
@@ -48,7 +22,7 @@ where
         file_id: row.file_id,
         snapshot_content,
         metadata,
-        schema_version: row.schema_version,
+        deleted,
         created_at: row.created_at,
         updated_at: row.updated_at,
         global: row.global,
@@ -81,77 +55,9 @@ impl UntrackedMaterializationProjection {
     }
 }
 
-fn stage_optional_json(
-    writes: &mut StorageWriteSet,
-    json_writer: &mut JsonStoreWriter,
-    value: Option<&str>,
-) -> Result<Option<JsonRef>, LixError> {
-    let Some(value) = value else {
+fn load_optional_metadata(metadata: Option<String>) -> Result<Option<String>, LixError> {
+    let Some(json) = metadata else {
         return Ok(None);
     };
-    json_writer.stage_bytes(writes, value.as_bytes()).map(Some)
-}
-
-fn stage_optional_metadata(
-    writes: &mut StorageWriteSet,
-    json_writer: &mut JsonStoreWriter,
-    value: Option<&RowMetadata>,
-) -> Result<Option<JsonRef>, LixError> {
-    let Some(value) = value else {
-        return Ok(None);
-    };
-    let serialized = serialize_row_metadata(value);
-    json_writer
-        .stage_bytes(writes, serialized.as_bytes())
-        .map(Some)
-}
-
-async fn load_optional_metadata<S>(
-    json_reader: &mut JsonStoreReader<S>,
-    json_ref: Option<&JsonRef>,
-) -> Result<Option<RowMetadata>, LixError>
-where
-    S: StorageReader,
-{
-    let Some(json) = load_optional_json(json_reader, json_ref, "metadata_ref").await? else {
-        return Ok(None);
-    };
-    let metadata = serde_json::from_str::<RowMetadata>(&json).map_err(|error| {
-        LixError::new(
-            "LIX_ERROR_INVALID_JSON",
-            format!("untracked_state metadata_ref is invalid JSON: {error}"),
-        )
-    })?;
-    validate_row_metadata(metadata, "untracked_state metadata_ref").map(Some)
-}
-
-async fn load_optional_json<S>(
-    json_reader: &mut JsonStoreReader<S>,
-    json_ref: Option<&JsonRef>,
-    field: &str,
-) -> Result<Option<String>, LixError>
-where
-    S: StorageReader,
-{
-    let Some(json_ref) = json_ref else {
-        return Ok(None);
-    };
-    let bytes = json_reader.load_bytes(json_ref).await?.ok_or_else(|| {
-        LixError::new(
-            "LIX_ERROR_UNKNOWN",
-            format!(
-                "untracked_state {field} '{}' is missing from json_store",
-                json_ref.to_hex()
-            ),
-        )
-    })?;
-    String::from_utf8(bytes).map(Some).map_err(|error| {
-        LixError::new(
-            "LIX_ERROR_UNKNOWN",
-            format!(
-                "untracked_state {field} '{}' is not valid UTF-8 JSON bytes: {error}",
-                json_ref.to_hex()
-            ),
-        )
-    })
+    parse_row_metadata(&json, "untracked_state metadata").map(Some)
 }

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

@@ -6,12 +6,10 @@ mod types;
 
 #[allow(unused_imports)]
 pub(crate) use context::{UntrackedStateContext, UntrackedStateStoreReader, UntrackedStateWriter};
-pub(crate) use materialization::{
-    canonicalize_materialized_row, materialize_row, UntrackedMaterializationProjection,
-};
+pub(crate) use materialization::{materialize_row, UntrackedMaterializationProjection};
 #[allow(unused_imports)]
 pub(crate) use types::{
     MaterializedUntrackedStateRow, UntrackedStateFilter, UntrackedStateIdentity,
-    UntrackedStateProjection, UntrackedStateRow, UntrackedStateRowRequest,
-    UntrackedStateScanRequest,
+    UntrackedStateIdentityRef, UntrackedStateProjection, UntrackedStateRow, UntrackedStateRowRef,
+    UntrackedStateRowRequest, UntrackedStateScanRequest,
 };