dirsql 0.3.94__tar.gz → 0.3.95__tar.gz

{dirsql-0.3.94 → dirsql-0.3.95}/Cargo.lock

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

{dirsql-0.3.94 → dirsql-0.3.95}/PKG-INFO

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

{dirsql-0.3.94 → dirsql-0.3.95}/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.94"
+version = "0.3.95"
 # abi3 note: the `abi3-py311` pyo3 feature (below) builds ONE stable-ABI
 # `cp311-abi3` wheel per platform that loads on every CPython >= 3.11
 # (matching `pyproject.toml`'s `requires-python = ">=3.11"`), instead of

dirsql-0.3.95/packages/python/e2e-attestations/claude-open-issues-review-le8hm5-red-546.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/ -x -q",
+  "ran_at": 1783942299,
+  "exit_code": 0,
+  "commit": "46b5f8c7f7b10a85f62c2098e1d43133ccf8101e",
+  "branch": "claude/open-issues-review-le8hm5-red-546"
+}

{dirsql-0.3.94 → dirsql-0.3.95}/packages/rust/src/bin/dirsql.rs

@@ -138,8 +138,8 @@ async fn main() -> ExitCode {
 /// stderr with a non-zero exit.
 async fn run_query(cli: &Cli, args: QueryArgs) -> ExitCode {
     let state = load_state(cli);
-    let pre_query = load_pre_query(cli);
-    let post_query = load_post_query(cli);
+    let pre_query: Vec<PreQuery> = load_pre_query(cli).into_iter().collect();
+    let post_query: Vec<PostQuery> = load_post_query(cli).into_iter().collect();
     // Same default the server binds with; the pipeline enforces it.
     let timeout = ServerConfig::default().query_timeout;
 
@@ -147,8 +147,8 @@ async fn run_query(cli: &Cli, args: QueryArgs) -> ExitCode {
         &state,
         query_body(&args.sql),
         timeout,
-        pre_query.as_ref(),
-        post_query.as_ref(),
+        &pre_query,
+        &post_query,
     )
     .await
     {

{dirsql-0.3.94 → dirsql-0.3.95}/packages/rust/src/cli/execute.rs

@@ -68,14 +68,22 @@ pub async fn execute_query(
     state: &AppState,
     raw_body: String,
     timeout: Duration,
-    pre_query: Option<&PreQuery>,
-    post_query: Option<&PostQuery>,
+    pre_query: &[PreQuery],
+    post_query: &[PostQuery],
 ) -> Result<Value, QueryFailure> {
-    // Resolve the SQL to run. With a `pre-query` hook the raw body is
-    // rewritten by the command; without one it is parsed as `{"sql": …}`.
-    let sql = match pre_query {
-        Some(pq) => run_pre_query(pq, raw_body).await?,
-        None => parse_sql_body(&raw_body)?,
+    // Resolve the SQL to run. A `pre-query` chain pipes the raw body FIFO
+    // through each stage (body → stage₁ → … → SQL), each stage receiving the
+    // previous stage's output as its `{args}`; with no stage the body is parsed
+    // as `{"sql": …}`. A failing stage fails the request (its `?` short-circuits
+    // the chain).
+    let sql = if pre_query.is_empty() {
+        parse_sql_body(&raw_body)?
+    } else {
+        let mut payload = raw_body;
+        for pq in pre_query {
+            payload = run_pre_query(pq, payload).await?;
+        }
+        payload
     };
 
     let db = require_ready(state)?;
@@ -86,9 +94,17 @@ pub async fn execute_query(
     match join {
         Ok(Ok(Ok(rows))) => {
             let rows_json = rows_to_json(&rows);
-            match post_query {
-                Some(pq) => run_post_query(pq, rows_json).await,
-                None => Ok(Value::Array(rows_json)),
+            // A `post-query` chain pipes the rows FIFO through each stage
+            // (rows → stage₁ → … → response), each stage receiving the previous
+            // stage's output; with no stage the rows return as-is.
+            if post_query.is_empty() {
+                Ok(Value::Array(rows_json))
+            } else {
+                let mut payload = Value::Array(rows_json);
+                for pq in post_query {
+                    payload = run_post_query(pq, payload).await?;
+                }
+                Ok(payload)
             }
         }
         Ok(Ok(Err(err))) => Err(classify_query_error(err)),
@@ -162,18 +178,19 @@ async fn run_pre_query(pq: &PreQuery, raw_body: String) -> Result<String, QueryF
         .map_err(|err| QueryFailure::Internal(err.to_string()))
 }
 
-/// Run the `post-query` hook over a successful result set and return the JSON
-/// body it prints. The rows are serialized to a JSON array and delivered two
-/// ways: always on the child's stdin (unbounded, injection-safe), and as the
-/// `{args}` placeholder when the payload is within [`POST_QUERY_ARGS_MAX`]
-/// (beyond that `{args}` is emptied and a warning names the size, directing
-/// the operator to stdin — never silent truncation). The command's last
-/// non-empty stdout line is parsed as JSON and returned as the result;
-/// anything that isn't valid JSON, or any failure (non-zero exit, timeout,
-/// spawn error), maps to `Internal`.
-async fn run_post_query(pq: &PostQuery, rows: Vec<Value>) -> Result<Value, QueryFailure> {
+/// Run one `post-query` stage over its `input` JSON and return the JSON body it
+/// prints. `input` is the serialized result rows for the first stage, or the
+/// previous stage's output thereafter. It is serialized and delivered two ways:
+/// always on the child's stdin (unbounded, injection-safe), and as the `{args}`
+/// placeholder when the payload is within [`POST_QUERY_ARGS_MAX`] (beyond that
+/// `{args}` is emptied and a warning names the size, directing the operator to
+/// stdin — never silent truncation). The command's last non-empty stdout line
+/// is parsed as JSON and returned as the result; anything that isn't valid
+/// JSON, or any failure (non-zero exit, timeout, spawn error), maps to
+/// `Internal`.
+async fn run_post_query(pq: &PostQuery, input: Value) -> Result<Value, QueryFailure> {
     let payload =
-        serde_json::to_string(&rows).map_err(|err| QueryFailure::Internal(err.to_string()))?;
+        serde_json::to_string(&input).map_err(|err| QueryFailure::Internal(err.to_string()))?;
     let command = pq.command.clone();
     let config_dir = pq.config_dir.clone();
     let timeout = pq.timeout;

{dirsql-0.3.94 → dirsql-0.3.95}/packages/rust/src/cli/mod.rs

@@ -127,12 +127,17 @@ pub struct ServerConfig {
     pub host: String,
     pub port: u16,
     pub query_timeout: Duration,
-    /// Optional server-wide `pre-query` command. When `None` (the default),
-    /// `POST /query` parses its body as `{"sql": …}`.
-    pub pre_query: Option<PreQuery>,
-    /// Optional server-wide `post-query` command. When `None` (the default),
-    /// `POST /query` returns the result rows as-is.
-    pub post_query: Option<PostQuery>,
+    /// Ordered `pre-query` command chain. Empty (the default) means
+    /// `POST /query` parses its body as `{"sql": …}`; otherwise the raw body is
+    /// piped through each stage in registration order (body → stage₁ → … → SQL),
+    /// each stage receiving the previous stage's output as its `{args}`.
+    pub pre_query: Vec<PreQuery>,
+    /// Ordered `post-query` command chain. Empty (the default) means
+    /// `POST /query` returns the result rows as-is; otherwise the rows are piped
+    /// through each stage in registration order (rows → stage₁ → … → response),
+    /// each stage receiving the previous stage's output as its `{args}` (and on
+    /// stdin).
+    pub post_query: Vec<PostQuery>,
 }
 
 impl ServerConfig {
@@ -143,8 +148,8 @@ impl ServerConfig {
             host: "localhost".into(),
             port: 0,
             query_timeout: Duration::from_secs(30),
-            pre_query: None,
-            post_query: None,
+            pre_query: Vec::new(),
+            post_query: Vec::new(),
         }
     }
 
@@ -154,8 +159,8 @@ impl ServerConfig {
             host: host.into(),
             port,
             query_timeout: Duration::from_secs(30),
-            pre_query: None,
-            post_query: None,
+            pre_query: Vec::new(),
+            post_query: Vec::new(),
         }
     }
 
@@ -166,19 +171,23 @@ impl ServerConfig {
         self
     }
 
-    /// Attach a server-wide [`PreQuery`] hook. With it set, `POST /query`
-    /// passes the raw request body to the command and runs the SQL it prints
-    /// instead of parsing the body as `{"sql": …}`.
+    /// Append a [`PreQuery`] stage to the chain. Stages run in registration
+    /// order (body → stage₁ → … → SQL); the first stage receives the raw
+    /// request body and each subsequent stage receives the previous stage's
+    /// output, the last stage's output being the SQL to run. With no stage the
+    /// body is parsed as `{"sql": …}`.
     pub fn with_pre_query(mut self, pre_query: PreQuery) -> Self {
-        self.pre_query = Some(pre_query);
+        self.pre_query.push(pre_query);
         self
     }
 
-    /// Attach a server-wide [`PostQuery`] hook. With it set, `POST /query`
-    /// hands each successful result set to the command and returns the JSON
-    /// body it prints instead of returning the rows as-is.
+    /// Append a [`PostQuery`] stage to the chain. Stages run in registration
+    /// order (rows → stage₁ → … → response); the first stage receives the
+    /// serialized result rows and each subsequent stage receives the previous
+    /// stage's output, the last stage's output being the response body. With no
+    /// stage the rows are returned as-is.
     pub fn with_post_query(mut self, post_query: PostQuery) -> Self {
-        self.post_query = Some(post_query);
+        self.post_query.push(post_query);
         self
     }
 }
@@ -276,8 +285,8 @@ mod tests {
         assert_eq!(cfg.host, "localhost");
         assert_eq!(cfg.port, 7117);
         assert_eq!(cfg.query_timeout, Duration::from_secs(30));
-        assert!(cfg.pre_query.is_none());
-        assert!(cfg.post_query.is_none());
+        assert!(cfg.pre_query.is_empty());
+        assert!(cfg.post_query.is_empty());
     }
 
     #[test]
@@ -295,11 +304,15 @@ mod tests {
     }
 
     #[test]
-    fn with_pre_query_sets_the_hook() {
-        let cfg = ServerConfig::ephemeral().with_pre_query(PreQuery::new("cmd {args}", "/proj"));
-        let pq = cfg.pre_query.expect("hook must be set");
-        assert_eq!(pq.command, "cmd {args}");
-        assert_eq!(pq.config_dir, PathBuf::from("/proj"));
+    fn with_pre_query_appends_stages_in_order() {
+        let cfg = ServerConfig::ephemeral()
+            .with_pre_query(PreQuery::new("first {args}", "/a"))
+            .with_pre_query(PreQuery::new("second {args}", "/b"));
+        assert_eq!(cfg.pre_query.len(), 2);
+        assert_eq!(cfg.pre_query[0].command, "first {args}");
+        assert_eq!(cfg.pre_query[0].config_dir, PathBuf::from("/a"));
+        assert_eq!(cfg.pre_query[1].command, "second {args}");
+        assert_eq!(cfg.pre_query[1].config_dir, PathBuf::from("/b"));
     }
 
     #[test]
@@ -317,12 +330,15 @@ mod tests {
     }
 
     #[test]
-    fn with_post_query_sets_the_hook() {
-        let cfg =
-            ServerConfig::ephemeral().with_post_query(PostQuery::new("reshape {args}", "/proj"));
-        let pq = cfg.post_query.expect("hook must be set");
-        assert_eq!(pq.command, "reshape {args}");
-        assert_eq!(pq.config_dir, PathBuf::from("/proj"));
+    fn with_post_query_appends_stages_in_order() {
+        let cfg = ServerConfig::ephemeral()
+            .with_post_query(PostQuery::new("first {args}", "/a"))
+            .with_post_query(PostQuery::new("second {args}", "/b"));
+        assert_eq!(cfg.post_query.len(), 2);
+        assert_eq!(cfg.post_query[0].command, "first {args}");
+        assert_eq!(cfg.post_query[0].config_dir, PathBuf::from("/a"));
+        assert_eq!(cfg.post_query[1].command, "second {args}");
+        assert_eq!(cfg.post_query[1].config_dir, PathBuf::from("/b"));
     }
 
     #[test]

{dirsql-0.3.94 → dirsql-0.3.95}/packages/rust/src/cli/router.rs

@@ -28,14 +28,14 @@ pub(super) struct AppContext {
     pub events: broadcast::Sender<String>,
     pub cancel: watch::Receiver<bool>,
     pub query_timeout: Duration,
-    /// Optional server-wide `pre-query` hook. When `Some`, `POST /query`
-    /// rewrites the request body through the command; when `None`, the body
-    /// is parsed as `{"sql": …}`.
-    pub pre_query: Option<PreQuery>,
-    /// Optional server-wide `post-query` hook. When `Some`, a successful
-    /// `POST /query` result set is reshaped by the command before responding;
-    /// when `None`, the rows are returned as-is.
-    pub post_query: Option<PostQuery>,
+    /// Ordered `pre-query` command chain. Empty means `POST /query` parses the
+    /// body as `{"sql": …}`; otherwise the raw body is piped through each stage
+    /// in order (body → stage₁ → … → SQL).
+    pub pre_query: Vec<PreQuery>,
+    /// Ordered `post-query` command chain. Empty means the rows are returned
+    /// as-is; otherwise a successful result set is piped through each stage in
+    /// order (rows → stage₁ → … → response).
+    pub post_query: Vec<PostQuery>,
 }
 
 pub(super) type SharedCtx = Arc<AppContext>;
@@ -58,8 +58,8 @@ async fn handle_query(State(ctx): State<SharedCtx>, body: String) -> Response {
         &ctx.state,
         body,
         ctx.query_timeout,
-        ctx.pre_query.as_ref(),
-        ctx.post_query.as_ref(),
+        &ctx.pre_query,
+        &ctx.post_query,
     )
     .await
     {