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

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

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

{lambda_erp-0.8.8 → lambda_erp-0.8.9}/api/routers/masters.py

@@ -2,13 +2,16 @@
 
 import re
 
-from fastapi import APIRouter, Depends, HTTPException, Query
+from fastapi import APIRouter, Depends, HTTPException, Query, Request
 from lambda_erp.database import get_db
 from lambda_erp.utils import _dict
 # The per-type registries live in api.services so `register_master` can extend
 # them; imported here (not moved) so existing `from api.routers.masters import
 # MASTER_IDENTITY_ALIAS`-style imports keep working.
-from api.services import MASTER_TABLES, MASTER_NAME_PREFIXES, MASTER_IDENTITY_ALIAS
+from api.services import (
+    MASTER_TABLES, MASTER_NAME_PREFIXES, MASTER_IDENTITY_ALIAS,
+    _search_clause, _where_from_filters, master_search_columns, count_query_cached,
+)
 from api.auth import require_role, require_non_public_manager
 
 router = APIRouter(prefix="/masters", tags=["masters"])
@@ -267,45 +270,91 @@ def update_master_record(master_type: str, name: str, data: dict) -> dict:
     return _echo_identity_alias(master_type, rows[0])
 
 
+# Query params list_masters consumes itself — anything else is treated as an
+# ad-hoc equality field filter (validated against the master's real columns).
+_MASTER_LIST_RESERVED = {
+    "limit", "offset", "include_disabled", "search", "search_fields",
+}
+
+
+@router.get("/{master_type}/filter-values")
+def master_filter_values(
+    master_type: str,
+    field: str,
+    _user: dict = _viewer,
+):
+    """Distinct non-empty values of one column — populates a master-list filter
+    dropdown. Capped; the field is validated against real columns."""
+    doctype, _ = _get_table(master_type)
+    if not doctype:
+        raise HTTPException(status_code=404, detail=f"Unknown master type: {master_type}")
+    db = get_db()
+    if field not in db._get_table_columns(doctype):
+        raise HTTPException(status_code=400, detail=f"Unknown field: {field}")
+    rows = db.sql(
+        f'SELECT DISTINCT "{field}" AS v FROM "{doctype}" '
+        f'WHERE "{field}" IS NOT NULL AND "{field}" <> \'\' '
+        f'ORDER BY "{field}" LIMIT 200'
+    )
+    return {"values": [r["v"] for r in rows]}
+
+
 @router.get("/{master_type}")
 def list_masters(
     master_type: str,
+    request: Request,
     limit: int = Query(default=50, le=1000),
     offset: int = Query(default=0, ge=0),
     include_disabled: bool = False,
+    search: str | None = None,
+    search_fields: str | None = None,
     _user: dict = _viewer,
 ):
     doctype, _ = _get_table(master_type)
     if not doctype:
         return {"detail": f"Unknown master type: {master_type}"}
     db = get_db()
-    filters = None if include_disabled else _with_active_filter(db, doctype)
-
-    # Build WHERE clause and params
-    where_parts = []
-    params = []
-    if filters:
-        for k, v in filters.items():
-            if isinstance(v, (list, tuple)) and len(v) == 2:
-                op, val = v
-                where_parts.append(f'"{k}" {op} ?')
-                params.append(val)
-            else:
-                where_parts.append(f'"{k}" = ?')
-                params.append(v)
-
-    count_query = f'SELECT COUNT(*) as c FROM "{doctype}"'
-    if where_parts:
-        count_query += " WHERE " + " AND ".join(where_parts)
-    total_rows = db.sql(count_query, params)
-    total = int(total_rows[0]["c"]) if total_rows else 0
-
-    query = f'SELECT * FROM "{doctype}"'
-    if where_parts:
-        query += " WHERE " + " AND ".join(where_parts)
-    # Deterministic order: without it Postgres returns pages in arbitrary order,
-    # which breaks OFFSET pagination and the /adjacent prev/next contract.
-    query += f" ORDER BY name LIMIT {int(limit)}"
+    columns = db._get_table_columns(doctype)
+
+    where_parts: list = []
+    params: list = []
+
+    # Active (non-disabled) filter, unless the caller opts in to disabled rows.
+    active = None if include_disabled else _with_active_filter(db, doctype)
+    if active:
+        wp, ps = _where_from_filters(active)
+        where_parts += wp
+        params += ps
+
+    # Ad-hoc equality field filters: any remaining query param naming a real
+    # column (e.g. /masters/customer?customer_group=Commercial). Unknown field
+    # -> 400 (a filter on a missing column is a client bug, never interpolated).
+    for key, value in request.query_params.items():
+        if key in _MASTER_LIST_RESERVED:
+            continue
+        if key not in columns:
+            raise HTTPException(status_code=400, detail=f"Unknown filter field: {key}")
+        where_parts.append(f'"{key}" = ?')
+        params.append(value)
+
+    # Free-text search — defaults to the master's text columns when the caller
+    # doesn't name search_fields (so a plain ?search=... just works).
+    if search:
+        sf = [f.strip() for f in (search_fields or "").split(",")
+              if f.strip() and f.strip() in columns]
+        if not sf:
+            sf = master_search_columns(db, doctype)
+        clause, sp = _search_clause(db, doctype, master_type, search, sf)
+        if clause:
+            where_parts.append(clause)
+            params += sp
+
+    where = (" WHERE " + " AND ".join(where_parts)) if where_parts else ""
+    total = count_query_cached(f'SELECT COUNT(*) as c FROM "{doctype}"{where}', params)
+
+    # Deterministic order by the `name` PK (already indexed) — required for
+    # OFFSET pagination and the /adjacent prev/next contract.
+    query = f'SELECT * FROM "{doctype}"{where} ORDER BY name LIMIT {int(limit)}'
     if offset:
         query += f" OFFSET {int(offset)}"
     rows = db.sql(query, params)

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

@@ -759,6 +759,38 @@ def invalidate_count_cache() -> None:
     _COUNT_CACHE.clear()
 
 
+def count_query_cached(query: str, params=None) -> int:
+    """Result of a single-column COUNT(*) query, cached per (query, params) with
+    the same policy as count_documents — until the next write (write-generation)
+    or the TTL. Lets the masters list share the exact-but-cached count."""
+    key = ("q", query, tuple(str(p) for p in (params or [])))
+    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]
+    rows = get_db().sql(query, params or [])
+    total = int(next(iter(rows[0].values()))) if rows else 0
+    if len(_COUNT_CACHE) >= _COUNT_CACHE_MAX:
+        _COUNT_CACHE.clear()
+    _COUNT_CACHE[key] = (now_mono, gen, total)
+    return total
+
+
+# Audit / plumbing columns never worth matching a free-text list search against.
+_MASTER_SEARCH_SKIP = {
+    "name", "creation", "modified", "owner", "modified_by", "disabled",
+    "idx", "parent", "parenttype", "parentfield", "docstatus",
+}
+
+
+def master_search_columns(db, doctype: str) -> list:
+    """Text columns a free-text master-list search matches by default — schema-
+    discovered (a new text field becomes searchable automatically), minus audit
+    noise. Mirrors the chat search_masters default so both search the same set."""
+    return sorted(db._get_text_columns(doctype) - _MASTER_SEARCH_SKIP)
+
+
 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."""

{lambda_erp-0.8.8 → lambda_erp-0.8.9}/frontend/src/api/client.ts

@@ -250,6 +250,10 @@ export const api = {
   searchMasters: (type: string, q: string) =>
     request<any[]>(`/masters/${type}/search?q=${encodeURIComponent(q)}`),
 
+  // Distinct values of one master column — populates a list filter dropdown.
+  masterFilterValues: (type: string, field: string) =>
+    request<{ values: any[] }>(`/masters/${type}/filter-values?field=${encodeURIComponent(field)}`),
+
   searchDocuments: (doctype: string, q: string) =>
     request<any[]>(`/documents/${doctype}/search?q=${encodeURIComponent(q)}`),
 

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

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