lambda-erp 0.8.5__tar.gz → 0.8.7__tar.gz

{lambda_erp-0.8.5 → lambda_erp-0.8.7}/PKG-INFO

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

{lambda_erp-0.8.5 → lambda_erp-0.8.7}/api/routers/documents.py

@@ -28,7 +28,7 @@ _manager = Depends(require_role("manager"))
 _LIST_RESERVED = {
     "status", "party", "from_date", "to_date", "docstatus",
     "include_discarded", "limit", "offset", "order_by", "order",
-    "date_field", "search", "search_fields",
+    "date_field", "search", "search_fields", "fields",
 }
 
 
@@ -47,6 +47,7 @@ def list_docs(
     date_field: str | None = None,
     search: str | None = None,
     search_fields: str | None = None,
+    fields: str | None = None,
     limit: int = Query(default=50, le=500),
     offset: int = Query(default=0, ge=0),
     _user: dict = _viewer,
@@ -87,20 +88,31 @@ def list_docs(
     # real columns, mirroring the arbitrary-filter / order_by contract.
     if search:
         filters["search"] = search
-        fields = [f.strip() for f in (search_fields or "").split(",") if f.strip()]
-        bad = [f for f in fields if f not in columns]
+        sf = [f.strip() for f in (search_fields or "").split(",") if f.strip()]
+        bad = [f for f in sf if f not in columns]
         if bad:
             raise HTTPException(status_code=400, detail=f"Unknown search field(s): {', '.join(bad)}")
-        if fields:
-            filters["search_fields"] = fields
+        if sf:
+            filters["search_fields"] = sf
 
     if order_by is not None and order_by not in columns:
         raise HTTPException(status_code=400, detail=f"Unknown order_by field: {order_by}")
     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).
+    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)}")
+
     rows = list_documents(doctype_slug, filters=filters, limit=limit, offset=offset,
-                          include_discarded=include_discarded, order_by=order_by, order=order)
+                          include_discarded=include_discarded, order_by=order_by, order=order,
+                          fields=projection)
     total = count_documents(doctype_slug, filters=filters, include_discarded=include_discarded)
     return {"rows": rows, "total": total, "limit": limit, "offset": offset}
 

{lambda_erp-0.8.5 → lambda_erp-0.8.7}/api/services.py

@@ -1,7 +1,9 @@
 """Bridge between FastAPI request data and lambda_erp Document classes."""
 
+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,
@@ -717,8 +719,10 @@ def list_documents(doctype_slug: str, filters: dict = None, limit: int = 50, off
     else:
         rows = db.get_all(
             doctype,
+            # Project to the requested columns at the DB (not just *-then-trim) so a
+            # wide table doesn't ship every column for a few-column list view.
+            fields=(sorted(_projection_columns(doctype_slug, fields)) if fields else ["*"]),
             filters=db_filters if db_filters else None,
-            fields=["*"],
             order_by=order_clause,
             limit=limit,
         )
@@ -732,7 +736,46 @@ def list_documents(doctype_slug: str, filters: dict = None, limit: int = 50, off
     return rows
 
 
+# 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
+
+
+def _count_cache_key(doctype_slug, filters, include_discarded):
+    items = tuple(sorted((k, str(v)) for k, v in (filters or {}).items()))
+    return (doctype_slug, items, bool(include_discarded))
+
+
+def invalidate_count_cache() -> None:
+    """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 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 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, gen, result)
+    return result
+
+
+def _count_documents_uncached(doctype_slug: str, filters: dict = None, include_discarded: bool = False) -> int:
     """Count documents matching the filters (ignores limit/offset)."""
     doctype = SLUG_TO_DOCTYPE.get(doctype_slug)
     if not doctype:

{lambda_erp-0.8.5 → lambda_erp-0.8.7}/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")
@@ -1457,6 +1495,7 @@ class Database:
             self.conn.execute(self._ddl(stmt))
         self.conn.commit()
         self._migrate()
+        self._ensure_list_indexes()
 
     def _ddl(self, stmt: str) -> str:
         """Translate SQLite DDL to the active dialect. No-op for SQLite.
@@ -1605,6 +1644,47 @@ class Database:
                 # covers the happy path; migrations are only needed for drift.
                 self.conn.rollback()
 
+    def _all_user_tables(self) -> list:
+        """Base tables in the active DB, minus internal bookkeeping."""
+        if self.dialect == "postgres":
+            rows = self.conn.execute(
+                "SELECT tablename FROM pg_tables WHERE schemaname = 'public'"
+            ).fetchall()
+        else:
+            rows = self.conn.execute(
+                "SELECT name FROM sqlite_master WHERE type = 'table'"
+            ).fetchall()
+        return [
+            r[0] for r in rows
+            if not str(r[0]).startswith("_") and not str(r[0]).startswith("sqlite_")
+        ]
+
+    def _ensure_list_indexes(self) -> None:
+        """Index `creation` on every table that has it — the generic list-speed fix.
+
+        Every document/master list defaults to `ORDER BY creation DESC`, but tables
+        ship with only a `name` primary key. So once a table grows large, each list
+        load does a full sequential scan + top-N sort: the Leads page at 89K rows
+        measured ~340ms; ~0.3ms with this index. Reconciled here (idempotent,
+        CREATE INDEX IF NOT EXISTS) so it covers core, plugin AND future doctypes,
+        and back-fills existing tables on the next deploy. `creation` is a
+        fixed-width ISO string, so a plain btree sorts chronologically and the
+        planner scans it backward for DESC. Best-effort per table — a failure on one
+        (e.g. two replicas racing to build it at boot) never blocks startup.
+        """
+        for table in self._all_user_tables():
+            try:
+                if "creation" not in self._get_table_columns(table):
+                    continue
+            except Exception:
+                continue
+            idx = f"ix_{table.replace(' ', '_')}_creation"
+            try:
+                self.conn.execute(f'CREATE INDEX IF NOT EXISTS "{idx}" ON "{table}" ("creation")')
+                self.conn.commit()
+            except Exception:
+                self.conn.rollback()
+
     # --- Core query interface (mirrors framework.db) ---
 
     def sql(self, query, values=None, as_dict=True):

{lambda_erp-0.8.5 → lambda_erp-0.8.7}/pyproject.toml

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