storepy 4.2.1__tar.gz → 4.4.2__tar.gz

{storepy-4.2.1/src/storepy.egg-info → storepy-4.4.2}/PKG-INFO

@@ -1,14 +1,14 @@
 Metadata-Version: 2.4
 Name: storepy
-Version: 4.2.1
-Summary: Multi-backend data layer for Python asyncio (MongoDB, MySQL, SQLite, PostgreSQL): pure JSON schemas, GQL tree queries compiled to a single native query, GROUP BY/HAVING aggregation, computed columns, soft-delete and role-based access control
+Version: 4.4.2
+Summary: Multi-backend data layer for Python asyncio (MongoDB, MySQL, SQLite, PostgreSQL, local disk): pure JSON schemas, GQL tree queries compiled to a single native query, GROUP BY/HAVING aggregation, computed columns, soft-delete and role-based access control
 Author-email: leo <coen_ddt@qq.com>
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/coenddt/py-store
 Project-URL: Documentation, https://coenddt.github.io/py-store/
 Project-URL: Repository, https://github.com/coenddt/py-store
 Project-URL: Issues, https://github.com/coenddt/py-store/issues
-Keywords: mongodb,mysql,sqlite,postgresql,postgres,asyncio,async,data-layer,query-builder,odm,orm-alternative,sqlalchemy-alternative,motor-alternative,beanie-alternative,gql,json-schema,pymongo,multi-database,cross-database,multi-tenant,acl,rbac,access-control,row-level-security,aggregation,group-by,computed-columns,soft-delete,fastapi,ai-agent,llm-tool,query-validation,natural-language-query
+Keywords: mongodb,mysql,sqlite,postgresql,postgres,local-disk,embedded,asyncio,async,data-layer,query-builder,odm,orm-alternative,sqlalchemy-alternative,motor-alternative,beanie-alternative,gql,json-schema,pymongo,multi-database,cross-database,multi-tenant,acl,rbac,access-control,row-level-security,aggregation,group-by,computed-columns,soft-delete,fastapi,ai-agent,llm-tool,query-validation,natural-language-query
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
@@ -42,15 +42,15 @@ Dynamic: license-file
 
 # py-store
 
-**One data layer for MongoDB, MySQL, SQLite and PostgreSQL in Python asyncio — define models as pure JSON, query them with a MongoDB-style GQL tree syntax, and get role-based access control, computed columns and soft-delete out of the box.**
+**One data layer for MongoDB, MySQL, SQLite, PostgreSQL and local disk in Python asyncio — define models as pure JSON, query them with a MongoDB-style GQL tree syntax, and get role-based access control, computed columns and soft-delete out of the box.**
 
 ![PyPI version](https://img.shields.io/pypi/v/storepy)
 ![license](https://img.shields.io/pypi/l/storepy)
 ![python versions](https://img.shields.io/pypi/pyversions/storepy)
-![backends](https://img.shields.io/badge/backends-MongoDB%20%7C%20MySQL%20%7C%20SQLite%20%7C%20PostgreSQL-blue)
+![backends](https://img.shields.io/badge/backends-MongoDB%20%7C%20MySQL%20%7C%20SQLite%20%7C%20PostgreSQL%20%7C%20Local-blue)
 ![query dialect](https://img.shields.io/badge/query%20dialect-GQL%20(MongoDB--flavoured)-green)
 
-`py-store` lets a Python service talk to MongoDB (native aggregation), MySQL, PostgreSQL and SQLite through a **single schema definition and a single query dialect**. Nested relations compile to **one native query per backend** — you never hand-write `$lookup` or raw SQL.
+`py-store` lets a Python service talk to MongoDB (native aggregation), MySQL, PostgreSQL, SQLite and local disk through a **single schema definition and a single query dialect**. Nested relations compile to **one native query per backend** — you never hand-write `$lookup` or raw SQL.
 
 > Also looking for the Node.js version? See [`nodejs-store`](https://github.com/coenddt/nodejs-store) (npm `nodejs-store`). Both are thin hosts over the shared Rust engine [`rust-store`](https://github.com/coenddt/rust-store).
 > 中文文档见 [README.zh-CN.md](README.zh-CN.md)。
@@ -164,7 +164,7 @@ General positioning, not a benchmark — always verify against each tool's curre
 | | py-store | SQLAlchemy | Beanie / Motor | Tortoise ORM | SQLModel | Django ORM |
 | --- | --- | --- | --- | --- | --- | --- |
 | Primary shape | JSON schema + GQL data layer | SQL toolkit + ORM | Async MongoDB ODM / driver | Async ORM | Pydantic + SQLAlchemy | ORM bundled with Django |
-| Backends | MongoDB, MySQL, SQLite, PostgreSQL | PostgreSQL, MySQL, SQLite, Oracle, MSSQL | MongoDB | PostgreSQL, MySQL, SQLite, Oracle, MSSQL | PostgreSQL, MySQL, SQLite, … | PostgreSQL, MySQL, SQLite, Oracle |
+| Backends | MongoDB, MySQL, SQLite, PostgreSQL, local | PostgreSQL, MySQL, SQLite, Oracle, MSSQL | MongoDB | PostgreSQL, MySQL, SQLite, Oracle, MSSQL | PostgreSQL, MySQL, SQLite, … | PostgreSQL, MySQL, SQLite, Oracle |
 | One query dialect across Mongo **and** SQL | ✅ (MongoDB-flavoured GQL) | ➖ (SQL only) | ➖ (Mongo only) | ➖ (SQL only) | ➖ (SQL only) | ➖ (SQL only) |
 | Nested relation reads in one query | ✅ declarative relations → `$lookup` / `JOIN` | ⚠️ manual `selectinload`/joins | ✅ `Link`/`fetch_links` | ✅ `prefetch_related` | ⚠️ via SQLAlchemy | ✅ `prefetch_related` |
 | Built-in role / field-level RBAC + owner injection | ✅ | ➖ | ➖ | ➖ | ➖ | ➖ (permissions are app-level) |
@@ -194,7 +194,7 @@ pip install storepy
 > The distribution name is `storepy`; the import package is `py_store`:
 > `from py_store import init, store`.
 
-Requires Python 3.10+ and one supported backend (MongoDB / MySQL / SQLite / PostgreSQL).
+Requires Python 3.10+ and one supported backend (MongoDB / MySQL / SQLite / PostgreSQL / local disk).
 
 Optional driver extras:
 
@@ -255,21 +255,38 @@ items = await store.query("Post($condition:@c0) { title, status }", {"c0": {"sta
 | MySQL | parameterized SQL, `information_schema` introspection (`asyncmy`) |
 | SQLite | parameterized SQL, `sqlite_master` + `PRAGMA` introspection (`aiosqlite`) |
 | PostgreSQL | parameterized SQL (`$n`), `RETURNING` support (`asyncpg`) |
+| local (local disk) | collections persisted as JSON files, evaluated directly by the core's local evaluator (no SQL, no driver); see [Local disk data source (local)](#local-disk-data-source-local) |
 
-GQL tree queries compile to a single native query per backend — never hand-write `$lookup` or raw SQL again.
+GQL tree queries compile to a single native query per backend (except the local source — commands are evaluated directly by the core's local evaluator) — never hand-write `$lookup` or raw SQL again.
+
+### Local disk data source (local)
+
+Zero external services, zero native DB engine: collections are persisted as JSON files and commands are evaluated directly inside the Rust core's local evaluator (semantics match the MongoDB driver).
+
+```python
+from py_store import init, local
+
+await init({'default': local.connect({'dir': './data/store'})})
+```
+
+- **Usage**: `local.connect({'dir': …})` returns a connection descriptor (`kind: 'local'`); pass it to `await init()` like any Mongo/SQL connection.
+- **On-disk format**: `<dir>/<physical collection>.json` (an array of documents); writes go through a `.tmp` temp file and an atomic `rename`.
+- **Transactions**: snapshot isolation — during a transaction reads/writes hit an in-memory snapshot; `commit()` persists the whole directory, `rollback()` discards it. Atomic by construction.
+- **Guardrails**: hard cap of 100,000 documents per collection (explicit error, never silent truncation); no indexes (sequential scan only) — declaring `schema.indexes` emits a `local_indexes_ignored` feedback event.
+- **Concurrency limit**: single process only — in-process writes are serialized by a directory lock; cross-process concurrency is outside the v1 guarantee.
 
 ## Features
 
 - **Pure JSON schemas, zero code** — a model is just a dict: fields, relations, computes, indexes.
 - **GQL tree queries → one native query** — nested relations resolve in a single query; never hand-write `$lookup` again.
-- **Normalized aggregation** — root-level `$group` / `$having` and relation aggregate predicates (semi/anti-join) in the same GQL, pushed down to all four backends.
+- **Normalized aggregation** — root-level `$group` / `$having` and relation aggregate predicates (semi/anti-join) in the same GQL, pushed down to all five backends.
 - **Read-time defaults & computed columns** — writes store only user data; reads fill defaults and run `fn` / `asyncFn` / relation-`agg` computes.
 - **Smart mutation** — `mutation()` auto-detects upsert by `_id` + unique index and recursively fills relation children.
 - **Soft-delete built in** — every schema auto-registers a `<Model>Deleted` archive collection/table; `remove()` archives before deleting.
 - **Permission context** — `ContextVar`-based roles (`super_admin`/`admin`/`guest`/`creator`...), schema/field-level read/write whitelists, automatic owner-condition injection.
 - **Multi-datasource & multi-tenant** — locate a schema by `(source, database, schema, collection)`; re-target per request with a route override.
 - **Async-first, Rust core** — built on PyMongo's `AsyncMongoClient` and a shared Rust core with SQL dialects.
-- **Relation predicates in mutations** — filter `update` / `remove` by related-table fields, pushed down to all four backends (previously a silent no-op on MongoDB).
+- **Relation predicates in mutations** — filter `update` / `remove` by related-table fields, pushed down to all five backends (previously a silent no-op on MongoDB).
 - **Autoincrement primary keys** — declare `_id` as `{"type": "int", "strategy": "autoincrement"}` for database-assigned integer IDs, with explicit errors where autoincrement is impossible.
 - **Index DDL** — `schema.indexes` compiles to real `CREATE [UNIQUE] INDEX` statements (per backend, byte-identical); the generator still only emits text.
 

{storepy-4.2.1 → storepy-4.4.2}/README.md

@@ -1,14 +1,14 @@
 # py-store
 
-**One data layer for MongoDB, MySQL, SQLite and PostgreSQL in Python asyncio — define models as pure JSON, query them with a MongoDB-style GQL tree syntax, and get role-based access control, computed columns and soft-delete out of the box.**
+**One data layer for MongoDB, MySQL, SQLite, PostgreSQL and local disk in Python asyncio — define models as pure JSON, query them with a MongoDB-style GQL tree syntax, and get role-based access control, computed columns and soft-delete out of the box.**
 
 ![PyPI version](https://img.shields.io/pypi/v/storepy)
 ![license](https://img.shields.io/pypi/l/storepy)
 ![python versions](https://img.shields.io/pypi/pyversions/storepy)
-![backends](https://img.shields.io/badge/backends-MongoDB%20%7C%20MySQL%20%7C%20SQLite%20%7C%20PostgreSQL-blue)
+![backends](https://img.shields.io/badge/backends-MongoDB%20%7C%20MySQL%20%7C%20SQLite%20%7C%20PostgreSQL%20%7C%20Local-blue)
 ![query dialect](https://img.shields.io/badge/query%20dialect-GQL%20(MongoDB--flavoured)-green)
 
-`py-store` lets a Python service talk to MongoDB (native aggregation), MySQL, PostgreSQL and SQLite through a **single schema definition and a single query dialect**. Nested relations compile to **one native query per backend** — you never hand-write `$lookup` or raw SQL.
+`py-store` lets a Python service talk to MongoDB (native aggregation), MySQL, PostgreSQL, SQLite and local disk through a **single schema definition and a single query dialect**. Nested relations compile to **one native query per backend** — you never hand-write `$lookup` or raw SQL.
 
 > Also looking for the Node.js version? See [`nodejs-store`](https://github.com/coenddt/nodejs-store) (npm `nodejs-store`). Both are thin hosts over the shared Rust engine [`rust-store`](https://github.com/coenddt/rust-store).
 > 中文文档见 [README.zh-CN.md](README.zh-CN.md)。
@@ -122,7 +122,7 @@ General positioning, not a benchmark — always verify against each tool's curre
 | | py-store | SQLAlchemy | Beanie / Motor | Tortoise ORM | SQLModel | Django ORM |
 | --- | --- | --- | --- | --- | --- | --- |
 | Primary shape | JSON schema + GQL data layer | SQL toolkit + ORM | Async MongoDB ODM / driver | Async ORM | Pydantic + SQLAlchemy | ORM bundled with Django |
-| Backends | MongoDB, MySQL, SQLite, PostgreSQL | PostgreSQL, MySQL, SQLite, Oracle, MSSQL | MongoDB | PostgreSQL, MySQL, SQLite, Oracle, MSSQL | PostgreSQL, MySQL, SQLite, … | PostgreSQL, MySQL, SQLite, Oracle |
+| Backends | MongoDB, MySQL, SQLite, PostgreSQL, local | PostgreSQL, MySQL, SQLite, Oracle, MSSQL | MongoDB | PostgreSQL, MySQL, SQLite, Oracle, MSSQL | PostgreSQL, MySQL, SQLite, … | PostgreSQL, MySQL, SQLite, Oracle |
 | One query dialect across Mongo **and** SQL | ✅ (MongoDB-flavoured GQL) | ➖ (SQL only) | ➖ (Mongo only) | ➖ (SQL only) | ➖ (SQL only) | ➖ (SQL only) |
 | Nested relation reads in one query | ✅ declarative relations → `$lookup` / `JOIN` | ⚠️ manual `selectinload`/joins | ✅ `Link`/`fetch_links` | ✅ `prefetch_related` | ⚠️ via SQLAlchemy | ✅ `prefetch_related` |
 | Built-in role / field-level RBAC + owner injection | ✅ | ➖ | ➖ | ➖ | ➖ | ➖ (permissions are app-level) |
@@ -152,7 +152,7 @@ pip install storepy
 > The distribution name is `storepy`; the import package is `py_store`:
 > `from py_store import init, store`.
 
-Requires Python 3.10+ and one supported backend (MongoDB / MySQL / SQLite / PostgreSQL).
+Requires Python 3.10+ and one supported backend (MongoDB / MySQL / SQLite / PostgreSQL / local disk).
 
 Optional driver extras:
 
@@ -213,21 +213,38 @@ items = await store.query("Post($condition:@c0) { title, status }", {"c0": {"sta
 | MySQL | parameterized SQL, `information_schema` introspection (`asyncmy`) |
 | SQLite | parameterized SQL, `sqlite_master` + `PRAGMA` introspection (`aiosqlite`) |
 | PostgreSQL | parameterized SQL (`$n`), `RETURNING` support (`asyncpg`) |
+| local (local disk) | collections persisted as JSON files, evaluated directly by the core's local evaluator (no SQL, no driver); see [Local disk data source (local)](#local-disk-data-source-local) |
 
-GQL tree queries compile to a single native query per backend — never hand-write `$lookup` or raw SQL again.
+GQL tree queries compile to a single native query per backend (except the local source — commands are evaluated directly by the core's local evaluator) — never hand-write `$lookup` or raw SQL again.
+
+### Local disk data source (local)
+
+Zero external services, zero native DB engine: collections are persisted as JSON files and commands are evaluated directly inside the Rust core's local evaluator (semantics match the MongoDB driver).
+
+```python
+from py_store import init, local
+
+await init({'default': local.connect({'dir': './data/store'})})
+```
+
+- **Usage**: `local.connect({'dir': …})` returns a connection descriptor (`kind: 'local'`); pass it to `await init()` like any Mongo/SQL connection.
+- **On-disk format**: `<dir>/<physical collection>.json` (an array of documents); writes go through a `.tmp` temp file and an atomic `rename`.
+- **Transactions**: snapshot isolation — during a transaction reads/writes hit an in-memory snapshot; `commit()` persists the whole directory, `rollback()` discards it. Atomic by construction.
+- **Guardrails**: hard cap of 100,000 documents per collection (explicit error, never silent truncation); no indexes (sequential scan only) — declaring `schema.indexes` emits a `local_indexes_ignored` feedback event.
+- **Concurrency limit**: single process only — in-process writes are serialized by a directory lock; cross-process concurrency is outside the v1 guarantee.
 
 ## Features
 
 - **Pure JSON schemas, zero code** — a model is just a dict: fields, relations, computes, indexes.
 - **GQL tree queries → one native query** — nested relations resolve in a single query; never hand-write `$lookup` again.
-- **Normalized aggregation** — root-level `$group` / `$having` and relation aggregate predicates (semi/anti-join) in the same GQL, pushed down to all four backends.
+- **Normalized aggregation** — root-level `$group` / `$having` and relation aggregate predicates (semi/anti-join) in the same GQL, pushed down to all five backends.
 - **Read-time defaults & computed columns** — writes store only user data; reads fill defaults and run `fn` / `asyncFn` / relation-`agg` computes.
 - **Smart mutation** — `mutation()` auto-detects upsert by `_id` + unique index and recursively fills relation children.
 - **Soft-delete built in** — every schema auto-registers a `<Model>Deleted` archive collection/table; `remove()` archives before deleting.
 - **Permission context** — `ContextVar`-based roles (`super_admin`/`admin`/`guest`/`creator`...), schema/field-level read/write whitelists, automatic owner-condition injection.
 - **Multi-datasource & multi-tenant** — locate a schema by `(source, database, schema, collection)`; re-target per request with a route override.
 - **Async-first, Rust core** — built on PyMongo's `AsyncMongoClient` and a shared Rust core with SQL dialects.
-- **Relation predicates in mutations** — filter `update` / `remove` by related-table fields, pushed down to all four backends (previously a silent no-op on MongoDB).
+- **Relation predicates in mutations** — filter `update` / `remove` by related-table fields, pushed down to all five backends (previously a silent no-op on MongoDB).
 - **Autoincrement primary keys** — declare `_id` as `{"type": "int", "strategy": "autoincrement"}` for database-assigned integer IDs, with explicit errors where autoincrement is impossible.
 - **Index DDL** — `schema.indexes` compiles to real `CREATE [UNIQUE] INDEX` statements (per backend, byte-identical); the generator still only emits text.
 

{storepy-4.2.1 → storepy-4.4.2}/pyproject.toml

@@ -4,14 +4,15 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "storepy"
-version = "4.2.1"
-description = "Multi-backend data layer for Python asyncio (MongoDB, MySQL, SQLite, PostgreSQL): pure JSON schemas, GQL tree queries compiled to a single native query, GROUP BY/HAVING aggregation, computed columns, soft-delete and role-based access control"
+version = "4.4.2"
+description = "Multi-backend data layer for Python asyncio (MongoDB, MySQL, SQLite, PostgreSQL, local disk): pure JSON schemas, GQL tree queries compiled to a single native query, GROUP BY/HAVING aggregation, computed columns, soft-delete and role-based access control"
 readme = "README.md"
 requires-python = ">=3.10"
 license = "MIT"
 license-files = ["LICENSE"]
 keywords = [
   "mongodb", "mysql", "sqlite", "postgresql", "postgres",
+  "local-disk", "embedded",
   "asyncio", "async", "data-layer", "query-builder", "odm",
   "orm-alternative", "sqlalchemy-alternative", "motor-alternative", "beanie-alternative",
   "gql", "json-schema", "pymongo",

{storepy-4.2.1 → storepy-4.4.2}/src/py_store/__init__.py

@@ -36,6 +36,7 @@ from . import (
     permission,
     resource,
     schema,
+    secure,
     workflow,
 )
 from . import (
@@ -47,8 +48,14 @@ from . import (
 from . import (
     load as load,
 )
+from . import (
+    local as local,
+)
 from .ask import AskExhausted as AskExhausted
 from .ask import AskResult as AskResult
+from .crud import triggers as triggers
+from .crud.triggers import assert_trigger_fns_covered as assert_trigger_fns_covered
+from .crud.triggers import set_trigger_fn as set_trigger_fn
 from .datasource import NativeCommandError as NativeCommandError
 from .datasource import NonAtomicWriteError as NonAtomicWriteError
 from .datasource import RawSqlError as RawSqlError
@@ -60,12 +67,14 @@ from .load import load_defs as load_defs
 from .schema import assert_fns_covered as assert_fns_covered
 from .schema import set_fn as set_fn
 from .schema import text2query
+from .scope import current_scope as current_scope
+from .scope import with_scope as with_scope
 from .sync import sync_schema
 
 
 def _build_pipeline(gql, params=None):
     """解析 GQL 并构建 pipeline，返回 `{tokens, ast, pipeline, projection}`"""
-    return schema.core.build_pipeline(
+    return schema.get_core().build_pipeline(
         gql, params if params is not None else {}, permission.get_context())
 
 
@@ -324,9 +333,12 @@ class Store:
     register = staticmethod(schema.register)
     # 运行期目录装载（读 store.config.json → 收集定义 → core 纯规划 → 带定位批量注册）
     load_defs = staticmethod(load.load_defs)
-    # 公开回调注入与启动期缺实现校验（对齐 nodejs-store store.set_fn / store.assert_fns_covered）
+    # 公开回调注入与启动期缺实现校验（对齐 nodejs-store store.set_fn / assert_fns_covered）
     set_fn = staticmethod(schema.set_fn)
     assert_fns_covered = staticmethod(schema.assert_fns_covered)
+    # 触发器回调注入与启动期缺实现校验（对齐 nodejs-store store.setTriggerFn / assertTriggerFnsCovered）
+    set_trigger_fn = staticmethod(triggers.set_trigger_fn)
+    assert_trigger_fns_covered = staticmethod(triggers.assert_trigger_fns_covered)
     has = staticmethod(schema.has)
     get = staticmethod(schema.get)
     # 数据源连接（多后端路由）
@@ -358,6 +370,11 @@ class Store:
     set_unconfigured_policy = staticmethod(permission.set_unconfigured_policy)
     # 定义层门禁策略（判决唯一在 core）：closed 时仅 internal/白名单可注册或覆盖
     set_meta_policy = staticmethod(schema.set_meta_policy)
+    # 统一安全模式（fail-secure 一键入口；见 secure.py）：同时翻转上下文强制 +
+    # 未配白名单全拒 + 定义注册门禁；admin_roles 为允许改定义的角色（默认仅 internal）
+    secure_mode = staticmethod(secure.secure_mode)
+    is_secure = staticmethod(secure.is_secure)
+    relax_mode = staticmethod(secure.relax_mode)
     # 查询档位（判决唯一在 core）：standard 默认放开 / text2query 功能收缩
     # 进入档即等效强制 ctx；未知档由 core 抛 ValueError 上抛（禁静默回落默认档）
     set_profile = staticmethod(schema.set_profile)
@@ -374,6 +391,9 @@ class Store:
 
 store = Store()
 
+# 触发链执行器装配：回调实现经门面（host['store']）消费 CRUD API
+triggers.set_store(store)
+
 # 索引名对齐 MongoDB 自动命名（k1_v1_k2_v2），用于幂等创建
 async def _create_indexes_if_needed():
     """按数据源分派：Mongo 源执行索引创建；SQL 后端**不建索引**（indexes 仅元数据）"""
@@ -385,6 +405,18 @@ async def _create_indexes_if_needed():
         # 其余配置错误（database 形态不匹配等）按 fail-fast 由 db_of_schema 上抛
         if not datasource.has_connection(datasource.source_of_schema(name)):
             continue
+        # local 源 v1 无索引（仅顺序扫描）：声明 indexes 即告警（禁静默忽略），直接跳过建索引
+        if datasource.is_local(datasource.get_connection(datasource.source_of_schema(name))):
+            if s.get('indexes'):
+                feedback.emit({
+                    'type': 'local_indexes_ignored',
+                    'code': 'localIndexesIgnored',
+                    'layer': 'local',
+                    'message': f'schema {name} 声明了 indexes，但 local 数据源 v1 不建索引（仅顺序扫描）',
+                    'hint': 'local 源请勿声明 indexes；需要索引请改用 sqlite/mongo 等后端',
+                    'schema': name,
+                })
+            continue
         db = datasource.db_of_schema(name)  # Mongo 按 (datasource, database) 解析；SQL 源返回 None
         if db is None:
             continue  # SQL 后端不建索引（铁律 6）

{storepy-4.2.1 → storepy-4.4.2}/src/py_store/ask.py

@@ -4,12 +4,12 @@
 
     用户问题 → ① describe_for_ai(ctx) 权限过滤摘要
              → ② LLM（注入式客户端）翻译为 {"gql","params"}
-             → ③ with text2query(): 规划期校验（core 判决：语法/档位/权限/硬限）
+             → ③ text2query 档位视图内规划期校验（core 判决：语法/档位/权限/硬限）
              → ④ crud.query 执行（只读）
              → ⑤ 失败结构化回喂 LLM 重试（≤ max_retries 次），耗尽抛 AskExhausted
 
 护栏面（D5，服务端硬编码，LLM 零可触）：
-  - 档位 = text2query：本模块硬编码 ``with text2query():`` 包裹全部执行；
+  - 档位 = text2query：本模块硬编码以作用域档位视图（with_scope + with_policy）包裹全部执行；
   - 用户上下文 = ctx：服务端注入参数，经 ``permission.scoped_context`` 进执行面，
     绝不进入任何 LLM 消息；core 档位门禁强制无 ctx 即拒（fail-secure，A4）；
   - route_override = None：硬编码（CWE-639；Host 兜底 ``_guard_route_override`` 双保险）；
@@ -21,8 +21,10 @@ LLM 输出永远当不可信输入：唯一产出形状 ``{"gql","params"}`` 单
 不可能变成不受控命令。一切失败结构化显式暴露（no-error-masking：是错就是错，
 禁降级、禁返回空结果——「问数失败」就是失败，交上层裁决，D4）。
 
-并发限制（如实声明）：``text2query`` 档位（core 单例）与反馈 sink 为进程级全局，
-同一进程内并发调用 ``ask()`` 会互相串扰，宿主需串行化（或每任务独享进程/事件循环）。
+并发隔离（R2）：``text2query`` 档位与反馈 sink 不再全局切换，改由 ``with_scope`` 承载
+「一请求一档位视图 / 一 sink」（派生视图见 rust-store 02，作用域形态见 03 §4.4）；
+同一进程内并发调用 ``ask()`` 各自独立、互不串扰——「宿主须串行化 / 每任务独享进程」
+的要求随之解除（fail-open 姿态与 core 判决语义均不变）。
 """
 
 from __future__ import annotations
@@ -32,9 +34,8 @@ import json
 from dataclasses import dataclass, field
 
 from . import crud, feedback, permission, schema
-from .core import core
 from .llm import get_llm as _get_llm
-from .schema import text2query
+from .scope import with_scope
 
 __all__ = ['AskExhausted', 'AskResult', 'ask', 'describe_for_ai']
 
@@ -128,16 +129,16 @@ def describe_for_ai(ctx=None) -> list[dict]:
         if ctx is None:
             summaries.append({'name': name, 'fields': sorted(mirror['fields'])})
             continue
-        if not core.can_read(name, ctx):
+        if not permission.can_read_schema(name, ctx):
             continue
-        readable = set(core.readable_fields(name, ctx))
+        readable = set(permission.get_readable_fields(name, ctx))
         fields = {fname: _field_type(fdef)
                   for fname, fdef in mirror['fields'].items() if fname in readable}
         for fname in sorted(readable - set(mirror['fields'])):
             # core 自动补的时间戳字段（createdAt/updatedAt）不在 Host 镜像——类型显式留白
             fields[fname] = None
         relations = {}
-        readable_rels = set(core.readable_relations(name, ctx))
+        readable_rels = set(permission.get_readable_relations(name, ctx))
         for rname, rdef in mirror['relations'].items():
             if rname in readable_rels:
                 relations[rname] = {'model': rdef.get('model'), 'type': rdef.get('type')}
@@ -239,6 +240,45 @@ def _error_from_exception(e, round_events):
     return {'code': 'planError', 'message': str(e)}
 
 
+async def _ask_body(*, client, messages, attempts, events, round_events, max_retries):
+    """ask 执行主体（作用域内运行：档位视图 / 反馈 sink / 用户 ctx 均已就位）。
+
+    R2 起本函数（及整个执行面）**不得**出现 ``set_profile`` / ``set_sink`` / ``set_meta``
+    全局切换——档位与 sink 由 ``with_scope`` 承载（03 §4.4，grep 核销为零）。
+    """
+    for _ in range(1 + max_retries):
+        round_events.clear()
+        # LLM 客户端异常（llmNetworkError/llmHttpError/llmEmptyContent）原样穿透
+        raw = await client(messages)
+        attempt = {'llm_raw': raw}
+        try:
+            gql, params = _parse_llm_output(raw)
+        except _BadLlmOutput as e:
+            attempt['error'] = e.detail
+            attempts.append(attempt)
+            messages.append({'role': 'assistant', 'content': raw})
+            messages.append({'role': 'user', 'content': json.dumps(
+                {'error': e.detail}, ensure_ascii=False)})
+            continue
+        attempt['gql'] = gql
+        attempt['params'] = params
+        try:
+            # route_override 硬编码 None（受信参数，禁 AI 侧指定，D5/CWE-639）
+            data = await crud.query(gql, params, None)
+        except Exception as e:
+            attempt['error'] = _error_from_exception(e, round_events)
+            attempts.append(attempt)
+            messages.append({'role': 'assistant', 'content': raw})
+            messages.append({'role': 'user', 'content': json.dumps(
+                {'error': attempt['error']}, ensure_ascii=False)})
+            continue
+        attempt['rows'] = len(data)
+        attempts.append(attempt)
+        return AskResult(data=data, attempts=attempts, events=events)
+    # 循环走完（重试耗尽）→ None，由入口抛 AskExhausted
+    return None
+
+
 async def ask(question: str, *, llm, ctx: dict, max_retries: int = 3,
               knowledge: str | None = None) -> AskResult:
     """AI 问数唯一入口（L1 只读）：自然语言 → LLM 翻译 → 受控沙箱执行 → 结构化回喂。
@@ -284,39 +324,16 @@ async def ask(question: str, *, llm, ctx: dict, max_retries: int = 3,
         events.append(event)
         round_events.append(event)
 
-    prev_sink = feedback.get_sink()
-    feedback.set_sink(_collect)
-    try:
-        with text2query(), permission.scoped_context(ctx):
-            for _ in range(1 + max_retries):
-                round_events.clear()
-                # LLM 客户端异常（llmNetworkError/llmHttpError/llmEmptyContent）原样穿透
-                raw = await client(messages)
-                attempt = {'llm_raw': raw}
-                try:
-                    gql, params = _parse_llm_output(raw)
-                except _BadLlmOutput as e:
-                    attempt['error'] = e.detail
-                    attempts.append(attempt)
-                    messages.append({'role': 'assistant', 'content': raw})
-                    messages.append({'role': 'user', 'content': json.dumps(
-                        {'error': e.detail}, ensure_ascii=False)})
-                    continue
-                attempt['gql'] = gql
-                attempt['params'] = params
-                try:
-                    # route_override 硬编码 None（受信参数，禁 AI 侧指定，D5/CWE-639）
-                    data = await crud.query(gql, params, None)
-                except Exception as e:
-                    attempt['error'] = _error_from_exception(e, round_events)
-                    attempts.append(attempt)
-                    messages.append({'role': 'assistant', 'content': raw})
-                    messages.append({'role': 'user', 'content': json.dumps(
-                        {'error': attempt['error']}, ensure_ascii=False)})
-                    continue
-                attempt['rows'] = len(data)
-                attempts.append(attempt)
-                return AskResult(data=data, attempts=attempts, events=events)
-    finally:
-        feedback.set_sink(prev_sink)
+    # R2（03 §4.4）：一次性派生 text2query 档位视图，档位与反馈 sink 随作用域承载——
+    # 不再全局 set_profile / set_sink，「进入即改进程档位 + 退出恢复」的串扰根源随之消除。
+    view = schema.get_core().with_policy({'profile': 'text2query'})
+    # sink：本作用域 emit 的事件只进本次 events（feedback.emit 优先取 current_scope().sink）；
+    # meta（ns 标签）不在此伪造——ask 无 tenant/env 入参，沿用进程级 feedback.set_meta 注入值。
+    # ctx 经 permission.scoped_context 注入执行面（core 档位门禁强制 ctx，fail-secure，A4）
+    with with_scope(view, sink=_collect), permission.scoped_context(ctx):
+        result = await _ask_body(
+            client=client, messages=messages, attempts=attempts,
+            events=events, round_events=round_events, max_retries=max_retries)
+    if result is not None:
+        return result
     raise AskExhausted(attempts, events)

{storepy-4.2.1 → storepy-4.4.2}/src/py_store/crud/exec.py

@@ -118,6 +118,9 @@ async def _exec_on(source, cmd):
     """在指定数据源上执行命令（Mongo 走原生驱动，SQL 走 translate → exec；
     事务 / 会话作用域内经 datasource.resolve_connection 落到事务专用连接）"""
     connection = await _datasource.resolve_connection(source, _datasource.is_write_cmd(cmd))
+    if _datasource.is_local(connection):
+        # 本地磁盘源：与 Mongo 同路径（复用 exec_mongo；handle 已绑定事务快照或直连 IO）
+        return _to_logical(await _exec_mongo(connection['handle'], _to_mongo(cmd)), cmd)
     if isinstance(connection, Mapping) and connection.get('kind') == 'mongo':
         # Mongo 事务视图：db 按命令 database 解析，session 透传给驱动
         db = _datasource.mongo_db(connection['conn'], source, cmd.get('database'))
@@ -149,9 +152,29 @@ def _sources_of(plan):
         cmd = (step or {}).get('command') or {}
         if cmd:
             out.add(cmd.get('source') or _datasource.DEFAULT_SOURCE)
+    # 触发链命令的源（plan_insert 直接产出 triggers；plan_update 二次规划才产出）
+    for t in (plan or {}).get('triggers') or []:
+        cmd = (t or {}).get('command') or {}
+        if cmd:
+            out.add(cmd.get('source') or _datasource.DEFAULT_SOURCE)
     return out or {_datasource.DEFAULT_SOURCE}
 
 
+def declare_trigger_sources(base_sources, triggers):
+    """触发链触及源的原子性声明（update 专用：其 triggers 在事务内二次规划后才产出，
+    顶层 ``_sources_of`` 已不及）——触发源超出已声明源集时发 ``non_atomic_write``
+    （含全部涉及源），此后顺序执行；会话内不发声明（跨源写由既有 fail-closed 拒绝）。
+    对齐 nodejs-store ``declareTriggerSources``。"""
+    uniq = set(base_sources)
+    for t in triggers or ():
+        cmd = (t or {}).get('command') or {}
+        if cmd:
+            uniq.add(cmd.get('source') or _datasource.DEFAULT_SOURCE)
+    if len(uniq) > 1 and _datasource.current_session() is None:
+        _warn_multi_source(uniq)
+    return uniq
+
+
 def _warn_multi_source(sources):
     """多源写：无法原子 → 程序化声明 nonAtomic（允许顺序执行，禁止静默）"""
     listed = sorted(sources)

{storepy-4.2.1 → storepy-4.4.2}/src/py_store/crud/mutation.py

@@ -1,8 +1,8 @@
 """Mutation / Upsert / 原生聚合 —— 规划步骤序列 → 依序执行 + 父子 _id 占位符回填"""
 
 from ..feedback import emit as _emit_feedback
-from ..schema import core as _core
 from ..schema import get as _get_schema
+from ..schema import get_core
 from .exec import (
     _call,
     _ctx,
@@ -17,7 +17,7 @@ from .id import _generate_id, _new_id_pool
 
 async def _mutation_one(schema_name, data, now, route_override=None):
     """mutation 单条：规划步骤序列 → 依序执行 + 父子 _id 占位符回填"""
-    plan = _call(lambda: _core.plan_mutation(
+    plan = _call(lambda: get_core().plan_mutation(
         schema_name, data, now, _new_id_pool(schema_name, data), _ctx(), route_override))
 
     # §11.4 静默点收口：规划期降级（如关系不可读被跳过）走统一反馈通道，禁止静默失守
@@ -36,7 +36,7 @@ async def _mutation_one(schema_name, data, now, route_override=None):
 
         if not root_result:
             return None
-        return _call(lambda: _core.apply_write_defaults(schema_name, root_result))
+        return _call(lambda: get_core().apply_write_defaults(schema_name, root_result))
 
     # 单一 SQL 源 → 步骤序列整体事务化（同连接同事务，任一步失败整体回滚）；
     # Mongo 源 / 跨源步骤按原样顺序执行（非原子边界见 README「事务边界」）
@@ -75,8 +75,8 @@ async def upsert(schema_name, condition, data, options=None, route_override=None
     与 mutation 不同，upsert 需要调用方显式提供 match 条件，不处理父子关系。
     """
     s = _get_schema(schema_name)
-    plan = _call(lambda: _core.plan_upsert(
+    plan = _call(lambda: get_core().plan_upsert(
         schema_name, condition, data, options, _now_for(schema_name),
         _generate_id(s) if s['idPrefix'] else '', _ctx(), route_override))
     result = await _exec(plan['command'])
-    return _call(lambda: _core.apply_write_defaults(schema_name, result)) if result else None
+    return _call(lambda: get_core().apply_write_defaults(schema_name, result)) if result else None

{storepy-4.2.1 → storepy-4.4.2}/src/py_store/crud/query.py

@@ -5,8 +5,7 @@ import asyncio
 import inspect
 
 from ..feedback import emit as _emit_feedback
-from ..schema import core as _core
-from ..schema import get_async_fn, get_profile
+from ..schema import get_async_fn, get_core, get_profile
 from .exec import (
     _PROFILE_HINT,
     ProfileViolation,
@@ -50,7 +49,7 @@ async def _run_query_plan(plan):
             return []
         cmd2 = resolve_placeholders(plan['commands'][1], ids=ids)
         items = await _exec(cmd2)
-        return _core.restore_sort_order(items, ids, plan.get('sort'))['items']
+        return get_core().restore_sort_order(items, ids, plan.get('sort'))['items']
     return await _exec(plan['commands'][0])
 
 
@@ -59,7 +58,7 @@ async def _finalize(plan, items):
     post = plan.get('postprocess')
     if not post:
         return items
-    prepared = _core.prepare_query(post, items, _ctx())
+    prepared = get_core().prepare_query(post, items, _ctx())
     for ref in prepared['fnRefs']:
         fn = get_async_fn(ref)
         if not fn:
@@ -67,7 +66,7 @@ async def _finalize(plan, items):
         out = fn(prepared['items'], _ctx())
         if inspect.isawaitable(out):
             await out
-    return _core.strip_query(post, prepared['items'])['items']
+    return get_core().strip_query(post, prepared['items'])['items']
 
 
 async def query(gql, params=None, route_override=None):
@@ -82,7 +81,7 @@ async def query(gql, params=None, route_override=None):
     注意：``route_override`` 为**受信服务端参数**，禁止透传用户输入（否则可被用于跨源路由，CWE-639）。
     """
     _guard_route_override(route_override)
-    plan = _call(lambda: _core.plan_query(
+    plan = _call(lambda: get_core().plan_query(
         gql, params if params is not None else {}, _ctx(), route_override))
     return await _finalize(plan, await _run_query_plan(plan))
 
@@ -94,7 +93,7 @@ async def query_one(gql, params=None, route_override=None):
     大集合不再全量取回后取首条（对齐 PyMongo ``find_one`` 的 limit-1 语义）。
     """
     _guard_route_override(route_override)
-    plan = _call(lambda: _core.plan_query_one(
+    plan = _call(lambda: get_core().plan_query_one(
         gql, params if params is not None else {}, _ctx(), route_override))
     items = await _finalize(plan, await _run_query_plan(plan))
     return items[0] if items else None
@@ -113,7 +112,7 @@ async def _run_federated_unit(unit):
             return []
         cmd2 = resolve_placeholders(commands[1], ids=ids)
         items = await _exec_on(unit['source'], cmd2)
-        return _core.restore_sort_order(items, ids, unit.get('sort'))['items']
+        return get_core().restore_sort_order(items, ids, unit.get('sort'))['items']
     return await _exec_on(unit['source'], commands[0])
 
 
@@ -128,7 +127,7 @@ async def query_federated(gql, params=None):
     每源取数上限 ``MAX_FEDERATION_ROWS`` 由 core 强制（超限即报错，拒绝静默全表拉取）；
     无法下推的分页/排序进 ``plan['degraded']`` 并告警，不阻断查询。
     """
-    plan = _call(lambda: _core.plan_federated(
+    plan = _call(lambda: get_core().plan_federated(
         gql, params if params is not None else {}, _ctx()))
 
     for d in plan.get('degraded') or []:
@@ -138,7 +137,7 @@ async def query_federated(gql, params=None):
     results = await asyncio.gather(
         *(_run_federated_unit(u) for u in plan.get('sources') or []))
 
-    merged = _call(lambda: _core.merge_federated(plan, results))
+    merged = _call(lambda: get_core().merge_federated(plan, results))
     return await _finalize(plan, merged)
 
 
@@ -152,7 +151,7 @@ async def query_with_count(gql, params=None, route_override=None):
     pageSize 上限 5000，防止拖库。
     """
     _guard_route_override(route_override)
-    plan = _call(lambda: _core.plan_query_with_count(
+    plan = _call(lambda: get_core().plan_query_with_count(
         gql, params if params is not None else {}, _ctx(), None, route_override))
     items = await _finalize(plan, await _run_query_plan(plan))
     total = await _exec(plan['countCommand'])