dirsql 0.3.78__tar.gz → 0.3.80__tar.gz

{dirsql-0.3.78 → dirsql-0.3.80}/Cargo.lock

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

{dirsql-0.3.78 → dirsql-0.3.80}/PKG-INFO

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

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

{dirsql-0.3.78 → dirsql-0.3.80}/packages/python/e2e-attestation.json

@@ -1,6 +1,6 @@
 {
   "command": "uv run python -m pytest tests/e2e/ -x -q",
-  "ran_at": 1783533003,
+  "ran_at": 1783542175,
   "exit_code": 0,
-  "commit": "3f25c20a8da1e922cc543bdc1ee43496b7e8ecd9"
+  "commit": "327255640a688bbd372efc17ab3f64cc59e8f651"
 }

{dirsql-0.3.78 → dirsql-0.3.80}/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)
 }
@@ -273,14 +280,14 @@ impl Db {
         // `_dirsql_internal_rows`, keyed on the row's rowid. A column-less row
         // (SQLite requires ≥1 declared column, so this is only reachable
         // defensively) uses `DEFAULT VALUES`.
-        let columns: Vec<String> = row.keys().cloned().collect();
+        let columns: Vec<String> = row.keys().map(|c| format!("\"{c}\"")).collect();
         let sql = if columns.is_empty() {
-            format!("INSERT INTO {} DEFAULT VALUES", table)
+            format!("INSERT INTO \"{table}\" DEFAULT VALUES")
         } else {
             let placeholders: Vec<String> =
                 (1..=columns.len()).map(|i| format!("?{}", i)).collect();
             format!(
-                "INSERT INTO {} ({}) VALUES ({})",
+                "INSERT INTO \"{}\" ({}) VALUES ({})",
                 table,
                 columns.join(", "),
                 placeholders.join(", "),
@@ -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();
@@ -1260,6 +1323,22 @@ mod tests {
         assert!(matches!(err, DbError::InvalidIdentifier(_)), "got: {err:?}");
     }
 
+    #[test]
+    fn insert_row_round_trips_reserved_word_column() {
+        let db = Db::new().unwrap();
+        db.create_table("CREATE TABLE t (path TEXT, \"order\" INTEGER)")
+            .unwrap();
+        let row = HashMap::from([
+            ("path".into(), Value::Text("a".into())),
+            ("order".into(), Value::Integer(7)),
+        ]);
+        db.insert_row("t", &row, "f.json", 0).unwrap();
+
+        let rows = db.get_rows_by_file("t", "f.json").unwrap();
+        assert_eq!(rows.len(), 1);
+        assert_eq!(rows[0]["order"], Value::Integer(7));
+    }
+
     #[test]
     fn load_extension_missing_file_errors() {
         let db = Db::new().unwrap();