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

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

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

{lambda_erp-0.8.4 → lambda_erp-0.8.6}/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.4 → lambda_erp-0.8.6}/api/services.py

@@ -1,5 +1,7 @@
 """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
 
@@ -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,44 @@ 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.
+_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 (call after a bulk import/delete if an
+    immediately-fresh total matters more than the ~60s TTL)."""
+    _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."""
+    key = _count_cache_key(doctype_slug, filters, include_discarded)
+    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]
+    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)
+    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.4 → lambda_erp-0.8.6}/lambda_erp/database.py

@@ -1457,6 +1457,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 +1606,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.4 → lambda_erp-0.8.6}/pyproject.toml

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