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

package/dist-engine-src/src/backend/conformance/runner.rs

@@ -1,90 +0,0 @@
-use crate::backend::conformance::{
-    baseline, model_based, persistence, projection, pushdown, scan, write, BackendFactory,
-};
-
-pub type ConformanceResult = Result<(), String>;
-
-#[derive(Clone, Debug, Default, PartialEq, Eq)]
-pub struct ConformanceReport {
-    pub tests: Vec<ConformanceTest>,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct ConformanceTest {
-    pub name: &'static str,
-    pub status: ConformanceStatus,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum ConformanceStatus {
-    Passed,
-    Failed(String),
-    Pending,
-}
-
-pub fn run_backend_conformance<F>(factory: &F) -> ConformanceReport
-where
-    F: BackendFactory,
-{
-    let mut report = ConformanceReport::default();
-
-    baseline::register(&mut report, factory);
-    model_based::register(&mut report, factory);
-    if !factory.config().ephemeral {
-        persistence::register(&mut report, factory);
-    }
-    scan::register(&mut report, factory);
-    write::register(&mut report, factory);
-    projection::register(&mut report, factory);
-    pushdown::register(&mut report, factory);
-
-    report
-}
-
-impl ConformanceReport {
-    pub(crate) fn add_pending(&mut self, name: &'static str) {
-        self.tests.push(ConformanceTest {
-            name,
-            status: ConformanceStatus::Pending,
-        });
-    }
-
-    pub(crate) fn run(&mut self, name: &'static str, test: impl FnOnce() -> ConformanceResult) {
-        let status = match test() {
-            Ok(()) => ConformanceStatus::Passed,
-            Err(error) => ConformanceStatus::Failed(error),
-        };
-        self.tests.push(ConformanceTest { name, status });
-    }
-
-    pub fn failed(&self) -> impl Iterator<Item = &ConformanceTest> {
-        self.tests
-            .iter()
-            .filter(|test| matches!(test.status, ConformanceStatus::Failed(_)))
-    }
-
-    pub fn pending(&self) -> impl Iterator<Item = &ConformanceTest> {
-        self.tests
-            .iter()
-            .filter(|test| matches!(test.status, ConformanceStatus::Pending))
-    }
-
-    pub fn assert_no_failures(&self) {
-        let problems = self
-            .failed()
-            .map(|test| match &test.status {
-                ConformanceStatus::Failed(error) => format!("{}: {error}", test.name),
-                _ => unreachable!("failed iterator only returns failed tests"),
-            })
-            .chain(
-                self.pending()
-                    .map(|test| format!("{}: pending capability conformance", test.name)),
-            )
-            .collect::<Vec<_>>();
-        assert!(
-            problems.is_empty(),
-            "backend conformance problems:\n{}",
-            problems.join("\n")
-        );
-    }
-}

package/dist-engine-src/src/backend/conformance/scan.rs

@@ -1,24 +0,0 @@
-use crate::backend::conformance::{BackendFactory, ConformanceReport};
-
-pub(crate) fn register<F>(report: &mut ConformanceReport, factory: &F)
-where
-    F: BackendFactory,
-{
-    let capabilities = factory.capabilities();
-
-    if capabilities.scan.native_prefix_scan {
-        report.add_pending("scan::native_prefix_scan_matches_range_lowering");
-    }
-    if capabilities.scan.reverse {
-        report.add_pending("scan::reverse_returns_descending_keys");
-    }
-    if capabilities.scan.limit_bytes {
-        report.add_pending("scan::limit_bytes_bounds_chunk_size");
-    }
-    if capabilities.scan.long_lived_cursors {
-        report.add_pending("scan::long_lived_cursors_resume_across_read_views");
-    }
-    if capabilities.scan.parallel_partitions {
-        report.add_pending("scan::parallel_partitions_cover_each_key_once");
-    }
-}

package/dist-engine-src/src/backend/conformance/write.rs

@@ -1,16 +0,0 @@
-use crate::backend::conformance::{BackendFactory, ConformanceReport};
-
-pub(crate) fn register<F>(report: &mut ConformanceReport, factory: &F)
-where
-    F: BackendFactory,
-{
-    let capabilities = factory.capabilities();
-
-    if capabilities.write.preconditions {
-        report.add_pending("write::preconditions_are_bound_to_commit");
-        report.add_pending("write::precondition_failures_identify_items");
-    }
-    if capabilities.write.idempotent_commit {
-        report.add_pending("write::idempotent_commit_retries_without_duplicate_effects");
-    }
-}

package/dist-engine-src/src/backend/error.rs

@@ -1,94 +0,0 @@
-use std::fmt;
-
-use bytes::Bytes;
-
-use crate::backend::{Key, KeyRange, SpaceId, Support};
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum BackendError {
-    Unsupported(Capability),
-    InvalidKey,
-    InvalidCursor,
-    ReadExpired,
-    WriteConflict,
-    PreconditionFailed(Vec<PreconditionFailure>),
-    Durability,
-    Corruption(String),
-    Io(String),
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum Capability {
-    EnvelopeProjection,
-    KeyOrderedPoints,
-    UnorderedPoints,
-    ReverseScan,
-    DeleteRange,
-    Preconditions,
-    IdempotentCommit,
-    PredicatePushdown,
-    ParallelPartitions,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum Precondition {
-    KeyAbsent {
-        space: SpaceId,
-        key: Key,
-    },
-    KeyPresent {
-        space: SpaceId,
-        key: Key,
-    },
-    KeyValueHashEquals {
-        space: SpaceId,
-        key: Key,
-        hash: [u8; 32],
-    },
-    RangeEmpty {
-        space: SpaceId,
-        range: KeyRange,
-    },
-    BranchEquals {
-        ref_key: Key,
-        expected: Bytes,
-    },
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct PreconditionSupportReport {
-    pub items: Vec<PreconditionItemSupport>,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct PreconditionItemSupport {
-    pub index: usize,
-    pub support: Support,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct PreconditionFailure {
-    pub index: usize,
-}
-
-impl fmt::Display for BackendError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            BackendError::Unsupported(capability) => {
-                write!(f, "unsupported capability: {capability:?}")
-            }
-            BackendError::InvalidKey => f.write_str("invalid key encoding"),
-            BackendError::InvalidCursor => f.write_str("cursor is invalid for this read view"),
-            BackendError::ReadExpired => f.write_str("read transaction is no longer valid"),
-            BackendError::WriteConflict => f.write_str("write conflict"),
-            BackendError::PreconditionFailed(failures) => {
-                write!(f, "precondition failed: {failures:?}")
-            }
-            BackendError::Durability => f.write_str("durability failure"),
-            BackendError::Corruption(message) => write!(f, "backend corruption: {message}"),
-            BackendError::Io(message) => write!(f, "io error: {message}"),
-        }
-    }
-}
-
-impl std::error::Error for BackendError {}