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

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

@@ -1,501 +0,0 @@
-use async_trait::async_trait;
-
-use crate::backend;
-use crate::backend::BytePage;
-use crate::LixError;
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) enum KvScanRange {
-    Prefix(Vec<u8>),
-    Range { start: Vec<u8>, end: Vec<u8> },
-}
-
-impl KvScanRange {
-    pub(crate) fn prefix(prefix: impl Into<Vec<u8>>) -> Self {
-        Self::Prefix(prefix.into())
-    }
-
-    pub(crate) fn range(start: impl Into<Vec<u8>>, end: impl Into<Vec<u8>>) -> Self {
-        Self::Range {
-            start: start.into(),
-            end: end.into(),
-        }
-    }
-}
-
-impl From<KvScanRange> for backend::BackendKvScanRange {
-    fn from(range: KvScanRange) -> Self {
-        match range {
-            KvScanRange::Prefix(prefix) => Self::Prefix(prefix),
-            KvScanRange::Range { start, end } => Self::Range { start, end },
-        }
-    }
-}
-
-#[async_trait]
-pub(crate) trait StorageReader: Send {
-    async fn get_values(&mut self, request: KvGetRequest) -> Result<KvValueBatch, LixError>;
-
-    async fn exists_many(&mut self, request: KvGetRequest) -> Result<KvExistsBatch, LixError>;
-
-    async fn scan_keys(&mut self, request: KvScanRequest) -> Result<KvKeyPage, LixError>;
-
-    async fn scan_values(&mut self, request: KvScanRequest) -> Result<KvValuePage, LixError>;
-
-    async fn scan_entries(&mut self, request: KvScanRequest) -> Result<KvEntryPage, LixError>;
-}
-
-#[async_trait]
-pub(crate) trait StorageWriter: StorageReader {
-    async fn write_kv_batch(&mut self, batch: KvWriteBatch) -> Result<KvWriteStats, LixError>;
-}
-
-#[async_trait]
-pub(crate) trait StorageReadTransaction: StorageReader + Send + Sync {
-    async fn rollback(self: Box<Self>) -> Result<(), LixError>;
-}
-
-#[async_trait]
-pub(crate) trait StorageWriteTransaction:
-    StorageReadTransaction + StorageWriter + Send + Sync
-{
-    async fn commit(self: Box<Self>) -> Result<(), LixError>;
-}
-
-#[async_trait]
-impl<T> StorageReader for &mut T
-where
-    T: StorageReader + ?Sized,
-{
-    async fn get_values(&mut self, request: KvGetRequest) -> Result<KvValueBatch, LixError> {
-        (**self).get_values(request).await
-    }
-
-    async fn exists_many(&mut self, request: KvGetRequest) -> Result<KvExistsBatch, LixError> {
-        (**self).exists_many(request).await
-    }
-
-    async fn scan_keys(&mut self, request: KvScanRequest) -> Result<KvKeyPage, LixError> {
-        (**self).scan_keys(request).await
-    }
-
-    async fn scan_values(&mut self, request: KvScanRequest) -> Result<KvValuePage, LixError> {
-        (**self).scan_values(request).await
-    }
-
-    async fn scan_entries(&mut self, request: KvScanRequest) -> Result<KvEntryPage, LixError> {
-        (**self).scan_entries(request).await
-    }
-}
-
-#[async_trait]
-impl<T> StorageReader for Box<T>
-where
-    T: StorageReader + ?Sized,
-{
-    async fn get_values(&mut self, request: KvGetRequest) -> Result<KvValueBatch, LixError> {
-        (**self).get_values(request).await
-    }
-
-    async fn exists_many(&mut self, request: KvGetRequest) -> Result<KvExistsBatch, LixError> {
-        (**self).exists_many(request).await
-    }
-
-    async fn scan_keys(&mut self, request: KvScanRequest) -> Result<KvKeyPage, LixError> {
-        (**self).scan_keys(request).await
-    }
-
-    async fn scan_values(&mut self, request: KvScanRequest) -> Result<KvValuePage, LixError> {
-        (**self).scan_values(request).await
-    }
-
-    async fn scan_entries(&mut self, request: KvScanRequest) -> Result<KvEntryPage, LixError> {
-        (**self).scan_entries(request).await
-    }
-}
-
-#[async_trait]
-impl<T> StorageWriter for &mut T
-where
-    T: StorageWriter + ?Sized,
-{
-    async fn write_kv_batch(&mut self, batch: KvWriteBatch) -> Result<KvWriteStats, LixError> {
-        (**self).write_kv_batch(batch).await
-    }
-}
-
-#[async_trait]
-impl<T> StorageWriter for Box<T>
-where
-    T: StorageWriter + ?Sized,
-{
-    async fn write_kv_batch(&mut self, batch: KvWriteBatch) -> Result<KvWriteStats, LixError> {
-        (**self).write_kv_batch(batch).await
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct KvGetRequest {
-    pub(crate) groups: Vec<KvGetGroup>,
-}
-
-impl From<KvGetRequest> for backend::BackendKvGetRequest {
-    fn from(request: KvGetRequest) -> Self {
-        Self {
-            groups: request.groups.into_iter().map(Into::into).collect(),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct KvGetGroup {
-    pub(crate) namespace: String,
-    pub(crate) keys: Vec<Vec<u8>>,
-}
-
-impl From<KvGetGroup> for backend::BackendKvGetGroup {
-    fn from(group: KvGetGroup) -> Self {
-        Self {
-            namespace: group.namespace,
-            keys: group.keys,
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct KvValueBatch {
-    pub(crate) groups: Vec<KvValueGroup>,
-}
-
-impl From<backend::BackendKvValueBatch> for KvValueBatch {
-    fn from(result: backend::BackendKvValueBatch) -> Self {
-        Self {
-            groups: result.groups.into_iter().map(Into::into).collect(),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct KvValueGroup {
-    namespace: String,
-    values: BytePage,
-    present: Vec<bool>,
-}
-
-impl From<backend::BackendKvValueGroup> for KvValueGroup {
-    fn from(group: backend::BackendKvValueGroup) -> Self {
-        let (namespace, values, present) = group.into_parts();
-        Self {
-            namespace,
-            values,
-            present,
-        }
-    }
-}
-
-impl KvValueGroup {
-    pub(crate) fn len(&self) -> usize {
-        self.present.len()
-    }
-
-    pub(crate) fn value(&self, index: usize) -> Option<Option<&[u8]>> {
-        let present = *self.present.get(index)?;
-        if present {
-            Some(Some(
-                self.values
-                    .get(index)
-                    .expect("storage value batch invariant violated"),
-            ))
-        } else {
-            Some(None)
-        }
-    }
-
-    pub(crate) fn values_iter(&self) -> impl Iterator<Item = Option<&[u8]>> {
-        (0..self.len()).filter_map(|index| self.value(index))
-    }
-
-    pub(crate) fn single_value_owned(&self) -> Option<Vec<u8>> {
-        if self.len() != 1 {
-            return None;
-        }
-        self.value(0).flatten().map(<[u8]>::to_vec)
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct KvExistsBatch {
-    pub(crate) groups: Vec<KvExistsGroup>,
-}
-
-impl From<backend::BackendKvExistsBatch> for KvExistsBatch {
-    fn from(result: backend::BackendKvExistsBatch) -> Self {
-        Self {
-            groups: result.groups.into_iter().map(Into::into).collect(),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct KvExistsGroup {
-    pub(crate) namespace: String,
-    pub(crate) exists: Vec<bool>,
-}
-
-impl From<backend::BackendKvExistsGroup> for KvExistsGroup {
-    fn from(group: backend::BackendKvExistsGroup) -> Self {
-        Self {
-            namespace: group.namespace,
-            exists: group.exists,
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct KvScanRequest {
-    pub(crate) namespace: String,
-    pub(crate) range: KvScanRange,
-    pub(crate) after: Option<Vec<u8>>,
-    pub(crate) limit: usize,
-}
-
-impl From<KvScanRequest> for backend::BackendKvScanRequest {
-    fn from(request: KvScanRequest) -> Self {
-        Self {
-            namespace: request.namespace,
-            range: request.range.into(),
-            after: request.after,
-            limit: request.limit,
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct KvKeyPage {
-    pub(crate) keys: BytePage,
-    pub(crate) resume_after: Option<Vec<u8>>,
-}
-
-impl From<backend::BackendKvKeyPage> for KvKeyPage {
-    fn from(result: backend::BackendKvKeyPage) -> Self {
-        Self {
-            keys: result.keys,
-            resume_after: result.resume_after,
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct KvValuePage {
-    pub(crate) values: BytePage,
-    pub(crate) resume_after: Option<Vec<u8>>,
-}
-
-impl From<backend::BackendKvValuePage> for KvValuePage {
-    fn from(result: backend::BackendKvValuePage) -> Self {
-        Self {
-            values: result.values,
-            resume_after: result.resume_after,
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct KvEntryPage {
-    pub(crate) keys: BytePage,
-    pub(crate) values: BytePage,
-    pub(crate) resume_after: Option<Vec<u8>>,
-}
-
-impl From<backend::BackendKvEntryPage> for KvEntryPage {
-    fn from(result: backend::BackendKvEntryPage) -> Self {
-        Self {
-            keys: result.keys,
-            values: result.values,
-            resume_after: result.resume_after,
-        }
-    }
-}
-
-impl KvEntryPage {
-    pub(crate) fn len(&self) -> usize {
-        self.keys.len()
-    }
-
-    pub(crate) fn is_empty(&self) -> bool {
-        self.keys.is_empty()
-    }
-
-    pub(crate) fn key(&self, index: usize) -> Option<&[u8]> {
-        self.keys.get(index)
-    }
-
-    pub(crate) fn value(&self, index: usize) -> Option<&[u8]> {
-        self.values.get(index)
-    }
-}
-
-#[derive(Debug, Default)]
-pub(crate) struct StorageWriteSet {
-    batch: KvWriteBatch,
-}
-
-impl StorageWriteSet {
-    pub(crate) fn new() -> Self {
-        Self::default()
-    }
-
-    pub(crate) fn put(&mut self, namespace: &'static str, key: Vec<u8>, value: Vec<u8>) {
-        self.batch.put(namespace, key, value);
-    }
-
-    pub(crate) fn delete(&mut self, namespace: &'static str, key: Vec<u8>) {
-        self.batch.delete(namespace, key);
-    }
-
-    pub(crate) fn is_empty(&self) -> bool {
-        self.batch.is_empty()
-    }
-
-    pub(crate) async fn apply(
-        self,
-        writer: &mut (impl StorageWriter + ?Sized),
-    ) -> Result<KvWriteStats, LixError> {
-        writer.write_kv_batch(self.batch).await
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Default)]
-pub(crate) struct KvWriteBatch {
-    pub(crate) groups: Vec<KvWriteGroup>,
-}
-
-impl KvWriteBatch {
-    pub(crate) fn new() -> Self {
-        Self::default()
-    }
-
-    pub(crate) fn put(
-        &mut self,
-        namespace: impl Into<String>,
-        key: impl Into<Vec<u8>>,
-        value: impl Into<Vec<u8>>,
-    ) {
-        let namespace = namespace.into();
-        let group = self.group_mut(namespace);
-        group.put(key.into(), value.into());
-    }
-
-    pub(crate) fn delete(&mut self, namespace: impl Into<String>, key: impl Into<Vec<u8>>) {
-        let namespace = namespace.into();
-        let group = self.group_mut(namespace);
-        group.delete(key.into());
-    }
-
-    pub(crate) fn is_empty(&self) -> bool {
-        self.groups
-            .iter()
-            .all(|group| group.put_count() == 0 && group.delete_count() == 0)
-    }
-
-    fn group_mut(&mut self, namespace: String) -> &mut KvWriteGroup {
-        if let Some(index) = self
-            .groups
-            .iter()
-            .position(|group| group.namespace == namespace)
-        {
-            return &mut self.groups[index];
-        }
-        self.groups.push(KvWriteGroup {
-            namespace,
-            put_keys: backend::BytePageBuilder::new(),
-            put_values: backend::BytePageBuilder::new(),
-            deletes: backend::BytePageBuilder::new(),
-        });
-        self.groups.last_mut().expect("group just pushed")
-    }
-}
-
-impl From<KvWriteBatch> for backend::BackendKvWriteBatch {
-    fn from(batch: KvWriteBatch) -> Self {
-        Self {
-            groups: batch.groups.into_iter().map(Into::into).collect(),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct KvWriteGroup {
-    namespace: String,
-    put_keys: backend::BytePageBuilder,
-    put_values: backend::BytePageBuilder,
-    deletes: backend::BytePageBuilder,
-}
-
-impl From<KvWriteGroup> for backend::BackendKvWriteGroup {
-    fn from(group: KvWriteGroup) -> Self {
-        Self::from_pages(
-            group.namespace,
-            group.put_keys.finish(),
-            group.put_values.finish(),
-            group.deletes.finish(),
-        )
-    }
-}
-
-impl KvWriteGroup {
-    pub(crate) fn new(namespace: impl Into<String>) -> Self {
-        Self {
-            namespace: namespace.into(),
-            put_keys: backend::BytePageBuilder::new(),
-            put_values: backend::BytePageBuilder::new(),
-            deletes: backend::BytePageBuilder::new(),
-        }
-    }
-
-    pub(crate) fn put(&mut self, key: impl AsRef<[u8]>, value: impl AsRef<[u8]>) {
-        self.put_keys.push(key);
-        self.put_values.push(value);
-    }
-
-    pub(crate) fn delete(&mut self, key: impl AsRef<[u8]>) {
-        self.deletes.push(key);
-    }
-
-    pub(crate) fn put_count(&self) -> usize {
-        self.put_keys.len()
-    }
-
-    pub(crate) fn delete_count(&self) -> usize {
-        self.deletes.len()
-    }
-
-    pub(crate) fn put_key(&self, index: usize) -> Option<&[u8]> {
-        self.put_keys.get(index)
-    }
-
-    pub(crate) fn put_value(&self, index: usize) -> Option<&[u8]> {
-        self.put_values.get(index)
-    }
-
-    pub(crate) fn delete_key(&self, index: usize) -> Option<&[u8]> {
-        self.deletes.get(index)
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
-pub(crate) struct KvWriteStats {
-    pub(crate) puts: usize,
-    pub(crate) deletes: usize,
-    pub(crate) bytes_written: usize,
-}
-
-impl From<backend::BackendKvWriteStats> for KvWriteStats {
-    fn from(stats: backend::BackendKvWriteStats) -> Self {
-        Self {
-            puts: stats.puts,
-            deletes: stats.deletes,
-            bytes_written: stats.bytes_written,
-        }
-    }
-}

package/dist-engine-src/src/tracked_state/by_file_index.rs

@@ -1,98 +0,0 @@
-use crate::tracked_state::codec::{
-    encode_key_ref as encode_tracked_key_ref, encode_value_ref as encode_tracked_value_ref,
-};
-use crate::tracked_state::types::{
-    TrackedStateIndexValueRef, TrackedStateKey, TrackedStateKeyRef, TrackedStateTreeScanRequest,
-};
-use crate::tracked_state::TrackedStateScanRequest;
-use crate::NullableKeyFilter;
-
-const NULL_COMPONENT: &str = "\0";
-const VALUE_PREFIX: &str = "\u{1}";
-
-pub(crate) struct ByFileIndex;
-
-impl ByFileIndex {
-    pub(crate) fn should_use(request: &TrackedStateScanRequest) -> bool {
-        !request.filter.file_ids.is_empty()
-            && request
-                .filter
-                .file_ids
-                .iter()
-                .all(|filter| matches!(filter, NullableKeyFilter::Value(_)))
-    }
-
-    pub(crate) fn scan_request_from_tracked(
-        request: &TrackedStateScanRequest,
-    ) -> TrackedStateTreeScanRequest {
-        debug_assert!(Self::should_use(request));
-        let schema_keys = request
-            .filter
-            .file_ids
-            .iter()
-            .filter_map(|filter| match filter {
-                NullableKeyFilter::Any | NullableKeyFilter::Null => None,
-                NullableKeyFilter::Value(file_id) => Some(value_component(file_id)),
-            })
-            .collect();
-        let file_ids = request
-            .filter
-            .schema_keys
-            .iter()
-            .cloned()
-            .map(NullableKeyFilter::Value)
-            .collect();
-        TrackedStateTreeScanRequest {
-            schema_keys,
-            entity_ids: request.filter.entity_ids.clone(),
-            file_ids,
-            include_tombstones: request.filter.include_tombstones,
-            limit: None,
-        }
-    }
-
-    pub(crate) fn encode_key_ref(row: TrackedStateKeyRef<'_>) -> Vec<u8> {
-        debug_assert!(row.file_id.is_some());
-        let schema_key = component(row.file_id);
-        encode_tracked_key_ref(TrackedStateKeyRef {
-            schema_key: &schema_key,
-            file_id: Some(row.schema_key),
-            entity_id: row.entity_id,
-        })
-    }
-
-    pub(crate) fn primary_key_from_index_key(
-        index_key: TrackedStateKey,
-    ) -> Option<TrackedStateKey> {
-        let schema_key = index_key.file_id?;
-        Some(TrackedStateKey {
-            schema_key,
-            file_id: file_id_from_component(&index_key.schema_key)?,
-            entity_id: index_key.entity_id,
-        })
-    }
-
-    pub(crate) fn encode_header_value_ref(value: TrackedStateIndexValueRef<'_>) -> Vec<u8> {
-        encode_tracked_value_ref(value)
-    }
-}
-
-fn component(file_id: Option<&str>) -> String {
-    match file_id {
-        Some(file_id) => value_component(file_id),
-        None => NULL_COMPONENT.to_string(),
-    }
-}
-
-fn value_component(file_id: &str) -> String {
-    format!("{VALUE_PREFIX}{file_id}")
-}
-
-fn file_id_from_component(component: &str) -> Option<Option<String>> {
-    if component == NULL_COMPONENT {
-        return Some(None);
-    }
-    component
-        .strip_prefix(VALUE_PREFIX)
-        .map(|file_id| Some(file_id.to_string()))
-}