storepy 4.2.0__tar.gz → 4.3.0__tar.gz

{storepy-4.2.0/src/storepy.egg-info → storepy-4.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: storepy
-Version: 4.2.0
+Version: 4.3.0
 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

{storepy-4.2.0 → storepy-4.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "storepy"
-version = "4.2.0"
+version = "4.3.0"
 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"

{storepy-4.2.0 → storepy-4.3.0}/src/py_store/__init__.py

@@ -49,6 +49,9 @@ from . import (
 )
 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
@@ -324,9 +327,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)
     # 数据源连接（多后端路由）
@@ -374,6 +380,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 仅元数据）"""

{storepy-4.2.0 → storepy-4.3.0}/src/py_store/crud/exec.py

@@ -149,9 +149,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.3.0/src/py_store/crud/triggers.py

@@ -0,0 +1,191 @@
+"""触发链执行器（Host 侧）：占位符替换 → 命中判定 → 依序执行（命令式 / 回调式）。
+
+边界：core 已产出 steps（含占位符、onFields、when）；本模块只做**运行时事实判定**
+（before/after 实际值）与执行，落在调用方的 ``run_atomic`` 作用域内 → 单源同事务。
+去重：同一次顶层调用内 ``(step.name, _id)`` 只执行一次（防重复触发）。
+不做级联：触发写不再触发任何触发器（首批契约，见总纲）。
+
+对齐 ``nodejs-store/src/crud/triggers.js``（同语义蛇形实现）。
+"""
+
+import re
+from typing import Set
+
+from .exec import _exec
+
+_store = None                 # 装配期由 py_store.__init__ 注入（避免循环导入）
+_trigger_fns: dict = {}
+_fn_refs: Set[str] = set()
+
+
+def set_store(s):
+    """装配门面（``py_store.__init__`` 在 ``store = Store()`` 后调用一次）"""
+    global _store
+    _store = s
+
+
+def set_trigger_fn(fn_ref, impl):
+    """回调注入：``fn_ref → impl(args, ctx, {'store': store})``（可为 async）"""
+    if not isinstance(fn_ref, str) or not fn_ref:
+        raise ValueError('ERR_TRIGGER_FN_REF:fnRef 须为非空字符串')
+    if not callable(impl):
+        raise ValueError('ERR_TRIGGER_FN_IMPL:impl 须为函数')
+    _trigger_fns[fn_ref] = impl
+    _fn_refs.add(fn_ref)
+
+
+def assert_trigger_fns_covered(defns):
+    """启动期校验：schema 的 triggers 里声明的 fnRef 必须都有实现（缺则显式抛错，不静默）。
+
+    注意：声明形状的 fnRef 在顶层（规划展开后才包成 ``callback:{fnRef,args}``），
+    见 core ``schema/triggers.rs``。
+    """
+    missing = []
+    for defn in defns or ():
+        for trigger_list in ((defn or {}).get('triggers') or {}).values():
+            for t in trigger_list or ():
+                ref = t.get('fnRef') if isinstance(t, dict) else None
+                if isinstance(ref, str) and ref and ref not in _fn_refs:
+                    missing.append(ref)
+    if missing:
+        raise RuntimeError(f'ERR_TRIGGER_FN_MISSING:未注入触发器回调实现 {", ".join(missing)}')
+
+
+# ─── 占位符（整值替换；禁内嵌拼接） ───────────────────────────
+
+_ROOT_PH = re.compile(r'^\{\{root\.([A-Za-z0-9_.]+)\}\}$')
+_BEFORE_PH = re.compile(r'^\{\{before\.([A-Za-z0-9_.]+)\}\}$')
+_NOW_PH = re.compile(r'^\{\{now\}\}$')
+
+
+def _dig(obj, path):
+    """点路径取值；缺失 → None（不抛）"""
+    if obj is None:
+        return None
+    cur = obj
+    for seg in str(path).split('.'):
+        if cur is None:
+            return None
+        if not isinstance(cur, dict):
+            return None
+        cur = cur.get(seg)
+    return cur
+
+
+def _deep_eq(a, b):
+    """深比较（结构相等；顺序无关的键集合比较）"""
+    if a is b:
+        return True
+    if a is None or b is None or not isinstance(a, dict) or not isinstance(b, dict):
+        return a == b
+    if list(a.keys()) != list(b.keys()) and set(a.keys()) != set(b.keys()):
+        return False
+    return all(_deep_eq(a[k], b[k]) for k in a)
+
+
+def resolve_trigger_placeholders(value, scope):
+    """深替换触发器步骤中的占位符。
+
+    未命中的占位符**显式报错**（``ERR_TRIGGER_PLACEHOLDER``）——占位符必须独占字符串值，
+    不支持 ``"order-{{root._id}}"`` 这类内嵌拼接（禁静默漂移）。
+    """
+    if isinstance(value, str):
+        if _NOW_PH.match(value):
+            return scope['now']
+        m = _ROOT_PH.match(value)
+        if m:
+            return _dig(scope['root'], m.group(1))
+        m = _BEFORE_PH.match(value)
+        if m:
+            return _dig(scope['before'], m.group(1))
+        if '{{root.' in value or '{{before.' in value or '{{now}}' in value:
+            raise ValueError(
+                f'ERR_TRIGGER_PLACEHOLDER:占位符必须独占字符串值（不支持内嵌拼接）：{value}')
+        return value
+    if isinstance(value, list):
+        return [resolve_trigger_placeholders(v, scope) for v in value]
+    if isinstance(value, dict):
+        return {k: resolve_trigger_placeholders(v, scope) for k, v in value.items()}
+    return value
+
+
+# ─── when 求值（极简文法；未知算子显式 Err） ──────────────────
+
+_WHEN_OPS = frozenset({'eq', 'ne', 'gt', 'gte', 'lt', 'lte', 'in', 'and', 'or', 'not'})
+
+
+def eval_when(when, scope):
+    if when is None:
+        return True
+    keys = list(when.keys())
+    if len(keys) != 1:
+        raise ValueError('ERR_TRIGGER_WHEN:when 必须且只能有一个算子键')
+    op = keys[0]
+    if op not in _WHEN_OPS:
+        raise ValueError(f'ERR_TRIGGER_WHEN:未知算子 {op}')
+    arg = when[op]
+
+    def rv(v):
+        return resolve_trigger_placeholders(v, scope)
+
+    if op == 'eq':
+        return rv(arg[0]) == rv(arg[1])
+    if op == 'ne':
+        return rv(arg[0]) != rv(arg[1])
+    if op == 'gt':
+        return rv(arg[0]) > rv(arg[1])
+    if op == 'gte':
+        return rv(arg[0]) >= rv(arg[1])
+    if op == 'lt':
+        return rv(arg[0]) < rv(arg[1])
+    if op == 'lte':
+        return rv(arg[0]) <= rv(arg[1])
+    if op == 'in':
+        return rv(arg[0]) in (rv(arg[1]) or [])
+    if op == 'and':
+        return all(eval_when(w, scope) for w in (arg or []))
+    if op == 'or':
+        return any(eval_when(w, scope) for w in (arg or []))
+    return not eval_when(arg, scope)  # not
+
+
+# ─── 命中判定 + 执行器 ───────────────────────────────────────
+
+def hit_trigger(step, *, before, after, scope):
+    """命中判定：``onFields 值真的变化`` → ``when 成立``。
+
+    ``onFields`` 为空（记录级）或事件为 insert（无 before）时跳过字段级检查。
+    """
+    on = step.get('onFields') or []
+    if on and before is not None:
+        changed = any(not _deep_eq(_dig(before, f), _dig(after, f)) for f in on)   # no-op 抑制
+        if not changed:
+            return False
+    return eval_when(step.get('when'), scope)
+
+
+async def run_triggers(steps, *, root, before, now, ctx, executed):
+    """依序执行触发链。
+
+    ``steps`` 为 core 产出的 triggers 数组；``executed`` 为本次顶层调用的去重集合
+    （键 ``name#_id``）；``_store`` 为门面，回调经 ``host['store']`` 消费。
+    """
+    for step in steps or ():
+        rid = _dig(root, '_id')
+        key = f"{step['name']}#{'' if rid is None else rid}"
+        if key in executed:
+            continue                                        # 同事务去重
+        scope = {'root': root, 'before': before, 'now': now}
+        if not hit_trigger(step, before=before, after=root, scope=scope):
+            continue
+        executed.add(key)
+        if step.get('command'):
+            await _exec(resolve_trigger_placeholders(step['command'], scope))
+        elif step.get('callback'):
+            fn_ref = step['callback'].get('fnRef')
+            impl = _trigger_fns.get(fn_ref)
+            if impl is None:
+                raise RuntimeError(f'ERR_TRIGGER_FN_MISSING:未注入触发器回调 {fn_ref}')
+            args = resolve_trigger_placeholders(step['callback'].get('args'), scope)
+            # 回调内 store.* 经 resolve_connection 落到当前事务连接 → 与主写同事务
+            await impl(args, ctx, {'store': _store})

{storepy-4.2.0 → storepy-4.3.0}/src/py_store/crud/write.py

@@ -2,8 +2,17 @@
 
 from ..schema import core as _core
 from ..schema import get as _get_schema
-from .exec import _call, _ctx, _exec, _now_for, _sources_of, run_atomic
+from .exec import (
+    _call,
+    _ctx,
+    _exec,
+    _now_for,
+    _sources_of,
+    declare_trigger_sources,
+    run_atomic,
+)
 from .id import _generate_id
+from .triggers import run_triggers
 
 
 async def _plan_with_probe(plan_fn):
@@ -18,15 +27,32 @@ async def _plan_with_probe(plan_fn):
 async def insert(schema_name, data, route_override=None):
     """插入一条（``route_override`` 可选：多租户路由 ``{'source', 'database', 'schema'}``）"""
     s = _get_schema(schema_name)
+    now = _now_for(schema_name)
     plan = _call(lambda: _core.plan_insert(
-        schema_name, data, _now_for(schema_name), _generate_id(s) if s['idPrefix'] else '', _ctx(),
+        schema_name, data, now, _generate_id(s) if s['idPrefix'] else '', _ctx(),
         route_override))
-    result = await _exec(plan['command'])
-    returns = plan['returns']
-    # 阶段2：autoincrement 主键 —— 执行器已回读自增值，returns 补 `_id`
-    if isinstance(returns, dict) and not returns.get('_id')             and isinstance(result, dict) and result.get('_id') is not None:
-        returns = {**returns, '_id': result['_id']}
-    return returns
+
+    def _finish(result):
+        returns = plan['returns']
+        # 阶段2：autoincrement 主键 —— 执行器已回读自增值，returns 补 `_id`
+        if (isinstance(returns, dict) and not returns.get('_id')
+                and isinstance(result, dict) and result.get('_id') is not None):
+            return {**returns, '_id': result['_id']}
+        return returns
+
+    # 无触发器：保持原路径（零回归）
+    if not plan.get('triggers'):
+        return _finish(await _exec(plan['command']))
+    # 有触发器：主写 + 触发链同一原子作用域（单源真事务 / 跨源发 non_atomic_write）
+    ctx = _ctx()
+
+    async def _do():
+        result = await _exec(plan['command'])
+        await run_triggers(plan['triggers'], root=result, before=None, now=now, ctx=ctx,
+                           executed=set())
+        return _finish(result)
+
+    return await run_atomic(_sources_of(plan), _do)
 
 
 async def insert_many(schema_name, docs, route_override=None):
@@ -74,12 +100,20 @@ async def update(schema_name, condition, data, options=None, route_override=None
 
     async def _do():
         out = first
+        before = None
         if out.get('needsProbe'):
-            probe_doc = await _exec(out['needsProbe'])
+            before = await _exec(out['needsProbe'])          # 探针文档 = before（含 onFields 投影）
             out = _call(lambda: _core.plan_update(
                 schema_name, condition, data, options, now, ctx,
-                probe_doc is not None, probe_doc, route_override))
+                before is not None, before, route_override))
+        # 触发链触及源并入原子性声明（update 的 triggers 二次规划才产出；跨源 → non_atomic_write）
+        if out.get('triggers'):
+            declare_trigger_sources(sources, out['triggers'])
         result = await _exec(out['command'])
+        # 主写有命中才触发（0 行命中 = 无 after，无从引用；配触发器的 update 由 core 强制发探针）
+        if out.get('triggers') and result:
+            await run_triggers(out['triggers'], root=result, before=before, now=now, ctx=ctx,
+                               executed=set())
         return _call(lambda: _core.apply_write_defaults(schema_name, result)) if result else None
 
     return await run_atomic(sources, _do)

{storepy-4.2.0 → storepy-4.3.0}/src/py_store/resource/__init__.py

@@ -130,8 +130,10 @@ async def open(resource_id, *, order=None):
                             "message": f'资源副本读取失败，降级到下一副本（backend={loc["backend"]}, id={resource_id}）：{e}',
                             "hint": "检查该 provider 可用性；该副本可能需要重建"})
     if last_err is not None:
-        raise last_err
-    raise FileNotFoundError(f"资源不存在或无可读副本: {resource_id}")
+        raise last_err  # 有副本行但读取失败：原样重抛（500 透传），禁改语义
+    # core 稳定前缀（与 ERR_PERMISSION: / ERR_GQL_PARSE: 同构）：适配层按前缀判定 → 404，
+    # 禁按中文文案匹配。仅「按 resource_id 查到零 ResourceLocation 行」时抛出。
+    raise FileNotFoundError(f"ERR_RESOURCE_NOT_FOUND:资源不存在或无可读副本: {resource_id}")
 
 
 async def remove(resource_id):

{storepy-4.2.0 → storepy-4.3.0/src/storepy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: storepy
-Version: 4.2.0
+Version: 4.3.0
 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

{storepy-4.2.0 → storepy-4.3.0}/src/storepy.egg-info/SOURCES.txt

@@ -23,6 +23,7 @@ src/py_store/crud/exec.py
 src/py_store/crud/id.py
 src/py_store/crud/mutation.py
 src/py_store/crud/query.py
+src/py_store/crud/triggers.py
 src/py_store/crud/write.py
 src/py_store/executors/__init__.py
 src/py_store/executors/_values.py
@@ -71,4 +72,5 @@ tests/test_scenario_course_platform.py
 tests/test_scenario_manager_transaction.py
 tests/test_session.py
 tests/test_sql_commit_and_registry.py
+tests/test_triggers.py
 tests/test_workflow.py

{storepy-4.2.0 → storepy-4.3.0}/tests/test_resource.py

@@ -10,6 +10,8 @@ import asyncio
 import re
 import tempfile
 
+import pytest
+
 from py_store import feedback, resource
 
 
@@ -156,6 +158,45 @@ def test_open_degrade_on_provider_failure():
     _run(scenario())
 
 
+def test_open_missing_resource_raises_prefixed_error():
+    """零副本行 → 抛 FileNotFoundError 且带 ERR_RESOURCE_NOT_FOUND: 稳定前缀（spec/03 判定顺序第 4 层）。"""
+    async def scenario():
+        store = _FakeStore()
+        resource.register_provider('memory', _MemoryProvider)
+        resource.configure({'store': store, 'providers': [{'kind': 'memory'}], 'url': {}})
+
+        rid = '0' * 40
+        prefix = 'ERR_RESOURCE_NOT_FOUND:'
+        with pytest.raises(FileNotFoundError) as ei:
+            await resource.open(rid)
+        assert str(ei.value).startswith(prefix), str(ei.value)
+        assert str(ei.value)[len(prefix):] == f'资源不存在或无可读副本: {rid}'
+
+    _run(scenario())
+
+
+def test_open_provider_failure_reraises_without_prefix():
+    """有副本行但 provider 读取失败 → 原样重抛、不带前缀（保持 500 语义，禁伪装成「不存在」）。"""
+    async def scenario():
+        store = _FakeStore()
+        prev = feedback.get_sink()
+        feedback.set_sink(lambda e: None)
+        try:
+            resource.register_provider('badget', _BrokenGetProvider)
+            resource.configure({'store': store, 'providers': [{'kind': 'badget'}], 'url': {}})
+            store.rows.append({'_schema': 'ResourceLocation', 'resourceId': 'a' * 40,
+                               'backend': 'badget', 'key': 'k', 'status': 'ok', 'priority': 0})
+
+            with pytest.raises(RuntimeError) as ei:
+                await resource.open('a' * 40)
+            assert str(ei.value) == 'disk boom'
+            assert not str(ei.value).startswith('ERR_RESOURCE_NOT_FOUND:')
+        finally:
+            feedback.set_sink(prev)
+
+    _run(scenario())
+
+
 def test_partial_write_failure_persists_failed_and_feedback():
     async def scenario():
         store = _FakeStore()

storepy-4.3.0/tests/test_triggers.py

@@ -0,0 +1,348 @@
+"""Schema 触发器真库 e2e（02 步骤 8；镜像 nodejs-store/tests/triggers.test.js）
+
+覆盖总纲 A2/A3/A4/A5/A6/A8/A9 + 回调式触发。全程只走 store 统一入口：
+register(triggers) → insert/update → core 规划（plan 附 triggers）→ Host 触发链
+执行器（占位符/命中判定/去重）→ run_atomic 单源真事务 / 跨源 non_atomic_write 声明。
+真库 = aiosqlite 内存库。
+
+运行：LOCAL_CORE=1 python -m pytest tests/test_triggers.py -q
+"""
+
+import asyncio
+
+import aiosqlite
+import pytest
+
+from py_store import executors, feedback, init, permission, store
+from py_store import schema as _sc
+from py_store.crud.exec import ProfileViolation
+from py_store.crud.triggers import resolve_trigger_placeholders
+
+SRC_A = 'trg_a'
+SRC_B = 'trg_b'
+
+_DDL = """
+CREATE TABLE t_order (_id TEXT PRIMARY KEY, amount REAL, status TEXT, note TEXT, __present TEXT);
+CREATE TABLE t_order_deleted (_id TEXT PRIMARY KEY, amount REAL, status TEXT, note TEXT,
+    deleted_at INTEGER, __present TEXT);
+CREATE TABLE t_audit (_id TEXT PRIMARY KEY, kind TEXT, ref TEXT, amount REAL, __present TEXT);
+CREATE TABLE t_audit_deleted (_id TEXT PRIMARY KEY, kind TEXT, ref TEXT, amount REAL,
+    deleted_at INTEGER, __present TEXT);
+CREATE TABLE t_boom (_id TEXT PRIMARY KEY, __present TEXT);
+CREATE TABLE t_boom_deleted (_id TEXT PRIMARY KEY, deleted_at INTEGER, __present TEXT);
+CREATE TABLE t_ghost (_id TEXT PRIMARY KEY, __present TEXT);
+CREATE TABLE t_ghost_deleted (_id TEXT PRIMARY KEY, deleted_at INTEGER, __present TEXT);
+CREATE TABLE t_cmd_fail (_id TEXT PRIMARY KEY, amount REAL, __present TEXT);
+CREATE TABLE t_cmd_fail_deleted (_id TEXT PRIMARY KEY, amount REAL, deleted_at INTEGER,
+    __present TEXT);
+CREATE TABLE t_x_order (_id TEXT PRIMARY KEY, amount REAL, __present TEXT);
+CREATE TABLE t_x_order_deleted (_id TEXT PRIMARY KEY, amount REAL, deleted_at INTEGER,
+    __present TEXT);
+CREATE TABLE t_x_audit (_id TEXT PRIMARY KEY, ref TEXT, __present TEXT);
+CREATE TABLE t_x_audit_deleted (_id TEXT PRIMARY KEY, ref TEXT, deleted_at INTEGER,
+    __present TEXT);
+"""
+
+
+def _register_test_schemas():
+    """测试 schema 注册（conftest 模块夹具重放；triggers 契约见总纲 T 字段表）"""
+    _sc.register({
+        'name': 'TOrder', 'collection': 'tOrder', 'idPrefix': 'o_', 'timestamps': False,
+        'datasource': SRC_A,
+        'fields': {'amount': {'type': 'number'}, 'status': {'type': 'string'},
+                   'note': {'type': 'string'}},
+        'triggers': {
+            'insert': [
+                # A8：aud_cmd 重复同名 —— 同事务 (name, _id) 去重，只执行一次
+                # （若不去重，第二次同 _id insertOne 主键冲突 → 整体失败）
+                {'name': 'aud_cmd', 'into': 'TAudit', 'op': 'insert',
+                 'data': {'_id': '{{root._id}}', 'kind': 'cmd', 'ref': '{{root._id}}',
+                          'amount': '{{root.amount}}'}},
+                {'name': 'aud_cmd', 'into': 'TAudit', 'op': 'insert',
+                 'data': {'_id': '{{root._id}}', 'kind': 'cmd', 'ref': '{{root._id}}',
+                          'amount': '{{root.amount}}'}},
+                {'name': 'aud_cb', 'fnRef': 'audRecorder', 'args': {'ref': '{{root._id}}'}},
+            ],
+            'update': [
+                {'name': 'aud_upd', 'onFields': ['amount'], 'into': 'TAudit', 'op': 'insert',
+                 'data': {'_id': '{{now}}', 'kind': 'upd', 'ref': '{{root._id}}',
+                          'amount': '{{root.amount}}'}},
+            ],
+        },
+    })
+    _sc.register({
+        'name': 'TAudit', 'collection': 'tAudit', 'idPrefix': 'a_', 'timestamps': False,
+        'datasource': SRC_A,
+        'fields': {'kind': {'type': 'string'}, 'ref': {'type': 'string'},
+                   'amount': {'type': 'number'}},
+    })
+    _sc.register({
+        'name': 'TBoom', 'collection': 'tBoom', 'idPrefix': 'b_', 'timestamps': False,
+        'datasource': SRC_A, 'fields': {},
+        'triggers': {'insert': [{'name': 'boom', 'fnRef': 'boom'}]},
+    })
+    _sc.register({
+        'name': 'TGhost', 'collection': 'tGhost', 'idPrefix': 'g_', 'timestamps': False,
+        'datasource': SRC_A, 'fields': {},
+        'triggers': {'insert': [{'name': 'ghost', 'fnRef': 'ghost'}]},
+    })
+    _sc.register({
+        'name': 'TCmdFail', 'collection': 'tCmdFail', 'idPrefix': 'cf_', 'timestamps': False,
+        'datasource': SRC_A, 'fields': {'amount': {'type': 'number'}},
+        # A5：命令式触发写失败（data._id 固定字面量，与预置行冲突）
+        'triggers': {
+            'insert': [{'name': 'cf_aud', 'into': 'TAudit', 'op': 'insert',
+                        'data': {'_id': 'fixed-collision', 'kind': 'cf', 'ref': '{{root._id}}'}}],
+        },
+    })
+    _sc.register({
+        'name': 'TXOrder', 'collection': 'tXOrder', 'idPrefix': 'x_', 'timestamps': False,
+        'datasource': SRC_A, 'fields': {'amount': {'type': 'number'}},
+        # A6：跨源触发链（目标在 SRC_B）
+        'triggers': {
+            'insert': [{'name': 'x_aud', 'into': 'TXAudit', 'op': 'insert',
+                        'data': {'_id': '{{root._id}}', 'ref': '{{root._id}}'}}],
+        },
+    })
+    _sc.register({
+        'name': 'TXAudit', 'collection': 'tXAudit', 'idPrefix': 'xa_', 'timestamps': False,
+        'datasource': SRC_B, 'fields': {'ref': {'type': 'string'}},
+    })
+
+
+# ─── 回调实现注入（启动期一次；运行期计数在用例内自管） ─────────
+
+cb_calls = []
+
+
+async def _aud_recorder(args, ctx, host):
+    cb_calls.append(args)
+    await host['store'].insert('TAudit', {'kind': 'cb', 'ref': args['ref'], 'amount': 0})
+
+
+async def _boom(args, ctx, host):
+    raise RuntimeError('boom-err')
+
+
+store.set_trigger_fn('audRecorder', _aud_recorder)
+store.set_trigger_fn('boom', _boom)
+
+
+def _run(coro):
+    return asyncio.run(coro)
+
+
+async def _setup():
+    """环境复位（node beforeEach 镜像）：sink / ctx / 档位 / 双源内存库"""
+    events.clear()
+    cb_calls.clear()
+    feedback.set_sink(events.append)
+    permission.set_context(None)
+    store.set_profile('standard')
+    db_a = await aiosqlite.connect(':memory:')
+    db_b = await aiosqlite.connect(':memory:')
+    db_a.row_factory = aiosqlite.Row
+    db_b.row_factory = aiosqlite.Row
+    await db_a.executescript(_DDL)
+    await db_b.executescript(_DDL)
+    await init({
+        SRC_A: executors.create_connection('sqlite', db_a),
+        SRC_B: executors.create_connection('sqlite', db_b),
+    })
+    return db_a, db_b
+
+
+async def _fetchall(db, sql):
+    cur = await db.execute(sql)
+    rows = await cur.fetchall()
+    await cur.close()
+    return rows
+
+
+async def _count(db, sql):
+    rows = await _fetchall(db, sql)
+    return rows[0][0]
+
+
+events = []
+
+
+# ─── 用例 ────────────────────────────────────────────────────
+
+def test_a2_a3_insert_command_and_callback():
+    """A2/A3 insert 触发链：命令式 + 回调式依序执行，占位符整值替换"""
+
+    async def scenario():
+        db_a, _ = await _setup()
+        doc = await store.insert('TOrder', {'amount': 100, 'status': 'new', 'note': ''})
+        rows = await _fetchall(db_a, 'SELECT _id, kind, ref, amount FROM t_audit ORDER BY kind')
+        await db_a.close()
+        return doc, rows
+
+    doc, rows = _run(scenario())
+    # aud_cmd（与重复同名去重后一次）+ aud_cb
+    assert [r['kind'] for r in rows] == ['cb', 'cmd']
+    cmd = next(r for r in rows if r['kind'] == 'cmd')
+    assert cmd['_id'] == doc['_id'], '{{root._id}} 整值替换'
+    assert cmd['ref'] == doc['_id']
+    assert cmd['amount'] == 100, '{{root.amount}} 整值替换'
+    assert len(cb_calls) == 1, '回调执行一次'
+    assert cb_calls[0]['ref'] == doc['_id'], '回调 args 占位符替换'
+
+
+def test_a3_a4_update_on_fields_hit_and_miss():
+    """A3/A4 update onFields 命中才触发；未命中（值未变/字段不在 onFields）不触发"""
+
+    async def scenario():
+        db_a, _ = await _setup()
+        doc = await store.insert('TOrder', {'amount': 100, 'status': 'new', 'note': ''})
+
+        upd_count = lambda: _count(  # noqa: E731
+            db_a, "SELECT COUNT(*) FROM t_audit WHERE kind = 'upd'")
+        # 未命中：字段不在 onFields
+        await store.update('TOrder', {'_id': doc['_id']}, {'note': 'x'})
+        n_miss_field = await upd_count()
+        # 未命中：值未变（no-op 抑制）
+        await store.update('TOrder', {'_id': doc['_id']}, {'amount': 100})
+        n_miss_value = await upd_count()
+        # 命中：amount 真变
+        updated = await store.update('TOrder', {'_id': doc['_id']}, {'amount': 200})
+        rows = await _fetchall(db_a, "SELECT ref, amount FROM t_audit WHERE kind = 'upd'")
+        await db_a.close()
+        return n_miss_field, n_miss_value, updated, rows, doc
+
+    n_miss_field, n_miss_value, updated, rows, doc = _run(scenario())
+    assert n_miss_field == 0, 'onFields 外的字段变化不触发'
+    assert n_miss_value == 0, 'onFields 字段值未变不触发'
+    assert updated['amount'] == 200
+    assert len(rows) == 1
+    assert rows[0]['ref'] == doc['_id'], '{{root._id}}'
+    assert rows[0]['amount'] == 200, '{{root.amount}} = 主写后的新值'
+
+
+def test_a5_rollback_callback_failure():
+    """A5 单源回滚：触发回调失败 → 主写整体回滚"""
+
+    async def scenario():
+        db_a, _ = await _setup()
+        with pytest.raises(RuntimeError, match='boom-err'):
+            await store.insert('TBoom', {})
+        n = await _count(db_a, 'SELECT COUNT(*) FROM t_boom')
+        await db_a.close()
+        return n
+
+    assert _run(scenario()) == 0, '主写已回滚'
+
+
+def test_a5_rollback_command_failure():
+    """A5 单源回滚：命令式触发写失败 → 主写整体回滚"""
+
+    async def scenario():
+        db_a, _ = await _setup()
+        # 预置同 _id 审计行 → 触发 insertOne 主键冲突 → 触发链失败 → 主写回滚
+        await db_a.execute(
+            "INSERT INTO t_audit (_id, kind, ref, amount) VALUES"
+            " ('fixed-collision', 'seed', '', 0)")
+        await db_a.commit()
+        with pytest.raises(Exception, match='UNIQUE constraint failed'):
+            await store.insert('TCmdFail', {'amount': 1})
+        n = await _count(db_a, 'SELECT COUNT(*) FROM t_cmd_fail')
+        await db_a.close()
+        return n
+
+    assert _run(scenario()) == 0, '主写已回滚'
+
+
+def test_a6_cross_source_non_atomic():
+    """A6 跨源触发链：发 non_atomic_write（含涉及源）并顺序执行落库"""
+
+    async def scenario():
+        db_a, db_b = await _setup()
+        doc = await store.insert('TXOrder', {'amount': 1})
+        rows = await _fetchall(db_b, f'SELECT COUNT(*) FROM t_x_audit WHERE ref = {doc["_id"]!r}')
+        await db_a.close()
+        await db_b.close()
+        return rows[0][0]
+
+    n = _run(scenario())
+    listed = [e for e in events if e.get('type') == 'non_atomic_write']
+    assert len(listed) == 1, '恰发一次 non_atomic_write 声明'
+    assert listed[0]['sources'] == sorted([SRC_A, SRC_B]), '声明含全部涉及源'
+    assert n == 1, '跨源触发写已落库（顺序执行，非原子）'
+
+
+def test_a6_session_cross_source_fail_closed():
+    """A6 会话内跨源触发 fail-closed：NonAtomicWriteError 且全部回滚"""
+
+    async def scenario():
+        from py_store import NonAtomicWriteError
+        db_a, db_b = await _setup()
+        try:
+            async with store.session() as s:
+                await s.insert('TXOrder', {'amount': 1})
+        except NonAtomicWriteError:
+            pass
+        else:
+            raise AssertionError('应抛 NonAtomicWriteError')
+        n_order = await _count(db_a, 'SELECT COUNT(*) FROM t_x_order')
+        n_audit = await _count(db_b, 'SELECT COUNT(*) FROM t_x_audit')
+        await db_a.close()
+        await db_b.close()
+        return n_order, n_audit
+
+    n_order, n_audit = _run(scenario())
+    assert n_order == 0, '主写已回滚'
+    assert n_audit == 0, '触发写已回滚'
+
+
+def test_a8_same_transaction_dedupe():
+    """A8 同事务去重：同名触发只执行一次（若不去重将主键冲突整体失败）"""
+
+    async def scenario():
+        db_a, _ = await _setup()
+        doc = await store.insert('TOrder', {'amount': 7, 'status': 'new', 'note': ''})
+        n = await _count(
+            db_a, f"SELECT COUNT(*) FROM t_audit WHERE kind = 'cmd' AND _id = {doc['_id']!r}")
+        await db_a.close()
+        return n
+
+    assert _run(scenario()) == 1, '同名 (aud_cmd) 触发去重后只执行一次'
+
+
+def test_a9_text2query_rejects_triggers():
+    """A9 text2query 档：触发器显式拒绝（ProfileViolation + profile_blocked 反馈）"""
+
+    async def scenario():
+        await _setup()
+        store.set_profile('text2query')
+        with pytest.raises(ProfileViolation):
+            await store.insert('TOrder', {'amount': 1, 'status': 'new', 'note': ''})
+
+    _run(scenario())
+    blocked = [e for e in events if e.get('type') == 'profile_blocked']
+    assert len(blocked) == 1, '发 profile_blocked 反馈事件'
+
+
+def test_trigger_fn_missing_start_and_runtime():
+    """回调缺实现：启动期 assert_trigger_fns_covered 与运行期均显式报 ERR_TRIGGER_FN_MISSING"""
+    with pytest.raises(RuntimeError, match='ERR_TRIGGER_FN_MISSING'):
+        store.assert_trigger_fns_covered(
+            [{'name': 'X', 'triggers': {'insert': [{'fnRef': 'ghost'}]}}])
+
+    async def scenario():
+        await _setup()
+        await store.insert('TGhost', {})
+
+    with pytest.raises(RuntimeError, match='ERR_TRIGGER_FN_MISSING'):
+        _run(scenario())
+
+
+def test_placeholder_embed_is_err():
+    """占位符内嵌拼接：显式报 ERR_TRIGGER_PLACEHOLDER（禁静默漂移）"""
+    scope = {'root': {'_id': 'x'}, 'before': None, 'now': 1}
+    with pytest.raises(ValueError, match='ERR_TRIGGER_PLACEHOLDER'):
+        resolve_trigger_placeholders('order-{{root._id}}', scope)
+    with pytest.raises(ValueError, match='ERR_TRIGGER_PLACEHOLDER'):
+        resolve_trigger_placeholders('a{{now}}b', scope)
+    # 引用缺失字段 = 整值替换语义（取值缺失 → None），不抛
+    assert resolve_trigger_placeholders('{{root.missing}}', scope) is None