dirsql 0.3.48__tar.gz → 0.3.50__tar.gz

{dirsql-0.3.48 → dirsql-0.3.50}/Cargo.lock

@@ -501,7 +501,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.3.48"
+version = "0.3.50"
 dependencies = [
  "dirsql",
  "pyo3",

{dirsql-0.3.48 → dirsql-0.3.50}/PKG-INFO

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

{dirsql-0.3.48 → dirsql-0.3.50}/docs/cli/config.md

@@ -310,6 +310,60 @@ curl -s http://localhost:7117/query -d 'recent-posts' | jq
 See [Command execution](#command-execution) for the full contract (argv
 splitting, injection safety, cwd, environment, timeout, and output framing).
 
+### Reshaping responses (`post-query`)
+
+The `post-query` hook lets you reshape every query response before it's
+returned — wrap the rows in an envelope, rename or project fields, add
+metadata, or emit whatever JSON shape your clients expect. Because the hook
+owns the response body, `POST /query` can return any structure you like instead
+of the default bare array of row objects. Like [`pre-query`](#rewriting-queries-pre-query),
+`post-query` is a **server-wide** `[dirsql]` key: every successful query flows
+through it.
+
+```toml
+[dirsql]
+post-query = "jq -c '{results: .}'"
+```
+
+The `-c` (compact) flag matters: the response body is the command's **last
+non-empty stdout line** (see [Command execution](#command-execution)), so the
+command must print its JSON on a single line — `jq`'s default multi-line
+pretty-printing would leave only a trailing `}` as the last line.
+
+After a successful query, `dirsql` serializes the result rows to a **JSON
+array** and hands it to the command two ways:
+
+- **On stdin** — always, unbounded and injection-safe. This is the recommended
+  path, and it's what the canonical `jq -c '{results: .}'` example reads.
+- **As the `{args}` placeholder** — for small result sets. When the serialized
+  payload exceeds **96 KiB** (comfortably under the OS single-argument limit),
+  `{args}` is substituted with an **empty string** and a warning naming the byte
+  size is logged to stderr, directing the operator to read stdin instead. The
+  full payload is still delivered on stdin — this is a fallback, **not**
+  truncation.
+
+| Placeholder | Value |
+|-------------|-------|
+| `{args}`    | The result rows as a JSON array, as one argv token — emptied (with a stderr warning) when the payload exceeds 96 KiB; read stdin for the full set. |
+
+The command prints the **JSON response body** on stdout (the last non-empty
+line is used); `dirsql` parses it with `serde_json` and returns it as `200
+application/json`. If that line is **not valid JSON**, the request returns `500
+Internal Server Error` with `post-query did not return valid JSON: <err>`.
+
+When `post-query` is **absent**, nothing changes: the rows are returned as-is —
+the [HTTP API](./http-api.md#post-query) default. Enabling the hook is fully
+backward compatible in reverse: remove the key and the bare-array contract
+returns.
+
+**On failure** — a non-zero exit, a timeout, or a spawn error — the request
+returns `500 Internal Server Error` with the command's stderr tail in the JSON
+`error` body. The command runs in the config file's directory and is bounded by
+a fixed **30-second** timeout.
+
+See [Command execution](#command-execution) for the full contract (argv
+splitting, injection safety, cwd, environment, timeout, and output framing).
+
 ### Full Example
 
 ```toml
@@ -331,8 +385,8 @@ glob = "logs/*.csv"
 
 ## Command execution
 
-Config keys that run an external command — today `on-file` and `pre-query`,
-with more events to follow — share one execution contract:
+Config keys that run an external command — today `on-file`, `pre-query`, and
+`post-query`, with more events to follow — share one execution contract:
 
 - **argv, not a shell.** The command string is split into an argv with
   shell-like quoting (spaces separate arguments; quotes group them), but **no

{dirsql-0.3.48 → dirsql-0.3.50}/docs/cli/http-api.md

@@ -44,6 +44,15 @@ command's stderr tail. With no `pre-query` key, the `{"sql": …}` contract abov
 applies.
 :::
 
+::: tip `post-query` changes the response body
+When [`[dirsql].post-query`](./config.md#reshaping-responses-post-query) is
+configured, the result rows are handed to the hook command (as a JSON array on
+stdin, and as `{args}` for small sets) and the JSON body it prints is returned
+instead of the bare array above. A hook that fails (non-zero exit, timeout,
+spawn error) or prints invalid JSON returns `500`. With no `post-query` key, the
+array-of-rows response above applies.
+:::
+
 ```bash
 curl -s http://localhost:7117/query \
   -H 'content-type: application/json' \

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

{dirsql-0.3.48/packages/rust → dirsql-0.3.50/packages/python}/docs/cli/config.md

@@ -310,6 +310,60 @@ curl -s http://localhost:7117/query -d 'recent-posts' | jq
 See [Command execution](#command-execution) for the full contract (argv
 splitting, injection safety, cwd, environment, timeout, and output framing).
 
+### Reshaping responses (`post-query`)
+
+The `post-query` hook lets you reshape every query response before it's
+returned — wrap the rows in an envelope, rename or project fields, add
+metadata, or emit whatever JSON shape your clients expect. Because the hook
+owns the response body, `POST /query` can return any structure you like instead
+of the default bare array of row objects. Like [`pre-query`](#rewriting-queries-pre-query),
+`post-query` is a **server-wide** `[dirsql]` key: every successful query flows
+through it.
+
+```toml
+[dirsql]
+post-query = "jq -c '{results: .}'"
+```
+
+The `-c` (compact) flag matters: the response body is the command's **last
+non-empty stdout line** (see [Command execution](#command-execution)), so the
+command must print its JSON on a single line — `jq`'s default multi-line
+pretty-printing would leave only a trailing `}` as the last line.
+
+After a successful query, `dirsql` serializes the result rows to a **JSON
+array** and hands it to the command two ways:
+
+- **On stdin** — always, unbounded and injection-safe. This is the recommended
+  path, and it's what the canonical `jq -c '{results: .}'` example reads.
+- **As the `{args}` placeholder** — for small result sets. When the serialized
+  payload exceeds **96 KiB** (comfortably under the OS single-argument limit),
+  `{args}` is substituted with an **empty string** and a warning naming the byte
+  size is logged to stderr, directing the operator to read stdin instead. The
+  full payload is still delivered on stdin — this is a fallback, **not**
+  truncation.
+
+| Placeholder | Value |
+|-------------|-------|
+| `{args}`    | The result rows as a JSON array, as one argv token — emptied (with a stderr warning) when the payload exceeds 96 KiB; read stdin for the full set. |
+
+The command prints the **JSON response body** on stdout (the last non-empty
+line is used); `dirsql` parses it with `serde_json` and returns it as `200
+application/json`. If that line is **not valid JSON**, the request returns `500
+Internal Server Error` with `post-query did not return valid JSON: <err>`.
+
+When `post-query` is **absent**, nothing changes: the rows are returned as-is —
+the [HTTP API](./http-api.md#post-query) default. Enabling the hook is fully
+backward compatible in reverse: remove the key and the bare-array contract
+returns.
+
+**On failure** — a non-zero exit, a timeout, or a spawn error — the request
+returns `500 Internal Server Error` with the command's stderr tail in the JSON
+`error` body. The command runs in the config file's directory and is bounded by
+a fixed **30-second** timeout.
+
+See [Command execution](#command-execution) for the full contract (argv
+splitting, injection safety, cwd, environment, timeout, and output framing).
+
 ### Full Example
 
 ```toml
@@ -331,8 +385,8 @@ glob = "logs/*.csv"
 
 ## Command execution
 
-Config keys that run an external command — today `on-file` and `pre-query`,
-with more events to follow — share one execution contract:
+Config keys that run an external command — today `on-file`, `pre-query`, and
+`post-query`, with more events to follow — share one execution contract:
 
 - **argv, not a shell.** The command string is split into an argv with
   shell-like quoting (spaces separate arguments; quotes group them), but **no

{dirsql-0.3.48 → dirsql-0.3.50}/packages/python/docs/cli/http-api.md

@@ -44,6 +44,15 @@ command's stderr tail. With no `pre-query` key, the `{"sql": …}` contract abov
 applies.
 :::
 
+::: tip `post-query` changes the response body
+When [`[dirsql].post-query`](./config.md#reshaping-responses-post-query) is
+configured, the result rows are handed to the hook command (as a JSON array on
+stdin, and as `{args}` for small sets) and the JSON body it prints is returned
+instead of the bare array above. A hook that fails (non-zero exit, timeout,
+spawn error) or prints invalid JSON returns `500`. With no `post-query` key, the
+array-of-rows response above applies.
+:::
+
 ```bash
 curl -s http://localhost:7117/query \
   -H 'content-type: application/json' \

{dirsql-0.3.48 → dirsql-0.3.50}/packages/python/e2e-attestation.json

@@ -1,6 +1,6 @@
 {
   "command": "uv run python -m pytest tests/e2e/ -x -q",
-  "ran_at": 1782996616,
+  "ran_at": 1783031403,
   "exit_code": 0,
-  "commit": "19cf2e30ef5bff8fe5e77b2c59fd54ca0fc46575"
+  "commit": "3d7c9268191f94a3180442716aa1c49f48699776"
 }

{dirsql-0.3.48/packages/python → dirsql-0.3.50/packages/rust}/docs/cli/config.md

@@ -310,6 +310,60 @@ curl -s http://localhost:7117/query -d 'recent-posts' | jq
 See [Command execution](#command-execution) for the full contract (argv
 splitting, injection safety, cwd, environment, timeout, and output framing).
 
+### Reshaping responses (`post-query`)
+
+The `post-query` hook lets you reshape every query response before it's
+returned — wrap the rows in an envelope, rename or project fields, add
+metadata, or emit whatever JSON shape your clients expect. Because the hook
+owns the response body, `POST /query` can return any structure you like instead
+of the default bare array of row objects. Like [`pre-query`](#rewriting-queries-pre-query),
+`post-query` is a **server-wide** `[dirsql]` key: every successful query flows
+through it.
+
+```toml
+[dirsql]
+post-query = "jq -c '{results: .}'"
+```
+
+The `-c` (compact) flag matters: the response body is the command's **last
+non-empty stdout line** (see [Command execution](#command-execution)), so the
+command must print its JSON on a single line — `jq`'s default multi-line
+pretty-printing would leave only a trailing `}` as the last line.
+
+After a successful query, `dirsql` serializes the result rows to a **JSON
+array** and hands it to the command two ways:
+
+- **On stdin** — always, unbounded and injection-safe. This is the recommended
+  path, and it's what the canonical `jq -c '{results: .}'` example reads.
+- **As the `{args}` placeholder** — for small result sets. When the serialized
+  payload exceeds **96 KiB** (comfortably under the OS single-argument limit),
+  `{args}` is substituted with an **empty string** and a warning naming the byte
+  size is logged to stderr, directing the operator to read stdin instead. The
+  full payload is still delivered on stdin — this is a fallback, **not**
+  truncation.
+
+| Placeholder | Value |
+|-------------|-------|
+| `{args}`    | The result rows as a JSON array, as one argv token — emptied (with a stderr warning) when the payload exceeds 96 KiB; read stdin for the full set. |
+
+The command prints the **JSON response body** on stdout (the last non-empty
+line is used); `dirsql` parses it with `serde_json` and returns it as `200
+application/json`. If that line is **not valid JSON**, the request returns `500
+Internal Server Error` with `post-query did not return valid JSON: <err>`.
+
+When `post-query` is **absent**, nothing changes: the rows are returned as-is —
+the [HTTP API](./http-api.md#post-query) default. Enabling the hook is fully
+backward compatible in reverse: remove the key and the bare-array contract
+returns.
+
+**On failure** — a non-zero exit, a timeout, or a spawn error — the request
+returns `500 Internal Server Error` with the command's stderr tail in the JSON
+`error` body. The command runs in the config file's directory and is bounded by
+a fixed **30-second** timeout.
+
+See [Command execution](#command-execution) for the full contract (argv
+splitting, injection safety, cwd, environment, timeout, and output framing).
+
 ### Full Example
 
 ```toml
@@ -331,8 +385,8 @@ glob = "logs/*.csv"
 
 ## Command execution
 
-Config keys that run an external command — today `on-file` and `pre-query`,
-with more events to follow — share one execution contract:
+Config keys that run an external command — today `on-file`, `pre-query`, and
+`post-query`, with more events to follow — share one execution contract:
 
 - **argv, not a shell.** The command string is split into an argv with
   shell-like quoting (spaces separate arguments; quotes group them), but **no

{dirsql-0.3.48 → dirsql-0.3.50}/packages/rust/docs/cli/http-api.md

@@ -44,6 +44,15 @@ command's stderr tail. With no `pre-query` key, the `{"sql": …}` contract abov
 applies.
 :::
 
+::: tip `post-query` changes the response body
+When [`[dirsql].post-query`](./config.md#reshaping-responses-post-query) is
+configured, the result rows are handed to the hook command (as a JSON array on
+stdin, and as `{args}` for small sets) and the JSON body it prints is returned
+instead of the bare array above. A hook that fails (non-zero exit, timeout,
+spawn error) or prints invalid JSON returns `500`. With no `post-query` key, the
+array-of-rows response above applies.
+:::
+
 ```bash
 curl -s http://localhost:7117/query \
   -H 'content-type: application/json' \

{dirsql-0.3.48 → dirsql-0.3.50}/packages/rust/src/bin/dirsql.rs

@@ -8,7 +8,9 @@ use std::path::{Path, PathBuf};
 use std::process::ExitCode;
 
 use clap::{Args, Parser, Subcommand};
-use dirsql::cli::{AppState, PreQuery, ServerConfig, init::InitOptions, serve_with_state};
+use dirsql::cli::{
+    AppState, PostQuery, PreQuery, ServerConfig, init::InitOptions, serve_with_state,
+};
 use dirsql::{DirSQL, Extension, Row, Table};
 
 #[derive(Debug, Parser)]
@@ -122,6 +124,9 @@ async fn run_server(cli: Cli) -> ExitCode {
     if let Some(pre_query) = load_pre_query(&cli) {
         server_config = server_config.with_pre_query(pre_query);
     }
+    if let Some(post_query) = load_post_query(&cli) {
+        server_config = server_config.with_post_query(post_query);
+    }
 
     let host = cli.host.clone();
     let handle = match serve_with_state(server_config, state).await {
@@ -228,6 +233,23 @@ fn load_pre_query(cli: &Cli) -> Option<PreQuery> {
     Some(PreQuery::new(command, config_dir))
 }
 
+/// Extract the server-wide `post-query` hook from the config, if any.
+///
+/// Returns `None` when the config is absent, unresolvable, unparsable, or
+/// declares no `post-query` — the server then returns `POST /query` result rows
+/// as-is (the degraded / zero-config paths never get a hook). The command's
+/// working directory is the config file's parent, mirroring [`load_pre_query`].
+fn load_post_query(cli: &Cli) -> Option<PostQuery> {
+    let config_path = &cli.config;
+    if !config_path.exists() {
+        return None;
+    }
+    let resolved = config_path.canonicalize().ok()?;
+    let command = dirsql::config::load_config(&resolved).ok()?.post_query?;
+    let config_dir = resolved.parent()?.to_path_buf();
+    Some(PostQuery::new(command, config_dir))
+}
+
 /// Zero-config fallback. When no `.dirsql.toml` is found, dirsql indexes the
 /// directory that would have held the config with a single default `files`
 /// table — one row per file, columns drawn entirely from filesystem facts —

{dirsql-0.3.48 → dirsql-0.3.50}/packages/rust/src/cli/mod.rs

@@ -63,6 +63,31 @@ impl PreQuery {
     }
 }
 
+/// A server-wide `post-query` command hook, carrying the command template plus
+/// the directory it runs in (the config file's parent). When set on a
+/// [`ServerConfig`], the server hands each successful `POST /query` result set
+/// (the rows serialized as a JSON array) to the command as `{args}` and on
+/// stdin, and returns the JSON body the command prints instead of the rows
+/// as-is. See [`crate::command`] for the execution contract.
+#[derive(Debug, Clone)]
+pub struct PostQuery {
+    /// The command template (argv-split, no shell). Receives the serialized
+    /// result rows as the `{args}` placeholder (and on stdin).
+    pub command: String,
+    /// The command's working directory — the config file's parent.
+    pub config_dir: PathBuf,
+}
+
+impl PostQuery {
+    /// Build a [`PostQuery`] from a command template and its working directory.
+    pub fn new(command: impl Into<String>, config_dir: impl Into<PathBuf>) -> Self {
+        Self {
+            command: command.into(),
+            config_dir: config_dir.into(),
+        }
+    }
+}
+
 /// Configure how the server binds. Defaults to `localhost:7117` with a
 /// 30-second per-query timeout and no `pre-query` hook.
 #[derive(Debug, Clone)]
@@ -73,6 +98,9 @@ pub struct ServerConfig {
     /// 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>,
 }
 
 impl ServerConfig {
@@ -84,6 +112,7 @@ impl ServerConfig {
             port: 0,
             query_timeout: Duration::from_secs(30),
             pre_query: None,
+            post_query: None,
         }
     }
 
@@ -94,6 +123,7 @@ impl ServerConfig {
             port,
             query_timeout: Duration::from_secs(30),
             pre_query: None,
+            post_query: None,
         }
     }
 
@@ -111,6 +141,14 @@ impl ServerConfig {
         self.pre_query = Some(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.
+    pub fn with_post_query(mut self, post_query: PostQuery) -> Self {
+        self.post_query = Some(post_query);
+        self
+    }
 }
 
 impl Default for ServerConfig {
@@ -214,6 +252,7 @@ mod tests {
         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());
     }
 
     #[test]
@@ -232,4 +271,22 @@ mod tests {
         assert_eq!(pq.command, "cmd {args}");
         assert_eq!(pq.config_dir, PathBuf::from("/proj"));
     }
+
+    #[test]
+    fn post_query_constructor_carries_command_and_dir() {
+        // `PostQuery::new` is pure data plumbing: the command template and the
+        // working directory it will run in.
+        let pq = PostQuery::new("jq '{results: .}'", "/proj");
+        assert_eq!(pq.command, "jq '{results: .}'");
+        assert_eq!(pq.config_dir, PathBuf::from("/proj"));
+    }
+
+    #[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"));
+    }
 }

{dirsql-0.3.48 → dirsql-0.3.50}/packages/rust/src/cli/router.rs

@@ -17,7 +17,7 @@ use tokio::sync::{broadcast, watch};
 use tokio_stream::wrappers::BroadcastStream;
 
 use super::serialize::rows_to_json;
-use super::{AppState, PreQuery};
+use super::{AppState, PostQuery, PreQuery};
 use crate::command::{Placeholder, run_command};
 use crate::{DirSQL, DirSqlError};
 
@@ -26,6 +26,16 @@ use crate::{DirSQL, DirSqlError};
 /// `on-file`'s `ON_FILE_TIMEOUT`).
 const PRE_QUERY_TIMEOUT: Duration = Duration::from_secs(30);
 
+/// Fixed timeout for a server-wide `post-query` command (mirrors
+/// `PRE_QUERY_TIMEOUT`).
+const POST_QUERY_TIMEOUT: Duration = Duration::from_secs(30);
+
+/// Cap on the serialized result payload passed as the `{args}` argv token.
+/// Beyond this, `{args}` is emptied and the operator is directed to stdin
+/// (which always carries the full payload) — comfortably under Linux's 128 KiB
+/// single-arg `MAX_ARG_STRLEN`.
+const POST_QUERY_ARGS_MAX: usize = 96 * 1024;
+
 pub(super) struct AppContext {
     pub state: AppState,
     pub events: broadcast::Sender<String>,
@@ -35,6 +45,10 @@ pub(super) struct AppContext {
     /// 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>,
 }
 
 pub(super) type SharedCtx = Arc<AppContext>;
@@ -81,7 +95,16 @@ async fn handle_query(State(ctx): State<SharedCtx>, body: String) -> Response {
         tokio::time::timeout(timeout, tokio::task::spawn_blocking(move || db.query(&sql))).await;
 
     match join {
-        Ok(Ok(Ok(rows))) => Json(rows_to_json(&rows)).into_response(),
+        Ok(Ok(Ok(rows))) => {
+            let rows_json = rows_to_json(&rows);
+            match &ctx.post_query {
+                Some(pq) => match run_post_query(pq, rows_json).await {
+                    Ok(value) => Json(value).into_response(),
+                    Err(resp) => resp,
+                },
+                None => Json(rows_json).into_response(),
+            }
+        }
         Ok(Ok(Err(err))) => {
             let status = classify_query_error(&err);
             error_response(status, err.to_string())
@@ -154,6 +177,66 @@ async fn run_pre_query(pq: &PreQuery, raw_body: String) -> Result<String, Respon
         .map_err(|err| error_response(StatusCode::INTERNAL_SERVER_ERROR, err.to_string()))
 }
 
+/// Run the server-wide `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
+/// `200` body; anything that isn't valid JSON, or any failure (non-zero exit,
+/// timeout, spawn error), maps to `500`.
+///
+/// `Response` is large (see [`parse_sql_body`]); returned by value for the same
+/// reason.
+#[allow(clippy::result_large_err)]
+async fn run_post_query(
+    pq: &PostQuery,
+    rows: Vec<serde_json::Value>,
+) -> Result<serde_json::Value, Response> {
+    let payload = serde_json::to_string(&rows)
+        .map_err(|err| error_response(StatusCode::INTERNAL_SERVER_ERROR, err.to_string()))?;
+    let command = pq.command.clone();
+    let config_dir = pq.config_dir.clone();
+    // `run_command` is blocking — it spawns a child and joins drain threads —
+    // so run it off the async runtime. It enforces `POST_QUERY_TIMEOUT`
+    // internally, so no outer `tokio::time::timeout` is needed.
+    let outcome = tokio::task::spawn_blocking(move || {
+        let args_value = if payload.len() <= POST_QUERY_ARGS_MAX {
+            payload.clone()
+        } else {
+            eprintln!(
+                "dirsql: post-query result payload is {} bytes, exceeding the \
+                 {POST_QUERY_ARGS_MAX}-byte argv threshold; `{{args}}` is emptied — \
+                 read the rows from stdin instead",
+                payload.len()
+            );
+            String::new()
+        };
+        run_command(
+            &command,
+            &[Placeholder::new("args", &args_value)],
+            &config_dir,
+            POST_QUERY_TIMEOUT,
+            Some(payload.as_bytes()),
+        )
+    })
+    .await
+    .map_err(|join_err| error_response(StatusCode::INTERNAL_SERVER_ERROR, join_err.to_string()))?;
+
+    let out = outcome
+        .map_err(|err| error_response(StatusCode::INTERNAL_SERVER_ERROR, err.to_string()))?;
+
+    // The command's payload (last non-empty stdout line) is the JSON response
+    // body; reject anything that doesn't parse as JSON.
+    serde_json::from_str(&out.payload).map_err(|err| {
+        error_response(
+            StatusCode::INTERNAL_SERVER_ERROR,
+            format!("post-query did not return valid JSON: {err}"),
+        )
+    })
+}
+
 async fn handle_events(State(ctx): State<SharedCtx>) -> Response {
     if let Err(resp) = require_ready(&ctx.state) {
         return resp;

{dirsql-0.3.48 → dirsql-0.3.50}/packages/rust/src/cli/server.rs

@@ -49,6 +49,7 @@ pub async fn serve_with_state(
         cancel: cancel_rx,
         query_timeout: config.query_timeout,
         pre_query: config.pre_query,
+        post_query: config.post_query,
     });
     let app = router(shared);
 

{dirsql-0.3.48 → dirsql-0.3.50}/packages/rust/src/config.rs

@@ -51,6 +51,13 @@ pub struct Config {
     /// execution contract. Only the CLI server consults this; the SDK ignores
     /// it.
     pub pre_query: Option<String>,
+    /// Optional server-wide `post-query` command (`[dirsql].post-query`). When
+    /// set, the HTTP server hands each successful `POST /query` result set (the
+    /// rows serialized as a JSON array) to this command as `{args}` and on
+    /// stdin, and returns the JSON body the command prints, instead of returning
+    /// the rows as-is. See `dirsql::command` for the execution contract. Only
+    /// the CLI server consults this; the SDK ignores it.
+    pub post_query: Option<String>,
 }
 
 /// A SQLite extension to load at startup.
@@ -109,6 +116,8 @@ struct RawDirsql {
     extension: Option<Vec<RawExtension>>,
     #[serde(rename = "pre-query")]
     pre_query: Option<String>,
+    #[serde(rename = "post-query")]
+    post_query: Option<String>,
 }
 
 #[derive(Deserialize)]
@@ -136,17 +145,19 @@ pub fn load_config(path: &Path) -> Result<Config> {
 pub fn load_config_str(content: &str) -> Result<Config> {
     let raw: RawConfig = toml::from_str(content)?;
 
-    let (root, ignore, persist, persist_path, raw_extensions, raw_pre_query) = match raw.dirsql {
-        Some(d) => (
-            d.root,
-            d.ignore.unwrap_or_default(),
-            d.persist.unwrap_or(false),
-            d.persist_path,
-            d.extension.unwrap_or_default(),
-            d.pre_query,
-        ),
-        None => (None, Vec::new(), false, None, Vec::new(), None),
-    };
+    let (root, ignore, persist, persist_path, raw_extensions, raw_pre_query, raw_post_query) =
+        match raw.dirsql {
+            Some(d) => (
+                d.root,
+                d.ignore.unwrap_or_default(),
+                d.persist.unwrap_or(false),
+                d.persist_path,
+                d.extension.unwrap_or_default(),
+                d.pre_query,
+                d.post_query,
+            ),
+            None => (None, Vec::new(), false, None, Vec::new(), None, None),
+        };
 
     // A present-but-empty `pre-query = ""` is as unusable as a missing key:
     // reject it at parse time rather than spawning an empty command later
@@ -158,6 +169,16 @@ pub fn load_config_str(content: &str) -> Result<Config> {
         other => other,
     };
 
+    // A present-but-empty `post-query = ""` is as unusable as a missing key:
+    // reject it at parse time rather than spawning an empty command later
+    // (mirrors the `pre-query` handling above).
+    let post_query = match raw_post_query {
+        Some(cmd) if cmd.trim().is_empty() => {
+            return Err(ConfigError::EmptyField("post-query"));
+        }
+        other => other,
+    };
+
     let mut extensions = Vec::with_capacity(raw_extensions.len());
     for raw_ext in raw_extensions {
         // An empty `path = ""` is as unusable as a missing key: reject it at
@@ -204,6 +225,7 @@ pub fn load_config_str(content: &str) -> Result<Config> {
         persist_path,
         extensions,
         pre_query,
+        post_query,
     })
 }
 
@@ -568,6 +590,44 @@ pre-query = "   "
         );
     }
 
+    #[test]
+    fn post_query_parses_when_present() {
+        let toml = r#"
+[dirsql]
+post-query = "jq '{results: .}'"
+
+[[table]]
+ddl = "CREATE TABLE t (_path TEXT)"
+glob = "*.json"
+"#;
+        let config = load_config_str(toml).unwrap();
+        assert_eq!(config.post_query.as_deref(), Some("jq '{results: .}'"));
+    }
+
+    #[test]
+    fn post_query_absent_is_none() {
+        let toml = r#"
+[[table]]
+ddl = "CREATE TABLE t (_path TEXT)"
+glob = "*.json"
+"#;
+        let config = load_config_str(toml).unwrap();
+        assert!(config.post_query.is_none());
+    }
+
+    #[test]
+    fn post_query_empty_errors() {
+        let toml = r#"
+[dirsql]
+post-query = "   "
+"#;
+        let err = load_config_str(toml).unwrap_err();
+        assert!(
+            matches!(err, ConfigError::EmptyField("post-query")),
+            "got: {err:?}"
+        );
+    }
+
     #[test]
     fn extension_empty_path_errors() {
         // An empty `path = ""` is as unusable as a missing key — it must be