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

package/dist-engine-src/src/sql2/{directory_history_provider.rs → providers/directory_history.rs}

@@ -25,28 +25,33 @@ use crate::commit_graph::CommitGraphReader;
 use crate::serialize_row_metadata;
 use crate::LixError;
 
-use super::history_projection::{tombstone_identity_column_value, HistoryIdentityProjection};
-use super::history_route::{
+use crate::sql2::change_materialization::MaterializedChange;
+use crate::sql2::history_projection::{tombstone_identity_column_value, HistoryIdentityProjection};
+use crate::sql2::history_route::{
     history_descriptor_event_matches, load_history_entries, parse_history_filter,
     HistoryColumnStyle, HistoryEntry, HistoryRoute, HistoryViewDescriptor, HISTORY_COL_CHANGE_ID,
-    HISTORY_COL_COMMIT_CREATED_AT, HISTORY_COL_DEPTH, HISTORY_COL_ENTITY_ID, HISTORY_COL_FILE_ID,
+    HISTORY_COL_COMMIT_CREATED_AT, HISTORY_COL_DEPTH, HISTORY_COL_ENTITY_PK, HISTORY_COL_FILE_ID,
     HISTORY_COL_METADATA, HISTORY_COL_OBSERVED_COMMIT_ID, HISTORY_COL_SCHEMA_KEY,
     HISTORY_COL_SNAPSHOT_CONTENT, HISTORY_COL_START_COMMIT_ID,
 };
-use super::result_metadata::json_field;
-use super::SqlCommitStoreQuerySource;
-use crate::commit_store::MaterializedChange;
+use crate::sql2::result_metadata::json_field;
+use crate::sql2::SqlHistoryQuerySource;
+use crate::storage::StorageRead;
 
 const DIRECTORY_DESCRIPTOR_SCHEMA_KEY: &str = "lix_directory_descriptor";
 
-pub(crate) async fn register_lix_directory_history_provider(
+pub(super) async fn register_lix_directory_history_surface<S>(
     session: &datafusion::prelude::SessionContext,
+    surface_name: &str,
     commit_graph: Box<dyn CommitGraphReader>,
-    query_source: SqlCommitStoreQuerySource,
-) -> Result<(), LixError> {
+    query_source: SqlHistoryQuerySource<S>,
+) -> Result<(), LixError>
+where
+    S: StorageRead + Clone + Send + Sync + 'static,
+{
     session
         .register_table(
-            "lix_directory_history",
+            surface_name,
             Arc::new(LixDirectoryHistoryProvider::new(
                 Arc::new(Mutex::new(commit_graph)),
                 query_source,
@@ -56,22 +61,22 @@ pub(crate) async fn register_lix_directory_history_provider(
     Ok(())
 }
 
-struct LixDirectoryHistoryProvider {
+struct LixDirectoryHistoryProvider<S> {
     schema: SchemaRef,
     commit_graph: Arc<Mutex<Box<dyn CommitGraphReader>>>,
-    query_source: SqlCommitStoreQuerySource,
+    query_source: SqlHistoryQuerySource<S>,
 }
 
-impl std::fmt::Debug for LixDirectoryHistoryProvider {
+impl<S> std::fmt::Debug for LixDirectoryHistoryProvider<S> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("LixDirectoryHistoryProvider").finish()
     }
 }
 
-impl LixDirectoryHistoryProvider {
+impl<S> LixDirectoryHistoryProvider<S> {
     fn new(
         commit_graph: Arc<Mutex<Box<dyn CommitGraphReader>>>,
-        query_source: SqlCommitStoreQuerySource,
+        query_source: SqlHistoryQuerySource<S>,
     ) -> Self {
         Self {
             schema: lix_directory_history_schema(),
@@ -82,7 +87,10 @@ impl LixDirectoryHistoryProvider {
 }
 
 #[async_trait]
-impl TableProvider for LixDirectoryHistoryProvider {
+impl<S> TableProvider for LixDirectoryHistoryProvider<S>
+where
+    S: StorageRead + Clone + Send + Sync + 'static,
+{
     fn as_any(&self) -> &dyn Any {
         self
     }
@@ -128,16 +136,16 @@ impl TableProvider for LixDirectoryHistoryProvider {
     }
 }
 
-struct LixDirectoryHistoryScanExec {
+struct LixDirectoryHistoryScanExec<S> {
     commit_graph: Arc<Mutex<Box<dyn CommitGraphReader>>>,
-    query_source: SqlCommitStoreQuerySource,
+    query_source: SqlHistoryQuerySource<S>,
     schema: SchemaRef,
     route: HistoryRoute,
     limit: Option<usize>,
     properties: Arc<PlanProperties>,
 }
 
-impl std::fmt::Debug for LixDirectoryHistoryScanExec {
+impl<S> std::fmt::Debug for LixDirectoryHistoryScanExec<S> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("LixDirectoryHistoryScanExec")
             .field("route", &self.route)
@@ -146,10 +154,10 @@ impl std::fmt::Debug for LixDirectoryHistoryScanExec {
     }
 }
 
-impl LixDirectoryHistoryScanExec {
+impl<S> LixDirectoryHistoryScanExec<S> {
     fn new(
         commit_graph: Arc<Mutex<Box<dyn CommitGraphReader>>>,
-        query_source: SqlCommitStoreQuerySource,
+        query_source: SqlHistoryQuerySource<S>,
         schema: SchemaRef,
         route: HistoryRoute,
         limit: Option<usize>,
@@ -171,7 +179,7 @@ impl LixDirectoryHistoryScanExec {
     }
 }
 
-impl DisplayAs for LixDirectoryHistoryScanExec {
+impl<S> DisplayAs for LixDirectoryHistoryScanExec<S> {
     fn fmt_as(&self, t: DisplayFormatType, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match t {
             DisplayFormatType::Default | DisplayFormatType::Verbose => write!(
@@ -184,7 +192,10 @@ impl DisplayAs for LixDirectoryHistoryScanExec {
     }
 }
 
-impl ExecutionPlan for LixDirectoryHistoryScanExec {
+impl<S> ExecutionPlan for LixDirectoryHistoryScanExec<S>
+where
+    S: StorageRead + Clone + Send + Sync + 'static,
+{
     fn name(&self) -> &str {
         "LixDirectoryHistoryScanExec"
     }
@@ -259,7 +270,7 @@ struct DirectoryHistoryRecord {
 
 #[derive(Debug, Clone)]
 struct DirectoryHistoryOutputRow {
-    entity_id: String,
+    entity_pk: String,
     id: String,
     path: Option<String>,
     parent_id: Option<String>,
@@ -287,11 +298,14 @@ struct DirectoryDescriptorSnapshot {
     hidden: Option<bool>,
 }
 
-async fn load_directory_history_rows(
+async fn load_directory_history_rows<S>(
     commit_graph: Arc<Mutex<Box<dyn CommitGraphReader>>>,
-    query_source: SqlCommitStoreQuerySource,
+    query_source: SqlHistoryQuerySource<S>,
     route: &HistoryRoute,
-) -> Result<Vec<DirectoryHistoryOutputRow>, LixError> {
+) -> Result<Vec<DirectoryHistoryOutputRow>, LixError>
+where
+    S: StorageRead + Clone + Send + Sync + 'static,
+{
     let event_route = route.traversal_only();
     let event_entries = load_history_entries(
         HistoryViewDescriptor {
@@ -345,7 +359,7 @@ async fn load_directory_history_rows(
         .and_then(|value| value.as_str().map(ToOwned::to_owned))
         .unwrap_or_else(|| visible_descriptor.id.clone());
         output.push(DirectoryHistoryOutputRow {
-            entity_id: visible_descriptor.id.clone(),
+            entity_pk: visible_descriptor.id.clone(),
             id,
             path,
             parent_id: visible_descriptor.parent_id.clone(),
@@ -356,18 +370,18 @@ async fn load_directory_history_rows(
         });
     }
     output.retain(|row| {
-        let entity_id = entity_id_json_array(&row.entity_id).ok();
+        let entity_pk = entity_pk_json_array(&row.entity_pk).ok();
         route.matches_surface_row(
             DIRECTORY_DESCRIPTOR_SCHEMA_KEY,
-            entity_id.as_deref().unwrap_or(&row.entity_id),
+            entity_pk.as_deref().unwrap_or(&row.entity_pk),
             None,
             row.event.depth,
         )
     });
 
     output.sort_by(|left, right| {
-        left.entity_id
-            .cmp(&right.entity_id)
+        left.entity_pk
+            .cmp(&right.entity_pk)
             .then(left.event.start_commit_id.cmp(&right.event.start_commit_id))
             .then(left.event.depth.cmp(&right.event.depth))
             .then(
@@ -389,7 +403,7 @@ fn parse_directory_history_records(
         .map(|entry| {
             let Some(snapshot_content) = entry.change.snapshot_content.as_deref() else {
                 return Ok(DirectoryHistoryRecord {
-                    id: entry.change.entity_id.as_single_string_owned()?,
+                    id: entry.change.entity_pk.as_single_string_owned()?,
                     parent_id: None,
                     name: None,
                     hidden: None,
@@ -529,9 +543,9 @@ fn directory_history_column_array(
         "hidden" => Arc::new(BooleanArray::from(
             rows.iter().map(|row| row.hidden).collect::<Vec<_>>(),
         )) as ArrayRef,
-        HISTORY_COL_ENTITY_ID => Arc::new(StringArray::from(
+        HISTORY_COL_ENTITY_PK => Arc::new(StringArray::from(
             rows.iter()
-                .map(|row| entity_id_json_array(&row.entity_id).map(Some))
+                .map(|row| entity_pk_json_array(&row.entity_pk).map(Some))
                 .collect::<std::result::Result<Vec<_>, _>>()?,
         )) as ArrayRef,
         HISTORY_COL_SCHEMA_KEY => {
@@ -583,14 +597,14 @@ fn directory_history_column_array(
     })
 }
 
-fn lix_directory_history_schema() -> SchemaRef {
+pub(super) fn lix_directory_history_schema() -> SchemaRef {
     Arc::new(Schema::new(vec![
         Field::new("id", DataType::Utf8, false),
         Field::new("path", DataType::Utf8, true),
         Field::new("parent_id", DataType::Utf8, true),
         Field::new("name", DataType::Utf8, true),
         Field::new("hidden", DataType::Boolean, true),
-        json_field(HISTORY_COL_ENTITY_ID, false),
+        json_field(HISTORY_COL_ENTITY_PK, false),
         Field::new(HISTORY_COL_SCHEMA_KEY, DataType::Utf8, false),
         Field::new(HISTORY_COL_FILE_ID, DataType::Utf8, true),
         json_field(HISTORY_COL_SNAPSHOT_CONTENT, true),
@@ -615,17 +629,17 @@ fn string_array<'a>(values: impl Iterator<Item = Option<&'a str>>) -> ArrayRef {
 }
 
 fn datafusion_error_to_lix_error(error: DataFusionError) -> LixError {
-    super::error::datafusion_error_to_lix_error(error)
+    crate::sql2::error::datafusion_error_to_lix_error(error)
 }
 
-fn entity_id_json_array(entity_id: &str) -> Result<String, LixError> {
-    serde_json::to_string(&[entity_id]).map_err(|error| {
+fn entity_pk_json_array(entity_pk: &str) -> Result<String, LixError> {
+    serde_json::to_string(&[entity_pk]).map_err(|error| {
         LixError::unknown(format!(
-            "failed to encode history entity id as JSON: {error}"
+            "failed to encode history entity pk as JSON: {error}"
         ))
     })
 }
 
 fn lix_error_to_datafusion_error(error: LixError) -> DataFusionError {
-    super::error::lix_error_to_datafusion_error(error)
+    crate::sql2::error::lix_error_to_datafusion_error(error)
 }