lambda-erp 0.6.1__tar.gz → 0.6.3__tar.gz

{lambda_erp-0.6.1 → lambda_erp-0.6.3}/PKG-INFO

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

{lambda_erp-0.6.1 → lambda_erp-0.6.3}/api/chat.py

@@ -1198,6 +1198,16 @@ def _chat_doctype_section() -> str:
         if links:
             link_str = ", ".join(f"`{f}` → the {t}'s name" for f, t in links.items())
             line += f" Links: {link_str}."
+        # How to open a record of this type (so links resolve).
+        page = services.chat_doctype_page_info(slug)
+        if page and page["kind"] == "self":
+            line += f" Open a record at `/app/{slug}/<name>`."
+        elif page and page["kind"] == "via":
+            line += (f" It has NO page of its own — open it via its parent: "
+                     f"`/app/{page['parent_slug']}/<{page['link_field']}>`; "
+                     f"never link `/app/{slug}/…`.")
+        elif page and page["kind"] == "none":
+            line += " It has no page — do not emit a link for it."
         lines.append(line)
     return (
         "\n\n## Custom record types (deployment-specific)\n"

{lambda_erp-0.6.1 → lambda_erp-0.6.3}/api/main.py

@@ -121,6 +121,27 @@ def health():
     return {"status": "ok", "version": get_app_version()}
 
 
+@app.get("/api/chat-doctypes")
+def chat_doctypes():
+    """Public metadata for doctypes registered via register_chat_doctype: their
+    description and, for the frontend, how each is opened (`page`). The frontend
+    uses the `page` of kind "via" to auto-register a redirect from the doctype's
+    (chat-generated) `/app/{slug}/{name}` link to its parent's page. Not
+    sensitive — it's the same info the chat system prompt carries."""
+    from api import services
+    out = []
+    for slug, meta in services.CHAT_DOCTYPES.items():
+        if slug not in services.SLUG_TO_DOCTYPE:
+            continue
+        out.append({
+            "slug": slug,
+            "description": meta.get("description"),
+            "fields": meta.get("fields", []),
+            "page": services.chat_doctype_page_info(slug),
+        })
+    return {"doctypes": out}
+
+
 @app.websocket("/ws/chat")
 async def ws_chat(websocket: WebSocket):
     # Authenticate via cookie, fall back to public_manager for demo mode

{lambda_erp-0.6.1 → lambda_erp-0.6.3}/api/services.py

@@ -225,12 +225,48 @@ def register_master(slug: str, table: str, name_field: str, *,
 CHAT_DOCTYPES: dict = {}
 
 
-def register_chat_doctype(slug: str, *, description: str, fields: list | None = None) -> None:
+def register_chat_doctype(slug: str, *, description: str, fields: list | None = None,
+                          page: str | None = "self") -> None:
     """Give the AI chat a description (and optional key-field hints) for a doctype
     already registered via `register_doctype`, so build_system_prompt can tell the
     model what it is and how it links (LINK_FIELDS are surfaced automatically).
-    No new tools — the document tools already cover every registered doctype."""
-    CHAT_DOCTYPES[slug] = {"description": description, "fields": fields or []}
+    No new tools — the document tools already cover every registered doctype.
+
+    `page` tells the chat how a record of this doctype is *opened*, so it emits
+    correct view links (and the frontend can auto-register redirects):
+      "self" (default) — its own page at `/app/{slug}/{name}`;
+      "<link_field>"   — no page of its own; it's shown inside the parent that
+                         `link_field` (a LINK_FIELD) references, so it opens at
+                         `/app/{parent-slug}/{value of link_field}` (e.g. a
+                         contact opens via its lead: page="lead_id");
+      None             — no page and no view link at all.
+    """
+    CHAT_DOCTYPES[slug] = {"description": description, "fields": fields or [], "page": page}
+
+
+def chat_doctype_page_info(slug: str) -> dict | None:
+    """Resolve a chat-doctype's `page` config into a link rule, for the system
+    prompt and the /api/chat-doctypes read. Returns one of:
+      {"kind": "self", "slug": slug}
+      {"kind": "via", "link_field": f, "parent_slug": p}   # opens via a parent
+      {"kind": "none"}
+    or None if the slug isn't a registered chat-doctype."""
+    meta = CHAT_DOCTYPES.get(slug)
+    if not meta:
+        return None
+    page = meta.get("page", "self")
+    if page == "self":
+        return {"kind": "self", "slug": slug}
+    if page is None:
+        return {"kind": "none"}
+    # page names a LINK_FIELD -> resolve the parent doctype -> its slug.
+    doctype = SLUG_TO_DOCTYPE.get(slug)
+    cls = DOCUMENT_CLASSES.get(doctype) if doctype else None
+    links = getattr(cls, "LINK_FIELDS", None) or {}
+    parent_slug = DOCTYPE_TO_SLUG.get(links.get(page)) if links.get(page) else None
+    if not parent_slug:
+        return {"kind": "self", "slug": slug}  # misconfigured -> safe fallback
+    return {"kind": "via", "link_field": page, "parent_slug": parent_slug}
 
 
 def get_document_class(doctype_slug: str):

{lambda_erp-0.6.1 → lambda_erp-0.6.3}/lambda_erp/database.py

@@ -1391,13 +1391,80 @@ class Database:
             self._col_cache.pop(table, None)
             self._text_col_cache.pop(table, None)
 
+    def _alter_table_lock_safe(self, statements, cache_tables, *,
+                               lock_timeout_ms=3000, retries=8, backoff=0.5):
+        """Run ALTER TABLE DDL with a bounded lock wait + retry on Postgres.
+
+        A schema change (ADD/DROP COLUMN) needs an ACCESS EXCLUSIVE lock; during
+        a rolling deploy the OLD app revision is still live and querying the
+        table, so an unbounded ALTER blocks *indefinitely* — and because these
+        migrations run in the app lifespan before it serves, a blocked ALTER
+        fails the container's startup probe and crash-loops the revision (this
+        actually happened in production). Bounding `lock_timeout` turns "hang
+        forever" into "fail fast", and retrying catches a gap between the old
+        revision's queries. If every attempt times out it raises, so the caller
+        (e.g. the plugin migration runner) can retry on the next boot rather
+        than hang. SQLite has no concurrent revision, so it runs directly."""
+        if self.dialect != "postgres":
+            for s in statements:
+                self.conn.execute(self._ddl(s))
+            self.conn.commit()
+            for t in cache_tables:
+                self._col_cache.pop(t, None)
+                self._text_col_cache.pop(t, None)
+            return
+
+        import time as _time
+        last = None
+        try:
+            for _ in range(retries):
+                try:
+                    self.conn.execute(f"SET lock_timeout = '{int(lock_timeout_ms)}ms'")
+                    for s in statements:
+                        self.conn.execute(self._ddl(s))
+                    self.conn.commit()
+                    for t in cache_tables:
+                        self._col_cache.pop(t, None)
+                        self._text_col_cache.pop(t, None)
+                    return
+                except Exception as e:
+                    last = e
+                    self.conn.rollback()
+                    _time.sleep(backoff)
+            raise RuntimeError(
+                f"lock-contended DDL failed after {retries} attempts: {statements!r}: {last!r}"
+            )
+        finally:
+            # lock_timeout is a session setting; restore the default so it
+            # doesn't leak onto later queries on this (pooled) connection.
+            try:
+                self.conn.execute("RESET lock_timeout")
+                self.conn.commit()
+            except Exception:
+                self.conn.rollback()
+
     def ensure_column(self, table: str, column: str, definition: str) -> None:
-        """Idempotently add a column if it's missing. Public helper for plugin
-        migrations registered via api.services.register_migration — the same
-        backend-portable, PRAGMA/information_schema-guarded add the core's own
-        migrations use. `definition` is the SQLite-flavoured column type (e.g.
-        "TEXT", "INTEGER DEFAULT 0"); it is translated per dialect via _ddl."""
-        self._add_column_if_missing(table, column, definition)
+        """Idempotently add a column if it's missing, LOCK-SAFELY. Public helper
+        for plugin migrations registered via api.services.register_migration.
+
+        On Postgres the ADD COLUMN is bounded by `lock_timeout` + retry so a
+        migration can't hang the boot against a live old revision during a
+        rolling deploy (see _alter_table_lock_safe). SQLite adds directly. The
+        `definition` is the SQLite-flavoured column type (e.g. "TEXT",
+        "INTEGER DEFAULT 0"); it is translated per dialect via _ddl."""
+        if column in self._get_table_columns(table):
+            return
+        self._alter_table_lock_safe(
+            [f'ALTER TABLE "{table}" ADD COLUMN {column} {definition}'], [table])
+
+    def drop_column(self, table: str, column: str) -> None:
+        """Idempotently drop a column if present, LOCK-SAFELY (same rolling-deploy
+        protection as ensure_column). No-op if the column is already gone.
+        Requires SQLite >= 3.35 for the SQLite backend (DROP COLUMN support)."""
+        if column not in self._get_table_columns(table):
+            return
+        self._alter_table_lock_safe(
+            [f'ALTER TABLE "{table}" DROP COLUMN "{column}"'], [table])
 
     def _migrate(self):
         """Run each pending migration in order, tracking applied versions."""

{lambda_erp-0.6.1 → lambda_erp-0.6.3}/pyproject.toml

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