nedb-engine 1.2.0__tar.gz → 1.2.2__tar.gz

{nedb_engine-1.2.0 → nedb_engine-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nedb-engine
-Version: 1.2.0
+Version: 1.2.2
 Summary: NEDB — a versioned, self-compressing, time-traveling embedded database (replay-protected, idempotent, relational, searchable) with durable AOF persistence and a server daemon (nedbd).
 Project-URL: Homepage, https://github.com/Eth-Interchained/nedb
 Project-URL: Repository, https://github.com/Eth-Interchained/nedb

{nedb_engine-1.2.0 → nedb_engine-1.2.2}/pyproject.toml

@@ -10,7 +10,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nedb-engine"
-version = "1.2.0"
+version = "1.2.2"
 description = "NEDB — a versioned, self-compressing, time-traveling embedded database (replay-protected, idempotent, relational, searchable) with durable AOF persistence and a server daemon (nedbd)."
 readme = "README.md"
 requires-python = ">=3.8"

{nedb_engine-1.2.0 → nedb_engine-1.2.2}/python/nedb/__init__.py

@@ -47,4 +47,4 @@ __all__ = [
     "wrap_redis", "WrappedRedis",
     "_native", "__has_native__",
 ]
-__version__ = "1.2.0"
+__version__ = "1.2.2"

{nedb_engine-1.2.0 → nedb_engine-1.2.2}/python/nedb/engine.py

@@ -29,7 +29,9 @@ def apply_op(store: MVCCStore, relations: Relations, indexes: Indexes, op: Op,
     """Deterministically fold one op into materialized state."""
     p = op.payload
     if op.op == "put":
-        key, coll, doc = p["key"], p["coll"], p["doc"]
+        key, coll = p["key"], p["coll"]
+        doc = dict(p["doc"])          # copy so we don't mutate the op payload
+        doc["_seq"] = op.seq          # inject sequence number into every stored doc
         old = store.get(key)
         if old is not None:
             indexes.remove(coll, key, old)
@@ -638,7 +640,10 @@ class NEDB:
                             if op.op == "put" and op.payload.get("key") == key_p:
                                 queue.append(op.seq)
                                 break
-                for seq in queue:
+                # BFS — feed found dep_seqs back into the queue for full
+                # transitive traversal (mirrors the backward TRACE frontier loop).
+                while queue:
+                    seq = queue.pop(0)
                     for dep_seq in self.cause_map.get(seq, []):
                         if dep_seq in visited_seqs_fwd:
                             continue
@@ -650,6 +655,7 @@ class NEDB:
                                 dep_doc = self.store.get(dep_key, as_of)
                                 if dep_doc is not None:
                                     out_fwd.append((dep_key, dep_doc))
+                                    queue.append(dep_seq)  # continue BFS
                 rows = out_fwd
 
         if plan.get("limit") is not None:

{nedb_engine-1.2.0 → nedb_engine-1.2.2}/python/nedb/server.py

@@ -320,7 +320,11 @@ def make_handler(manager: Manager, token: Optional[str]):
                         coll, rid, doc = b.get("coll"), b.get("id"), b.get("doc")
                         if not coll or rid is None or not isinstance(doc, dict):
                             raise HttpError(400, "coll, id, and doc are required")
-                        kw = {k: b[k] for k in ("client", "nonce", "idem") if b.get(k) is not None}
+                        _scalar = ("client", "nonce", "idem", "evidence", "confidence",
+                                   "valid_from", "valid_to")
+                        kw = {k: b[k] for k in _scalar if b.get(k) is not None}
+                        if b.get("caused_by") is not None:
+                            kw["caused_by"] = list(b["caused_by"])
                         try:
                             stored = db.put(str(coll), str(rid), dict(doc), **kw)
                         except ReplayError as e:

{nedb_engine-1.2.0 → nedb_engine-1.2.2}/python/nedb/wrap_redis.py

@@ -38,11 +38,157 @@ from __future__ import annotations
 import fnmatch
 import json
 import re
+import urllib.error
+import urllib.request
 from typing import Any, Callable, Dict, List, Optional
 
 from .engine import NEDB as _NEDB
 from .backends.redis_backend import RedisBackend
 
+
+# ── NedBdProxy ────────────────────────────────────────────────────────────────
+
+class NedBdProxy:
+    """
+    Drop-in replacement for the in-process NEDB engine when a nedbd server
+    is available.  All r.nedb.* calls are forwarded to nedbd's HTTP/JSON API
+    instead of running in-process.
+
+    Usage::
+
+        r = wrap_redis(redis.Redis(...), db_name="rideshare",
+                       nedbd_url="http://localhost:8421",
+                       nedbd_token="secret")   # token is optional
+
+    The proxy auto-creates the database on first write.
+    ``head`` and ``seq`` are cached from the last response and refreshed
+    on demand via ``_refresh()``.
+    """
+
+    def __init__(self, base_url: str, db_name: str, token: Optional[str] = None):
+        self._base   = base_url.rstrip("/")
+        self._name   = db_name
+        self._token  = token
+        self._seq: int  = -1
+        self._head: str = "0" * 64
+        self._ensure_db()
+
+    # ── HTTP helpers ─────────────────────────────────────────────────────────
+
+    def _headers(self) -> dict:
+        h = {"Content-Type": "application/json", "Accept": "application/json"}
+        if self._token:
+            h["Authorization"] = f"Bearer {self._token}"
+        return h
+
+    def _req(self, method: str, path: str, body: Optional[dict] = None) -> dict:
+        url  = f"{self._base}{path}"
+        data = json.dumps(body).encode() if body is not None else None
+        req  = urllib.request.Request(url, data=data, headers=self._headers(),
+                                      method=method)
+        try:
+            with urllib.request.urlopen(req, timeout=30) as resp:
+                result = json.loads(resp.read().decode())
+                if "seq"  in result: self._seq  = result["seq"]
+                if "head" in result: self._head = result["head"]
+                return result
+        except urllib.error.HTTPError as e:
+            body_text = e.read().decode("utf-8", errors="replace")
+            try:
+                detail = json.loads(body_text).get("error", body_text)
+            except Exception:
+                detail = body_text
+            raise RuntimeError(f"nedbd {method} {url} → HTTP {e.code}: {detail}") from e
+
+    def _db(self, suffix: str = "") -> str:
+        return f"/v1/databases/{self._name}{suffix}"
+
+    # ── Bootstrap ────────────────────────────────────────────────────────────
+
+    def _ensure_db(self) -> None:
+        """Create the database if it doesn't exist yet; load seq/head if it does."""
+        try:
+            info = self._req("GET", self._db())
+            self._seq  = info.get("seq",  self._seq)
+            self._head = info.get("head", self._head)
+        except RuntimeError as e:
+            if "404" in str(e):
+                self._req("POST", "/v1/databases", {"name": self._name})
+            else:
+                raise
+
+    def _refresh(self) -> None:
+        info = self._req("GET", self._db())
+        self._seq  = info.get("seq",  self._seq)
+        self._head = info.get("head", self._head)
+
+    # ── NEDB engine interface ─────────────────────────────────────────────────
+
+    def put(self, coll: str, id: str, doc: dict, **kw) -> dict:
+        payload: dict = {"coll": coll, "id": id, "doc": doc}
+        for k in ("client", "nonce", "idem", "evidence", "confidence",
+                  "valid_from", "valid_to"):
+            if kw.get(k) is not None:
+                payload[k] = kw[k]
+        if kw.get("caused_by") is not None:
+            payload["caused_by"] = list(kw["caused_by"])
+        result = self._req("POST", self._db("/put"), payload)
+        return result.get("doc", doc)
+
+    def get(self, coll: str, id: str, as_of: Optional[int] = None):
+        as_of_clause = f" AS OF {as_of}" if as_of is not None else ""
+        nql = f'FROM {coll}{as_of_clause} WHERE _id = "{id}"'
+        rows = self._req("POST", self._db("/query"), {"nql": nql}).get("rows", [])
+        return rows[0] if rows else None
+
+    def query(self, nql: str) -> List[dict]:
+        return self._req("POST", self._db("/query"), {"nql": nql}).get("rows", [])
+
+    def create_index(self, coll: str, field: str, kind: str = "eq") -> None:
+        self._req("POST", self._db("/index"), {"coll": coll, "field": field, "kind": kind})
+
+    def delete(self, coll: str, id: str, **_kw) -> None:
+        self._req("DELETE", f"/v1/databases/{self._name}/rows/{coll}/{id}")
+
+    def link(self, frm: str, rel: str, to: str, **_kw) -> None:
+        self._req("POST", self._db("/link"), {"frm": frm, "rel": rel, "to": to})
+
+    def unlink(self, frm: str, rel: str, to: str, **_kw) -> None:
+        # nedbd doesn't have a dedicated unlink endpoint yet — use NQL delete
+        # fallback: store as a tombstone via link with _unlinked flag
+        pass  # no-op; future: DELETE /v1/databases/{name}/links/{frm}/{rel}/{to}
+
+    def neighbors(self, frm: str, rel: str, as_of: Optional[int] = None) -> List[str]:
+        frm_coll, frm_id = (frm.split(":", 1) + [""])[:2]
+        as_of_clause = f" AS OF {as_of}" if as_of is not None else ""
+        nql = f'FROM {frm_coll}{as_of_clause} WHERE _id = "{frm_id}" TRAVERSE {rel}'
+        rows = self._req("POST", self._db("/query"), {"nql": nql}).get("rows", [])
+        return [f"{r.get('_coll', frm_coll)}:{r['_id']}" for r in rows if "_id" in r]
+
+    def inbound(self, to: str, rel: str, as_of: Optional[int] = None) -> List[str]:
+        # Approximate via NQL — nedbd doesn't expose inbound traversal directly
+        to_coll, to_id = (to.split(":", 1) + [""])[:2]
+        nql = f'FROM {to_coll} WHERE _id = "{to_id}" TRAVERSE {rel} REVERSE'
+        try:
+            rows = self._req("POST", self._db("/query"), {"nql": nql}).get("rows", [])
+            return [f"{r.get('_coll', to_coll)}:{r['_id']}" for r in rows if "_id" in r]
+        except Exception:
+            return []
+
+    def verify(self) -> bool:
+        return self._req("GET", self._db("/verify")).get("ok", False)
+
+    def checkpoint(self) -> str:
+        return self._req("POST", self._db("/checkpoint")).get("head", self._head)
+
+    @property
+    def head(self) -> str:
+        return self._head
+
+    @property
+    def seq(self) -> int:
+        return self._seq
+
 # ── Write command detection ──────────────────────────────────────────────────
 
 # Redis commands that mutate state — these are shadowed when shadow_writes=True
@@ -119,22 +265,37 @@ class NEDBSurface:
     - register(pattern, collection, ...)  → teach NEDB about Alice's key structure
     - backfill()                          → one-time import of existing Redis data
     - shadow_writes = True               → auto-chain all surface-1 Redis writes
+
+    nedbd mode (nedbd_url=):
+    - All r.nedb.* calls are forwarded to a running nedbd HTTP server.
+    - nedbd handles its own persistence (durable AOF on disk).
+    - Redis Stream backend is bypassed; _persist_last_op() is a no-op.
     """
 
-    def __init__(self, r: Any, db_name: str):
+    def __init__(self, r: Any, db_name: str,
+                 nedbd_url: Optional[str] = None,
+                 nedbd_token: Optional[str] = None):
         self._r        = r
         self._db_name  = db_name
-        self._backend  = RedisBackend(r, db_name)
         self._mappings: List[CollectionMapping] = []
         self.shadow_writes: bool = False
         self._backfilled: bool = False
+        self._nedbd_mode: bool = nedbd_url is not None
 
-        # Build the NEDB engine and replay from Redis Stream
-        self._db = _NEDB()
-        self._db._backend = self._backend
-        self._reload()
+        if self._nedbd_mode:
+            # Route all NEDB operations to a running nedbd server
+            self._db      = NedBdProxy(nedbd_url, db_name, token=nedbd_token)  # type: ignore[assignment]
+            self._backend = None
+        else:
+            # In-process engine with Redis Stream persistence
+            self._backend = RedisBackend(r, db_name)
+            self._db = _NEDB()
+            self._db._backend = self._backend
+            self._reload()
 
     def _reload(self) -> None:
+        if self._nedbd_mode:
+            return  # nedbd manages its own state
         ops_json = self._backend.read_all()
         if not ops_json:
             return
@@ -155,6 +316,8 @@ class NEDBSurface:
             self._db._nonce = dict(self._db.log._last_nonce)
 
     def _persist_last_op(self) -> None:
+        if self._nedbd_mode:
+            return  # nedbd persists atomically on each HTTP call
         if self._db.log.ops:
             last = self._db.log.ops[-1]
             self._backend.append(json.dumps(last.to_dict()))
@@ -427,12 +590,23 @@ class WrappedRedis:
 
     Surface 1 (r.set/get/hset/…): every Redis command passes through unchanged.
     Surface 2 (r.nedb.*): full NEDB API + backfill + write shadowing.
+
+    nedbd mode::
+
+        r = wrap_redis(redis.Redis(...), db_name="rideshare",
+                       nedbd_url="http://localhost:8421",
+                       nedbd_token="secret")   # token optional
     """
 
-    def __init__(self, r: Any, db_name: str):
+    def __init__(self, r: Any, db_name: str,
+                 nedbd_url: Optional[str] = None,
+                 nedbd_token: Optional[str] = None):
         object.__setattr__(self, "_r",       r)
         object.__setattr__(self, "_db_name", db_name)
-        object.__setattr__(self, "nedb",     NEDBSurface(r, db_name))
+        object.__setattr__(self, "nedb",
+                           NEDBSurface(r, db_name,
+                                       nedbd_url=nedbd_url,
+                                       nedbd_token=nedbd_token))
 
     def __getattr__(self, name: str) -> Any:
         r    = object.__getattribute__(self, "_r")
@@ -454,7 +628,9 @@ class WrappedRedis:
         return f"<WrappedRedis db_name={db!r} redis={r!r}>"
 
 
-def wrap_redis(r: Any, db_name: str = "default") -> WrappedRedis:
+def wrap_redis(r: Any, db_name: str = "default",
+               nedbd_url: Optional[str] = None,
+               nedbd_token: Optional[str] = None) -> WrappedRedis:
     """
     Wrap an existing Redis connection with NEDB's layer-2 features.
 
@@ -462,6 +638,16 @@ def wrap_redis(r: Any, db_name: str = "default") -> WrappedRedis:
         r:        An existing ``redis.Redis`` (or compatible) connection.
         db_name:  Logical database name. NEDB uses ``nedb:{db_name}:*``.
 
+    Args:
+        r:           An existing ``redis.Redis`` (or compatible) connection.
+        db_name:     Logical database name. NEDB uses ``nedb:{db_name}:*``.
+        nedbd_url:   Optional URL of a running nedbd server, e.g.
+                     ``"http://localhost:8421"``.  When set, all ``r.nedb.*``
+                     calls are forwarded to nedbd instead of running in-process.
+                     nedbd handles its own durable AOF persistence on disk.
+        nedbd_token: Optional bearer token for nedbd authentication
+                     (set via ``NEDBD_TOKEN`` env on the server).
+
     Returns:
         A ``WrappedRedis`` with ``.nedb`` for the full NEDB API.
 
@@ -489,4 +675,4 @@ def wrap_redis(r: Any, db_name: str = "default") -> WrappedRedis:
         r.nedb.query('FROM driver WHERE status = "active" ORDER BY name ASC')
         r.nedb.verify()   # → True
     """
-    return WrappedRedis(r, db_name)
+    return WrappedRedis(r, db_name, nedbd_url=nedbd_url, nedbd_token=nedbd_token)