lambda-erp 0.6.4__tar.gz → 0.6.6__tar.gz

{lambda_erp-0.6.4 → lambda_erp-0.6.6}/PKG-INFO

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

{lambda_erp-0.6.4 → lambda_erp-0.6.6}/api/routers/documents.py

@@ -28,6 +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",
 }
 
 
@@ -43,6 +44,7 @@ def list_docs(
     include_discarded: bool = False,
     order_by: str | None = None,
     order: str = "desc",
+    date_field: str | None = None,
     limit: int = Query(default=50, le=500),
     offset: int = Query(default=0, ge=0),
     _user: dict = _viewer,
@@ -70,6 +72,14 @@ def list_docs(
             raise HTTPException(status_code=400, detail=f"Unknown filter field: {key}")
         filters[key] = value
 
+    # Which column from_date/to_date filter on. The frontend passes its declared
+    # dateField so plugin doctypes get working date filters without a server-side
+    # map. Passed through untouched here; list_documents ignores it unless it's a
+    # real column (so a config with a synthetic dateField degrades to no date
+    # filter rather than 400-ing the whole list), and never interpolates it blind.
+    if date_field:
+        filters["date_field"] = date_field
+
     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"):
@@ -94,6 +104,7 @@ def adjacent_doc(
     include_discarded: bool = False,
     order_by: str | None = None,
     order: str = "desc",
+    date_field: str | None = None,
     _user: dict = _viewer,
 ):
     """Prev/next record around `name` in the same order+filters the list uses.
@@ -117,6 +128,8 @@ def adjacent_doc(
         if key not in columns:
             raise HTTPException(status_code=400, detail=f"Unknown filter field: {key}")
         filters[key] = value
+    if date_field:
+        filters["date_field"] = date_field
     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"):

{lambda_erp-0.6.4 → lambda_erp-0.6.6}/api/routers/masters.py

@@ -299,7 +299,9 @@ def list_masters(
     query = f'SELECT * FROM "{doctype}"'
     if where_parts:
         query += " WHERE " + " AND ".join(where_parts)
-    query += f" LIMIT {int(limit)}"
+    # 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)}"
     if offset:
         query += f" OFFSET {int(offset)}"
     rows = db.sql(query, params)
@@ -325,6 +327,29 @@ def search_masters(master_type: str, q: str = "", _user: dict = _viewer):
     return rows
 
 
+@router.get("/{master_type}/{name}/adjacent")
+def adjacent_master(master_type: str, name: str, include_disabled: bool = True,
+                    _user: dict = _viewer):
+    """The records immediately before/after `name` in the list's order (name
+    ASC) — {"prev": name|None, "next": name|None}. Keyset queries on the
+    primary key. include_disabled defaults True to step 1:1 with the master
+    list, which shows disabled records too."""
+    doctype, _ = _get_table(master_type)
+    if not doctype:
+        raise HTTPException(status_code=404, detail=f"Unknown master type: {master_type}")
+    db = get_db()
+    active = ("" if include_disabled or "disabled" not in db._get_table_columns(doctype)
+              else "disabled = 0 AND ")
+
+    def neighbor(cmp: str, direction: str):
+        rows = db.sql(
+            f'SELECT name FROM "{doctype}" WHERE {active}name {cmp} ? '
+            f"ORDER BY name {direction} LIMIT 1", [name])
+        return rows[0]["name"] if rows else None
+
+    return {"prev": neighbor("<", "DESC"), "next": neighbor(">", "ASC")}
+
+
 @router.get("/{master_type}/{name}")
 def get_master(master_type: str, name: str, _user: dict = _viewer):
     doctype, _ = _get_table(master_type)

{lambda_erp-0.6.4 → lambda_erp-0.6.6}/api/services.py

@@ -392,6 +392,17 @@ DATE_FIELDS = {
 }
 
 
+def _resolve_date_field(db, doctype: str, override: str | None) -> str | None:
+    """The column that from_date/to_date range-filter against. An explicit
+    override (the frontend's declared `dateField`, passed as the `date_field`
+    filter) wins when it names a real column; otherwise fall back to the
+    built-in DATE_FIELDS map for core doctypes. Guarded so the override is never
+    interpolated into SQL unless it's an actual column."""
+    if override and override in db._get_table_columns(doctype):
+        return override
+    return DATE_FIELDS.get(doctype)
+
+
 def _exclude_discarded(db, doctype: str, db_filters: dict, include_discarded: bool) -> None:
     """Hide voided drafts (discarded=1) unless explicitly requested. Guarded on
     the column existing so non-submittable doctypes are unaffected."""
@@ -421,6 +432,7 @@ def list_documents(doctype_slug: str, filters: dict = None, limit: int = 50, off
     db_filters = {}
     from_date = None
     to_date = None
+    date_field_override = None
     if filters:
         for key, value in filters.items():
             if value is None or value == "":
@@ -429,13 +441,15 @@ def list_documents(doctype_slug: str, filters: dict = None, limit: int = 50, off
                 from_date = value
             elif key == "to_date":
                 to_date = value
+            elif key == "date_field":
+                date_field_override = value
             else:
                 db_filters[key] = value
 
     _exclude_discarded(db, doctype, db_filters, include_discarded)
 
     # Date range filtering via the doctype's primary date field
-    date_field = DATE_FIELDS.get(doctype)
+    date_field = _resolve_date_field(db, doctype, date_field_override)
     if date_field:
         if from_date:
             db_filters[date_field] = (">=", from_date)
@@ -481,6 +495,7 @@ def count_documents(doctype_slug: str, filters: dict = None, include_discarded:
     db_filters = {}
     from_date = None
     to_date = None
+    date_field_override = None
     if filters:
         for key, value in filters.items():
             if value is None or value == "":
@@ -489,12 +504,14 @@ def count_documents(doctype_slug: str, filters: dict = None, include_discarded:
                 from_date = value
             elif key == "to_date":
                 to_date = value
+            elif key == "date_field":
+                date_field_override = value
             else:
                 db_filters[key] = value
 
     _exclude_discarded(db, doctype, db_filters, include_discarded)
 
-    date_field = DATE_FIELDS.get(doctype)
+    date_field = _resolve_date_field(db, doctype, date_field_override)
     where_parts = []
     params = []
     if date_field and from_date:
@@ -524,7 +541,7 @@ def _filter_where(db, doctype: str, filters: dict, include_discarded: bool):
     (equality filters + from_date/to_date on the doctype's date field + discard
     exclusion). Same semantics as list_documents/count_documents so prev/next
     matches exactly what the list shows."""
-    db_filters, from_date, to_date = {}, None, None
+    db_filters, from_date, to_date, date_field_override = {}, None, None, None
     for key, value in (filters or {}).items():
         if value is None or value == "":
             continue
@@ -532,11 +549,13 @@ def _filter_where(db, doctype: str, filters: dict, include_discarded: bool):
             from_date = value
         elif key == "to_date":
             to_date = value
+        elif key == "date_field":
+            date_field_override = value
         else:
             db_filters[key] = value
     _exclude_discarded(db, doctype, db_filters, include_discarded)
 
-    date_field = DATE_FIELDS.get(doctype)
+    date_field = _resolve_date_field(db, doctype, date_field_override)
     where_parts, params = [], []
     if date_field and from_date:
         where_parts.append(f'"{date_field}" >= ?'); params.append(from_date)

{lambda_erp-0.6.4 → lambda_erp-0.6.6}/frontend/src/api/client.ts

@@ -129,6 +129,12 @@ export const api = {
       `/documents/${doctype}/${encodeURIComponent(name)}/adjacent${qs(params)}`,
     ),
 
+  // Prev/next master record around `name` in the master list's order (name ASC).
+  adjacentMaster: (masterType: string, name: string) =>
+    request<{ prev: string | null; next: string | null }>(
+      `/masters/${masterType}/${encodeURIComponent(name)}/adjacent`,
+    ),
+
   createDocument: (doctype: string, data: any) =>
     request<any>(`/documents/${doctype}`, { method: "POST", body: JSON.stringify(data) }),
 

{lambda_erp-0.6.4 → lambda_erp-0.6.6}/lambda_erp/database.py

@@ -99,10 +99,38 @@ def _pg_row_factory(cursor):
 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()
-    / rollback() flow gives the same atomicity as SQLite's implicit transaction."""
-
-    def __init__(self, raw):
+    / rollback() flow gives the same atomicity as SQLite's implicit transaction.
+
+    With autocommit off, even a plain SELECT opens a transaction that stays
+    open until commit/rollback — and these thread-local connections live as
+    long as their (pooled) thread, so a request whose last statement was a read
+    left the connection 'idle in transaction' forever, pinning ACCESS SHARE
+    locks on every table it touched. That starves any ALTER TABLE of its
+    ACCESS EXCLUSIVE lock, which made lock-safe plugin migrations time out on
+    every boot in production. The fix: after a read, when there is no pending
+    write and no explicit transaction, end the implicit transaction right away
+    (_maybe_release), so connections never idle inside one."""
+
+    def __init__(self, raw, in_explicit_txn=None):
         self._raw = raw
+        self._dirty = False  # uncommitted write on this connection
+        self._in_explicit_txn = in_explicit_txn or (lambda: False)
+
+    @staticmethod
+    def _is_read(sql):
+        s = sql.lstrip().lower()
+        return s.startswith("select") and "for update" not in s and "for share" not in s
+
+    def _maybe_release(self, sql):
+        if self._in_explicit_txn():
+            return
+        if self._is_read(sql):
+            # psycopg's default cursor has already buffered the full result set
+            # client-side, so the caller can still fetch after the rollback.
+            if not self._dirty:
+                self._safe_rollback()
+        else:
+            self._dirty = True
 
     def execute(self, sql, params=None):
         try:
@@ -114,7 +142,6 @@ class _PgConn:
                 cur.execute(sql.replace("%", "%%").replace("?", "%s"), list(params))
             else:
                 cur.execute(sql.replace("?", "%s"))
-            return cur
         except Exception:
             # A failed statement leaves the connection in an aborted transaction
             # (autocommit=False); every later query on this pooled/thread-local
@@ -122,28 +149,34 @@ class _PgConn:
             # so the connection stays usable, then re-raise the real error.
             self._safe_rollback()
             raise
+        self._maybe_release(sql)
+        return cur
 
     def executemany(self, sql, seq_params):
         try:
             cur = self._raw.cursor()
             cur.executemany(sql.replace("%", "%%").replace("?", "%s"),
                             [list(p) for p in seq_params])
-            return cur
         except Exception:
             self._safe_rollback()
             raise
+        self._dirty = True
+        return cur
 
     def _safe_rollback(self):
         try:
             self._raw.rollback()
+            self._dirty = False
         except Exception:
             pass
 
     def commit(self):
         self._raw.commit()
+        self._dirty = False
 
     def rollback(self):
         self._raw.rollback()
+        self._dirty = False
 
     def close(self):
         self._raw.close()
@@ -224,9 +257,11 @@ class Database:
 
         # autocommit off: matches SQLite's implicit transaction so the existing
         # _in_transaction + commit()/rollback() atomicity (GL submit/cancel) is
-        # preserved exactly.
+        # preserved exactly. in_explicit_txn lets the wrapper see the
+        # thread-local flag so reads inside submit/cancel keep their snapshot.
         return _PgConn(psycopg.connect(self.db_path, autocommit=False,
-                                       row_factory=_pg_row_factory))
+                                       row_factory=_pg_row_factory),
+                       in_explicit_txn=lambda: self._in_transaction)
 
     @property
     def conn(self):

{lambda_erp-0.6.4 → lambda_erp-0.6.6}/pyproject.toml

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