storepy 2.1.0__tar.gz → 2.3.1__tar.gz

{storepy-2.1.0/src/storepy.egg-info → storepy-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: storepy
-Version: 2.1.0
+Version: 2.3.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
 Author-email: leo <coen_ddt@qq.com>
 License-Expression: MIT
@@ -33,6 +33,7 @@ Provides-Extra: sqlite
 Requires-Dist: aiosqlite>=0.19; extra == "sqlite"
 Provides-Extra: dev
 Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: pytest-cov>=5; extra == "dev"
 Requires-Dist: ruff>=0.16; extra == "dev"
 Requires-Dist: mypy>=1.0; extra == "dev"
 Dynamic: license-file
@@ -372,6 +373,7 @@ await store.transaction("default", transfer)
 - `store.transaction(source, fn)` opens a transaction scope on one SQL source: every `execute_raw` / CRUD call inside `fn` lands on that source's transaction connection, with `commit` / `rollback` as one unit (reuses the internal `run_in_transaction`). Mongo sources or executors without transactions run `fn` as-is — it never pretends to be atomic.
 - `store.execute_raw(source, sql, params=None, is_write=False)` runs raw SQL, bypassing GQL parsing and dialect translation. Placeholders follow each backend's native style: `?` for MySQL / SQLite, `$1..$n` for PostgreSQL. SQL sources only — a Mongo source raises `RawSqlError` (`py_store.RawSqlError` / `store.RawSqlError`).
 - `is_write=False` (default) returns `{"rows", "affectedRows"}` with the result-set rows; `is_write=True` returns the affected-row count.
+- **The non-transactional path commits explicitly**: on SQL sources, a write plan that runs outside `store.transaction` is committed by the executor (`commit` on success; `rollback` then re-raise on failure). `aiosqlite` is not autocommit by default, so without that commit the write would be visible only on the current connection while `execute_raw` still reported success — a silent data-loss hazard. Multi-statement writes that must be atomic as a group belong inside `store.transaction`.
 
 ### DDL generation
 
@@ -384,6 +386,7 @@ sql = store.generate_ddl("postgres", ["Course", "CourseDeleted"])
 
 - Only scalar fields become columns; `object` / `array` fields do not.
 - Every table gets the `__present` sentinel column; `timestamps` models also get `createdAt` / `updatedAt`; the `<collection>_deleted` archive table is generated like any other registered def.
+- The `<Name>Deleted` archive def is **derived by the Rust core when the model is registered**; the Python host only mirrors it (`collection` `<c>_deleted`, the `deletedAt` field, empty `idPrefix`) and never re-registers it into the core. So `schema.list()` and `generate_ddl()` contain each archive table exactly once; if a duplicate ever appears (upstream regression), they deduplicate and emit a `schemaDuplicateName` / `ddlDuplicateTable` feedback event instead of silently emitting duplicate `CREATE TABLE`s.
 - No `CREATE INDEX` is emitted — SQL backends keep indexes as metadata only.
 - MySQL `__present` is `VARCHAR(255)`; a schema whose present-token string would overflow emits a `ddlPresentOverflow` feedback event rather than failing silently.
 

{storepy-2.1.0 → storepy-2.3.1}/README.md

@@ -333,6 +333,7 @@ await store.transaction("default", transfer)
 - `store.transaction(source, fn)` opens a transaction scope on one SQL source: every `execute_raw` / CRUD call inside `fn` lands on that source's transaction connection, with `commit` / `rollback` as one unit (reuses the internal `run_in_transaction`). Mongo sources or executors without transactions run `fn` as-is — it never pretends to be atomic.
 - `store.execute_raw(source, sql, params=None, is_write=False)` runs raw SQL, bypassing GQL parsing and dialect translation. Placeholders follow each backend's native style: `?` for MySQL / SQLite, `$1..$n` for PostgreSQL. SQL sources only — a Mongo source raises `RawSqlError` (`py_store.RawSqlError` / `store.RawSqlError`).
 - `is_write=False` (default) returns `{"rows", "affectedRows"}` with the result-set rows; `is_write=True` returns the affected-row count.
+- **The non-transactional path commits explicitly**: on SQL sources, a write plan that runs outside `store.transaction` is committed by the executor (`commit` on success; `rollback` then re-raise on failure). `aiosqlite` is not autocommit by default, so without that commit the write would be visible only on the current connection while `execute_raw` still reported success — a silent data-loss hazard. Multi-statement writes that must be atomic as a group belong inside `store.transaction`.
 
 ### DDL generation
 
@@ -345,6 +346,7 @@ sql = store.generate_ddl("postgres", ["Course", "CourseDeleted"])
 
 - Only scalar fields become columns; `object` / `array` fields do not.
 - Every table gets the `__present` sentinel column; `timestamps` models also get `createdAt` / `updatedAt`; the `<collection>_deleted` archive table is generated like any other registered def.
+- The `<Name>Deleted` archive def is **derived by the Rust core when the model is registered**; the Python host only mirrors it (`collection` `<c>_deleted`, the `deletedAt` field, empty `idPrefix`) and never re-registers it into the core. So `schema.list()` and `generate_ddl()` contain each archive table exactly once; if a duplicate ever appears (upstream regression), they deduplicate and emit a `schemaDuplicateName` / `ddlDuplicateTable` feedback event instead of silently emitting duplicate `CREATE TABLE`s.
 - No `CREATE INDEX` is emitted — SQL backends keep indexes as metadata only.
 - MySQL `__present` is `VARCHAR(255)`; a schema whose present-token string would overflow emits a `ddlPresentOverflow` feedback event rather than failing silently.
 

{storepy-2.1.0 → storepy-2.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "storepy"
-version = "2.1.0"
+version = "2.3.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"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -45,7 +45,7 @@ classifiers = [
 mysql = ["asyncmy>=0.2.9"]
 postgres = ["asyncpg>=0.29"]
 sqlite = ["aiosqlite>=0.19"]
-dev = ["pytest>=8", "ruff>=0.16", "mypy>=1.0"]
+dev = ["pytest>=8", "pytest-cov>=5", "ruff>=0.16", "mypy>=1.0"]
 
 [project.urls]
 Homepage = "https://github.com/coenddt/py-store"
@@ -83,3 +83,15 @@ python_version = "3.10"
 # 宽松起步：py_store 为动态薄适配层，注解覆盖不足，先只挡「导入失败/明显类型矛盾」
 ignore_missing_imports = true
 check_untyped_defs = true
+
+# ── 覆盖率（门禁口径：语句 ≥90%，见 .github/workflows/ci.yml；分支单独出具） ──
+[tool.coverage.run]
+source = ["py_store"]
+relative_files = true
+
+[tool.coverage.report]
+show_missing = true
+exclude_lines = [
+  "pragma: no cover",
+  "if TYPE_CHECKING:",
+]

{storepy-2.1.0 → storepy-2.3.1}/src/py_store/__init__.py

@@ -20,6 +20,7 @@ py-store — 轻量多后端数据层（Python 版，Rust 单核心架构；支
 """
 
 from collections.abc import Mapping
+from contextlib import contextmanager
 from typing import Any
 
 from pymongo.errors import PyMongoError
@@ -48,6 +49,21 @@ def _build_pipeline(gql, params=None):
         gql, params if params is not None else {}, permission.get_context())
 
 
+@contextmanager
+def text2query():
+    """以 text2query 档执行（功能收缩 + 硬限制），退出恢复原档位。
+
+    AI 问数链路入口；与 ``permission.scoped_roles`` 同构（token-set/reset，嵌套安全）。
+    进入档位即等效强制携带用户上下文（core `ensure_profile_ctx`，见执行文档 §4.2）。
+    """
+    prev = schema.get_profile()
+    schema.set_profile('text2query')
+    try:
+        yield
+    finally:
+        schema.set_profile(prev)
+
+
 class Store:
     """以属性方式访问各 API（**全显式类方法，无动态查找**）
 
@@ -182,6 +198,16 @@ class Store:
     set_require_context = staticmethod(schema.set_require_context)
     requireContext = staticmethod(schema.require_context)
     require_context = staticmethod(schema.require_context)
+    # 查询档位（判决唯一在 core）：standard 默认放开 / text2query 功能收缩
+    # 进入档即等效强制 ctx；未知档由 core 抛 ValueError 上抛（禁静默回落默认档）
+    setProfile = staticmethod(schema.set_profile)
+    set_profile = staticmethod(schema.set_profile)
+    getProfile = staticmethod(schema.get_profile)
+    get_profile = staticmethod(schema.get_profile)
+    # 档位拒绝错误（实例可被 store.ProfileViolation 捕获；权限错误另见 PermissionError）
+    ProfileViolation = crud.ProfileViolation
+    # text2query 便捷上下文（进入设档、退出恢复；同 scoped_roles 的 token-set/reset）
+    text2query = staticmethod(text2query)
     # 反馈事件通道（兜底/降级/拦截的统一出口，接入自动反馈闭环）
     setFeedbackSink = staticmethod(feedback.set_sink)
     set_feedback_sink = staticmethod(feedback.set_sink)
@@ -229,8 +255,17 @@ async def _create_indexes_if_needed():
 
                 await coll.create_index(list(keys.items()), **final_options)
             except PyMongoError as e:
-                import sys
-                print(f'[py-store] 创建索引失败 {s["collection"]}: {e}', file=sys.stderr)
+                # 索引创建失败不阻塞 init（辅助动作），但必须走统一反馈通道：
+                # 无 sink 时由 feedback 默认落 stderr（不双份打印），宿主可 set_sink 接管。
+                # 对齐 nodejs-store/src/index.js（评审项 R7-m1）。
+                feedback.emit({
+                    'type': 'index_create_failed',
+                    'code': 'indexCreateFailed',
+                    'layer': 'host',
+                    'message': f'创建索引失败 {s["collection"]}: {e}',
+                    'hint': ('检查该集合的索引定义与连接权限；'
+                             '索引缺失不影响读写，相关查询将退化为全表扫描'),
+                })
 
 
 async def init(connections):

{storepy-2.1.0 → storepy-2.3.1}/src/py_store/crud/__init__.py

@@ -7,12 +7,13 @@ CRUD 包 —— 薄 Host 适配层（对齐 nodejs-store/src/crud.js 的分工
   - 写入时不补默认值（DB 存最少数据）；读取时由 core 补默认值 + 计算列
 """
 
-from .exec import _get_db, set_connections, set_db
+from .exec import ProfileViolation, _get_db, set_connections, set_db
 from .mutation import mutation, upsert
 from .query import query, query_federated, query_one, query_with_count
 from .write import count, exists, insert, insert_many, remove, update, update_many
 
 __all__ = [
+    'ProfileViolation',
     '_get_db',
     'count',
     'exists',

{storepy-2.1.0 → storepy-2.3.1}/src/py_store/crud/exec.py

@@ -15,6 +15,7 @@ import time
 
 from .. import datasource as _datasource
 from ..executors.mongo import exec_mongo as _exec_mongo
+from ..feedback import emit as _emit_feedback
 from ..permission import PermissionError, get_context
 from ..schema import get as _schema_get
 
@@ -26,6 +27,31 @@ _STEP_PH = re.compile(r'^\{\{step\.(\d+)\._id\}\}$')
 # 可自由调整，映射不随文案漂移而静默失效。构造 PermissionError 时剥离前缀。
 _PERM_PREFIX = 'ERR_PERMISSION:'
 
+# 档位类错误识别：core text2query 档门禁统一携带 `ERR_TEXT2QUERY:` 稳定前缀
+# （见 core `command/mod.rs::ERR_TEXT2QUERY`），同上按前缀映射。命中即 emit
+# 反馈事件 `profile_blocked`（自动反馈原则：允许拦截，禁止静默）。
+_PROFILE_PREFIX = 'ERR_TEXT2QUERY:'
+
+# 从 core 文案 `... [$feature]（功能收缩）` 中提取门禁项名；无 `[..]` 时留白（None），
+# 不伪造 feature —— 缺值必须显式暴露（禁静默兜底）。
+_FEATURE_RE = re.compile(r'\[(.+?)\]')
+
+# 档位拦截反馈的统一提示（反馈事件契约 §4.6 的一部分；单点定义防文案漂移）
+_PROFILE_HINT = ('上游（LLM 产出的 GQL / 调用方入参）越界；'
+                 'text2query 档白名单见 SKILL.md §后端无关性与边界')
+
+
+class ProfileViolation(Exception):
+    """档位（profile）拒绝：text2query 档违反功能收缩 / 硬限制
+
+    与权限错误（``PermissionError``，403）区分：档位拒绝是**调用方合约违反**（400），
+    非授权问题（见执行文档 §4.4）。实参 ``status`` 供上层（HTTP 网关等）映射响应码。
+    """
+
+    def __init__(self, message, status=400):
+        super().__init__(message)
+        self.status = status
+
 
 def set_db(db):
     """单库简写：等价于 ``set_connections({'default': db})``"""
@@ -53,13 +79,33 @@ def _ctx():
 
 
 def _call(fn):
-    """绑定层调用包装：权限类错误（``ERR_PERMISSION:`` 前缀）映射为 PermissionError"""
+    """绑定层调用包装：
+
+      - 权限类错误（``ERR_PERMISSION:`` 前缀）→ ``PermissionError``
+      - 档位类错误（``ERR_TEXT2QUERY:`` 前缀）→ emit ``profile_blocked`` 反馈 + ``ProfileViolation``
+
+    按前缀映射而非具体文案（core 文案可自由调整，映射不随文案漂移而静默失效）。
+    其余异常原样上抛（不吞错）。
+    """
     try:
         return fn()
     except Exception as e:
         msg = str(e)
         if msg.startswith(_PERM_PREFIX):
             raise PermissionError(msg[len(_PERM_PREFIX):]) from e
+        if msg.startswith(_PROFILE_PREFIX):
+            detail = msg[len(_PROFILE_PREFIX):]
+            m = _FEATURE_RE.search(detail)
+            _emit_feedback({
+                'type': 'profile_blocked',
+                'code': 'profileBlocked',
+                'layer': 'core',
+                'profile': 'text2query',
+                'feature': m.group(1) if m else None,
+                'message': detail,
+                'hint': _PROFILE_HINT,
+            })
+            raise ProfileViolation(detail) from e
         raise
 
 

{storepy-2.1.0 → storepy-2.3.1}/src/py_store/crud/query.py

@@ -6,8 +6,39 @@ import inspect
 
 from ..feedback import emit as _emit_feedback
 from ..schema import core as _core
-from ..schema import get_async_fn
-from .exec import _call, _ctx, _exec, _exec_on, resolve_placeholders
+from ..schema import get_async_fn, get_profile
+from .exec import (
+    _PROFILE_HINT,
+    ProfileViolation,
+    _call,
+    _ctx,
+    _exec,
+    _exec_on,
+    resolve_placeholders,
+)
+
+
+def _guard_route_override(route_override):
+    """Host 兜底：text2query 档禁用 ``route_override``（受信参数，禁 AI 侧指定）
+
+    判决唯一在 core（执行文档 §4.2 ⑤：各 ``plan_query*`` 入口已判并 Err）；此为
+    第二层防护——即使 core 判决被绕过，Host 也不放行受信参数（CWE-639）。命中即
+    emit ``profile_blocked``，``layer='host'`` 本身即反馈：core 层未拦住，须回溯加固
+    （自动反馈原则：允许拦截，禁止静默）。
+    """
+    if route_override is None or get_profile() != 'text2query':
+        return
+    detail = 'text2query 档禁用 route_override（受信参数，禁 AI 侧指定）'
+    _emit_feedback({
+        'type': 'profile_blocked',
+        'code': 'profileBlocked',
+        'layer': 'host',
+        'profile': 'text2query',
+        'feature': 'route_override',
+        'message': detail,
+        'hint': _PROFILE_HINT,
+    })
+    raise ProfileViolation(detail)
 
 
 async def _run_query_plan(plan):
@@ -50,6 +81,7 @@ async def query(gql, params=None, route_override=None):
     权限/计算列仍按结构 schema 判定（见 multi-datasource-routing-plan.md §6）。
     注意：``route_override`` 为**受信服务端参数**，禁止透传用户输入（否则可被用于跨源路由，CWE-639）。
     """
+    _guard_route_override(route_override)
     plan = _call(lambda: _core.plan_query(
         gql, params if params is not None else {}, _ctx(), route_override))
     return await _finalize(plan, await _run_query_plan(plan))
@@ -61,6 +93,7 @@ async def query_one(gql, params=None, route_override=None):
     走 core ``plan_query_one``：用户未显式 ``$limit`` 时强制下推 ``$limit(1)``，
     大集合不再全量取回后取首条（对齐 PyMongo ``find_one`` 的 limit-1 语义）。
     """
+    _guard_route_override(route_override)
     plan = _call(lambda: _core.plan_query_one(
         gql, params if params is not None else {}, _ctx(), route_override))
     items = await _finalize(plan, await _run_query_plan(plan))
@@ -118,6 +151,7 @@ async def query_with_count(gql, params=None, route_override=None):
       2. 传统 $skip/$limit — 从 GQL 参数推导 page/pageSize
     pageSize 上限 5000，防止拖库。
     """
+    _guard_route_override(route_override)
     plan = _call(lambda: _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))

{storepy-2.1.0 → storepy-2.3.1}/src/py_store/ddl.py

@@ -2,7 +2,9 @@
 DDL 生成（schema def → CREATE TABLE 文本；纯函数，不连库、不回写）
 
 与 core 契约严格对齐（schema→DDL 单向映射）：
-  - 只对 scalar 字段建列（object/array 不建列；同 core dialect::scalar_column）；
+  - 标量字段按声明类型建列；object/array 字段建 **JSON 列**（MySQL `JSON` / PG `jsonb` /
+    SQLite `TEXT`，同 core dialect::Backend::json_type_name）——落单列存 JSON 文本，
+    读侧由 core row::parse_json_col 还原为嵌套对象，跨后端对齐 Mongo 嵌套文档；
   - 每表必建 __present 哨兵列（形态 ,f1,f2,；同 core write/insert.rs::present_value）；
   - timestamps !== false → 追加 createdAt / updatedAt（同 core schema/registry.rs::add_timestamp_fields）；
   - 归档表 <collection>_deleted 由 registry 自动派生，本模块按已注册 def 逐表生成（不特判）；
@@ -32,6 +34,8 @@ _TYPES = {
     'date': ('BIGINT', 'BIGINT', 'INTEGER'),
 }
 _NON_COLUMN = ('object', 'array')
+# object/array 字段的列类型（JSON 文本列；同 core Backend::json_type_name）
+_JSON_TYPE = ('JSON', 'jsonb', 'TEXT')
 _ID_TYPE = ('VARCHAR(64)', 'TEXT', 'TEXT')
 _PRESENT_TYPE = ('VARCHAR(255)', 'TEXT', 'TEXT')
 _TIMESTAMP_FIELDS = ('createdAt', 'updatedAt')
@@ -56,17 +60,19 @@ def _declared_type(field_def):
 
 
 def _columns(defn, backend):
-    """返回 [(name, sql_type, pk)]，顺序：声明的标量字段 → timestamps → __present"""
+    """返回 [(name, sql_type, pk)]，顺序：声明的字段（标量 / object·array JSON 列）→ timestamps → __present"""
     i = _idx(backend)
     cols = []
     fields = defn.get('fields') or {}
     for name, fdef in fields.items():
         ftype = _declared_type(fdef)
-        if ftype in _NON_COLUMN:
-            continue
         if name == '_id':
             cols.append((name, _ID_TYPE[i], True))
             continue
+        if ftype in _NON_COLUMN:
+            # object/array → 单列 JSON 文本（同 core field_column_ref::Json）
+            cols.append((name, _JSON_TYPE[i], False))
+            continue
         if ftype not in _TYPES:
             raise ValueError(
                 f'DDL 生成：字段 "{defn["name"]}.{name}" 类型 {ftype!r} 未知，'
@@ -117,8 +123,32 @@ def _create_table(defn, backend):
 
 
 def generate(backend, names=None):
-    """生成 DDL 文本（多表以空行分隔）；backend ∈ mysql/postgres/sqlite"""
+    """生成 DDL 文本（多表以空行分隔）；backend ∈ mysql/postgres/sqlite
+
+    按表名去重：同名表只出一次 CREATE TABLE（防御 core 注册表出现重复名 ——
+    上游失守即告警，禁静默）。
+    """
     if backend not in _BACKENDS:
         raise ValueError(f'DDL 生成：不支持的后端 {backend!r}（支持 {list(_BACKENDS)}）')
     targets = list(names) if names else list(_list_schema())
-    return '\n\n'.join(_create_table(_get_schema(n), backend) for n in targets)
+    blocks = []
+    seen_tables = set()
+    dup = []
+    for n in targets:
+        defn = _get_schema(n)
+        table = defn.get('collection') or n
+        if table in seen_tables:
+            dup.append(table)
+            continue
+        seen_tables.add(table)
+        blocks.append(_create_table(defn, backend))
+    if dup:
+        _emit_feedback({
+            'type': 'ddl_duplicate_table',
+            'code': 'ddlDuplicateTable',
+            'layer': 'host',
+            'message': f'DDL 生成：表 {sorted(set(dup))} 重复注册，已去重',
+            'hint': 'schema 注册表出现重复名（见 schemaDuplicateName 告警）；修复注册侧根因',
+            'backend': backend,
+        })
+    return '\n\n'.join(blocks)

{storepy-2.1.0 → storepy-2.3.1}/src/py_store/executors/mysql.py

@@ -96,9 +96,17 @@ def create(driver, options=None):
         return {'docs': docs, 'rows': rows, 'affectedRows': affected_rows}
 
     async def exec_(plan):
-        # 整个 plan 固定在同一连接上执行（池路径也保持语句顺序与连接一致性）
+        """非事务路径：整个 plan 固定在同一连接执行，成功后显式 commit
+        （池 autocommit=True 时为幂等 no-op；单连接 autocommit=False 时杜绝「只执行不提交」）；
+        失败则 rollback 后上抛，绝不提交半截写入"""
         async with acquire(driver) as conn:
-            return await run_stmts(conn, plan)
+            try:
+                out = await run_stmts(conn, plan)
+            except BaseException:
+                await conn.rollback()
+                raise
+            await conn.commit()
+            return out
 
     async def with_transaction(body):
         """事务执行：显式 BEGIN + commit/rollback（对 autocommit 任意配置均确定成立）；

{storepy-2.1.0 → storepy-2.3.1}/src/py_store/executors/sqlite.py

@@ -48,7 +48,16 @@ def create(db, options=None):
         return {'docs': docs, 'rows': rows, 'affectedRows': affected_rows}
 
     async def exec_(plan):
-        return await run_stmts(plan)
+        """非事务路径：plan 成功后显式提交（aiosqlite 默认非 autocommit，
+        不提交则仅当前连接可见 —— 落盘场景会丢数据/读到幻象，且无任何告警）；
+        失败则回滚后上抛，绝不提交半截写入"""
+        try:
+            out = await run_stmts(plan)
+        except BaseException:
+            await db.rollback()
+            raise
+        await db.commit()
+        return out
 
     async def with_transaction(body):
         """事务执行：显式 BEGIN + commit/rollback（先清理遗留隐式事务，保证 BEGIN 干净）；

{storepy-2.1.0 → storepy-2.3.1}/src/py_store/schema.py

@@ -33,6 +33,7 @@ Schema 管理 — 薄适配层
 """
 
 from .core import core
+from .feedback import emit as _emit_feedback
 
 # 缓存内置 list 类型（本模块的 list() 函数会遮蔽内置名）
 _LIST_TYPES = (list, tuple)
@@ -74,7 +75,13 @@ def _to_core_defn(defn):
 
 
 def register(defn):
-    """注册一个 schema（自动派生 `<Name>Deleted` 归档表镜像），返回 Host 侧元数据"""
+    """注册一个 schema（core 注册 + Host 侧元数据镜像）
+
+    归档表 `<Name>Deleted` 由 core 在 register 内**自动派生并注册**
+    （rust-store/core/src/schema/registry.rs:52-55）；Host 只补 Host 侧镜像，
+    **不再调用 core.register** —— 否则同名条目二次进入 core.order，使 list()/
+    generate_ddl() 出现重复表（基线实测 list=['User','UserDeleted','UserDeleted']）。
+    """
     core.register(_to_core_defn(defn))
 
     # 计算列回调：fn → core 回调桥；asyncFn → Host 侧映射
@@ -106,19 +113,24 @@ def register(defn):
         'datasource': defn.get('datasource'),
     }
 
-    # 归档表镜像（与 core register 的自动派生保持一致，供 Host 查询元数据）
+    # 归档表镜像（形状对齐 core archive_defn：registry.rs:395-417）
+    # —— 字段 + deletedAt、collection=<c>_deleted、idPrefix=''、timestamps 默认 true
     if not defn.get('_isArchive') and not defn['name'].endswith('Deleted'):
-        register({
+        _schemas[f"{defn['name']}Deleted"] = {
             'name': f"{defn['name']}Deleted",
             'collection': f"{defn.get('collection') or defn['name']}_deleted",
-            'idPrefix': '',
-            '_isArchive': True,
-            # 归档表与原表同 (source, namespace)
-            'datasource': defn.get('datasource'),
             'namespace': defn.get('namespace') or None,
+            'idPrefix': '',
+            'timestamps': True,
+            'timestampUnit': 'ms',
             'fields': {**(defn.get('fields') or {}), 'deletedAt': {'type': 'number'}},
+            'relations': {},
+            'computes': {},
             'indexes': defn.get('indexes') or [],
-        })
+            'read': None,
+            'write': None,
+            'datasource': defn.get('datasource'),
+        }
 
     return _schemas[defn['name']]
 
@@ -136,9 +148,38 @@ def has(name):
     return core.has(name)
 
 
+# 去重告警签名（同一重复形态只告警一次，避免 list() 高频调用刷屏）
+_dup_signatures: set = set()
+
+
 def list():
-    """所有已注册 schema 名称（core 侧，含归档表，按注册顺序）"""
-    return core.list()
+    """所有已注册 schema 名称（core 侧，含归档表，按注册顺序；同名只保留首次出现）
+
+    去重是纵深防御的第二层：一旦检出重复即说明上游（register/core）失守，
+    去重同时 emit 告警（同签名只告警一次），禁静默。
+    """
+    names = core.list()
+    seen = set()
+    out = []
+    for name in names:
+        if name in seen:
+            continue
+        seen.add(name)
+        out.append(name)
+    if len(out) != len(names):
+        sig = tuple(names)
+        if sig not in _dup_signatures:
+            _dup_signatures.add(sig)
+            _emit_feedback({
+                'type': 'schema_duplicate_name',
+                'code': 'schemaDuplicateName',
+                'layer': 'host',
+                'message': f'schema 注册表存在重复名（多 {len(names) - len(out)} 条），已顺序去重',
+                'hint': ('上游注册逻辑失守（core.order 同名两次）；'
+                         '核查 register 是否重复调用 core.register，或 core.register 未对同名去重'),
+                'names': names,
+            })
+    return out
 
 
 def set_require_context(require=True):
@@ -157,6 +198,20 @@ def require_context():
     return core.require_context()
 
 
+def set_profile(profile):
+    """设置查询档位：'standard'（默认，功能最大化 + 跨 DB 对齐）/
+    'text2query'（功能收缩 + 硬限制）
+
+    判决唯一在 core；未知档位由 core 抛 ValueError 上抛（禁静默回落到默认档）。
+    """
+    core.set_profile(profile)
+
+
+def get_profile():
+    """当前档位字符串（'standard' / 'text2query'）"""
+    return core.profile()
+
+
 def get_async_fn(fn_ref):
     """取 asyncFn 计算列实现（fnRef 缺省 = 计算列 key 名）"""
     return _async_fns.get(fn_ref)

{storepy-2.1.0 → storepy-2.3.1/src/storepy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: storepy
-Version: 2.1.0
+Version: 2.3.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
 Author-email: leo <coen_ddt@qq.com>
 License-Expression: MIT
@@ -33,6 +33,7 @@ Provides-Extra: sqlite
 Requires-Dist: aiosqlite>=0.19; extra == "sqlite"
 Provides-Extra: dev
 Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: pytest-cov>=5; extra == "dev"
 Requires-Dist: ruff>=0.16; extra == "dev"
 Requires-Dist: mypy>=1.0; extra == "dev"
 Dynamic: license-file
@@ -372,6 +373,7 @@ await store.transaction("default", transfer)
 - `store.transaction(source, fn)` opens a transaction scope on one SQL source: every `execute_raw` / CRUD call inside `fn` lands on that source's transaction connection, with `commit` / `rollback` as one unit (reuses the internal `run_in_transaction`). Mongo sources or executors without transactions run `fn` as-is — it never pretends to be atomic.
 - `store.execute_raw(source, sql, params=None, is_write=False)` runs raw SQL, bypassing GQL parsing and dialect translation. Placeholders follow each backend's native style: `?` for MySQL / SQLite, `$1..$n` for PostgreSQL. SQL sources only — a Mongo source raises `RawSqlError` (`py_store.RawSqlError` / `store.RawSqlError`).
 - `is_write=False` (default) returns `{"rows", "affectedRows"}` with the result-set rows; `is_write=True` returns the affected-row count.
+- **The non-transactional path commits explicitly**: on SQL sources, a write plan that runs outside `store.transaction` is committed by the executor (`commit` on success; `rollback` then re-raise on failure). `aiosqlite` is not autocommit by default, so without that commit the write would be visible only on the current connection while `execute_raw` still reported success — a silent data-loss hazard. Multi-statement writes that must be atomic as a group belong inside `store.transaction`.
 
 ### DDL generation
 
@@ -384,6 +386,7 @@ sql = store.generate_ddl("postgres", ["Course", "CourseDeleted"])
 
 - Only scalar fields become columns; `object` / `array` fields do not.
 - Every table gets the `__present` sentinel column; `timestamps` models also get `createdAt` / `updatedAt`; the `<collection>_deleted` archive table is generated like any other registered def.
+- The `<Name>Deleted` archive def is **derived by the Rust core when the model is registered**; the Python host only mirrors it (`collection` `<c>_deleted`, the `deletedAt` field, empty `idPrefix`) and never re-registers it into the core. So `schema.list()` and `generate_ddl()` contain each archive table exactly once; if a duplicate ever appears (upstream regression), they deduplicate and emit a `schemaDuplicateName` / `ddlDuplicateTable` feedback event instead of silently emitting duplicate `CREATE TABLE`s.
 - No `CREATE INDEX` is emitted — SQL backends keep indexes as metadata only.
 - MySQL `__present` is `VARCHAR(255)`; a schema whose present-token string would overflow emits a `ddlPresentOverflow` feedback event rather than failing silently.
 

{storepy-2.1.0 → storepy-2.3.1}/src/storepy.egg-info/SOURCES.txt

@@ -30,12 +30,16 @@ src/storepy.egg-info/SOURCES.txt
 src/storepy.egg-info/dependency_links.txt
 src/storepy.egg-info/requires.txt
 src/storepy.egg-info/top_level.txt
+tests/test_coverage_margin.py
 tests/test_federation_e2e.py
 tests/test_host_contract.py
+tests/test_host_paths.py
 tests/test_mongo_executor.py
 tests/test_multi_datasource.py
+tests/test_profile.py
 tests/test_py_store.py
 tests/test_raw_sql_and_ddl.py
 tests/test_real_backends_e2e.py
 tests/test_require_context.py
-tests/test_scenario_course_platform.py
+tests/test_scenario_course_platform.py
+tests/test_sql_commit_and_registry.py

{storepy-2.1.0 → storepy-2.3.1}/src/storepy.egg-info/requires.txt

@@ -3,6 +3,7 @@ rust-store-py<3.0.0,>=2.0.0
 
 [dev]
 pytest>=8
+pytest-cov>=5
 ruff>=0.16
 mypy>=1.0