dirsql 0.3.34__tar.gz → 0.3.36__tar.gz

{dirsql-0.3.34 → dirsql-0.3.36}/Cargo.lock

@@ -499,7 +499,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.3.34"
+version = "0.3.36"
 dependencies = [
  "dirsql",
  "pyo3",

{dirsql-0.3.34 → dirsql-0.3.36}/PKG-INFO

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

{dirsql-0.3.34 → dirsql-0.3.36}/dirsql/_async.py

@@ -1,10 +1,21 @@
 """Async-by-default DirSQL wrapper."""
 
 import asyncio
+from typing import TYPE_CHECKING
 
 from dirsql._dirsql import DirSQL as _RustDirSQL
 from dirsql.resolve_config import resolve_config
 
+if TYPE_CHECKING:
+    # `typing.override` is 3.12+; the package supports 3.11, so source it from
+    # `typing_extensions` for the type checker only. At runtime `@override` is
+    # a pure marker, so a no-op identity avoids the runtime dependency.
+    from typing_extensions import override
+else:
+
+    def override(func):
+        return func
+
 
 class _WatchStream:
     """Async iterator that polls for file events."""
@@ -111,15 +122,24 @@ class DirSQL:
             raise self._init_error
 
     async def query(self, sql):
-        """Execute a SQL query asynchronously."""
-        return await asyncio.to_thread(self._db.query, sql)  # ty:ignore[unresolved-attribute]
+        """Execute a SQL query asynchronously.
+
+        Awaits :meth:`ready` first, so calling ``query`` before an explicit
+        ``await db.ready()`` waits for the background scan (and re-raises any
+        initialization error) instead of failing on a still-``None`` ``_db``.
+        """
+        await self.ready()
+        db = self._db
+        assert db is not None  # ready() returned, so _init_bg set _db
+        return await asyncio.to_thread(db.query, sql)
 
     def watch(self):
         """Start watching for file changes. Returns an async iterable of RowEvent."""
         return _WatchStream(self._db)
 
     @property
-    def __dict__(self):  # ty:ignore[missing-override-decorator]
+    @override
+    def __dict__(self):
         """Resolved construction state as a JSON-serializable dict.
 
         Recomputed on each access; reads the ``.dirsql.toml`` if ``config=``

{dirsql-0.3.34 → dirsql-0.3.36}/dirsql/_dirsql.pyi

@@ -13,6 +13,8 @@ from collections.abc import Callable
 from os import PathLike
 from typing import Any, NotRequired, TypedDict
 
+from typing_extensions import override
+
 __version__: str
 
 Row = dict[str, Any]
@@ -51,7 +53,8 @@ class RowEvent:
     error: str | None
     file_path: str | None
 
-    def __repr__(self) -> str: ...  # ty:ignore[missing-override-decorator]
+    @override
+    def __repr__(self) -> str: ...
 
 class DirSQL:
     """Synchronous binding class. ``dirsql._async.DirSQL`` wraps it."""

{dirsql-0.3.34 → dirsql-0.3.36}/dirsql/resolve_config.py

@@ -23,7 +23,11 @@ def resolve_config(
         cfg_dir = os.path.dirname(os.path.abspath(config))
 
     def _abs(p):
-        return p if os.path.isabs(p) else os.path.join(cfg_dir, p)  # ty:ignore[no-matching-overload]
+        # Only reached from the `"<key>" in cfg` branches below, and cfg is
+        # non-empty only after a config file was loaded -- which sets cfg_dir.
+        base = cfg_dir
+        assert base is not None
+        return p if os.path.isabs(p) else os.path.join(base, p)
 
     return {
         "root": root or (_abs(cfg["root"]) if "root" in cfg else cfg_dir),

{dirsql-0.3.34 → dirsql-0.3.36}/packages/python/Cargo.toml

@@ -4,7 +4,7 @@ name = "dirsql-py-ext"
 # pypi/maturin handler can rewrite it via `write-version` before
 # `maturin build`. `pyproject.toml` declares `dynamic = ["version"]`
 # and maturin reads this field. Mirrors `packages/rust/Cargo.toml`.
-version = "0.3.34"
+version = "0.3.36"
 edition.workspace = true
 publish = false
 readme = "README.md"

{dirsql-0.3.34 → dirsql-0.3.36}/packages/rust/src/cli/mod.rs

@@ -160,7 +160,15 @@ pub enum ServerError {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use tempfile::TempDir;
+
+    // `From<DirSQL> for AppState` produces the `Ready` arm -- this is
+    // verified at the integration tier by `from_dirsql_yields_ready_state`
+    // in `tests/cli_integration.rs`, which builds a real `DirSQL` over a
+    // temp directory (so the initial scan runs) and asserts the public
+    // `AppState::Ready` variant. It lived here once but needed
+    // `std::fs::write` to populate the scanned directory, which the
+    // `testing-conventions` `unit lint` isolation rule forbids in a unit
+    // test (effectful std). The pure config-default test below stays inline.
 
     #[test]
     fn default_config_binds_localhost_7117_with_30s_timeout() {
@@ -169,35 +177,4 @@ mod tests {
         assert_eq!(cfg.port, 7117);
         assert_eq!(cfg.query_timeout, Duration::from_secs(30));
     }
-
-    #[test]
-    fn app_state_from_dirsql_is_ready() {
-        // `AppState: !Debug` (it wraps a `DirSQL`). Assert the `Ready` variant
-        // without a dead match arm by routing through `require_ready`, which
-        // returns `Ok` only for `Ready` -- a branch-free `.is_ok()` check.
-        let dir = TempDir::new().unwrap();
-        // Write a matching file so the extract closure runs during the initial
-        // scan (otherwise the closure body would be a dead coverage region).
-        std::fs::write(dir.path().join("a.txt"), b"").unwrap();
-        let db = DirSQL::with_ignore(
-            dir.path(),
-            vec![crate::Table::new(
-                "CREATE TABLE t (name TEXT)",
-                "*.txt",
-                |_| {
-                    vec![crate::Row::from_iter([(
-                        "name".to_string(),
-                        crate::Value::Text("x".into()),
-                    )])]
-                },
-            )],
-            Vec::<String>::new(),
-        )
-        .unwrap();
-        let state: AppState = db.into();
-        assert!(
-            router::require_ready(&state).is_ok(),
-            "From<DirSQL> must produce AppState::Ready",
-        );
-    }
 }

{dirsql-0.3.34 → dirsql-0.3.36}/packages/rust/src/cli/native_config.rs

@@ -296,7 +296,16 @@ fn json_to_value(v: serde_json::Value) -> Value {
 mod tests {
     use super::*;
     use std::io::Cursor;
-    use std::process::{Command, Stdio};
+
+    // The subprocess-driven tests (`InterpretHelper::from_child` against a
+    // real `bash`/`true` child, and the `build_dirsql` round-trips that
+    // spawn a fake helper and write real fixture files) live in
+    // `tests/native_config.rs`. They exercise effectful std
+    // (`std::process::Command`, `std::fs::write`) and so belong at the
+    // integration tier per the `testing-conventions` `unit lint` isolation
+    // rule. The pure wire-format tests below operate on in-memory
+    // `Cursor`/`Vec` streams and stay inline next to the private functions
+    // they cover.
 
     // -- parse_handshake -----------------------------------------------
 
@@ -511,160 +520,10 @@ mod tests {
     }
 
     // -- build_dirsql --------------------------------------------------
-
-    // -- InterpretHelper end-to-end (subprocess via bash) -------------
-
-    /// Spawn a fake helper that prints `handshake` once on stdout then
-    /// emits one canned response per line received on stdin (an infinite
-    /// loop until stdin closes). Returns the helper paired with the
-    /// parsed [`NativeConfig`]. Drives the production
-    /// `InterpretHelper::from_child` constructor so the post-spawn
-    /// plumbing is exercised by these tests.
-    fn spawn_fake_helper(
-        handshake: &str,
-        response_per_request: &str,
-    ) -> (Arc<InterpretHelper>, NativeConfig) {
-        let child = Command::new("bash")
-            .arg("-c")
-            .arg(format!(
-                "printf '%s\\n' '{handshake}'; while IFS= read -r line; do printf '%s\\n' '{response_per_request}'; done",
-            ))
-            .stdin(Stdio::piped())
-            .stdout(Stdio::piped())
-            .spawn()
-            .unwrap();
-        InterpretHelper::from_child(child).unwrap()
-    }
-
-    #[test]
-    fn build_dirsql_threads_persist_and_persist_path_into_the_builder() {
-        // Cover the `if config.persist` and `if let Some(p) = config.persist_path`
-        // branches in `build_dirsql`. A real persist build needs the cache file
-        // to live under root, so point persist_path at a path inside the
-        // tempdir and pass persist=true.
-        let tmp = tempfile::TempDir::new().unwrap();
-        std::fs::write(tmp.path().join("a.json"), b"{}").unwrap();
-        let cache_path = tmp.path().join(".dirsql/cache.db");
-
-        let handshake = format!(
-            r#"{{"type":"config","state":{{"root":"{}","tables":[{{"ddl":"CREATE TABLE papers (title TEXT)","glob":"*.json"}}],"persist":true,"persist_path":"{}"}}}}"#,
-            tmp.path().display(),
-            cache_path.display(),
-        );
-        let (helper, config) = spawn_fake_helper(
-            &handshake,
-            r#"{"type":"result","id":1,"ok":true,"rows":[{"title":"y"}]}"#,
-        );
-        assert!(config.persist);
-        assert_eq!(config.persist_path.as_ref().unwrap(), &cache_path);
-
-        let db = build_dirsql(helper, config).unwrap();
-        let rows = db.query("SELECT COUNT(*) AS n FROM papers").unwrap();
-        assert_eq!(rows[0].get("n"), Some(&Value::Integer(1)));
-        assert!(cache_path.exists(), "persist build should create the cache");
-    }
-
-    #[test]
-    fn build_dirsql_threads_extensions_into_the_builder() {
-        // A handshake whose `extensions` names a missing shared library must
-        // fail the build, proving the parsed extensions reach the core's
-        // load-at-startup path (enable -> load -> disable). (#229)
-        let tmp = tempfile::TempDir::new().unwrap();
-        std::fs::write(tmp.path().join("a.json"), b"{}").unwrap();
-
-        let handshake = format!(
-            r#"{{"type":"config","state":{{"root":"{}","tables":[{{"ddl":"CREATE TABLE papers (title TEXT)","glob":"*.json"}}],"extensions":[{{"path":"/nonexistent/dirsql-no-such-ext.so"}}]}}}}"#,
-            tmp.path().display(),
-        );
-        let (helper, config) = spawn_fake_helper(
-            &handshake,
-            r#"{"type":"result","id":1,"ok":true,"rows":[{"title":"y"}]}"#,
-        );
-        assert_eq!(config.extensions.len(), 1);
-        assert_eq!(
-            config.extensions[0].path,
-            PathBuf::from("/nonexistent/dirsql-no-such-ext.so"),
-        );
-
-        let err = match build_dirsql(helper, config) {
-            Ok(_) => panic!("expected build to fail on a missing extension"),
-            Err(e) => e,
-        };
-        assert!(err.contains("failed to load extension"), "got: {err}");
-    }
-
-    #[test]
-    fn build_dirsql_round_trip_with_fake_helper_invokes_extract_per_matched_file() {
-        // Create a tempdir with two matching files so the scan invokes
-        // `extract` twice — exercising the closure created inside
-        // `build_dirsql`, the `dispatch_extract` path through the
-        // helper's IO mutex, and end-to-end DDL/glob wiring.
-        let tmp = tempfile::TempDir::new().unwrap();
-        std::fs::write(tmp.path().join("a.json"), b"{}").unwrap();
-        std::fs::write(tmp.path().join("b.json"), b"{}").unwrap();
-
-        let handshake = format!(
-            r#"{{"type":"config","state":{{"root":"{}","tables":[{{"ddl":"CREATE TABLE papers (title TEXT)","glob":"*.json"}}]}}}}"#,
-            tmp.path().display(),
-        );
-        let (helper, config) = spawn_fake_helper(
-            &handshake,
-            r#"{"type":"result","id":1,"ok":true,"rows":[{"title":"x"}]}"#,
-        );
-
-        let db = build_dirsql(helper, config).unwrap();
-        let rows = db.query("SELECT COUNT(*) AS n FROM papers").unwrap();
-        assert_eq!(rows.len(), 1);
-        assert_eq!(rows[0].get("n"), Some(&Value::Integer(2)));
-    }
-
-    #[test]
-    fn helper_extract_round_trip_succeeds_against_a_fake_subprocess() {
-        let (helper, _config) = spawn_fake_helper(
-            r#"{"type":"config","state":{"root":"/tmp","tables":[{"ddl":"CREATE TABLE papers (title TEXT)","glob":"*"}]}}"#,
-            r#"{"type":"result","id":1,"ok":true,"rows":[{"title":"Alpha"}]}"#,
-        );
-
-        let rows = helper.extract("papers", "/x/a.json").unwrap();
-        assert_eq!(rows.len(), 1);
-        assert_eq!(rows[0].get("title"), Some(&Value::Text("Alpha".into())));
-
-        // Second request increments the id counter and still works against
-        // the canned response (the fake echoes the same line per request).
-        let rows2 = helper.extract("papers", "/x/b.json").unwrap();
-        assert_eq!(rows2.len(), 1);
-    }
-
-    #[test]
-    fn helper_from_child_errors_when_stdin_was_not_piped() {
-        // `Command::spawn` without `.stdin(Stdio::piped())` inherits the
-        // parent's stdin — `child.stdin.take()` returns `None`, driving
-        // the first `.ok_or_else` arm in `from_child`.
-        let child = Command::new("true").spawn().unwrap();
-        let err = match InterpretHelper::from_child(child) {
-            Ok(_) => panic!("expected error when stdin is not piped"),
-            Err(e) => e,
-        };
-        assert!(
-            err.contains("failed to capture interpret stdin"),
-            "got: {err}",
-        );
-    }
-
-    #[test]
-    fn helper_from_child_errors_when_stdout_was_not_piped() {
-        // Pipe stdin but leave stdout inherited — `child.stdout.take()`
-        // returns `None`, driving the second `.ok_or_else` arm.
-        let child = Command::new("true").stdin(Stdio::piped()).spawn().unwrap();
-        let err = match InterpretHelper::from_child(child) {
-            Ok(_) => panic!("expected error when stdout is not piped"),
-            Err(e) => e,
-        };
-        assert!(
-            err.contains("failed to capture interpret stdout"),
-            "got: {err}",
-        );
-    }
+    //
+    // The `build_dirsql` round-trips and the `InterpretHelper::from_child`
+    // success/error paths spawn a real subprocess (`bash`/`true`) and write
+    // real fixture files, so they live in `tests/native_config.rs`.
 
     /// A writer that fails every write with the given `io::ErrorKind`,
     /// used to exercise `dispatch_extract`'s IO-error arms.
@@ -720,64 +579,4 @@ mod tests {
         let err = dispatch_extract(&mut stdout, &mut stdin, 1, "t", "p").unwrap_err();
         assert!(err.contains("read from interpret"), "got: {err}");
     }
-
-    #[test]
-    fn helper_from_child_errors_when_subprocess_emits_no_handshake() {
-        // A subprocess that exits without writing anything drives
-        // `from_child` through to `parse_handshake`'s empty-line arm.
-        let child = Command::new("true")
-            .stdin(Stdio::piped())
-            .stdout(Stdio::piped())
-            .spawn()
-            .unwrap();
-        let err = match InterpretHelper::from_child(child) {
-            Ok(_) => panic!("expected error from empty-stdout subprocess"),
-            Err(e) => e,
-        };
-        assert!(
-            err.contains("exited before sending handshake"),
-            "got: {err}"
-        );
-    }
-
-    #[test]
-    fn build_dirsql_errors_when_ddl_has_no_table_name() {
-        // The DDL is rejected by `parse_table_name` before any extract
-        // closure is created, so the helper's IO is never touched. Use a
-        // real child (`true` exits cleanly) just to satisfy the
-        // `InterpretHelper` shape.
-        let mut child = Command::new("true")
-            .stdin(Stdio::piped())
-            .stdout(Stdio::piped())
-            .spawn()
-            .unwrap();
-        let stdin = child.stdin.take().unwrap();
-        let stdout = child.stdout.take().unwrap();
-        let helper = Arc::new(InterpretHelper {
-            _child: child,
-            io: Arc::new(Mutex::new(HelperIo {
-                stdin: BufWriter::new(stdin),
-                stdout: BufReader::new(stdout),
-            })),
-            next_id: AtomicU64::new(1),
-        });
-        let config = NativeConfig {
-            root: PathBuf::from("/tmp"),
-            tables: vec![HandshakeTable {
-                ddl: "NOT VALID DDL".into(),
-                glob: "*.json".into(),
-                strict: false,
-            }],
-            ignore: Vec::new(),
-            persist: false,
-            persist_path: None,
-            extensions: Vec::new(),
-        };
-        // `DirSQL` doesn't impl Debug, so we can't use `unwrap_err` directly.
-        let err = match build_dirsql(helper, config) {
-            Ok(_) => panic!("expected build_dirsql to fail on invalid DDL"),
-            Err(e) => e,
-        };
-        assert!(err.contains("could not parse table name"), "got: {err}");
-    }
 }

{dirsql-0.3.34 → dirsql-0.3.36}/packages/rust/src/cli/router.rs

@@ -167,15 +167,16 @@ pub(super) fn error_response(status: StatusCode, message: impl Into<String>) ->
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::db::DbError;
 
-    #[test]
-    fn classify_core_error_is_bad_request() {
-        // A SQLite-level failure is the client's fault (bad SQL), so it maps
-        // to 400 rather than a server error.
-        let err = DirSqlError::Core(DbError::SchemaMismatch("nope".into()));
-        assert_eq!(classify_query_error(&err), StatusCode::BAD_REQUEST);
-    }
+    // The `DirSqlError::Core => 400` arm of `classify_query_error` is
+    // exercised end-to-end at the integration tier by
+    // `post_query_malformed_sql_returns_400_not_500` in
+    // `tests/cli_integration.rs`, which posts malformed SQL to `/query` and
+    // asserts the 400. Constructing a `Core` value inline would require
+    // importing the first-party `crate::db::DbError`, which the
+    // `testing-conventions` `unit lint` isolation rule forbids (a unit test
+    // may reach only `super::` and pure `std`). The non-Core arm below is
+    // pure -- it builds a `super::DirSqlError::Lock` -- so it stays inline.
 
     #[test]
     fn classify_non_core_error_is_internal_server_error() {

{dirsql-0.3.34 → dirsql-0.3.36}/pyproject.toml

@@ -65,9 +65,10 @@ include = [
 ]
 manifest-path = "packages/python/Cargo.toml"
 
-# Type checking. Migration model: existing untyped code is frozen behind
-# `# ty: ignore[...]` baseline comments inserted by `ty check --add-ignore`;
-# any new error in new or touched code fails CI. Every rule is promoted to
+# Type checking. The source tree currently type-checks clean: the initial
+# `# ty: ignore[...]` baseline (seeded by `ty check --add-ignore`) has been
+# driven to zero, so any new error in new or touched code fails CI with no
+# pre-existing suppressions to hide behind. Every rule is promoted to
 # `"error"`, matching TypeScript-strict discipline. Test files are excluded
 # because they monkeypatch fakes onto production module attributes
 # (`monkeypatch.setattr(async_mod, "_RustDirSQL", ...)`) -- AGENTS.md flags