初步实现多project pipeline

sync_state_machine/common/persistence_service.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from .persistence import PersistenceBackend
+
+
+class PersistenceService:
+    """Shared persistence service that owns the backend lifecycle."""
+
+    def __init__(self, backend: PersistenceBackend):
+        self._backend = backend
+
+    @property
+    def backend(self) -> PersistenceBackend:
+        return self._backend
+
+    async def initialize(self) -> None:
+        await self._backend.initialize()
+
+    def view(self, scope: str) -> "ScopedPersistenceView":
+        return ScopedPersistenceView(self._backend, scope=scope)
+
+    async def close(self) -> None:
+        await self._backend.close()
+
+
+class ScopedPersistenceView:
+    """Thin scope-bound persistence view used by project runtimes."""
+
+    def __init__(self, backend: PersistenceBackend, *, scope: str):
+        self._backend = backend
+        self.scope = scope
+
+    @property
+    def backend(self) -> PersistenceBackend:
+        return self._backend
+
+    async def load_nodes(
+        self,
+        collection_id: str,
+        *,
+        exclude_node_types: Optional[List[str]] = None,
+    ) -> List[Dict[str, Any]]:
+        return await self._backend.load_nodes(
+            collection_id,
+            self.scope,
+            exclude_node_types=exclude_node_types,
+        )
+
+    async def save_node(self, collection_id: str, node) -> None:
+        await self._backend.save_node(collection_id, self.scope, node)
+
+    async def save_nodes_bulk(self, collection_id: str, nodes) -> None:
+        await self._backend.save_nodes_bulk(collection_id, self.scope, nodes)
+
+    async def delete_node(self, collection_id: str, node_id: str) -> None:
+        await self._backend.delete_node(collection_id, self.scope, node_id)
+
+    async def delete_nodes_bulk(self, collection_id: str, node_ids: List[str]) -> None:
+        await self._backend.delete_nodes_bulk(collection_id, self.scope, node_ids)
+
+    async def load_bindings(self, node_type: str) -> List[Dict[str, Any]]:
+        return await self._backend.load_bindings(self.scope, node_type)
+
+    async def save_binding(self, node_type: str, local_id: str, payload_dict: Dict[str, Any]) -> None:
+        await self._backend.save_binding(self.scope, node_type, local_id, payload_dict)
+
+    async def save_bindings_bulk(self, node_type: str, bindings: Dict[str, Optional[str]]) -> None:
+        await self._backend.save_bindings_bulk(self.scope, node_type, bindings)
+
+    async def delete_binding(self, node_type: str, local_id: str) -> None:
+        await self._backend.delete_binding(self.scope, node_type, local_id)
+
+    async def delete_bindings_bulk(self, node_type: str, local_ids: List[str]) -> None:
+        await self._backend.delete_bindings_bulk(self.scope, node_type, local_ids)
+
+    async def load_bind_data_id_overrides(self, node_type: str) -> Dict[str, Optional[str]]:
+        return await self._backend.load_bind_data_id_overrides(node_type, self.scope)
+
+    async def delete_scope_node_types(self, *, node_types: List[str]) -> None:
+        await self._backend.delete_scope_node_types(scope=self.scope, node_types=node_types)
+
+    async def close(self) -> None:
+        return None