GeneralManager 0.82.0__tar.gz → 0.82.1__tar.gz

{generalmanager-0.82.0/src/GeneralManager.egg-info → generalmanager-0.82.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.82.0
+Version: 0.82.1
 Summary: Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching.
 Author-email: Tim Kleindick <tkleindick@yahoo.de>
 License: MIT License

{generalmanager-0.82.0 → generalmanager-0.82.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GeneralManager"
-version = "0.82.0"
+version = "0.82.1"
 description = "Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching."
 readme = "README.md"
 authors = [{ name = "Tim Kleindick", email = "tkleindick@yahoo.de" }]

{generalmanager-0.82.0 → generalmanager-0.82.1/src/GeneralManager.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.82.0
+Version: 0.82.1
 Summary: Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching.
 Author-email: Tim Kleindick <tkleindick@yahoo.de>
 License: MIT License

{generalmanager-0.82.0 → generalmanager-0.82.1}/src/GeneralManager.egg-info/SOURCES.txt

@@ -82,6 +82,7 @@ src/general_manager/cache/model_dependency_collector.py
 src/general_manager/cache/run_context.py
 src/general_manager/cache/run_context_lru.py
 src/general_manager/cache/signals.py
+src/general_manager/cache/transaction_barrier.py
 src/general_manager/chat/__init__.py
 src/general_manager/chat/audit.py
 src/general_manager/chat/bootstrap.py

{generalmanager-0.82.0 → generalmanager-0.82.1}/src/general_manager/cache/dependency_index.py

@@ -7,7 +7,8 @@ import random
 from threading import Event, Thread
 import time
 import uuid
-from collections.abc import Mapping
+from collections.abc import Iterator, Mapping
+from contextlib import contextmanager
 from contextvars import ContextVar
 from datetime import date, datetime
 from time import perf_counter
@@ -73,6 +74,9 @@ _pending_graphql_rewarm_cache_keys: ContextVar[frozenset[str]] = ContextVar(
     "general_manager_pending_graphql_rewarm_cache_keys",
     default=frozenset(),
 )
+_dependency_rewarm_scope_depth: ContextVar[int] = ContextVar(
+    "general_manager_dependency_rewarm_scope_depth", default=0
+)
 
 
 class DependencyLockTimeoutError(TimeoutError):
@@ -118,6 +122,8 @@ DEPENDENCY_GENERATION_KEY = "dependency_index_generation"
 DATA_CHANGE_LOCK_KEY = "dependency_index_data_change_lock"
 DATA_CHANGE_COUNT_KEY = "dependency_index_data_change_count"
 DATA_CHANGE_RECOVERY_KEY = "dependency_index_data_change_recovery"
+DATA_CHANGE_OWNERS_KEY = "dependency_index_data_change_owners"
+COMMITTED_GRAPHQL_REWARM_KEY = "dependency_index_committed_graphql_rewarm"
 LOCK_TIMEOUT = 5  # Lock TTL in seconds
 UNDEFINED = object()  # Sentinel for undefined values
 ACTIONS: tuple[Literal["filter"], Literal["exclude"]] = ("filter", "exclude")
@@ -241,6 +247,15 @@ def _set_dependency_data_change_count(count: int) -> int:
     return count
 
 
+def _get_dependency_data_change_owners() -> frozenset[str]:
+    owners = cache.get(DATA_CHANGE_OWNERS_KEY, frozenset())
+    if not isinstance(owners, frozenset) or not all(
+        isinstance(owner, str) for owner in owners
+    ):
+        raise DependencyBarrierStateError("journal")
+    return owners
+
+
 def _discard_active_context_dependency_cache_state() -> None:
     from general_manager.cache.run_context import current_calculation_run_context
 
@@ -304,10 +319,21 @@ def _clear_data_change_recovery(
 
 
 def _prepare_data_change_recovery(
-    token: DependencyLockToken, count: int, flag: object
+    token: DependencyLockToken,
+    count: int,
+    flag: object,
+    owners: frozenset[str],
+    generation: int | None = None,
 ) -> dict[str, object]:
     _require_data_change_lock_owner(token)
-    recovery: dict[str, object] = {"owner": token, "count": count, "flag": flag}
+    recovery: dict[str, object] = {
+        "owner": token,
+        "count": count,
+        "flag": flag,
+        "owners": owners,
+    }
+    if generation is not None:
+        recovery["generation"] = generation
     cache.set(DATA_CHANGE_RECOVERY_KEY, recovery, None)
     _verify_data_change_cache_value(DATA_CHANGE_RECOVERY_KEY, recovery)
     return recovery
@@ -321,6 +347,24 @@ def _recover_data_change_barrier(token: DependencyLockToken) -> None:
     # previous snapshot never overwrites a later operation's active barrier.
     if not isinstance(recovery, dict) or not isinstance(recovery.get("count"), int):
         raise DependencyBarrierStateError("journal")
+    generation = recovery.get("generation")
+    if generation is not None:
+        if not isinstance(generation, int):
+            raise DependencyBarrierStateError("journal")
+        _require_data_change_lock_owner(token)
+        generation = max(get_dependency_generation(), generation)
+        _set_dependency_generation(generation)
+        _verify_data_change_cache_value(DEPENDENCY_GENERATION_KEY, generation)
+    # Older journals have no owner set. Retain compatibility with #519 recovery.
+    if "owners" in recovery:
+        owners = recovery["owners"]
+        if not isinstance(owners, frozenset) or not all(
+            isinstance(owner, str) for owner in owners
+        ):
+            raise DependencyBarrierStateError("journal")
+        _require_data_change_lock_owner(token)
+        cache.set(DATA_CHANGE_OWNERS_KEY, owners, None)
+        _verify_data_change_cache_value(DATA_CHANGE_OWNERS_KEY, owners)
     _require_data_change_lock_owner(token)
     count = recovery["count"]
     _set_dependency_data_change_count(count)
@@ -359,7 +403,7 @@ def _release_data_change_lock(token: DependencyLockToken) -> None:
         logger.exception("dependency data-change mutex release failed")
 
 
-def begin_dependency_data_change() -> int:
+def begin_dependency_data_change(*, owner: str | None = None) -> int:
     """Open a publish barrier, preserving a recoverable pre-begin snapshot.
 
     Failed starts restore only their own count/flag under the mutex. If cleanup
@@ -375,8 +419,11 @@ def begin_dependency_data_change() -> int:
         _recover_data_change_barrier(lock_token)
         count = _get_dependency_data_change_count()
         flag = cache.get(DATA_CHANGE_LOCK_KEY)
-        recovery = {"owner": lock_token, "count": count, "flag": flag}
-        _prepare_data_change_recovery(lock_token, count, flag)
+        owners = _get_dependency_data_change_owners()
+        if owner is not None and owner in owners:
+            return get_dependency_generation()
+        recovery = {"owner": lock_token, "count": count, "flag": flag, "owners": owners}
+        _prepare_data_change_recovery(lock_token, count, flag, owners)
         _require_data_change_lock_owner(lock_token)
         generation = _set_dependency_generation(get_dependency_generation() + 1)
         _verify_data_change_cache_value(DEPENDENCY_GENERATION_KEY, generation)
@@ -386,6 +433,10 @@ def begin_dependency_data_change() -> int:
         _require_data_change_lock_owner(lock_token)
         cache.set(DATA_CHANGE_LOCK_KEY, "1", None)
         _verify_data_change_cache_value(DATA_CHANGE_LOCK_KEY, "1")
+        if owner is not None:
+            _require_data_change_lock_owner(lock_token)
+            cache.set(DATA_CHANGE_OWNERS_KEY, owners | {owner}, None)
+            _verify_data_change_cache_value(DATA_CHANGE_OWNERS_KEY, owners | {owner})
         _discard_active_context_dependency_cache_state()
         _clear_data_change_recovery(lock_token, recovery)
     except Exception:
@@ -400,18 +451,35 @@ def begin_dependency_data_change() -> int:
     return generation
 
 
-def end_dependency_data_change() -> None:
-    """Close one barrier, journaling its completed operation for forward recovery."""
+def end_dependency_data_change(*, owner: str | None = None) -> None:
+    """Fence in-flight calculations and close one barrier with forward recovery.
+
+    Owned ends are idempotent, including when cache writes applied then raised.
+    A retry completes the journal before checking ownership, so it cannot
+    decrement another transaction's barrier.
+    """
     if isinstance(caches["default"], DummyCache):
         return
     lock_token = acquire_lock_with_retry("end_dependency_data_change")
     recovery: dict[str, object] | None = None
     try:
         _recover_data_change_barrier(lock_token)
+        owners = _get_dependency_data_change_owners()
+        if owner is not None and owner not in owners:
+            return
+        if owner is not None:
+            owners = owners - {owner}
         count = max(_get_dependency_data_change_count() - 1, 0)
         flag = "1" if count else None
-        recovery = {"owner": lock_token, "count": count, "flag": flag}
-        _prepare_data_change_recovery(lock_token, count, flag)
+        generation = get_dependency_generation() + 1
+        recovery = {
+            "owner": lock_token,
+            "count": count,
+            "flag": flag,
+            "owners": owners,
+            "generation": generation,
+        }
+        _prepare_data_change_recovery(lock_token, count, flag, owners, generation)
         _recover_data_change_barrier(lock_token)
     except Exception:
         if recovery is not None:
@@ -449,6 +517,50 @@ def drain_invalidated_cache_keys_for_graphql_rewarm() -> tuple[str, ...]:
     return cache_keys
 
 
+def record_committed_graphql_rewarm_keys(cache_keys: Iterable[str]) -> None:
+    """Share committed work with the process that closes the final barrier."""
+    keys = frozenset(cache_keys)
+    if not keys:
+        return
+    token = acquire_lock_with_retry("record_committed_graphql_rewarm_keys")
+    try:
+        existing = cache.get(COMMITTED_GRAPHQL_REWARM_KEY, frozenset())
+        cache.set(COMMITTED_GRAPHQL_REWARM_KEY, existing | keys, None)
+    finally:
+        release_lock(token)
+
+
+def drain_committed_graphql_rewarm_keys() -> tuple[str, ...]:
+    """Claim committed keys only when no writer is pausing publication."""
+    if not cache.get(COMMITTED_GRAPHQL_REWARM_KEY):
+        return ()
+    token = acquire_lock_with_retry("drain_committed_graphql_rewarm_keys")
+    try:
+        if is_dependency_data_change_active():
+            return ()
+        keys = tuple(sorted(cache.get(COMMITTED_GRAPHQL_REWARM_KEY, frozenset())))
+        cache.delete(COMMITTED_GRAPHQL_REWARM_KEY)
+        return keys
+    finally:
+        release_lock(token)
+
+
+@contextmanager
+def dependency_rewarm_scope() -> Iterator[None]:
+    """Isolate a mutation's keys from enclosing writes on other connections."""
+    depth = _dependency_rewarm_scope_depth.get()
+    scope_token = _dependency_rewarm_scope_depth.set(depth + 1)
+    token = _pending_graphql_rewarm_cache_keys.set(frozenset()) if depth else None
+    try:
+        yield
+    finally:
+        if token is not None:
+            remaining = _pending_graphql_rewarm_cache_keys.get()
+            _pending_graphql_rewarm_cache_keys.reset(token)
+            record_invalidated_cache_keys_for_graphql_rewarm(remaining)
+        _dependency_rewarm_scope_depth.reset(scope_token)
+
+
 def acquire_lock_with_retry(operation: str) -> DependencyLockToken:
     """
     Acquire the dependency index lock, retrying with exponential backoff.

{generalmanager-0.82.0 → generalmanager-0.82.1}/src/general_manager/cache/signals.py

@@ -123,6 +123,11 @@ def data_change(
             is_dependency_data_change_active,
         )
         from general_manager.cache.run_context import current_calculation_run_context
+        from general_manager.cache.transaction_barrier import (
+            collect_transaction_rewarm_keys,
+            flush_transaction_rewarm_keys,
+            hold_dependency_transaction_barrier,
+        )
         from general_manager.interface.orm_interface import OrmInterfaceBase
         from general_manager.manager.bulk_create import (
             CreateManyUnsupportedError,
@@ -179,6 +184,8 @@ def data_change(
         transaction_outcome = "rolled_back"
         begin_dependency_data_change()
         try:
+            if is_orm_backed:
+                hold_dependency_transaction_barrier(database_alias)
             context = current_calculation_run_context()
             if context is not None:
                 context.clear_orm_bucket_results()
@@ -294,6 +301,8 @@ def data_change(
                         sender=sender,
                         **lifecycle_kwargs,
                     )
+                if is_orm_backed:
+                    collect_transaction_rewarm_keys(database_alias, completed=True)
             if transaction_scope is not None and transaction_scope.is_outermost:
                 transaction_outcome = "committed"
             completed = True
@@ -333,8 +342,15 @@ def data_change(
                     raise
             finally:
                 try:
+                    collected = is_orm_backed and collect_transaction_rewarm_keys(
+                        database_alias, completed=completed
+                    )
                     if not is_dependency_data_change_active():
-                        cache_keys = drain_invalidated_cache_keys_for_graphql_rewarm()
+                        if not collected:
+                            cache_keys = (
+                                drain_invalidated_cache_keys_for_graphql_rewarm()
+                            )
+                        flush_transaction_rewarm_keys()
                 except Exception:
                     if primary_exc is not None:
                         logger.exception(
@@ -355,9 +371,10 @@ def data_change(
 
     @wraps(decorator_source)
     def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+        from general_manager.cache.dependency_index import dependency_rewarm_scope
         from general_manager.manager.bulk_create import create_many_signal_scope
 
-        with create_many_signal_scope():
+        with create_many_signal_scope(), dependency_rewarm_scope():
             return perform_change(*args, **kwargs)
 
     return wrapper

generalmanager-0.82.1/src/general_manager/cache/transaction_barrier.py

@@ -0,0 +1,283 @@
+"""Retain native dependency-cache barriers until database completion."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from functools import wraps
+import sys
+from typing import Callable, cast
+from uuid import uuid4
+
+from django.db import connections
+from django.db.backends.base.base import BaseDatabaseWrapper
+from django.utils.connection import ConnectionDoesNotExist
+
+from general_manager.logging import get_logger
+
+logger = get_logger("cache.transaction_barrier")
+_STATE_ATTRIBUTE = "_general_manager_dependency_barrier"
+
+
+def _clear_transaction_run_cache() -> None:
+    from general_manager.cache.run_context import current_calculation_run_context
+
+    context = current_calculation_run_context()
+    if context is not None:
+        try:
+            context.discard_dependency_cache_state()
+        finally:
+            # Fallible lease cleanup must not preserve rolled-back DB rows.
+            context.clear_orm_bucket_results()
+            context.clear_bucket_indexes()
+            context.clear_bucket_projections()
+            context.clear_trusted_orm_managers()
+
+
+@dataclass
+class _TransactionBarrier:
+    connection: BaseDatabaseWrapper
+    owner: str | None = None
+    release_pending: bool = False
+    completion_committed: bool | None = None
+    restore_hooks: Callable[[bool], None] | None = None
+
+    def finish(self, *, committed: bool) -> None:
+        from general_manager.cache.dependency_index import end_dependency_data_change
+
+        if self.owner is None:
+            if self.restore_hooks is not None:
+                self.restore_hooks(False)
+            return
+        if self.completion_committed is None:
+            self.completion_committed = committed
+        self.release_pending = True
+        # Keep the owner on an error. Owner-aware end can be retried even when
+        # transport failure followed an applied decrement.
+        try:
+            end_dependency_data_change(owner=self.owner)
+        except BaseException:
+            try:
+                _clear_transaction_run_cache()
+            except BaseException:
+                logger.exception("Transaction run-cache cleanup failed.")
+            raise
+        # Ownership reflects the shared barrier, independently of fallible
+        # run-local cleanup. A released owner must not block the next write.
+        self.owner = None
+        self.release_pending = False
+        self.completion_committed = None
+        try:
+            _clear_transaction_run_cache()
+        finally:
+            if self.restore_hooks is not None:
+                self.restore_hooks(False)
+
+
+def _install_completion_hooks(connection: BaseDatabaseWrapper) -> _TransactionBarrier:
+    state = _TransactionBarrier(connection)
+    original_commit = connection.commit
+    original_rollback = connection.rollback
+    original_close = connection.close
+    original_savepoint_rollback = connection.savepoint_rollback
+    original_set_autocommit = connection.set_autocommit
+
+    @wraps(original_commit)
+    def commit() -> None:
+        original_commit()
+        try:
+            state.finish(committed=True)
+        except Exception:
+            # A DB-backed cache can raise DatabaseError here. SQL already
+            # committed; Django must still run its commit callbacks, rather
+            # than mistake this ancillary failure for a failed SQL commit.
+            logger.exception("Dependency barrier cleanup after commit failed.")
+
+    @wraps(original_rollback)
+    def rollback() -> None:
+        original_rollback()
+        try:
+            state.finish(committed=False)
+        except Exception:
+            # Atomic may be unwinding a primary mutation/database exception.
+            logger.exception("Dependency barrier cleanup after rollback failed.")
+
+    @wraps(original_close)
+    def close() -> None:
+        try:
+            original_close()
+        finally:
+            # SQLite's in-memory close is a no-op: it hasn't settled a pending
+            # transaction and must not reopen cache publication.
+            if connection.connection is None or connection.closed_in_transaction:
+                try:
+                    state.finish(committed=False)
+                except Exception:
+                    logger.exception("Dependency barrier cleanup after close failed.")
+
+    @wraps(original_savepoint_rollback)
+    def savepoint_rollback(sid: str) -> None:
+        original_savepoint_rollback(sid)
+        if state.owner is not None:
+            try:
+                _clear_transaction_run_cache()
+            except Exception:
+                logger.exception(
+                    "Dependency cache cleanup after savepoint rollback failed."
+                )
+
+    @wraps(original_set_autocommit)
+    def set_autocommit(
+        autocommit: bool, force_begin_transaction_with_broken_autocommit: bool = False
+    ) -> None:
+        # Atomic's finally can restore autocommit while a commit interruption
+        # is already unwinding. An ancillary retry must preserve that primary.
+        primary: BaseException | None = sys.exception()
+        try:
+            original_set_autocommit(
+                autocommit,
+                force_begin_transaction_with_broken_autocommit,
+            )
+        except BaseException as error:
+            primary = error
+            raise
+        finally:
+            # User on_commit callbacks run inside set_autocommit and can raise
+            # after the DB already committed. Cleanup must still run.
+            if autocommit and connection.autocommit and not connection.in_atomic_block:
+                rolled_back = state.completion_committed is False
+                try:
+                    state.finish(committed=True)
+                    flush_transaction_rewarm_keys()
+                except Exception:
+                    if primary is None and not rolled_back:
+                        raise
+                    logger.exception("Dependency barrier cleanup after commit failed.")
+
+    hooks = (
+        ("commit", commit),
+        ("rollback", rollback),
+        ("close", close),
+        ("savepoint_rollback", savepoint_rollback),
+        ("set_autocommit", set_autocommit),
+    )
+    missing = object()
+    previous = {name: vars(connection).get(name, missing) for name, _ in hooks}
+
+    def restore_hooks(force: bool) -> None:
+        # Remove only our instance overrides. Restoring class lookup avoids
+        # retaining bound-method cycles on completed thread-local connections.
+        # Keep the completion setter until Django restores autocommit. Eager
+        # warm-up must not open a new SQL transaction before that restoration.
+        defer_dispatch = (
+            not force
+            and connection.connection is not None
+            and not connection.autocommit
+            and not connection.closed_in_transaction
+        )
+        for name, hook in hooks:
+            if defer_dispatch and name in {"close", "set_autocommit"}:
+                continue
+            if vars(connection).get(name) is hook:
+                if previous[name] is missing:
+                    vars(connection).pop(name, None)
+                else:
+                    setattr(connection, name, previous[name])
+        if not defer_dispatch:
+            if getattr(connection, _STATE_ATTRIBUTE, None) is state:
+                vars(connection).pop(_STATE_ATTRIBUTE, None)
+            state.restore_hooks = None
+
+    state.restore_hooks = restore_hooks
+    for name, hook in hooks:
+        setattr(connection, name, hook)
+    setattr(connection, _STATE_ATTRIBUTE, state)
+    return state
+
+
+def hold_dependency_transaction_barrier(database_alias: str) -> None:
+    """Hold one owned barrier through all savepoints on a writing connection."""
+    from general_manager.cache.dependency_index import begin_dependency_data_change
+
+    try:
+        connection = connections[database_alias]
+    except ConnectionDoesNotExist:
+        # Lightweight signal callers sometimes replace transaction.atomic.
+        # The real atomic operation remains responsible for rejecting aliases.
+        return
+    if not connection.in_atomic_block and (
+        connection.autocommit
+        or (connection.connection is None and connection.settings_dict["AUTOCOMMIT"])
+    ):
+        return
+    state = cast(
+        _TransactionBarrier | None, getattr(connection, _STATE_ATTRIBUTE, None)
+    )
+    if state is not None:
+        if state.release_pending:
+            state.finish(committed=False)
+        if state.owner is None:
+            # A manual transaction can write again before restoring
+            # autocommit. Replace its completed lifecycle before acquiring
+            # another owner, including the deferred completion setter.
+            if state.restore_hooks is not None:
+                state.restore_hooks(True)
+            state = None
+    if state is None:
+        state = _install_completion_hooks(connection)
+    if state.owner is None:
+        owner = uuid4().hex
+        try:
+            begin_dependency_data_change(owner=owner)
+        except BaseException:
+            if state.restore_hooks is not None:
+                state.restore_hooks(True)
+            raise
+        state.owner = owner
+
+
+def collect_transaction_rewarm_keys(database_alias: str, *, completed: bool) -> bool:
+    """Register eligible work with Django's savepoint-aware commit callbacks.
+
+    Callbacks own only optional warm-up work, never the transaction barrier.
+    Discarding them on rollback therefore cannot leak a barrier.
+    """
+    from general_manager.cache.dependency_index import (
+        drain_invalidated_cache_keys_for_graphql_rewarm,
+        record_committed_graphql_rewarm_keys,
+    )
+
+    try:
+        connection = connections[database_alias]
+    except ConnectionDoesNotExist:
+        return False
+    if connection.connection is None or (
+        not connection.in_atomic_block and not connection.autocommit
+    ):
+        return False
+    keys = drain_invalidated_cache_keys_for_graphql_rewarm()
+    if completed and keys:
+
+        def committed_rewarm() -> None:
+            try:
+                record_committed_graphql_rewarm_keys(keys)
+                flush_transaction_rewarm_keys()
+            except Exception:
+                logger.exception("GraphQL warm-up requeue failed.")
+
+        connection.on_commit(committed_rewarm)
+    return True
+
+
+def flush_transaction_rewarm_keys() -> None:
+    """Dispatch shared committed work after the final mutation barrier closes."""
+    try:
+        from general_manager.cache.dependency_index import (
+            drain_committed_graphql_rewarm_keys,
+        )
+        from general_manager.api.graphql_warmup import enqueue_graphql_recipe_warmup
+
+        keys = drain_committed_graphql_rewarm_keys()
+        if keys:
+            enqueue_graphql_recipe_warmup(keys)
+    except Exception:
+        logger.exception("GraphQL warm-up requeue failed.")

{generalmanager-0.82.0 → generalmanager-0.82.1}/src/general_manager/interface/capabilities/orm/create_many.py

@@ -286,6 +286,7 @@ class OrmCreateManyCapability(BaseCapability):
                             if use_bulk_sql:
                                 from general_manager.cache.dependency_index import (
                                     begin_dependency_data_change,
+                                    dependency_rewarm_scope,
                                     drain_invalidated_cache_keys_for_graphql_rewarm,
                                     end_dependency_data_change,
                                     is_dependency_data_change_active,
@@ -293,6 +294,10 @@ class OrmCreateManyCapability(BaseCapability):
                                 from general_manager.cache.run_context import (
                                     current_calculation_run_context,
                                 )
+                                from general_manager.cache.transaction_barrier import (
+                                    collect_transaction_rewarm_keys,
+                                    hold_dependency_transaction_barrier,
+                                )
                                 from general_manager.cache.batch_refresh import (
                                     flush_batch_refresh_callbacks,
                                 )
@@ -302,9 +307,15 @@ class OrmCreateManyCapability(BaseCapability):
 
                                 run_context = current_calculation_run_context()
                                 bulk_succeeded = False
-                                with create_many_signal_scope():
+                                with (
+                                    create_many_signal_scope(),
+                                    dependency_rewarm_scope(),
+                                ):
                                     begin_dependency_data_change()
                                     try:
+                                        hold_dependency_transaction_barrier(
+                                            database_alias
+                                        )
                                         if run_context is not None:
                                             run_context.clear_orm_bucket_results()
                                             run_context.clear_bucket_indexes()
@@ -347,9 +358,13 @@ class OrmCreateManyCapability(BaseCapability):
                                             run_context.clear_bucket_projections()
                                             run_context.clear_trusted_orm_managers()
                                         end_dependency_data_change()
+                                        collected = collect_transaction_rewarm_keys(
+                                            database_alias, completed=bulk_succeeded
+                                        )
                                         cache_keys = (
                                             drain_invalidated_cache_keys_for_graphql_rewarm()
-                                            if not is_dependency_data_change_active()
+                                            if not collected
+                                            and not is_dependency_data_change_active()
                                             else ()
                                         )
                                         if bulk_succeeded and cache_keys:

{generalmanager-0.82.0 → generalmanager-0.82.1}/src/general_manager/utils/testing.py

@@ -25,6 +25,8 @@ from general_manager.cache.cache_decorator import _SENTINEL
 from general_manager.cache.dependency_index import (
     DATA_CHANGE_COUNT_KEY,
     DATA_CHANGE_LOCK_KEY,
+    DATA_CHANGE_OWNERS_KEY,
+    COMMITTED_GRAPHQL_REWARM_KEY,
     DATA_CHANGE_RECOVERY_KEY,
     DEPENDENCY_GENERATION_KEY,
     INDEX_KEY,
@@ -50,6 +52,8 @@ _original_get_app: Callable[[str], AppConfig | None] = (
 _DEPENDENCY_COORDINATION_KEYS = {
     DATA_CHANGE_COUNT_KEY,
     DATA_CHANGE_LOCK_KEY,
+    DATA_CHANGE_OWNERS_KEY,
+    COMMITTED_GRAPHQL_REWARM_KEY,
     DATA_CHANGE_RECOVERY_KEY,
     DEPENDENCY_GENERATION_KEY,
     INDEX_KEY,