dirsql 0.2.0__tar.gz → 0.2.2__tar.gz

{dirsql-0.2.0 → dirsql-0.2.2}/PKG-INFO

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

{dirsql-0.2.0 → dirsql-0.2.2}/packages/rust/src/lib.rs

@@ -44,6 +44,8 @@ use thiserror::Error;
 
 pub use crate::db::{DbError, Value};
 pub use crate::differ::RowEvent;
+#[doc(hidden)]
+pub use crate::watcher::FileEvent as RawFileEvent;
 
 pub type Row = HashMap<String, Value>;
 pub type WatchStream = UnboundedReceiver<RowEvent>;
@@ -272,6 +274,51 @@ impl DirSQL {
         self.poll_once(timeout)
     }
 
+    /// Split-phase wait helper used by async bindings that cannot safely
+    /// invoke the `extract` callback off the host thread (e.g. the napi-rs
+    /// TypeScript binding, where JS callbacks must run on the main JS
+    /// thread). Blocks up to `timeout` for raw file events and returns them
+    /// unprocessed. Pair with [`apply_file_events`](Self::apply_file_events)
+    /// to finish the pipeline on the correct thread.
+    #[doc(hidden)]
+    pub fn wait_file_events(&self, timeout: Duration) -> Result<Vec<FileEvent>> {
+        if self.inner.watch_thread_started.load(Ordering::SeqCst) {
+            return Err(DirSqlError::Watch(
+                "watch() is active; cannot mix with poll_events()".into(),
+            ));
+        }
+        self.inner.poll_used.store(true, Ordering::SeqCst);
+        self.start_watching()?;
+        let guard = self
+            .inner
+            .watcher
+            .lock()
+            .map_err(|e| DirSqlError::Lock(e.to_string()))?;
+        let watcher = guard
+            .as_ref()
+            .ok_or_else(|| DirSqlError::Watch("watcher not started".into()))?;
+        let mut events = Vec::new();
+        if let Some(first) = watcher.recv_timeout(timeout) {
+            events.push(first);
+            events.extend(watcher.try_recv_all());
+        }
+        Ok(events)
+    }
+
+    /// Apply a batch of raw file events through the extract/DB update
+    /// pipeline. Counterpart to [`wait_file_events`](Self::wait_file_events).
+    /// Runs the `extract` callback inline, so the caller must invoke this on
+    /// a thread where that callback is safe to call (the JS main thread for
+    /// the TypeScript binding).
+    #[doc(hidden)]
+    pub fn apply_file_events(&self, events: Vec<FileEvent>) -> Vec<RowEvent> {
+        let mut out = Vec::new();
+        for fe in events {
+            out.extend(self.process_file_event(fe));
+        }
+        out
+    }
+
     /// Channel-based watch API. Spawns a background thread that pushes
     /// [`RowEvent`]s into the returned stream. Intended for long-running Rust
     /// consumers (e.g. a CLI `watch` command). Can only be called once per

{dirsql-0.2.0 → dirsql-0.2.2}/packages/rust/tests/sdk.rs

@@ -1,4 +1,4 @@
-use dirsql::{DirSQL, Row, Table, Value};
+use dirsql::{DirSQL, RawFileEvent, Row, Table, Value};
 use futures_executor::block_on;
 use futures_util::StreamExt;
 use std::collections::HashMap;
@@ -398,3 +398,41 @@ fn it_streams_watch_error_events() {
         other => panic!("expected error event, got: {other:?}"),
     }
 }
+
+// The split-phase wait/apply API is used by async bindings (TypeScript) that
+// cannot safely invoke the `extract` callback off the host thread. Verify the
+// two halves round-trip to the same result as the combined `poll_events`.
+#[test]
+fn it_splits_wait_and_apply_for_async_bindings() {
+    let root = TempDir::new().unwrap();
+    let db = DirSQL::new(root.path(), vec![items_table()]).unwrap();
+    db.start_watching().unwrap();
+
+    // Empty wait returns no events and apply on empty returns no row events.
+    let empty = db.wait_file_events(Duration::from_millis(50)).unwrap();
+    assert!(empty.is_empty());
+    assert!(db.apply_file_events(Vec::new()).is_empty());
+
+    // Write a file, then drain raw FileEvents without running extract.
+    fs::write(root.path().join("new.txt"), "hello").unwrap();
+    let mut raw = Vec::new();
+    let deadline = std::time::Instant::now() + Duration::from_secs(2);
+    while raw.is_empty() && std::time::Instant::now() < deadline {
+        raw.extend(db.wait_file_events(Duration::from_millis(250)).unwrap());
+    }
+    assert!(!raw.is_empty(), "expected at least one raw file event");
+    assert!(
+        raw.iter()
+            .any(|e| matches!(e, RawFileEvent::Created(_) | RawFileEvent::Modified(_)))
+    );
+
+    // Apply runs extract and mutates the DB. Inserts land in the index.
+    let row_events = db.apply_file_events(raw);
+    assert!(!row_events.is_empty());
+
+    let rows = db.query("SELECT name FROM items").unwrap();
+    assert!(rows.iter().any(|r| matches!(
+        r.get("name"),
+        Some(Value::Text(name)) if name == "hello"
+    )));
+}

{dirsql-0.2.0 → dirsql-0.2.2}/pyproject.toml

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