dirsql 0.3.77__tar.gz → 0.3.79__tar.gz

{dirsql-0.3.77 → dirsql-0.3.79}/Cargo.lock

@@ -500,7 +500,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.3.77"
+version = "0.3.79"
 dependencies = [
  "dirsql",
  "pyo3",

{dirsql-0.3.77 → dirsql-0.3.79}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dirsql
-Version: 0.3.77
+Version: 0.3.79
 Summary: Ephemeral SQL index over a local directory
 Keywords: sql,filesystem,directory,sqlite,index
 Author: Kevin Scott

{dirsql-0.3.77 → dirsql-0.3.79}/dirsql/_async.py

@@ -11,8 +11,9 @@ from dirsql.resolve_extension import resolve_extension_path
 class _WatchStream:
     """Async iterator that polls for file events."""
 
-    def __init__(self, db):
-        self._db = db
+    def __init__(self, owner):
+        self._owner = owner
+        self._db = None
         self._started = False
         self._buffer = []
 
@@ -21,13 +22,19 @@ class _WatchStream:
 
     async def __anext__(self):
         if not self._started:
-            await asyncio.to_thread(self._db._start_watcher)
+            await self._owner.ready()
+            db = self._owner._db
+            assert db is not None  # ready() returned, so _init_bg set _db
+            self._db = db
+            await asyncio.to_thread(db._start_watcher)
             self._started = True
 
+        db = self._db
+        assert db is not None
         while True:
             if self._buffer:
                 return self._buffer.pop(0)
-            events = await asyncio.to_thread(self._db._poll_events, 200)
+            events = await asyncio.to_thread(db._poll_events, 200)
             if events:
                 self._buffer.extend(events)
 
@@ -166,5 +173,12 @@ class DirSQL:
         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)
+        """Start watching for file changes. Returns an async iterable of RowEvent.
+
+        Like :meth:`query`, the returned stream awaits :meth:`ready` on its
+        first iteration before starting the watcher, so calling ``watch``
+        before an explicit ``await db.ready()`` waits for the background scan
+        (and surfaces any initialization error) instead of failing on a
+        still-``None`` ``_db``.
+        """
+        return _WatchStream(self)

{dirsql-0.3.77 → dirsql-0.3.79}/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.77"
+version = "0.3.79"
 edition.workspace = true
 publish = false
 readme = "README.md"

{dirsql-0.3.77 → dirsql-0.3.79}/packages/python/e2e-attestation.json

@@ -1,6 +1,6 @@
 {
   "command": "uv run python -m pytest tests/e2e/ -x -q",
-  "ran_at": 1783524611,
+  "ran_at": 1783534394,
   "exit_code": 0,
-  "commit": "ee0a7c75d1e80868ace1390d0a99c92420c2f60e"
+  "commit": "b66bf19ce2c568fc2aa08773caf8c708bad462e9"
 }

{dirsql-0.3.77 → dirsql-0.3.79}/packages/rust/src/db.rs

@@ -37,6 +37,13 @@ const INTERNAL_TABLE_PREFIX: &str = "_dirsql_";
 const INTERNAL_TABLE_DENIED_MSG: &str = "not authorized: dirsql's internal bookkeeping tables (the `_dirsql_*` namespace) \
      are not readable through query()";
 
+/// The message carried by [`DbError::Unauthorized`] when `query()` rejects an
+/// `ATTACH`/`DETACH`. SQLite classifies both as read-only, so the `readonly()`
+/// gate lets them through; they are effectful (ATTACH creates/opens an
+/// arbitrary database file) and denied at prepare time instead.
+const ATTACH_DENIED_MSG: &str = "not authorized: query() does not permit ATTACH or DETACH; \
+     attaching external databases is disabled on this surface";
+
 fn is_internal_table(name: &str) -> bool {
     name.starts_with(INTERNAL_TABLE_PREFIX)
 }
@@ -402,16 +409,33 @@ impl Db {
     /// through `query()`, are unaffected.
     pub fn query(&self, sql: &str) -> Result<Vec<HashMap<String, Value>>> {
         use rusqlite::hooks::{AuthAction, AuthContext, Authorization};
+        use std::sync::{Arc, Mutex};
 
+        // The authorizer runs at prepare time and may deny for two distinct
+        // reasons; it records which one here so the caught error can carry the
+        // matching message (the closure must be `'static`, so it owns a clone).
+        let denial: Arc<Mutex<Option<&'static str>>> = Arc::new(Mutex::new(None));
+        let denial_cb = Arc::clone(&denial);
         self.conn
-            .authorizer(Some(|ctx: AuthContext<'_>| match ctx.action {
+            .authorizer(Some(move |ctx: AuthContext<'_>| match ctx.action {
                 AuthAction::Read { table_name, .. } if is_internal_table(table_name) => {
+                    *denial_cb.lock().unwrap() = Some(INTERNAL_TABLE_DENIED_MSG);
                     Authorization::Deny
                 }
                 AuthAction::Pragma {
                     pragma_value: Some(value),
                     ..
-                } if is_internal_table(value) => Authorization::Deny,
+                } if is_internal_table(value) => {
+                    *denial_cb.lock().unwrap() = Some(INTERNAL_TABLE_DENIED_MSG);
+                    Authorization::Deny
+                }
+                // ATTACH/DETACH are the only effectful actions SQLite classifies
+                // as read-only, so the `readonly()` gate below can't catch them;
+                // deny here before the file is ever created or opened.
+                AuthAction::Attach { .. } | AuthAction::Detach { .. } => {
+                    *denial_cb.lock().unwrap() = Some(ATTACH_DENIED_MSG);
+                    Authorization::Deny
+                }
                 _ => Authorization::Allow,
             }));
         let prepared = self.conn.prepare(sql);
@@ -426,7 +450,8 @@ impl Db {
                 if e.sqlite_error_code()
                     == Some(rusqlite::ErrorCode::AuthorizationForStatementDenied) =>
             {
-                return Err(DbError::Unauthorized(INTERNAL_TABLE_DENIED_MSG.to_string()));
+                let msg = denial.lock().unwrap().unwrap_or(INTERNAL_TABLE_DENIED_MSG);
+                return Err(DbError::Unauthorized(msg.to_string()));
             }
             Err(e) => return Err(DbError::Sqlite(e)),
         };
@@ -1057,6 +1082,44 @@ mod tests {
         assert!(INTERNAL_TABLE_DENIED_MSG.contains("_dirsql_"));
     }
 
+    #[test]
+    fn query_denies_attach() {
+        let db = Db::new().unwrap();
+        let err = db
+            .query("ATTACH 'file:should-not-open?mode=ro' AS ext")
+            .unwrap_err();
+        assert!(matches!(err, DbError::Unauthorized(_)), "got: {err}");
+        let msg = err.to_string();
+        assert!(msg.contains("not authorized"), "got: {msg}");
+        assert!(msg.contains("ATTACH"), "got: {msg}");
+    }
+
+    #[test]
+    fn query_denies_detach() {
+        let db = Db::new().unwrap();
+        let err = db.query("DETACH ext").unwrap_err();
+        assert!(matches!(err, DbError::Unauthorized(_)), "got: {err}");
+        assert!(err.to_string().contains("not authorized"), "got: {err}");
+    }
+
+    #[test]
+    fn attach_denied_message_mentions_attach_and_detach() {
+        assert!(ATTACH_DENIED_MSG.contains("not authorized"));
+        assert!(ATTACH_DENIED_MSG.contains("ATTACH"));
+        assert!(ATTACH_DENIED_MSG.contains("DETACH"));
+    }
+
+    #[test]
+    fn query_still_allows_select_after_attach_denial() {
+        // The authorizer is cleared after each query, so a denied ATTACH must
+        // not poison the next normal read.
+        let db = Db::new().unwrap();
+        db.create_table("CREATE TABLE t (id TEXT)").unwrap();
+        let _ = db.query("ATTACH 'x.db' AS ext").unwrap_err();
+        let rows = db.query("SELECT * FROM t").unwrap();
+        assert_eq!(rows.len(), 0);
+    }
+
     #[test]
     fn query_invalid_sql_returns_error() {
         let db = Db::new().unwrap();