lambda-erp 0.2.5__tar.gz → 0.2.7__tar.gz

{lambda_erp-0.2.5 → lambda_erp-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lambda-erp
-Version: 0.2.5
+Version: 0.2.7
 Summary: Core ERP logic - accounting, sales, purchasing, inventory
 Author: TORUS INVESTMENTS AG
 License-Expression: MIT

{lambda_erp-0.2.5 → lambda_erp-0.2.7}/api/chat.py

@@ -583,7 +583,7 @@ TOOLS = [
         "type": "function",
         "function": {
             "name": "search_masters",
-            "description": "Search master data (customers, suppliers, items, warehouses, accounts, companies, cost centers). Case-insensitive, with fuzzy fallback for misspellings. By default matches across standard text fields (name, display name, address/city/zip); large free-text columns like description/templates are skipped unless named in `fields`. PREFER passing `fields` whenever you know which attribute you're matching on (e.g. a city, an email, a tax id) — it's faster, more precise, and avoids false hits from other columns. Returns matching records.",
+            "description": "Search master data (customers, suppliers, items, warehouses, accounts, companies, cost centers). Case-insensitive, with fuzzy fallback for misspellings. By default matches across standard text fields (name, display name, address/city/zip); large free-text columns like description/templates are skipped unless named in `fields`. PREFER passing `fields` whenever you know which attribute you're matching on (e.g. a city, an email, a tax id) — it's faster, more precise, and avoids false hits from other columns. Returns ALL matching records by default (no cap); pass `limit` only to bound a large list.",
             "parameters": {
                 "type": "object",
                 "properties": {
@@ -594,6 +594,7 @@ TOOLS = [
                         "items": {"type": "string"},
                         "description": "Recommended: the column(s) to search, e.g. [\"city\"] or [\"customer_name\"]. Narrowing here is faster and avoids matching unrelated columns. Omit only when you genuinely don't know which field holds the value, to search all standard text fields.",
                     },
+                    "limit": {"type": "integer", "description": "Optional max number of results. OMIT for no cap — returns ALL matches (e.g. to see the entire chart of accounts). Pass a number only to bound a large list."},
                 },
                 "required": ["master_type"],
             },
@@ -1308,6 +1309,17 @@ def _handle_search_masters(args):
     master_type = args["master_type"]
     query = (args.get("query") or "").strip()
 
+    # Optional result cap the caller sets per call; omit for NO cap (return all —
+    # e.g. the whole chart of accounts). Coerced to int so the LIMIT clause below
+    # can't be injected.
+    _raw_limit = args.get("limit")
+    limit = None
+    if _raw_limit not in (None, "", 0):
+        try:
+            limit = max(1, int(_raw_limit))
+        except (TypeError, ValueError):
+            limit = None
+
     entry = services.MASTER_TABLES.get(master_type)
     if not entry:
         return {"error": f"Unknown master type: {master_type}"}
@@ -1317,7 +1329,7 @@ def _handle_search_masters(args):
 
     if not query:
         filters = {"disabled": 0} if has_disabled else None
-        return db.get_all(doctype, filters=filters, fields=["*"], limit=20)
+        return db.get_all(doctype, filters=filters, fields=["*"], limit=limit)
 
     # Optional `fields` narrows the search to specific columns — cheaper, more
     # precise, and the only way to reach bulk columns (description, templates)
@@ -1338,15 +1350,16 @@ def _handle_search_masters(args):
     # silently broke prod search); CAST lets targeted non-text columns match too.
     where = " OR ".join(f'lower(CAST("{col}" AS TEXT)) LIKE ?' for col in search_cols)
     pattern = f"%{query.lower()}%"
+    limit_sql = f" LIMIT {limit}" if limit else ""
     rows = db.sql(
-        f'SELECT * FROM "{doctype}" WHERE {active_prefix}({where}) LIMIT 20',
+        f'SELECT * FROM "{doctype}" WHERE {active_prefix}({where}){limit_sql}',
         [pattern] * len(search_cols),
     )
     if rows:
         return [dict(r) for r in rows]
 
     # Nothing matched literally — try fuzzy matching to catch misspellings.
-    return _fuzzy_master_search(db, doctype, search_cols, query, has_disabled, limit=20)
+    return _fuzzy_master_search(db, doctype, search_cols, query, has_disabled, limit=limit)
 
 
 def _ignored_master_fields(master_type: str, data: dict) -> list[str]:

{lambda_erp-0.2.5 → lambda_erp-0.2.7}/api/main.py

@@ -158,11 +158,29 @@ async def ws_chat(websocket: WebSocket):
 # semantics: real files (assets, favicon, logos) resolve as-is; anything
 # else falls through to index.html and React Router handles it
 # client-side. API and WebSocket paths keep returning their normal 404s.
+class _ImmutableStaticFiles(StaticFiles):
+    """Serve content-hashed build assets with a long-lived immutable cache.
+
+    Vite fingerprints every file under /assets (index-<hash>.js, etc.), so the
+    bytes at a given URL never change — a new build emits new filenames. The
+    `immutable` directive lets the browser skip revalidation entirely (no 304
+    round-trip on reload), while index.html stays `no-cache` so a new build is
+    still picked up. Net effect vs. the old default: fewer requests, not more.
+    """
+
+    async def get_response(self, path, scope):
+        response = await super().get_response(path, scope)
+        response.headers.setdefault(
+            "Cache-Control", "public, max-age=31536000, immutable"
+        )
+        return response
+
+
 frontend_dist = os.path.join(os.path.dirname(__file__), "..", "frontend", "dist")
 if os.path.isdir(frontend_dist):
     assets_dir = os.path.join(frontend_dist, "assets")
     if os.path.isdir(assets_dir):
-        app.mount("/assets", StaticFiles(directory=assets_dir), name="assets")
+        app.mount("/assets", _ImmutableStaticFiles(directory=assets_dir), name="assets")
 
     frontend_root = os.path.realpath(frontend_dist)
     index_html = os.path.join(frontend_root, "index.html")
@@ -183,4 +201,11 @@ if os.path.isdir(frontend_dist):
                 return FileResponse(candidate)
 
         # SPA fallback — React Router takes over from here.
-        return FileResponse(index_html)
+        #
+        # `no-cache` = always revalidate the shell before reuse (a cheap 304
+        # when unchanged, fresh bytes after a deploy). index.html is the only
+        # UNHASHED file and it points at the hashed /assets bundles, so if the
+        # browser heuristically caches it (which it does when no Cache-Control
+        # is set), a soft reload serves a stale shell referencing old asset
+        # URLs — the "refresh doesn't refresh, need a hard-refresh" bug.
+        return FileResponse(index_html, headers={"Cache-Control": "no-cache"})

{lambda_erp-0.2.5 → lambda_erp-0.2.7}/pyproject.toml

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