lambda-erp 0.8.6__tar.gz → 0.8.8__tar.gz

{lambda_erp-0.8.6 → lambda_erp-0.8.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lambda-erp
-Version: 0.8.6
+Version: 0.8.8
 Summary: Core ERP logic - accounting, sales, purchasing, inventory
 Author: TORUS INVESTMENTS AG
 License-Expression: Apache-2.0

{lambda_erp-0.8.6 → lambda_erp-0.8.8}/api/routers/documents.py

@@ -100,15 +100,16 @@ def list_docs(
     if order.lower() not in ("asc", "desc"):
         raise HTTPException(status_code=400, detail="order must be 'asc' or 'desc'")
 
-    # Column projection: the frontend sends the columns its list view actually
-    # renders, so a wide doctype doesn't ship every column for a few-column grid.
-    # Validated against real columns (name is always kept, added downstream).
+    # Column projection: the frontend sends the columns its list view renders, so
+    # a wide doctype doesn't ship every column for a few-column grid. This is
+    # ADVISORY — unknown columns are silently dropped, never a 400: the frontend
+    # appends display-only fields (currency, party_type) that not every doctype
+    # has, and a projection can only ever narrow the response (name is kept
+    # downstream), so an unknown field is harmless. (Contrast order_by/search_
+    # fields, which affect query correctness and stay strict.)
     projection = None
     if fields:
-        projection = [f.strip() for f in fields.split(",") if f.strip()]
-        bad = [f for f in projection if f not in columns]
-        if bad:
-            raise HTTPException(status_code=400, detail=f"Unknown field(s): {', '.join(bad)}")
+        projection = [f.strip() for f in fields.split(",") if f.strip() and f.strip() in columns]
 
     rows = list_documents(doctype_slug, filters=filters, limit=limit, offset=offset,
                           include_discarded=include_discarded, order_by=order_by, order=order,

{lambda_erp-0.8.6 → lambda_erp-0.8.8}/api/services.py

@@ -3,7 +3,7 @@
 import time
 
 from lambda_erp.utils import _dict, now
-from lambda_erp.database import get_db
+from lambda_erp.database import get_db, get_write_generation
 
 from lambda_erp.selling.quotation import (
     Quotation, make_sales_order,
@@ -736,13 +736,13 @@ def list_documents(doctype_slug: str, filters: dict = None, limit: int = 50, off
     return rows
 
 
-# Exact list counts are cached briefly per (doctype, filters). The count is the
-# one O(N) part of a list load — a full scan even with the creation index, since
-# the discard/search predicates aren't covered — and paging within a view repeats
-# the identical count. A short TTL keeps the page-jump total EXACT (unlike a
-# reltuples estimate, which would make the "of N" bound approximate) while
-# collapsing repeat counts to a dict lookup. Stale for at most _COUNT_CACHE_TTL
-# seconds after a write, which is fine for a total-count display.
+# Exact list counts are cached per (doctype, filters). The count is the one O(N)
+# part of a list load — a full scan even with the creation index, since the
+# discard/search predicates aren't covered — and paging within a view repeats the
+# identical count. The cache stays EXACT (unlike a reltuples estimate, which would
+# make the page-jump "of N" bound approximate): every entry is tagged with the DB
+# write-generation, so any in-process write invalidates it immediately; the TTL is
+# only a backstop for cross-replica writes this process didn't see.
 _COUNT_CACHE: dict = {}
 _COUNT_CACHE_TTL = 60.0
 _COUNT_CACHE_MAX = 512
@@ -754,22 +754,24 @@ def _count_cache_key(doctype_slug, filters, include_discarded):
 
 
 def invalidate_count_cache() -> None:
-    """Clear the list-count cache (call after a bulk import/delete if an
-    immediately-fresh total matters more than the ~60s TTL)."""
+    """Clear the list-count cache (writes already invalidate via the write-
+    generation; call this only to force-drop cross-replica staleness early)."""
     _COUNT_CACHE.clear()
 
 
 def count_documents(doctype_slug: str, filters: dict = None, include_discarded: bool = False) -> int:
-    """Exact count of documents matching the filters, cached ~60s per filter-set."""
+    """Exact count of documents matching the filters, cached per filter-set until
+    the next write (write-generation) or the TTL, whichever comes first."""
     key = _count_cache_key(doctype_slug, filters, include_discarded)
+    gen = get_write_generation()
     now_mono = time.monotonic()
     hit = _COUNT_CACHE.get(key)
-    if hit is not None and now_mono - hit[0] < _COUNT_CACHE_TTL:
-        return hit[1]
+    if hit is not None and hit[1] == gen and now_mono - hit[0] < _COUNT_CACHE_TTL:
+        return hit[2]
     result = _count_documents_uncached(doctype_slug, filters, include_discarded)
     if len(_COUNT_CACHE) >= _COUNT_CACHE_MAX:
         _COUNT_CACHE.clear()
-    _COUNT_CACHE[key] = (now_mono, result)
+    _COUNT_CACHE[key] = (now_mono, gen, result)
     return result
 
 

{lambda_erp-0.8.6 → lambda_erp-0.8.8}/lambda_erp/database.py

@@ -96,6 +96,28 @@ def _pg_row_factory(cursor):
     return make
 
 
+_write_generation = 0
+
+
+def _stmt_is_read(sql: str) -> bool:
+    s = sql.lstrip().lower()
+    return s.startswith("select") and "for update" not in s and "for share" not in s
+
+
+def _note_write(sql: str) -> None:
+    """Bump the process write-generation on any non-SELECT statement. The list
+    count cache keys on it, so an in-process write invalidates cached counts at
+    once (cross-process staleness stays bounded by the cache TTL)."""
+    global _write_generation
+    if not _stmt_is_read(sql):
+        _write_generation += 1
+
+
+def get_write_generation() -> int:
+    """Monotonic per-process write counter — see _note_write."""
+    return _write_generation
+
+
 class _PgConn:
     """Adapts a psycopg (v3) connection to the sqlite3 connection API the code
     uses. autocommit is off so the existing `_in_transaction` + single commit()
@@ -150,6 +172,7 @@ class _PgConn:
             self._safe_rollback()
             raise
         self._maybe_release(sql)
+        _note_write(sql)
         return cur
 
     def executemany(self, sql, seq_params):
@@ -161,6 +184,7 @@ class _PgConn:
             self._safe_rollback()
             raise
         self._dirty = True
+        _note_write(sql)
         return cur
 
     def _safe_rollback(self):
@@ -185,6 +209,20 @@ class _PgConn:
         return self._raw.cursor(*args, **kwargs)
 
 
+class _SqliteConn(sqlite3.Connection):
+    """SQLite connection that bumps the write-generation like _PgConn does, so the
+    list count cache invalidates on writes under both backends (SQLite is a raw
+    connection where Postgres is wrapped)."""
+
+    def execute(self, sql, *args, **kwargs):
+        _note_write(sql)
+        return super().execute(sql, *args, **kwargs)
+
+    def executemany(self, sql, *args, **kwargs):
+        _note_write(sql)
+        return super().executemany(sql, *args, **kwargs)
+
+
 class _NullLock:
     """No-op context manager used when SQLite-level locking is sufficient."""
 
@@ -240,7 +278,7 @@ class Database:
         return conn
 
     def _open_sqlite_conn(self):
-        conn = sqlite3.connect(self.db_path, check_same_thread=False)
+        conn = sqlite3.connect(self.db_path, check_same_thread=False, factory=_SqliteConn)
         conn.row_factory = sqlite3.Row
         conn.execute(f"PRAGMA journal_mode={_journal_mode()}")
         conn.execute("PRAGMA foreign_keys=ON")

{lambda_erp-0.8.6 → lambda_erp-0.8.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lambda-erp"
-version = "0.8.6"
+version = "0.8.8"
 description = "Core ERP logic - accounting, sales, purchasing, inventory"
 readme = "README.md"
 license = "Apache-2.0"