Rename document_store.py to document_store.hpp

document_store.hpp

@@ -0,0 +1,135 @@
+#pragma once
+/*
+ * CollabDocs C++ — Document Store
+ *
+ * Manages in-memory documents with:
+ *   - Snapshot every N ops (fast recovery)
+ *   - OT application with per-doc mutex
+ *   - Bounded op_log (last 2000 ops)
+ */
+
+#include "ot_engine.hpp"
+#include <unordered_map>
+#include <mutex>
+#include <chrono>
+#include <optional>
+#include <memory>
+
+namespace collab {
+
+static constexpr int SNAPSHOT_EVERY_N = 100;
+static constexpr int MAX_OP_LOG       = 2000;
+
+// ─── Snapshot ────────────────────────────────────────────────────────────────
+
+struct Snapshot {
+    int         version;
+    std::string content;
+    double      timestamp;
+};
+
+// ─── Document ────────────────────────────────────────────────────────────────
+
+struct Document {
+    std::string doc_id;
+    std::string title   = "Untitled Document";
+    std::string content;
+    int         version = 0;
+
+    std::vector<std::pair<int, Operation>> op_log;
+    std::vector<Snapshot>                 snapshots;
+
+    double created_at;
+    double updated_at;
+
+    mutable std::mutex mu; // per-doc lock
+
+    explicit Document(std::string id)
+        : doc_id(std::move(id))
+    {
+        auto now = std::chrono::duration_cast<std::chrono::duration<double>>(
+            std::chrono::system_clock::now().time_since_epoch()).count();
+        created_at = updated_at = now;
+    }
+
+    // Non-copyable (has mutex)
+    Document(const Document&) = delete;
+    Document& operator=(const Document&) = delete;
+
+    // Must be called with mu held
+    Operation apply_op_locked(Operation op) {
+        // Transform if client is behind
+        if (op.base_version < version)
+            op = transform_against_log(op, op_log, op.base_version, version);
+
+        // Apply to content
+        content = apply_operation(content, op);
+        version++;
+        op.base_version = version; // stamp
+
+        // Store in log
+        op_log.emplace_back(version, op);
+
+        // Bound log
+        if (static_cast<int>(op_log.size()) > MAX_OP_LOG)
+            op_log.erase(op_log.begin(),
+                         op_log.begin() + (static_cast<int>(op_log.size()) - MAX_OP_LOG));
+
+        // Update timestamp
+        updated_at = std::chrono::duration_cast<std::chrono::duration<double>>(
+            std::chrono::system_clock::now().time_since_epoch()).count();
+
+        // Snapshot
+        if (version % SNAPSHOT_EVERY_N == 0)
+            snapshots.push_back({version, content, updated_at});
+
+        return op;
+    }
+
+    nlohmann::json get_state_json() const;
+};
+
+// ─── Document Store ───────────────────────────────────────────────────────────
+
+class DocumentStore {
+public:
+    // Returns existing or newly created document (thread-safe)
+    std::shared_ptr<Document> get_or_create(const std::string& doc_id) {
+        std::lock_guard<std::mutex> lk(store_mu_);
+        auto it = docs_.find(doc_id);
+        if (it != docs_.end()) return it->second;
+        auto doc = std::make_shared<Document>(doc_id);
+        docs_[doc_id] = doc;
+        return doc;
+    }
+
+    std::shared_ptr<Document> get(const std::string& doc_id) {
+        std::lock_guard<std::mutex> lk(store_mu_);
+        auto it = docs_.find(doc_id);
+        return (it != docs_.end()) ? it->second : nullptr;
+    }
+
+    void update_title(const std::string& doc_id, const std::string& title) {
+        auto doc = get(doc_id);
+        if (doc) {
+            std::lock_guard<std::mutex> lk(doc->mu);
+            doc->title = title;
+        }
+    }
+
+    std::vector<nlohmann::json> list_docs();
+
+    size_t size() const {
+        std::lock_guard<std::mutex> lk(store_mu_);
+        return docs_.size();
+    }
+
+private:
+    mutable std::mutex store_mu_;
+    std::unordered_map<std::string, std::shared_ptr<Document>> docs_;
+};
+
+// Global singleton
+inline DocumentStore g_store;
+
+} // namespace collab

document_store.py

@@ -1,135 +0,0 @@
-"""
-Document Store
-Manages in-memory document state with snapshot support and asyncio locking.
-
-Fixes over original:
-- asyncio.Lock per document prevents concurrent op_apply races
-- Color reclamation in PresenceManager.leave() actually works
-- Snapshot keeps bounded list (max 20 snapshots)
-- get_state() returns a clean dict copy, not references into internal state
-"""
-
-from __future__ import annotations
-
-import asyncio
-import time
-from dataclasses import dataclass, field
-from typing import Dict, List, Optional, Tuple
-
-from ot_engine import Operation, apply_operation, transform_against_log
-
-SNAPSHOT_EVERY_N_OPS = 50
-MAX_SNAPSHOTS = 20
-MAX_OP_LOG = 1000
-
-
-@dataclass
-class Snapshot:
-    version: int
-    content: str
-    timestamp: float = field(default_factory=time.time)
-
-
-@dataclass
-class Document:
-    doc_id: str
-    title: str = "Untitled Document"
-    content: str = ""
-    version: int = 0
-    op_log: List[Tuple[int, Operation]] = field(default_factory=list)
-    snapshots: List[Snapshot] = field(default_factory=list)
-    created_at: float = field(default_factory=time.time)
-    updated_at: float = field(default_factory=time.time)
-    # Per-document lock: prevents concurrent apply_op races
-    _lock: asyncio.Lock = field(default_factory=asyncio.Lock, repr=False, compare=False)
-
-    def get_latest_snapshot(self) -> Optional[Snapshot]:
-        return self.snapshots[-1] if self.snapshots else None
-
-    def _maybe_take_snapshot(self):
-        if self.version > 0 and self.version % SNAPSHOT_EVERY_N_OPS == 0:
-            snap = Snapshot(version=self.version, content=self.content)
-            self.snapshots.append(snap)
-            if len(self.snapshots) > MAX_SNAPSHOTS:
-                self.snapshots = self.snapshots[-MAX_SNAPSHOTS:]
-
-    def _apply_op_unsafe(self, op: Operation) -> Operation:
-        """
-        Internal: apply with OT. Caller must hold self._lock.
-        Returns the (possibly transformed) op that was stamped to the log.
-        """
-        if op.base_version < self.version:
-            op = transform_against_log(
-                op,
-                self.op_log,
-                from_version=op.base_version,
-                to_version=self.version,
-            )
-
-        # Guard: zero-length ops are no-ops
-        if op.op_type == "delete" and op.length <= 0:
-            return op
-
-        self.content = apply_operation(self.content, op)
-        self.version += 1
-        op.base_version = self.version
-
-        self.op_log.append((self.version, op))
-        if len(self.op_log) > MAX_OP_LOG:
-            self.op_log = self.op_log[-MAX_OP_LOG:]
-
-        self.updated_at = time.time()
-        self._maybe_take_snapshot()
-        return op
-
-    async def apply_op(self, op: Operation) -> Operation:
-        """Thread-safe apply via asyncio lock."""
-        async with self._lock:
-            return self._apply_op_unsafe(op)
-
-    def get_state(self) -> dict:
-        return {
-            "doc_id": self.doc_id,
-            "title": self.title,
-            "content": self.content,
-            "version": self.version,
-        }
-
-
-class DocumentStore:
-    def __init__(self):
-        self._docs: Dict[str, Document] = {}
-        self._global_lock = asyncio.Lock()
-
-    async def get_or_create(self, doc_id: str) -> Document:
-        async with self._global_lock:
-            if doc_id not in self._docs:
-                self._docs[doc_id] = Document(doc_id=doc_id)
-            return self._docs[doc_id]
-
-    def get(self, doc_id: str) -> Optional[Document]:
-        return self._docs.get(doc_id)
-
-    def update_title(self, doc_id: str, title: str):
-        doc = self.get(doc_id)
-        if doc:
-            doc.title = title
-
-    def list_docs(self) -> List[dict]:
-        return sorted(
-            [
-                {
-                    "doc_id": d.doc_id,
-                    "title": d.title,
-                    "version": d.version,
-                    "updated_at": d.updated_at,
-                }
-                for d in self._docs.values()
-            ],
-            key=lambda x: x["updated_at"],
-            reverse=True,
-        )
-
-
-# Global singleton
-store = DocumentStore()