dirsql 0.1.3__tar.gz → 0.1.4__tar.gz

{dirsql-0.1.3 → dirsql-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dirsql
-Version: 0.1.3
+Version: 0.1.4
 Requires-Dist: pytest>=8 ; extra == 'dev'
 Requires-Dist: pytest-describe>=2 ; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.23 ; extra == 'dev'

{dirsql-0.1.3 → dirsql-0.1.4}/packages/python/src/lib.rs

@@ -49,10 +49,14 @@ mod python {
     }
 
     /// A row event produced by the watch loop.
+    ///
+    /// `table` is `Optional[str]` because error events may occur before a
+    /// file has been attributed to any table (e.g. a watch-channel failure).
+    /// For insert / update / delete events it is always set.
     #[pyclass(name = "RowEvent", frozen)]
     struct PyRowEvent {
         #[pyo3(get)]
-        table: String,
+        table: Option<String>,
         #[pyo3(get)]
         action: String,
         #[pyo3(get)]
@@ -199,7 +203,7 @@ mod python {
                 row,
                 file_path,
             } => PyRowEvent {
-                table: table.clone(),
+                table: Some(table.clone()),
                 action: "insert".to_string(),
                 row: Some(value_row_to_py_dict(py, row)?),
                 old_row: None,
@@ -212,7 +216,7 @@ mod python {
                 new_row,
                 file_path,
             } => PyRowEvent {
-                table: table.clone(),
+                table: Some(table.clone()),
                 action: "update".to_string(),
                 row: Some(value_row_to_py_dict(py, new_row)?),
                 old_row: Some(value_row_to_py_dict(py, old_row)?),
@@ -224,15 +228,19 @@ mod python {
                 row,
                 file_path,
             } => PyRowEvent {
-                table: table.clone(),
+                table: Some(table.clone()),
                 action: "delete".to_string(),
                 row: Some(value_row_to_py_dict(py, row)?),
                 old_row: None,
                 error: None,
                 file_path: Some(file_path.clone()),
             },
-            RowEvent::Error { file_path, error } => PyRowEvent {
-                table: String::new(),
+            RowEvent::Error {
+                table,
+                file_path,
+                error,
+            } => PyRowEvent {
+                table: table.clone(),
                 action: "error".to_string(),
                 row: None,
                 old_row: None,

{dirsql-0.1.3 → dirsql-0.1.4}/packages/python/tests/integration/test_async_dirsql.py

@@ -341,6 +341,10 @@ def describe_DirSQL_async():
             assert len(events) >= 1
             assert events[0].action == "error"
             assert events[0].error is not None
+            # The failing file matched the `items` table's glob; the error
+            # event must carry that attribution so multi-table consumers can
+            # route the error to the right handler.
+            assert events[0].table == "items"
 
         @pytest.mark.asyncio
         async def it_updates_db_on_file_changes(tmp_dir):

{dirsql-0.1.3 → dirsql-0.1.4}/packages/rust/src/differ.rs

@@ -26,6 +26,10 @@ pub enum RowEvent {
         file_path: String,
     },
     Error {
+        /// The table whose glob matched the failing file, when known.
+        /// `None` for errors that aren't tied to a specific table (e.g.
+        /// a watch-channel failure before file attribution).
+        table: Option<String>,
         file_path: PathBuf,
         error: String,
     },

{dirsql-0.1.3 → dirsql-0.1.4}/packages/rust/src/lib.rs

@@ -341,18 +341,18 @@ impl DirSQL {
     fn handle_delete(&self, table: &str, rel_path: &str) -> Vec<RowEvent> {
         let old_rows = match self.inner.file_rows.lock() {
             Ok(mut file_rows) => file_rows.remove(rel_path).map(|(_, r)| r),
-            Err(e) => return vec![error_event(rel_path, e.to_string())],
+            Err(e) => return vec![error_event(Some(table), rel_path, e.to_string())],
         };
 
         let row_events = differ::diff(table, old_rows.as_deref(), None, rel_path);
 
         let delete_result = match self.inner.db.lock() {
             Ok(db) => db.delete_rows_by_file(table, rel_path),
-            Err(e) => return vec![error_event(rel_path, e.to_string())],
+            Err(e) => return vec![error_event(Some(table), rel_path, e.to_string())],
         };
 
         if let Err(e) = delete_result {
-            return vec![error_event(rel_path, e.to_string())];
+            return vec![error_event(Some(table), rel_path, e.to_string())];
         }
 
         row_events
@@ -362,7 +362,7 @@ impl DirSQL {
         let content = match std::fs::read_to_string(abs_path) {
             Ok(c) => c,
             Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Vec::new(),
-            Err(e) => return vec![error_event(rel_path, e.to_string())],
+            Err(e) => return vec![error_event(Some(table), rel_path, e.to_string())],
         };
 
         let extract = match self.inner.extract_map.get(table) {
@@ -372,7 +372,7 @@ impl DirSQL {
 
         let raw_rows = match extract(rel_path, &content) {
             Ok(r) => r,
-            Err(e) => return vec![error_event(rel_path, e.to_string())],
+            Err(e) => return vec![error_event(Some(table), rel_path, e.to_string())],
         };
 
         let strict = *self.inner.strict_map.get(table).unwrap_or(&false);
@@ -380,13 +380,13 @@ impl DirSQL {
         let new_rows = {
             let db = match self.inner.db.lock() {
                 Ok(g) => g,
-                Err(e) => return vec![error_event(rel_path, e.to_string())],
+                Err(e) => return vec![error_event(Some(table), rel_path, e.to_string())],
             };
             let mut normalized = Vec::with_capacity(raw_rows.len());
             for raw in &raw_rows {
                 match db.normalize_row(table, raw, strict) {
                     Ok(row) => normalized.push(row),
-                    Err(e) => return vec![error_event(rel_path, e.to_string())],
+                    Err(e) => return vec![error_event(Some(table), rel_path, e.to_string())],
                 }
             }
             normalized
@@ -394,7 +394,7 @@ impl DirSQL {
 
         let old_rows = match self.inner.file_rows.lock() {
             Ok(guard) => guard.get(rel_path).map(|(_, r)| r.clone()),
-            Err(e) => return vec![error_event(rel_path, e.to_string())],
+            Err(e) => return vec![error_event(Some(table), rel_path, e.to_string())],
         };
 
         let row_events = differ::diff(table, old_rows.as_deref(), Some(&new_rows), rel_path);
@@ -406,11 +406,11 @@ impl DirSQL {
                 }
                 Ok(())
             }),
-            Err(e) => return vec![error_event(rel_path, e.to_string())],
+            Err(e) => return vec![error_event(Some(table), rel_path, e.to_string())],
         };
 
         if let Err(e) = db_result {
-            return vec![error_event(rel_path, e.to_string())];
+            return vec![error_event(Some(table), rel_path, e.to_string())];
         }
 
         if let Ok(mut guard) = self.inner.file_rows.lock() {
@@ -491,8 +491,9 @@ impl DirSQL {
     }
 }
 
-fn error_event(rel_path: &str, error: String) -> RowEvent {
+fn error_event(table: Option<&str>, rel_path: &str, error: String) -> RowEvent {
     RowEvent::Error {
+        table: table.map(str::to_string),
         file_path: PathBuf::from(rel_path),
         error,
     }
@@ -510,6 +511,7 @@ fn run_channel_loop(db: DirSQL, tx: UnboundedSender<RowEvent>) {
             }
             Err(e) => {
                 let _ = tx.unbounded_send(RowEvent::Error {
+                    table: None,
                     file_path: db.inner.root.clone(),
                     error: e.to_string(),
                 });

{dirsql-0.1.3 → dirsql-0.1.4}/packages/rust/tests/sdk.rs

@@ -382,8 +382,18 @@ fn it_streams_watch_error_events() {
 
     let event = block_on(stream.next()).expect("watch event");
     match event {
-        dirsql::RowEvent::Error { error, .. } => {
+        dirsql::RowEvent::Error {
+            table,
+            error,
+            file_path,
+        } => {
             assert!(error.contains("intentional parse failure"));
+            assert_eq!(
+                table.as_deref(),
+                Some("items"),
+                "error event should attribute the failure to the matching table"
+            );
+            assert!(file_path.to_string_lossy().contains("bad.txt"));
         }
         other => panic!("expected error event, got: {other:?}"),
     }

{dirsql-0.1.3 → dirsql-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "dirsql"
-version = "0.1.3"
+version = "0.1.4"
 description = "Ephemeral SQL index over a local directory"
 license = "MIT"
 requires-python = ">=3.12"