dirsql 0.4.120__tar.gz → 0.4.122__tar.gz

{dirsql-0.4.120 → dirsql-0.4.122}/Cargo.lock

@@ -573,7 +573,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql"
-version = "0.4.120"
+version = "0.4.122"
 dependencies = [
  "assert_cmd",
  "axum",
@@ -625,7 +625,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.4.120"
+version = "0.4.122"
 dependencies = [
  "dirsql",
  "pyo3",

{dirsql-0.4.120 → dirsql-0.4.122}/PKG-INFO

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

{dirsql-0.4.120 → dirsql-0.4.122}/dirsql/_async.py

@@ -1,6 +1,7 @@
 """Async-by-default DirSQL wrapper."""
 
 import asyncio
+import contextlib
 import os
 import weakref
 
@@ -129,11 +130,20 @@ class DirSQL:
         """Run the scan in the background."""
         try:
             self._db = await asyncio.to_thread(self._build_db)
+            if self._watch_streams:
+                await asyncio.to_thread(self._start_watcher_quietly, self._db)
         except Exception as exc:
             self._init_error = exc
         finally:
             self._ready_event.set()
 
+    @staticmethod
+    def _start_watcher_quietly(db):
+        # A watcher that cannot start is the stream's error, not init's: the
+        # stream's first iteration retries the start and raises it there.
+        with contextlib.suppress(Exception):
+            db._start_watcher()
+
     def _build_db(self):
         """Resolve extensions and construct the Rust-backed instance.
 
@@ -229,14 +239,22 @@ class DirSQL:
     def watch(self):
         """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``.
+        The watcher is live once both ``watch()`` and :meth:`ready` have
+        returned, in either order: a file written after that point produces
+        an event and reaches the index. Called after the scan, ``watch()``
+        starts the watcher before returning; called before it, the watcher
+        starts before :meth:`ready` resolves. Writes made while the scan is
+        still running may be missed.
+
+        The returned stream awaits :meth:`ready` on its first iteration, so
+        iterating before an explicit ``await db.ready()`` waits for the
+        background scan and surfaces any initialization error.
 
         Each call returns an independent stream, and every stream receives
         every event observed after it was created, so several consumers
         (one per client, say) can share one instance.
         """
-        return _WatchStream(self)
+        stream = _WatchStream(self)
+        if self._db is not None:
+            self._db._start_watcher()
+        return stream

{dirsql-0.4.120/packages/rust → dirsql-0.4.122}/docs/reference/config.md

@@ -374,9 +374,12 @@ foreign key violation: `task` row from `projects/beta/tasks/t1.json` has project
   batch that touches the same table carries the orphaning change and waits
   too.
 
-`ON DELETE` and `ON UPDATE` actions are not deferred. `dirsql` applies a changed
-file as a delete and an insert, so `ON DELETE CASCADE` deletes the children of a
-parent whose file is edited or renamed, even though their files still exist.
+`ON DELETE` and `ON UPDATE` actions are not deferred. A parent table with a
+`PRIMARY KEY`, or a `UNIQUE` column its rows fill, has an edited row `UPDATE`d
+in place, so its children stay. A table without one has a changed row deleted
+and inserted, so `ON DELETE CASCADE` deletes the children of a parent whose
+file is edited. A row whose key changes, as when the key is taken from a
+renamed file's name, is a delete and an insert either way.
 
 ### `on-file` row mapping
 

{dirsql-0.4.120 → dirsql-0.4.122}/docs/reference/sdk.md

@@ -297,9 +297,14 @@ while let Some(event) = stream.next().await { ... }
 :::
 
 Returns a stream of [`RowEvent`](#rowevent)s reflecting filesystem changes
-under the root. The watcher starts on first iteration (Python/TypeScript)
-or at the `watch()` call (Rust). The stream never terminates on its own;
-stop consuming it to stop.
+under the root. The stream never terminates on its own; stop consuming it
+to stop.
+
+A file written once the watcher is live produces an event and reaches the
+index. Rust: the watcher is live when `watch()` returns. Python: it is live
+once both `watch()` and `ready()` have returned, in either order; a write made
+while the initial scan is still running may be missed. TypeScript: the watcher
+starts on first iteration.
 
 An instance with no named tables cannot be watched: path-tables emit no
 watch events, so `watch()` (and the polling primitives) raise an error naming

{dirsql-0.4.120 → dirsql-0.4.122}/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.120"
+version = "0.4.122"
 # 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.122/packages/python/changelog.d/2026-11-02-watch-dirs-created-mid-registration.md

@@ -0,0 +1 @@
+**Fixed** On Linux, a directory created inside a new directory before the watcher registered that new directory is now watched too. Before, files written into it later produced no events.

dirsql-0.4.122/packages/python/changelog.d/2026-11-02-watch-live-on-return.md

@@ -0,0 +1 @@
+**Fixed** `watch()` now starts the watcher before it returns (or, when called before the initial scan finishes, before `ready()` resolves). A file written right after `watch()` previously produced no event and never reached the index, because the watcher only started on the stream's first iteration.

{dirsql-0.4.120 → dirsql-0.4.122/packages/python}/docs/reference/config.md

@@ -374,9 +374,12 @@ foreign key violation: `task` row from `projects/beta/tasks/t1.json` has project
   batch that touches the same table carries the orphaning change and waits
   too.
 
-`ON DELETE` and `ON UPDATE` actions are not deferred. `dirsql` applies a changed
-file as a delete and an insert, so `ON DELETE CASCADE` deletes the children of a
-parent whose file is edited or renamed, even though their files still exist.
+`ON DELETE` and `ON UPDATE` actions are not deferred. A parent table with a
+`PRIMARY KEY`, or a `UNIQUE` column its rows fill, has an edited row `UPDATE`d
+in place, so its children stay. A table without one has a changed row deleted
+and inserted, so `ON DELETE CASCADE` deletes the children of a parent whose
+file is edited. A row whose key changes, as when the key is taken from a
+renamed file's name, is a delete and an insert either way.
 
 ### `on-file` row mapping
 

{dirsql-0.4.120/packages/rust → dirsql-0.4.122/packages/python}/docs/reference/sdk.md

@@ -297,9 +297,14 @@ while let Some(event) = stream.next().await { ... }
 :::
 
 Returns a stream of [`RowEvent`](#rowevent)s reflecting filesystem changes
-under the root. The watcher starts on first iteration (Python/TypeScript)
-or at the `watch()` call (Rust). The stream never terminates on its own;
-stop consuming it to stop.
+under the root. The stream never terminates on its own; stop consuming it
+to stop.
+
+A file written once the watcher is live produces an event and reaches the
+index. Rust: the watcher is live when `watch()` returns. Python: it is live
+once both `watch()` and `ready()` have returned, in either order; a write made
+while the initial scan is still running may be missed. TypeScript: the watcher
+starts on first iteration.
 
 An instance with no named tables cannot be watched: path-tables emit no
 watch events, so `watch()` (and the polling primitives) raise an error naming

dirsql-0.4.122/packages/python/e2e-attestations/bot-1461-step3-1020.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/glob_speed_one_level_test.py tests/e2e/glob_speed_recursive_test.py tests/e2e/glob_speed_dotfiles_test.py tests/e2e/glob_speed_gitignore_test.py tests/e2e/glob_speed_node_modules_test.py tests/e2e/query_contract_test.py -x -q",
+  "ran_at": 1792499219,
+  "exit_code": 0,
+  "commit": "f0b743744d6e038ad678de855df59c843e109ad1",
+  "branch": "bot/1461-step3-1020"
+}

dirsql-0.4.122/packages/python/e2e-attestations/bot-1544-perfile-update-1020.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run --no-sync python -m pytest tests/e2e/watch_speed_test.py tests/e2e/on_file_query_test.py tests/e2e/fanout_test.py -q -p no:cacheprovider",
+  "ran_at": 1792496178,
+  "exit_code": 0,
+  "commit": "f4fd6d6b79a97b877a175884e377004b7ff144f2",
+  "branch": "bot/1544-perfile-update-1020"
+}

dirsql-0.4.122/packages/python/e2e-attestations/bot-1552-watch-gap-1102.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/extension_package_test.py tests/e2e/plugin_discovery_test.py tests/e2e/plugin_extension_discovery_test.py tests/e2e/on_file_query_test.py tests/e2e/fanout_test.py tests/e2e/query_contract_test.py -x -q",
+  "ran_at": 1793651115,
+  "exit_code": 0,
+  "commit": "91c319050e0960f87324c774ed7593895947fb35",
+  "branch": "bot/1552-watch-gap-1102"
+}

dirsql-0.4.122/packages/python/e2e-attestations/bot-1557-watch-rename-1102.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/watch_speed_test.py tests/e2e/jsonl_parse_speed_test.py tests/e2e/on_file_query_test.py tests/e2e/fanout_test.py -q",
+  "ran_at": 1793653639,
+  "exit_code": 0,
+  "commit": "90967ba7a324453df04aa604126a0d4c004ea887",
+  "branch": "bot/1557-watch-rename-1102"
+}

dirsql-0.4.122/packages/python/migrations.d/2026-11-02-watch-dirs-created-mid-registration.md

@@ -0,0 +1,29 @@
+### Directories created mid-registration are watched
+
+#### Summary
+
+On Linux, the watcher walks a new directory again after watching it, until a walk finds nothing new, so a subdirectory created in between is watched too. Nothing breaks.
+
+#### Required changes
+
+_None._
+
+#### Deprecations removed
+
+_None._
+
+#### Behavior changes without code changes
+
+Files written into a directory created in a burst of nested `mkdir`s now produce events where some were missed before.
+
+#### Verification
+
+```bash
+dirsql init
+dirsql server -c .dirsql.toml &
+curl -sN http://localhost:7117/events &
+mkdir -p a/b/c/d/e/f/g
+echo '{"id":"1","name":"x"}' > a/b/c/d/e/f/g/r.json
+```
+
+Prints an insert for `a/b/c/d/e/f/g/r.json`.

dirsql-0.4.122/packages/python/migrations.d/2026-11-02-watch-live-on-return.md

@@ -0,0 +1,21 @@
+### `watch()` starts the watcher before it returns
+
+#### Summary
+
+The Python `watch()` now starts the native watcher before it returns; called before the initial scan finishes, it starts the watcher before `ready()` resolves. A file written after both `watch()` and `ready()` have returned produces an event and reaches the index. Nothing breaks.
+
+#### Required changes
+
+_None._
+
+#### Deprecations removed
+
+_None._
+
+#### Behavior changes without code changes
+
+On an instance with no named tables, `watch()` called after `ready()` raises immediately instead of on the stream's first iteration. A sleep between `watch()` and the first write is no longer needed.
+
+#### Verification
+
+`await db.ready(); stream = db.watch()`, write a matching file, then `await anext(stream)`: expect an `insert` event, and `await db.query(...)` returns the row.

{dirsql-0.4.120 → dirsql-0.4.122}/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.120"
+version = "0.4.122"
 edition.workspace = true
 # Literal `license` (not `license.workspace = true`) because
 # putitoutthere's preflight check reads `[package].license` directly

{dirsql-0.4.120/packages/python → dirsql-0.4.122/packages/rust}/docs/reference/config.md

@@ -374,9 +374,12 @@ foreign key violation: `task` row from `projects/beta/tasks/t1.json` has project
   batch that touches the same table carries the orphaning change and waits
   too.
 
-`ON DELETE` and `ON UPDATE` actions are not deferred. `dirsql` applies a changed
-file as a delete and an insert, so `ON DELETE CASCADE` deletes the children of a
-parent whose file is edited or renamed, even though their files still exist.
+`ON DELETE` and `ON UPDATE` actions are not deferred. A parent table with a
+`PRIMARY KEY`, or a `UNIQUE` column its rows fill, has an edited row `UPDATE`d
+in place, so its children stay. A table without one has a changed row deleted
+and inserted, so `ON DELETE CASCADE` deletes the children of a parent whose
+file is edited. A row whose key changes, as when the key is taken from a
+renamed file's name, is a delete and an insert either way.
 
 ### `on-file` row mapping
 

{dirsql-0.4.120/packages/python → dirsql-0.4.122/packages/rust}/docs/reference/sdk.md

@@ -297,9 +297,14 @@ while let Some(event) = stream.next().await { ... }
 :::
 
 Returns a stream of [`RowEvent`](#rowevent)s reflecting filesystem changes
-under the root. The watcher starts on first iteration (Python/TypeScript)
-or at the `watch()` call (Rust). The stream never terminates on its own;
-stop consuming it to stop.
+under the root. The stream never terminates on its own; stop consuming it
+to stop.
+
+A file written once the watcher is live produces an event and reaches the
+index. Rust: the watcher is live when `watch()` returns. Python: it is live
+once both `watch()` and `ready()` have returned, in either order; a write made
+while the initial scan is still running may be missed. TypeScript: the watcher
+starts on first iteration.
 
 An instance with no named tables cannot be watched: path-tables emit no
 watch events, so `watch()` (and the polling primitives) raise an error naming