dirsql 0.1.3__tar.gz → 0.1.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dirsql
-Version: 0.1.3
+Version: 0.1.5
 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.5}/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.5}/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.5}/packages/rust/src/db.rs

@@ -133,7 +133,11 @@ impl Db {
     }
 
     /// Query the database, returning rows as a list of column-name -> value maps.
-    /// Internal tracking columns (_dirsql_*) are excluded from results.
+    ///
+    /// Internal tracking columns (`_dirsql_*`) are excluded from `SELECT *`
+    /// results so they don't leak. But if the user names one explicitly in the
+    /// projection (e.g. `SELECT _dirsql_file_path FROM t`), it's returned —
+    /// users opt into the tracking surface by typing the column name.
     pub fn query(&self, sql: &str) -> Result<Vec<HashMap<String, Value>>> {
         let mut stmt = self.conn.prepare(sql)?;
         let column_names: Vec<String> = stmt.column_names().iter().map(|s| s.to_string()).collect();
@@ -141,7 +145,7 @@ impl Db {
         let rows = stmt.query_map([], |row| {
             let mut map = HashMap::new();
             for (i, name) in column_names.iter().enumerate() {
-                if name.starts_with("_dirsql_") {
+                if name.starts_with("_dirsql_") && !sql.contains(name) {
                     continue;
                 }
                 let val: rusqlite::types::Value = row.get(i)?;
@@ -635,6 +639,69 @@ mod tests {
         assert!(results[0].contains_key("id"));
     }
 
+    #[test]
+    fn query_honors_explicit_dirsql_file_path() {
+        let db = Db::new().unwrap();
+        db.create_table("CREATE TABLE t (id TEXT)").unwrap();
+        let row = HashMap::from([("id".into(), Value::Text("1".into()))]);
+        db.insert_row("t", &row, "file.json", 0).unwrap();
+
+        let results = db.query("SELECT _dirsql_file_path FROM t").unwrap();
+        assert_eq!(results.len(), 1);
+        assert_eq!(
+            results[0].get("_dirsql_file_path"),
+            Some(&Value::Text("file.json".into())),
+        );
+    }
+
+    #[test]
+    fn query_honors_explicit_dirsql_alongside_user_columns() {
+        let db = Db::new().unwrap();
+        db.create_table("CREATE TABLE posts (title TEXT)").unwrap();
+        let row = HashMap::from([("title".into(), Value::Text("Hello".into()))]);
+        db.insert_row("posts", &row, "posts/hello.json", 0).unwrap();
+
+        let results = db
+            .query("SELECT title, _dirsql_file_path FROM posts")
+            .unwrap();
+        assert_eq!(results.len(), 1);
+        assert_eq!(results[0]["title"], Value::Text("Hello".into()));
+        assert_eq!(
+            results[0]["_dirsql_file_path"],
+            Value::Text("posts/hello.json".into()),
+        );
+    }
+
+    #[test]
+    fn query_honors_explicit_dirsql_row_index() {
+        let db = Db::new().unwrap();
+        db.create_table("CREATE TABLE t (id TEXT)").unwrap();
+        let row = HashMap::from([("id".into(), Value::Text("a".into()))]);
+        db.insert_row("t", &row, "f.jsonl", 7).unwrap();
+
+        let results = db.query("SELECT _dirsql_row_index FROM t").unwrap();
+        assert_eq!(results.len(), 1);
+        assert_eq!(results[0]["_dirsql_row_index"], Value::Integer(7));
+    }
+
+    #[test]
+    fn query_keeps_dirsql_when_filter_references_it_with_star_projection() {
+        // Naming `_dirsql_file_path` anywhere in the SQL is treated as
+        // "the user is aware of this tracking column", so `SELECT *` with
+        // a `_dirsql_*` reference in WHERE returns it.
+        let db = Db::new().unwrap();
+        db.create_table("CREATE TABLE t (id TEXT)").unwrap();
+        let row = HashMap::from([("id".into(), Value::Text("1".into()))]);
+        db.insert_row("t", &row, "file.json", 0).unwrap();
+
+        let results = db
+            .query("SELECT * FROM t WHERE _dirsql_file_path = 'file.json'")
+            .unwrap();
+        assert_eq!(results.len(), 1);
+        assert!(results[0].contains_key("id"));
+        assert!(results[0].contains_key("_dirsql_file_path"));
+    }
+
     // --- Error path: query with invalid SQL ---
 
     #[test]

{dirsql-0.1.3 → dirsql-0.1.5}/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.5}/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.5}/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.5}/pyproject.toml

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