dirsql 0.4.85__tar.gz → 0.4.86__tar.gz

{dirsql-0.4.85 → dirsql-0.4.86}/Cargo.lock

@@ -552,7 +552,7 @@ checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8"
 
 [[package]]
 name = "dirsql"
-version = "0.4.85"
+version = "0.4.86"
 dependencies = [
  "assert_cmd",
  "axum",
@@ -586,6 +586,7 @@ dependencies = [
  "tokio",
  "tokio-stream",
  "toml",
+ "tower-http",
  "typed-path",
 ]
 
@@ -602,7 +603,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.4.85"
+version = "0.4.86"
 dependencies = [
  "dirsql",
  "pyo3",

{dirsql-0.4.85 → dirsql-0.4.86}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dirsql
-Version: 0.4.85
+Version: 0.4.86
 Requires-Dist: bin-shim>=0.1
 Summary: Ephemeral SQL index over a local directory
 Keywords: sql,filesystem,directory,sqlite,index

{dirsql-0.4.85 → dirsql-0.4.86}/docs/reference/cli.md

@@ -247,6 +247,7 @@ Config flags are subcommand-local: pass them after `server`
 | `-c, --config <path>` | none | Path to a [config file](./config.md). **Repeatable** (`-c a -c b`): the configs load and merge in argv order — see [Composing multiple configs](./config.md#composing-multiple-configs). The index root is the **invocation directory** (the current working directory) and governs path-tables; a config's `[[table]]` globs anchor at **that config's own directory** (see [glob anchor](./config.md#glob-anchor)), so `--config /elsewhere/.dirsql.toml` indexes `/elsewhere`, from any working directory. With none given, **no named tables are defined** — query the filesystem with a [path-table](./path-tables.md) (`FROM './'`). A `./.dirsql.toml` on disk is **not** auto-loaded; pass it explicitly. A `-c` naming a file that does not exist is an [error](#degraded-mode). |
 | `--host <addr>` | `localhost` | Bind address. |
 | `--port <n>` | `7117` | TCP port to bind. |
+| `--cors-origin <origin>` | off | Let browser pages on `<origin>` (an exact origin such as `http://localhost:3202`, or `*` for any) call `/query` and open `/events`. See [Cross-origin requests](#cross-origin-requests). |
 | `--persist [<path>]` | off | Keep the SQLite index on disk between runs so a restart only re-parses files that actually changed. Bare `--persist` caches at `<root>/.dirsql/cache.db`; `--persist <path>` caches at `<path>`. Off by default (the index is ephemeral). Also available on [`dirsql query`](#dirsql-query). See [Keep the index across restarts](../howto/persist.md). |
 | `--no-ignore` | off | Scan files a `.gitignore` would hide. [Path-tables](./path-tables.md#skip-rules) respect `.gitignore` files by default; this flag restores the full walk. The built-in skips (`node_modules`/`.git`) and configured `ignore` patterns still apply. Also available on [`dirsql query`](#dirsql-query). |
 | `--extension <path>` | none | Load a SQLite extension by literal path, overriding the config's `[[dirsql.extension]]` entries. Repeatable. Format: `<path>` or `<path>::<entrypoint>`. Internal plumbing for the pip/npm launchers, which resolve package-name extensions and pass the resolved paths here — not intended for direct use. When any `--extension` is present, the config file's own extension entries are not loaded. |
@@ -262,6 +263,23 @@ Config flags are subcommand-local: pass them after `server`
   command in `timeout(1)` (see
   [Bounding a hook](./hooks.md#bounding-a-hook)).
 
+### Cross-origin requests
+
+By default the server sends no CORS headers, so a browser blocks a page on
+another origin from reading `/query` responses or opening `/events`. This is
+deliberate: any web page the browser visits can send requests to
+`localhost`, and permissive CORS would let it read the indexed files.
+
+`--cors-origin <origin>` opts in. Every response then carries
+`Access-Control-Allow-Origin: <origin>`, and the preflight a JSON
+`POST /query` triggers is answered (methods `GET`, `POST`; header
+`content-type`). The value is sent verbatim: an origin is
+`scheme://host[:port]` with no trailing slash, and `*` allows every origin.
+
+```bash
+dirsql server --cors-origin http://localhost:3202
+```
+
 ### Configless mode
 
 With no `-c/--config`, the server indexes the invocation directory but

{dirsql-0.4.85/packages/rust → dirsql-0.4.86}/docs/reference/http-api.md

@@ -1,7 +1,10 @@
 # HTTP API
 
 The [`dirsql` server](./cli.md#dirsql-server) (default `localhost:7117`)
-exposes two endpoints: `POST /query` and `GET /events`.
+exposes two endpoints: `POST /query` and `GET /events`. It sends no CORS
+headers unless started with
+[`--cors-origin`](./cli.md#cross-origin-requests), so a browser page on
+another origin can reach it only after that opt-in.
 
 ## `POST /query`
 

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

{dirsql-0.4.85/packages/rust → dirsql-0.4.86/packages/python}/docs/reference/cli.md

@@ -247,6 +247,7 @@ Config flags are subcommand-local: pass them after `server`
 | `-c, --config <path>` | none | Path to a [config file](./config.md). **Repeatable** (`-c a -c b`): the configs load and merge in argv order — see [Composing multiple configs](./config.md#composing-multiple-configs). The index root is the **invocation directory** (the current working directory) and governs path-tables; a config's `[[table]]` globs anchor at **that config's own directory** (see [glob anchor](./config.md#glob-anchor)), so `--config /elsewhere/.dirsql.toml` indexes `/elsewhere`, from any working directory. With none given, **no named tables are defined** — query the filesystem with a [path-table](./path-tables.md) (`FROM './'`). A `./.dirsql.toml` on disk is **not** auto-loaded; pass it explicitly. A `-c` naming a file that does not exist is an [error](#degraded-mode). |
 | `--host <addr>` | `localhost` | Bind address. |
 | `--port <n>` | `7117` | TCP port to bind. |
+| `--cors-origin <origin>` | off | Let browser pages on `<origin>` (an exact origin such as `http://localhost:3202`, or `*` for any) call `/query` and open `/events`. See [Cross-origin requests](#cross-origin-requests). |
 | `--persist [<path>]` | off | Keep the SQLite index on disk between runs so a restart only re-parses files that actually changed. Bare `--persist` caches at `<root>/.dirsql/cache.db`; `--persist <path>` caches at `<path>`. Off by default (the index is ephemeral). Also available on [`dirsql query`](#dirsql-query). See [Keep the index across restarts](../howto/persist.md). |
 | `--no-ignore` | off | Scan files a `.gitignore` would hide. [Path-tables](./path-tables.md#skip-rules) respect `.gitignore` files by default; this flag restores the full walk. The built-in skips (`node_modules`/`.git`) and configured `ignore` patterns still apply. Also available on [`dirsql query`](#dirsql-query). |
 | `--extension <path>` | none | Load a SQLite extension by literal path, overriding the config's `[[dirsql.extension]]` entries. Repeatable. Format: `<path>` or `<path>::<entrypoint>`. Internal plumbing for the pip/npm launchers, which resolve package-name extensions and pass the resolved paths here — not intended for direct use. When any `--extension` is present, the config file's own extension entries are not loaded. |
@@ -262,6 +263,23 @@ Config flags are subcommand-local: pass them after `server`
   command in `timeout(1)` (see
   [Bounding a hook](./hooks.md#bounding-a-hook)).
 
+### Cross-origin requests
+
+By default the server sends no CORS headers, so a browser blocks a page on
+another origin from reading `/query` responses or opening `/events`. This is
+deliberate: any web page the browser visits can send requests to
+`localhost`, and permissive CORS would let it read the indexed files.
+
+`--cors-origin <origin>` opts in. Every response then carries
+`Access-Control-Allow-Origin: <origin>`, and the preflight a JSON
+`POST /query` triggers is answered (methods `GET`, `POST`; header
+`content-type`). The value is sent verbatim: an origin is
+`scheme://host[:port]` with no trailing slash, and `*` allows every origin.
+
+```bash
+dirsql server --cors-origin http://localhost:3202
+```
+
 ### Configless mode
 
 With no `-c/--config`, the server indexes the invocation directory but

{dirsql-0.4.85 → dirsql-0.4.86}/packages/python/docs/reference/http-api.md

@@ -1,7 +1,10 @@
 # HTTP API
 
 The [`dirsql` server](./cli.md#dirsql-server) (default `localhost:7117`)
-exposes two endpoints: `POST /query` and `GET /events`.
+exposes two endpoints: `POST /query` and `GET /events`. It sends no CORS
+headers unless started with
+[`--cors-origin`](./cli.md#cross-origin-requests), so a browser page on
+another origin can reach it only after that opt-in.
 
 ## `POST /query`
 

dirsql-0.4.86/packages/python/e2e-attestations/bot-1399-server-cors.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/fanout_test.py tests/e2e/query_contract_test.py -x -q",
+  "ran_at": 1791312715,
+  "exit_code": 0,
+  "commit": "517f231592489abeec2e15d76c19865b7f651c3b",
+  "branch": "bot/1399-server-cors"
+}

dirsql-0.4.86/packages/python/e2e-attestations/bot-1401-watch-scope.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/fanout_test.py tests/e2e/declared_table_name_test.py tests/e2e/query_contract_test.py tests/e2e/on_file_query_test.py -x -q",
+  "ran_at": 1791324350,
+  "exit_code": 0,
+  "commit": "20cb91d9d8f0a1b24c57f426b95aff4dd97e433b",
+  "branch": "bot/1401-watch-scope"
+}

{dirsql-0.4.85 → dirsql-0.4.86}/packages/rust/Cargo.toml

@@ -6,7 +6,7 @@ description = "Ephemeral SQL index over a local directory"
 # version stays for the binding crates (publish = false). The literal
 # intentionally lags the published version: putitoutthere rewrites it to
 # the planned release version at build time and never commits it back.
-version = "0.4.85"
+version = "0.4.86"
 edition.workspace = true
 # Literal `license` (not `license.workspace = true`) because
 # putitoutthere's preflight check reads `[package].license` directly
@@ -50,6 +50,7 @@ cli = [
     "dep:hex",
     "dep:reedline",
     "dep:tokio-stream",
+    "dep:tower-http",
     "tokio/rt-multi-thread",
     "tokio/macros",
     "tokio/signal",
@@ -86,6 +87,7 @@ shlex = "1"
 thiserror.workspace = true
 tokio.workspace = true
 tokio-stream = { version = "0.1", features = ["sync"], optional = true }
+tower-http = { version = "0.6", features = ["cors"], optional = true }
 toml = "0.8"
 typed-path = "0.12"
 

{dirsql-0.4.85 → dirsql-0.4.86}/packages/rust/README.md

@@ -124,7 +124,7 @@ cargo install dirsql --features cli
 dirsql "SELECT * FROM './'"
 ```
 
-`dirsql "<sql>"` runs one query and prints the rows as JSON — the default. `dirsql server` starts an HTTP server bound to `localhost:7117` that exposes the SDK over HTTP: `POST /query` for SQL and `GET /events` for a Server-Sent Events change stream. Override the bind with `dirsql server --host`, `--port`, `--config`. See the [CLI reference](https://dirsql.dev/reference/cli).
+`dirsql "<sql>"` runs one query and prints the rows as JSON — the default. `dirsql server` starts an HTTP server bound to `localhost:7117` that exposes the SDK over HTTP: `POST /query` for SQL and `GET /events` for a Server-Sent Events change stream. Override the bind with `dirsql server --host`, `--port`, `--config`; add `--cors-origin <origin>` to let a browser page on another origin call it. See the [CLI reference](https://dirsql.dev/reference/cli).
 
 The `cli` feature is **opt-in** -- `cargo add dirsql` pulls no CLI dependencies. `cargo install dirsql` without `--features cli` silently installs nothing (`required-features` skips the bin target with no warning); always include the flag, or use `npx dirsql` / `uvx dirsql` for prebuilt binaries.
 

{dirsql-0.4.85/packages/python → dirsql-0.4.86/packages/rust}/docs/reference/cli.md

@@ -247,6 +247,7 @@ Config flags are subcommand-local: pass them after `server`
 | `-c, --config <path>` | none | Path to a [config file](./config.md). **Repeatable** (`-c a -c b`): the configs load and merge in argv order — see [Composing multiple configs](./config.md#composing-multiple-configs). The index root is the **invocation directory** (the current working directory) and governs path-tables; a config's `[[table]]` globs anchor at **that config's own directory** (see [glob anchor](./config.md#glob-anchor)), so `--config /elsewhere/.dirsql.toml` indexes `/elsewhere`, from any working directory. With none given, **no named tables are defined** — query the filesystem with a [path-table](./path-tables.md) (`FROM './'`). A `./.dirsql.toml` on disk is **not** auto-loaded; pass it explicitly. A `-c` naming a file that does not exist is an [error](#degraded-mode). |
 | `--host <addr>` | `localhost` | Bind address. |
 | `--port <n>` | `7117` | TCP port to bind. |
+| `--cors-origin <origin>` | off | Let browser pages on `<origin>` (an exact origin such as `http://localhost:3202`, or `*` for any) call `/query` and open `/events`. See [Cross-origin requests](#cross-origin-requests). |
 | `--persist [<path>]` | off | Keep the SQLite index on disk between runs so a restart only re-parses files that actually changed. Bare `--persist` caches at `<root>/.dirsql/cache.db`; `--persist <path>` caches at `<path>`. Off by default (the index is ephemeral). Also available on [`dirsql query`](#dirsql-query). See [Keep the index across restarts](../howto/persist.md). |
 | `--no-ignore` | off | Scan files a `.gitignore` would hide. [Path-tables](./path-tables.md#skip-rules) respect `.gitignore` files by default; this flag restores the full walk. The built-in skips (`node_modules`/`.git`) and configured `ignore` patterns still apply. Also available on [`dirsql query`](#dirsql-query). |
 | `--extension <path>` | none | Load a SQLite extension by literal path, overriding the config's `[[dirsql.extension]]` entries. Repeatable. Format: `<path>` or `<path>::<entrypoint>`. Internal plumbing for the pip/npm launchers, which resolve package-name extensions and pass the resolved paths here — not intended for direct use. When any `--extension` is present, the config file's own extension entries are not loaded. |
@@ -262,6 +263,23 @@ Config flags are subcommand-local: pass them after `server`
   command in `timeout(1)` (see
   [Bounding a hook](./hooks.md#bounding-a-hook)).
 
+### Cross-origin requests
+
+By default the server sends no CORS headers, so a browser blocks a page on
+another origin from reading `/query` responses or opening `/events`. This is
+deliberate: any web page the browser visits can send requests to
+`localhost`, and permissive CORS would let it read the indexed files.
+
+`--cors-origin <origin>` opts in. Every response then carries
+`Access-Control-Allow-Origin: <origin>`, and the preflight a JSON
+`POST /query` triggers is answered (methods `GET`, `POST`; header
+`content-type`). The value is sent verbatim: an origin is
+`scheme://host[:port]` with no trailing slash, and `*` allows every origin.
+
+```bash
+dirsql server --cors-origin http://localhost:3202
+```
+
 ### Configless mode
 
 With no `-c/--config`, the server indexes the invocation directory but

{dirsql-0.4.85 → dirsql-0.4.86/packages/rust}/docs/reference/http-api.md

@@ -1,7 +1,10 @@
 # HTTP API
 
 The [`dirsql` server](./cli.md#dirsql-server) (default `localhost:7117`)
-exposes two endpoints: `POST /query` and `GET /events`.
+exposes two endpoints: `POST /query` and `GET /events`. It sends no CORS
+headers unless started with
+[`--cors-origin`](./cli.md#cross-origin-requests), so a browser page on
+another origin can reach it only after that opt-in.
 
 ## `POST /query`
 

{dirsql-0.4.85 → dirsql-0.4.86}/packages/rust/src/cli/mod.rs

@@ -26,6 +26,7 @@
 use std::net::SocketAddr;
 use std::time::Duration;
 
+use axum::http::HeaderValue;
 use tokio::sync::{oneshot, watch};
 use tokio::task::JoinError;
 use tokio::task::JoinHandle;
@@ -52,12 +53,15 @@ pub use server::{serve, serve_with_state};
 pub use crate::DEFAULT_CONFIG_TOML;
 
 /// Configure how the server binds. Defaults to `localhost:7117` with a
-/// 30-second per-query timeout.
+/// 30-second per-query timeout and no CORS headers.
 #[derive(Debug, Clone)]
 pub struct ServerConfig {
     pub host: String,
     pub port: u16,
     pub query_timeout: Duration,
+    /// The `Access-Control-Allow-Origin` value sent on every response, or
+    /// `None` to send no CORS headers (browsers then block cross-origin reads).
+    pub cors_origin: Option<HeaderValue>,
 }
 
 impl ServerConfig {
@@ -68,6 +72,7 @@ impl ServerConfig {
             host: "localhost".into(),
             port: 0,
             query_timeout: Duration::from_secs(30),
+            cors_origin: None,
         }
     }
 
@@ -77,6 +82,7 @@ impl ServerConfig {
             host: host.into(),
             port,
             query_timeout: Duration::from_secs(30),
+            cors_origin: None,
         }
     }
 
@@ -86,6 +92,13 @@ impl ServerConfig {
         self.query_timeout = timeout;
         self
     }
+
+    /// Allow browser pages on `origin` (or any origin, for `*`) to read
+    /// responses and open `/events`.
+    pub fn with_cors_origin(mut self, origin: HeaderValue) -> Self {
+        self.cors_origin = Some(origin);
+        self
+    }
 }
 
 impl Default for ServerConfig {
@@ -181,6 +194,22 @@ mod tests {
         assert_eq!(cfg.host, "localhost");
         assert_eq!(cfg.port, 7117);
         assert_eq!(cfg.query_timeout, Duration::from_secs(30));
+        assert_eq!(cfg.cors_origin, None);
+    }
+
+    #[test]
+    fn ephemeral_config_binds_port_zero_on_localhost_without_cors() {
+        let cfg = ServerConfig::ephemeral();
+        assert_eq!(cfg.host, "localhost");
+        assert_eq!(cfg.port, 0);
+        assert_eq!(cfg.query_timeout, Duration::from_secs(30));
+        assert_eq!(cfg.cors_origin, None);
+    }
+
+    #[test]
+    fn with_cors_origin_sets_the_allowed_origin() {
+        let cfg = ServerConfig::ephemeral().with_cors_origin(HeaderValue::from_static("*"));
+        assert_eq!(cfg.cors_origin, Some(HeaderValue::from_static("*")));
     }
 
     #[test]

{dirsql-0.4.85 → dirsql-0.4.86}/packages/rust/src/cli/run.rs

@@ -26,6 +26,7 @@ use super::{
     serve_with_state, table,
 };
 use crate::{DirSQL, Extension};
+use axum::http::HeaderValue;
 use clap::{Args, Parser, Subcommand, ValueEnum};
 use serde_json::Value;
 
@@ -184,6 +185,12 @@ struct ServerArgs {
     #[arg(long, default_value_t = 7117)]
     port: u16,
 
+    /// Send `Access-Control-Allow-Origin: <ORIGIN>` so browser pages on that
+    /// origin (`*` for any) can call `/query` and open `/events`. Without it
+    /// the server sends no CORS headers.
+    #[arg(long = "cors-origin", value_name = "ORIGIN")]
+    cors_origin: Option<HeaderValue>,
+
     #[command(flatten)]
     common: ConfigArgs,
 }
@@ -330,7 +337,7 @@ pub fn run_cli(argv: Vec<String>) -> i32 {
         match cli.command.take() {
             Some(Command::Init(args)) => run_init(args),
             Some(Command::Query(args)) => run_query(args, &mut std::io::stdout()).await,
-            Some(Command::Server(args)) => run_server(args).await,
+            Some(Command::Server(args)) => run_server(args, wait_for_shutdown()).await,
             Some(Command::Context) => {
                 print!("{}", super::context::guide());
                 0
@@ -462,11 +469,17 @@ fn run_init(args: InitArgs) -> u8 {
     }
 }
 
-async fn run_server(args: ServerArgs) -> u8 {
+async fn run_server(
+    args: ServerArgs,
+    shutdown: impl std::future::Future<Output = std::io::Result<()>>,
+) -> u8 {
     // The server has no `--on-file`: clap rejects it as an unknown flag before
     // reaching here. Path-tables served over HTTP keep their stat columns.
     let state = load_state(&args.common, None);
-    let server_config = ServerConfig::bind(args.host.clone(), args.port);
+    let mut server_config = ServerConfig::bind(args.host.clone(), args.port);
+    if let Some(origin) = args.cors_origin {
+        server_config = server_config.with_cors_origin(origin);
+    }
 
     let host = args.host.clone();
     let handle = match serve_with_state(server_config, state).await {
@@ -480,7 +493,7 @@ async fn run_server(args: ServerArgs) -> u8 {
     // Echo back the user-facing hostname (not the resolved IP SocketAddr).
     println!("Running at {host}:{}", handle.local_addr().port());
 
-    if let Err(err) = wait_for_shutdown().await {
+    if let Err(err) = shutdown.await {
         eprintln!("dirsql: signal handler error: {err}");
     }
 
@@ -857,12 +870,68 @@ mod tests {
         }
     }
 
+    fn server_args(argv: &[&str]) -> ServerArgs {
+        match Cli::parse_from(argv).command {
+            Some(Command::Server(args)) => args,
+            other => panic!("expected a server subcommand, got {other:?}"),
+        }
+    }
+
+    #[tokio::test]
+    async fn run_server_exits_zero_after_a_clean_shutdown() {
+        let args = server_args(&[
+            "dirsql",
+            "server",
+            "--host",
+            "127.0.0.1",
+            "--port",
+            "0",
+            "-c",
+            "/nonexistent/.dirsql.toml",
+        ]);
+        assert_eq!(run_server(args, std::future::ready(Ok(()))).await, 0);
+    }
+
+    #[tokio::test]
+    async fn run_server_exits_one_when_the_bind_fails() {
+        let args = server_args(&[
+            "dirsql",
+            "server",
+            "--host",
+            "192.0.2.1",
+            "--port",
+            "9",
+            "-c",
+            "/nonexistent/.dirsql.toml",
+        ]);
+        assert_eq!(run_server(args, std::future::pending()).await, 1);
+    }
+
+    #[test]
+    fn server_subcommand_parses_a_cors_origin() {
+        match Cli::parse_from(["dirsql", "server", "--cors-origin", "http://localhost:3202"])
+            .command
+        {
+            Some(Command::Server(args)) => assert_eq!(
+                args.cors_origin,
+                Some(HeaderValue::from_static("http://localhost:3202"))
+            ),
+            other => panic!("expected a server subcommand, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn server_subcommand_rejects_a_cors_origin_that_is_not_a_header_value() {
+        assert!(Cli::try_parse_from(["dirsql", "server", "--cors-origin", "a\nb"]).is_err());
+    }
+
     #[test]
     fn server_subcommand_defaults_host_and_port() {
         match Cli::parse_from(["dirsql", "server"]).command {
             Some(Command::Server(args)) => {
                 assert_eq!(args.host, "localhost");
                 assert_eq!(args.port, 7117);
+                assert_eq!(args.cors_origin, None);
             }
             other => panic!("expected a server subcommand, got {other:?}"),
         }

{dirsql-0.4.85 → dirsql-0.4.86}/packages/rust/src/cli/server.rs

@@ -2,9 +2,11 @@
 
 use std::sync::Arc;
 
+use axum::http::{Method, header};
 use futures::stream::StreamExt;
 use tokio::net::TcpListener;
 use tokio::sync::{broadcast, oneshot, watch};
+use tower_http::cors::CorsLayer;
 
 use super::router::{AppContext, router};
 use super::serialize::event_to_json;
@@ -51,7 +53,15 @@ pub async fn serve_with_state(
         cancel: cancel_rx,
         query_timeout: config.query_timeout,
     });
-    let app = router(shared);
+    let mut app = router(shared);
+    if let Some(origin) = config.cors_origin {
+        app = app.layer(
+            CorsLayer::new()
+                .allow_origin(origin)
+                .allow_methods([Method::GET, Method::POST])
+                .allow_headers([header::CONTENT_TYPE]),
+        );
+    }
 
     let (shutdown_tx, shutdown_rx) = oneshot::channel::<()>();
     let task = tokio::spawn(async move {

{dirsql-0.4.85 → dirsql-0.4.86}/packages/rust/src/lib.rs

@@ -66,7 +66,7 @@ use crate::persist::{
 };
 use crate::progress::Progress;
 use crate::scanner::scan_directory_reporting;
-use crate::watcher::{FileEvent, Watcher};
+use crate::watcher::{FileEvent, WatchScope, Watcher};
 use futures_channel::mpsc::{UnboundedReceiver, UnboundedSender, unbounded};
 use std::collections::HashMap;
 use std::error::Error as StdError;
@@ -445,20 +445,20 @@ struct DirSqlInner {
     fs: Arc<dyn FileSystem>,
 }
 
-fn watch_roots(index_root: &Path, groups: &[AnchorGroup]) -> Vec<PathBuf> {
+fn watch_scopes(index_root: &Path, groups: &[AnchorGroup]) -> Vec<WatchScope> {
     if groups.is_empty() {
-        return vec![index_root.to_path_buf()];
+        return vec![WatchScope {
+            root: index_root.to_path_buf(),
+            ignore: TableMatcher::new(&[], &[]).expect("no patterns to compile"),
+        }];
     }
-    let mut roots: Vec<PathBuf> = Vec::new();
-    for group in groups {
-        let anchor = &group.watch_anchor;
-        if roots.iter().any(|kept| anchor.starts_with(kept)) {
-            continue;
-        }
-        roots.retain(|kept| !kept.starts_with(anchor));
-        roots.push(anchor.clone());
-    }
-    roots
+    groups
+        .iter()
+        .map(|group| WatchScope {
+            root: group.watch_anchor.clone(),
+            ignore: group.matcher.clone(),
+        })
+        .collect()
 }
 
 /// The tables sharing one anchor, matched against paths relative to it.
@@ -597,17 +597,17 @@ impl DirSQL {
         if guard.is_none() {
             // Watch the canonicalized anchors, never the (possibly relative)
             // user-supplied ones — `notify` misbehaves on relative paths.
-            let watcher = Watcher::over(&self.watch_roots()).map_err(DirSqlError::watch)?;
+            let watcher = Watcher::scoped(self.watch_scopes()).map_err(DirSqlError::watch)?;
             *guard = Some(watcher);
         }
         Ok(())
     }
 
-    /// The directories the live watcher must cover: each table anchor, minus
-    /// any already inside another's recursive watch. A build with no tables
-    /// still watches the index root.
-    fn watch_roots(&self) -> Vec<PathBuf> {
-        watch_roots(&self.inner.watch_root, &self.inner.groups)
+    /// The trees the live watcher must cover: each table anchor, under the
+    /// skip rules its tables' scan applies. A build with no tables still
+    /// watches the index root.
+    fn watch_scopes(&self) -> Vec<WatchScope> {
+        watch_scopes(&self.inner.watch_root, &self.inner.groups)
     }
 
     /// Poll-based watch API. Blocks up to `timeout` waiting for the next
@@ -5558,14 +5558,19 @@ mod internal_tests {
         assert_eq!(hits[0].1, PathBuf::from("/elsewhere/x.txt"));
     }
 
-    fn roots_for(anchors: &[&str]) -> Vec<PathBuf> {
+    fn scopes_for(anchors: &[&str], ignore: &[&str]) -> Vec<WatchScope> {
         let tables: Vec<Table> = anchors
             .iter()
             .enumerate()
             .map(|(i, anchor)| anchored_table(&format!("t{i}"), "*.txt", anchor))
             .collect();
-        let (groups, _, _) = compile_groups(&tables, &[], Path::new("/idx")).unwrap();
-        watch_roots(Path::new("/canonical-idx"), &groups)
+        let ignore: Vec<String> = ignore.iter().map(|p| p.to_string()).collect();
+        let (groups, _, _) = compile_groups(&tables, &ignore, Path::new("/idx")).unwrap();
+        watch_scopes(Path::new("/canonical-idx"), &groups)
+    }
+
+    fn roots(scopes: &[WatchScope]) -> Vec<PathBuf> {
+        scopes.iter().map(|scope| scope.root.clone()).collect()
     }
 
     #[test]
@@ -5573,36 +5578,27 @@ mod internal_tests {
         let dir = TempDir::new().unwrap();
         let db = populated_db(dir.path(), "**/*.txt", &["a.txt"]);
 
-        assert_eq!(db.watch_roots(), vec![db.inner.watch_root.clone()]);
-        assert!(!db.watch_roots().is_empty());
-    }
-
-    #[test]
-    fn watch_roots_without_tables_is_the_index_root() {
-        assert_eq!(roots_for(&[]), vec![PathBuf::from("/canonical-idx")]);
+        assert_eq!(roots(&db.watch_scopes()), vec![db.inner.watch_root.clone()]);
     }
 
     #[test]
-    fn watch_roots_lists_each_distinct_anchor() {
-        assert_eq!(
-            roots_for(&["/one", "/two"]),
-            vec![PathBuf::from("/one"), PathBuf::from("/two")]
-        );
+    fn watch_scopes_without_tables_is_the_whole_index_root() {
+        let scopes = scopes_for(&[], &[]);
+        assert_eq!(roots(&scopes), vec![PathBuf::from("/canonical-idx")]);
+        assert!(!scopes[0].ignore.is_ignored_dir(Path::new("node_modules")));
     }
 
     #[test]
-    fn watch_roots_drops_an_anchor_inside_an_earlier_one() {
+    fn watch_scopes_lists_each_anchor_under_its_skip_rules() {
+        let scopes = scopes_for(&["/one", "/one/deep"], &["node_modules/**"]);
         assert_eq!(
-            roots_for(&["/one", "/one/deep"]),
-            vec![PathBuf::from("/one")]
+            roots(&scopes),
+            vec![PathBuf::from("/one"), PathBuf::from("/one/deep")]
         );
-    }
-
-    #[test]
-    fn watch_roots_replaces_an_anchor_with_the_enclosing_later_one() {
-        assert_eq!(
-            roots_for(&["/one/deep", "/one"]),
-            vec![PathBuf::from("/one")]
+        assert!(
+            scopes
+                .iter()
+                .all(|scope| scope.ignore.is_ignored_dir(Path::new("node_modules")))
         );
     }
 }

{dirsql-0.4.85 → dirsql-0.4.86}/packages/rust/src/matcher.rs

@@ -16,7 +16,7 @@ pub enum GlobError {
 /// does in a UTF-8 locale. globset parses the pattern, but its regex is
 /// byte-oriented, so it is recompiled in Unicode mode over the `/`-separated
 /// path text.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub(crate) struct Pattern(Regex);
 
 impl Pattern {
@@ -81,6 +81,7 @@ pub struct MatchResult {
 
 /// A compiled glob pattern. `{name}` placeholders are rewritten to `*` before
 /// compilation, so they are pure match wildcards.
+#[derive(Clone)]
 struct PatternEntry {
     pattern: PathGlob,
     table_name: String,
@@ -91,6 +92,7 @@ struct PatternEntry {
 /// `MatchResult`s (one per table), so a file can belong to multiple tables.
 /// An ignore list filters paths entirely. `{name}` placeholders in glob
 /// patterns are accepted and behave like `*`.
+#[derive(Clone)]
 pub struct TableMatcher {
     entries: Vec<PatternEntry>,
     ignore_set: Vec<Pattern>,