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

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

@@ -1,88 +0,0 @@
-use std::sync::Arc;
-
-use crate::storage::{
-    KvEntryPage, KvExistsBatch, KvGetRequest, KvKeyPage, KvScanRequest, KvValueBatch, KvValuePage,
-    StorageReadTransaction, StorageReader,
-};
-use crate::LixError;
-use tokio::sync::Mutex;
-
-/// Shared read visibility over one KV store handle.
-///
-/// This lets multiple subsystem readers share the same transaction/backend view
-/// even when the underlying handle itself is not cloneable.
-pub(crate) struct StorageReadScope<S> {
-    store: Arc<Mutex<S>>,
-}
-
-impl<S> StorageReadScope<S>
-where
-    S: StorageReader,
-{
-    pub(crate) fn new(store: S) -> Self {
-        Self {
-            store: Arc::new(Mutex::new(store)),
-        }
-    }
-
-    pub(crate) fn store(&self) -> ScopedStorageReader<S> {
-        ScopedStorageReader {
-            store: Arc::clone(&self.store),
-        }
-    }
-}
-
-impl StorageReadScope<Box<dyn StorageReadTransaction + Send + Sync + 'static>> {
-    pub(crate) async fn rollback(self) -> Result<(), LixError> {
-        let store = Arc::try_unwrap(self.store).map_err(|_| {
-            LixError::new(
-                "LIX_ERROR_UNKNOWN",
-                "cannot close storage read scope while scoped readers are still alive",
-            )
-        })?;
-        store.into_inner().rollback().await
-    }
-}
-
-pub(crate) struct ScopedStorageReader<S> {
-    store: Arc<Mutex<S>>,
-}
-
-impl<S> Clone for ScopedStorageReader<S> {
-    fn clone(&self) -> Self {
-        Self {
-            store: Arc::clone(&self.store),
-        }
-    }
-}
-
-#[async_trait::async_trait]
-impl<S> StorageReader for ScopedStorageReader<S>
-where
-    S: StorageReader,
-{
-    async fn get_values(&mut self, request: KvGetRequest) -> Result<KvValueBatch, LixError> {
-        let mut store = self.store.lock().await;
-        store.get_values(request).await
-    }
-
-    async fn exists_many(&mut self, request: KvGetRequest) -> Result<KvExistsBatch, LixError> {
-        let mut store = self.store.lock().await;
-        store.exists_many(request).await
-    }
-
-    async fn scan_keys(&mut self, request: KvScanRequest) -> Result<KvKeyPage, LixError> {
-        let mut store = self.store.lock().await;
-        store.scan_keys(request).await
-    }
-
-    async fn scan_values(&mut self, request: KvScanRequest) -> Result<KvValuePage, LixError> {
-        let mut store = self.store.lock().await;
-        store.scan_values(request).await
-    }
-
-    async fn scan_entries(&mut self, request: KvScanRequest) -> Result<KvEntryPage, LixError> {
-        let mut store = self.store.lock().await;
-        store.scan_entries(request).await
-    }
-}

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,
-        }
-    }
-}