lambda-erp 0.8.32__tar.gz → 0.8.34__tar.gz

{lambda_erp-0.8.32 → lambda_erp-0.8.34}/PKG-INFO

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

{lambda_erp-0.8.32 → lambda_erp-0.8.34}/api/chat.py

@@ -179,6 +179,17 @@ def save_chat_message(session_id: str, role: str, content: str, message_type: st
     touch_session(session_id)
 
 
+def _save_tool_trace(session_id: str, message_type: str, payload: dict):
+    """Audit visible tool activity without masking a completed business write."""
+    try:
+        save_chat_message(session_id, "tool", json.dumps(payload, default=str), message_type=message_type)
+    except Exception:
+        # A session can be deleted while a tool is running. In particular, a
+        # failed result audit must not turn a successful write into a retry.
+        get_db().conn.rollback()
+        logger.warning("Could not persist %s trace for session %s", message_type, session_id)
+
+
 def load_chat_history(session_id: str, limit: int = 50, before_id: int | None = None) -> list[dict]:
     """Load recent chat messages for a session.
 
@@ -189,13 +200,13 @@ def load_chat_history(session_id: str, limit: int = 50, before_id: int | None =
     if before_id:
         rows = db.sql(
             'SELECT id, role, message_type, content, metadata_json, created_at '
-            'FROM "Chat Message" WHERE session_id = ? AND id < ? ORDER BY id DESC LIMIT ?',
+            'FROM "Chat Message" WHERE session_id = ? AND role IN (\'user\', \'assistant\') AND id < ? ORDER BY id DESC LIMIT ?',
             [session_id, int(before_id), limit],
         )
     else:
         rows = db.sql(
             'SELECT id, role, message_type, content, metadata_json, created_at '
-            'FROM "Chat Message" WHERE session_id = ? ORDER BY id DESC LIMIT ?',
+            'FROM "Chat Message" WHERE session_id = ? AND role IN (\'user\', \'assistant\') ORDER BY id DESC LIMIT ?',
             [session_id, limit],
         )
     rows.reverse()
@@ -275,7 +286,7 @@ def load_serialized_chat_history(
     if oldest_id is not None:
         db = get_db()
         older = db.sql(
-            'SELECT 1 FROM "Chat Message" WHERE session_id = ? AND id < ? LIMIT 1',
+            'SELECT 1 FROM "Chat Message" WHERE session_id = ? AND role IN (\'user\', \'assistant\') AND id < ? LIMIT 1',
             [session_id, int(oldest_id)],
         )
         has_more = bool(older)
@@ -483,7 +494,7 @@ TOOLS = [
         "type": "function",
         "function": {
             "name": "get_document_fields",
-            "description": "List the available columns of a document type and identify which are text fields. Call this before building list_documents filters when you are unsure of a field name or whether it supports the case-insensitive contains operator. Also returns the default fields used by free-text search.",
+            "description": "List the available columns of a document type and identify which are text fields. Call this before building list_documents filters when you are unsure of a field name or whether it supports the case-insensitive contains operator. Also returns required fields, conditional business rules, child requirements, dynamic links and supported transient inputs. Check these before creating or updating a document; unknown fields are rejected.",
             "parameters": {
                 "type": "object",
                 "properties": {
@@ -513,7 +524,7 @@ TOOLS = [
         "function": {
             "name": "create_document",
             "description": (
-                "Create a new draft document (docstatus=0). The document is saved but NOT submitted. IMPORTANT: you MUST pass the 'data' object with ALL document fields — doctype alone is not enough. Example: {\"doctype\": \"purchase-order\", \"data\": {\"supplier\": \"SUPP-001\", \"company\": \"My Co\", \"transaction_date\": \"2026-04-14\", \"items\": [{\"item_code\": \"ITEM-001\", \"qty\": 10, \"rate\": 100}]}}\n"
+                "Create a new draft document (docstatus=0). The document is saved but NOT submitted. Use get_document_fields for required/conditional fields. Never omit an ambiguous business reference to make a call succeed: ask a targeted question. Relay _validation.warnings from saved documents. IMPORTANT: you MUST pass the 'data' object with ALL document fields — doctype alone is not enough. Example: {\"doctype\": \"purchase-order\", \"data\": {\"supplier\": \"SUPP-001\", \"company\": \"My Co\", \"transaction_date\": \"2026-04-14\", \"items\": [{\"item_code\": \"ITEM-001\", \"qty\": 10, \"rate\": 100}]}}\n"
                 "Currency: `currency` is optional — it defaults to the customer/supplier's currency, else the company's base currency. To bill in a foreign currency, also pass `conversion_rate` = how many units of the company's base currency equal 1 unit of the document currency (no automatic FX lookup yet, so you MUST supply it for a foreign currency). Item rates stay in the document currency. Example (base USD, invoicing in EUR at 1 EUR = 1.10 USD): {\"doctype\": \"sales-invoice\", \"data\": {\"customer\": \"CUST-001\", \"company\": \"My Co\", \"posting_date\": \"2026-05-22\", \"currency\": \"EUR\", \"conversion_rate\": 1.10, \"items\": [{\"item_code\": \"ITEM-001\", \"qty\": 1, \"rate\": 100}]}}"
             ),
             "parameters": {
@@ -1469,20 +1480,7 @@ def _handle_list_documents(args):
 
 
 def _handle_get_document_fields(args):
-    doctype = args["doctype"]
-    table = services.SLUG_TO_DOCTYPE.get(doctype)
-    if not table:
-        return {"error": f"Unknown document type: {doctype}"}
-    db = get_db()
-    cls = services.DOCUMENT_CLASSES.get(table)
-    return {
-        "doctype": doctype,
-        "fields": sorted(db._get_table_columns(table)),
-        "text_fields": sorted(db._get_text_columns(table)),
-        "default_search_fields": services.document_search_columns(db, doctype),
-        "child_tables": sorted((cls.CHILD_TABLES or {}).keys()) if cls else [],
-        "link_fields": dict(getattr(cls, "LINK_FIELDS", None) or {}) if cls else {},
-    }
+    return services.document_field_metadata(args["doctype"])
 
 
 def _handle_get_document(args):
@@ -1569,6 +1567,7 @@ def _fuzzy_master_search(db, doctype, search_cols, query, has_disabled, limit):
 
 
 def _handle_get_master_fields(args):
+    from api.routers.masters import master_requirements, MASTER_LINK_FIELDS
     db = get_db()
     master_type = args["master_type"]
     entry = services.MASTER_TABLES.get(master_type)
@@ -1577,6 +1576,7 @@ def _handle_get_master_fields(args):
     doctype, _ = entry
     default_search = _master_search_columns(db, doctype)
     bulk = services.master_bulk_text_columns(db, doctype)
+    cls = services.DOCUMENT_CLASSES.get(doctype)
     return {
         "master_type": master_type,
         "fields": sorted(db._get_table_columns(doctype)),
@@ -1585,6 +1585,10 @@ def _handle_get_master_fields(args):
         "default_search_fields": default_search,
         # Large text fields searched ONLY when named in search_masters `fields`.
         "bulk_text_fields": bulk,
+        "requirements": master_requirements(master_type),
+        "link_fields": dict(cls.LINK_FIELDS) if cls else MASTER_LINK_FIELDS.get(master_type, {}),
+        "dynamic_link_fields": dict(cls.DYNAMIC_LINK_FIELDS) if cls else {},
+        "input_fields": sorted(set(cls.INPUT_FIELDS if cls else ()) | ({services.MASTER_IDENTITY_ALIAS[master_type]} if master_type in services.MASTER_IDENTITY_ALIAS else set())),
     }
 
 
@@ -2138,7 +2142,11 @@ def _handle_create_custom_analytics_report(args, user_info: dict | None = None,
 
     if not args.get("title"):
         return {"error": "title is required"}
-    return create_report_draft_record(args, user_info, source_chat_session_id=session_id)
+    # ``intent`` is a tool-control field for the specialist handoff, not part
+    # of the persisted declarative report.  Keep every other key so the strict
+    # ReportDraftPayload boundary still rejects unexpected/executable fields.
+    payload = {key: value for key, value in args.items() if key != "intent"}
+    return create_report_draft_record(payload, user_info, source_chat_session_id=session_id)
 
 
 def _handle_get_custom_analytics_report(args, user_info: dict | None = None):
@@ -2352,12 +2360,30 @@ def _prompt_uom_context() -> str:
     )
 
 
+def _prompt_validation_context():
+    from lambda_erp.validation import document_requirements
+    from api.routers.masters import master_requirements
+    groups = {}
+    for doctype, cls in services.DOCUMENT_CLASSES.items():
+        rules = document_requirements(cls)
+        if not any(rules.values()):
+            continue
+        key = json.dumps(rules, sort_keys=True)
+        groups.setdefault(key, []).append(doctype)
+    for slug, (doctype, _) in services.MASTER_TABLES.items():
+        if doctype not in services.DOCUMENT_CLASSES:
+            key = json.dumps(master_requirements(slug), sort_keys=True)
+            groups.setdefault(key, []).append(doctype + ' (master)')
+    return "\n".join(f"- {', '.join(names)}: {rules}" for rules, names in groups.items())
+
+
 def build_system_prompt(user_info: dict | None = None, channel: str = "web"):
     user_name = user_info.get("full_name", "User") if user_info else "User"
     user_role = user_info.get("role", "viewer") if user_info else "viewer"
     company_context = _prompt_company_context()
     analytics_context = _prompt_analytics_context()
     uom_context = _prompt_uom_context()
+    validation_context = _prompt_validation_context()
 
     # Deployment-registered types (register_doctype / register_master). Folded
     # into the type lists below so the assistant knows they exist and can act
@@ -2449,11 +2475,16 @@ If `jurisdiction.is_fallback` is true, tell the user their country isn't localiz
 
 You help users manage their business by creating documents, looking up data, and running reports — all through natural conversation.
 
+## Enforced document requirements (generated from backend rule metadata)
+{validation_context}
+Use get_document_fields for full field and relationship metadata. On updates these rules apply to the merged document, so already stored values need not be resubmitted. Never remove an ambiguous link to bypass a validation error.
+
 ## Never fabricate actions or results
-Only state that something was done — created, changed, enabled/disabled, booked, repointed — **after a tool call returns a success result that confirms it**, and check the returned record actually reflects the change (after `update_master` with {{"disabled": 0}}, confirm the returned row shows `disabled = 0`; after submitting a journal entry, confirm it posted non-zero GL). If a tool returns an error, a warning, or a record that doesn't reflect your intent, tell the user it did **not** work and why — never smooth it over as success.
+Only state that something was done — created, changed, enabled/disabled, booked, repointed — **after a tool call returns a success result that confirms it**, and check the returned record actually reflects the change (after `update_master` with {{"disabled": 0}}, confirm the returned row shows `disabled = 0`; after submitting a journal entry, confirm it posted non-zero GL). An error means the action failed. For a successful result with warnings, explain both what was saved and what remains incomplete (for example, pool capacity reserved but no machine assigned). If the record doesn't reflect your intent, explain the mismatch — never smooth it over as success.
 - If a capability doesn't exist, say so plainly. There is **no rename** for accounts or other masters — a master's identifying `name`/number is immutable; you can only edit display fields or create a new record and migrate. Never claim you "renamed" an account.
 - Never assert a field or capability is missing without checking (e.g. an item's income account) — verify with `get_master_fields` / `search_masters` first.
 - A master you can't find via `search_masters` may just be **disabled** (search hides disabled by default). Retry with `include_disabled: true` before concluding it doesn't exist — you need this to re-enable a disabled account.
+- Respect document requirements from get_document_fields. Missing required data or ambiguous matches require a targeted question, not guessed IDs, omitted links, or zero quantities. A tool error means the action failed; _validation.warnings must be explained.
 - If you can't confirm an action took effect, re-fetch and look, or tell the user you couldn't confirm it — never guess.
 
 ## Answering data questions — three paths
@@ -2639,9 +2670,11 @@ Use these only for items flagged `is_asset_tracked` on the Item master. Neither
 - **Item vs Asset:** the Item is the *type* ("17t Excavator") and carries the rate and pricing rules. An **Asset** (slug `asset`) is ONE physical unit of it. Three identical machines = one Item + three Assets. Create with `item_code` (required) plus `asset_tag` (plate / serial — optional but must be unique), `warehouse` (its home yard), and optionally `purchase_date`, `purchase_value`, `meter_reading`. `status` is Available / On Hire / Maintenance / Retired — the unit's state *today*, not a date range. Retired units leave the pool.
 - **Opting in:** creating an Asset for an Item that isn't asset-tracked is refused. Fix it by setting `is_asset_tracked` = 1 on the Item via update_master, then retry. Never suggest the user edit the database.
 - **Reservation** (slug `reservation`) books a time window. Required: `from_datetime` and `to_datetime` (`YYYY-MM-DD` or `YYYY-MM-DD HH:MM:SS`; a bare date means midnight). Windows are **half-open** — a hire ending on the 19th and the next starting on the 19th do NOT clash. Two ways to book:
-  - **pooled** — set `item_code`, `warehouse` and `qty`: "*a* machine of this type from that yard". Use this at quotation/order time when the specific unit doesn't matter yet.
+  - **pooled** — explicitly set `allocation_mode="Pool"`; set `item_code`, `warehouse` and `qty`: "*a* machine of this type from that yard". Use this at quotation/order time when the specific unit doesn't matter yet.
   - **unit** — set `asset`: "*that* machine". `item_code`, `warehouse` and `qty` are filled in from the Asset automatically.
-- **Who it's for (do NOT skip this):** set `party` to the hiring customer's id (e.g. `CUST-005`) with `party_type = "Customer"`. The customer is almost always given by NAME — "reserve the 17t for Hans Meisterhans" — so FIRST resolve the name to a record with `search_masters` (master_type "customer") and set `party` to the matched id; never put the raw name in `party`. No match → create the customer (or ask which existing one is meant), then book. A reservation with no `party` is only for an internal block (maintenance, transport, transfer) — if the user named a customer, a booking without `party` set is a bug, not an option.
+- **Choosing a machine:** resolve the Item, then list active, non-discarded Assets and the relevant reservations. If multiple usable units match and the customer has not specified a yard/unit, ask which yard/plate is meant; do not guess and do not silently omit asset. Only create a Pool booking when the user intentionally wants unassigned capacity. A uniquely identified available unit can be booked by asset ID. Asset and reservation warehouse must match; record a transfer first if needed.
+- **Calendar:** Pool bookings appear on separate unassigned rows, not on a specific machine. Always tell the user when no machine is assigned. On a report of a missing booking, get_document and inspect asset, status, discarded and warehouse; do not claim a unit is booked merely because a Reservation exists. Out requires an asset.
+- **Who it's for (do NOT skip this):** set `party` to the hiring customer's id (e.g. `CUST-005`) with `party_type = "Customer"`. The customer is almost always given by NAME — "reserve the 17t for Hans Meisterhans" — so FIRST resolve the name to a record with `search_masters` (master_type "customer") and set `party` to the matched id; never put the raw name in `party`. No match → create the customer (or ask which existing one is meant), then book. A reservation with no `party` is only for an internal block (maintenance, transport, transfer) — if the user named a customer, a booking without `party` set is a bug, not an option. Internal blocks without party require an explicit purpose.
 - `status` is Reserved / Out / Returned / Cancelled. **Reserved and Out block the calendar; Returned and Cancelled do not** — so a hire that comes back early frees its slot the moment you set it to Returned. Link a booking to the order that caused it with `voucher_type` + `voucher_no`.
 - **Double-booking is refused at save time.** If you get "already committed" (that unit is taken) or "free at" (the yard's pool is exhausted for that window), do NOT retry blindly — report the conflict, then offer the alternatives: different dates, a different yard, or a different model.
 - To answer "what's free between X and Y", list reservations for the item over the window and compare against the Assets that exist; a unit with no overlapping Reserved/Out row is available.
@@ -3617,6 +3650,8 @@ async def run_thinking_loop(
             tool_call_id = tc.id
 
             await on_event({"type": "tool_call", "tool": fn_name, "args": fn_args})
+            if session_id:
+                _save_tool_trace(session_id, "tool_call", {"tool": fn_name, "args": fn_args})
 
             # LLM turns can run for many seconds. Re-resolve the principal at
             # the actual execution boundary so a demotion, disable, or key
@@ -3652,7 +3687,7 @@ async def run_thinking_loop(
             else:
                 try:
                     result = await asyncio.to_thread(handler, fn_args)
-                    success = True
+                    success = not (isinstance(result, dict) and ("error" in result or result.get("ok") is False or result.get("failed", 0)))
                 except Exception as e:
                     result = {"error": str(e)}
                     success = False
@@ -3673,6 +3708,10 @@ async def run_thinking_loop(
                 "success": success,
                 "summary": summary,
             }
+            if isinstance(result, dict):
+                event_payload["warnings"] = (result.get("_validation") or {}).get("warnings", [])
+                if not success:
+                    event_payload["error"] = result.get("error") or "One or more operations failed; inspect the tool result."
             # Surface the report id so the sidebar can flash the specific draft.
             if (
                 success
@@ -3681,6 +3720,8 @@ async def run_thinking_loop(
                 and result.get("id")
             ):
                 event_payload["report_id"] = result["id"]
+            if session_id:
+                _save_tool_trace(session_id, "tool_result", {**event_payload, "result": result})
             await on_event(event_payload)
 
             messages.append({

{lambda_erp-0.8.32 → lambda_erp-0.8.34}/api/errors.py

@@ -63,6 +63,15 @@ def _friendly_integrity(msg: str) -> str:
 
 
 async def _integrity_handler(request: Request, exc: Exception):
+    msg = str(exc)
+    code = getattr(exc, 'sqlstate', None)
+    if code == '23502' or 'NOT NULL constraint failed:' in msg:
+        column = getattr(getattr(exc, 'diag', None), 'column_name', None)
+        if not column and 'NOT NULL constraint failed:' in msg:
+            column = msg.split('NOT NULL constraint failed:', 1)[1].strip()
+        return JSONResponse(status_code=422, content={'detail': f'{column or "A required field"} is required'})
+    if code == '23503' or 'foreign key constraint failed' in msg.lower():
+        return JSONResponse(status_code=422, content={'detail': "This links to a record that does not exist or is still referenced."})
     return JSONResponse(status_code=409, content={"detail": _friendly_integrity(str(exc))})
 
 

{lambda_erp-0.8.32 → lambda_erp-0.8.34}/api/pdf.py

@@ -266,6 +266,8 @@ def generate_proposal_pdf(name: str) -> bytes:
     """Render a Proposal (Sammelofferte): a cover letter plus each referenced
     Quotation as a lettered position (A, B, C…), then append the uploaded
     appendix PDF if there is one. Never mutates the quotations."""
+    from lambda_erp.selling.proposal import Proposal
+    Proposal.load(name).validate_for_output()
     proposal = load_document("proposal", name)
     db = get_db()
 
@@ -301,12 +303,7 @@ def generate_proposal_pdf(name: str) -> bytes:
     rows = sorted(proposal.get("quotations", []) or [], key=lambda r: r.get("idx") or 0)
     for i, row in enumerate(rows):
         qname = row.get("quotation")
-        if not qname:
-            continue
-        try:
-            quote = load_document("quotation", qname)
-        except Exception:
-            continue
+        quote = load_document("quotation", qname)
         items = quote.get("items", []) or []
         # Refresh each line's item_name from the master, consistent with the
         # single-document path.

{lambda_erp-0.8.32 → lambda_erp-0.8.34}/api/routers/availability.py

@@ -117,7 +117,7 @@ def calendar_feed(
             "meter_reading": a.get("meter_reading"),
         }
         for a in db.get_all("Asset", filters=asset_filters, fields=["*"], order_by="item_code, asset_tag")
-        if a.get("status") != "Retired"
+        if a.get("status") != "Retired" and not a.get("discarded")
     ]
 
     try:

{lambda_erp-0.8.32 → lambda_erp-0.8.34}/api/routers/chat_api.py

@@ -78,11 +78,6 @@ def _extract_documents(reply: str, request: Request) -> list[dict]:
     return documents
 
 
-async def _noop_event(event: dict) -> None:
-    """Discard streamed loop events — the REST response is the final reply only."""
-    return None
-
-
 def _client_ip(request: Request) -> str | None:
     xff = request.headers.get("x-forwarded-for", "")
     if xff:
@@ -117,11 +112,17 @@ async def chat(payload: ChatApiRequest, request: Request, caller: dict = Depends
 
     save_chat_message(target_session_id, "user", message)
 
+    tool_results = []
+
+    async def collect_event(event):
+        if event.get("type") == "tool_result":
+            tool_results.append({key: event[key] for key in ("tool", "success", "error", "warnings") if key in event})
+
     reply = await run_session_turn(
         target_session_id,
         message,
         caller,
-        _noop_event,
+        collect_event,
         client_ip=_client_ip(request),
         replay_history=replay_history,
         channel="api",
@@ -133,6 +134,7 @@ async def chat(payload: ChatApiRequest, request: Request, caller: dict = Depends
         "session_id": target_session_id,
         "title": session["title"] if session else None,
         "documents": _extract_documents(reply or "", request),
+        "tool_results": tool_results,
     }
 
 

{lambda_erp-0.8.32 → lambda_erp-0.8.34}/api/routers/documents.py

@@ -37,6 +37,12 @@ _LIST_RESERVED = {
 }
 
 
+@router.get("/{doctype_slug}/fields")
+def document_fields(doctype_slug: str, _user: dict = _viewer):
+    from api.services import document_field_metadata
+    return document_field_metadata(doctype_slug)
+
+
 @router.get("/{doctype_slug}")
 def list_docs(
     doctype_slug: str,

{lambda_erp-0.8.32 → lambda_erp-0.8.34}/api/routers/masters.py

@@ -18,6 +18,8 @@ from api.services import (
 )
 from api.auth import require_role, require_non_public_manager
 from api.list_values import distinct_list_values
+from lambda_erp.exceptions import ValidationError
+from lambda_erp.validation import missing
 
 router = APIRouter(prefix="/masters", tags=["masters"])
 
@@ -54,7 +56,7 @@ DELETE_REFERENCE_CHECKS = {
         ('SELECT 1 FROM "POS Invoice" WHERE company = ? LIMIT 1', "POS invoice"),
         ('SELECT 1 FROM "Budget" WHERE company = ? LIMIT 1', "budget"),
         ('SELECT 1 FROM "Subscription" WHERE company = ? LIMIT 1', "subscription"),
-        ('SELECT 1 FROM "Bank Transaction" WHERE company = ? LIMIT 1', "bank transaction"),
+        ('SELECT 1 FROM "Bank Transaction" t JOIN "Bank Account" a ON a.name = t.bank_account WHERE a.company = ? LIMIT 1', "bank transaction"),
     ],
     "customer": [
         ('SELECT 1 FROM "Quotation" WHERE customer = ? LIMIT 1', "quotation"),
@@ -117,7 +119,6 @@ DELETE_REFERENCE_CHECKS = {
         ('SELECT 1 FROM "Tax Template Detail" WHERE account_head = ? LIMIT 1', "tax template detail"),
         ('SELECT 1 FROM "Company" WHERE round_off_account = ? OR default_receivable_account = ? OR default_payable_account = ? OR default_income_account = ? OR default_expense_account = ? OR stock_received_but_not_billed = ? OR stock_adjustment_account = ? OR accumulated_depreciation_account = ? OR depreciation_expense_account = ? LIMIT 1', "company"),
         ('SELECT 1 FROM "Warehouse" WHERE account = ? LIMIT 1', "warehouse"),
-        ('SELECT 1 FROM "Pricing Rule" WHERE discount_account = ? LIMIT 1', "pricing rule"),
         ('SELECT 1 FROM "Budget" WHERE account = ? LIMIT 1', "budget"),
         ('SELECT 1 FROM "Bank Transaction" WHERE bank_account = ? LIMIT 1', "bank transaction"),
     ],
@@ -210,7 +211,78 @@ def _normalize_master_data(data: dict) -> dict:
     return normalized
 
 
+MASTER_LINK_FIELDS = {
+    'item': {'default_warehouse': 'Warehouse'},
+    'warehouse': {'company': 'Company', 'account': 'Account', 'parent_warehouse': 'Warehouse'},
+    'account': {'company': 'Company', 'parent_account': 'Account'},
+    'cost-center': {'company': 'Company', 'parent_cost_center': 'Cost Center'},
+}
+
+
+def master_requirements(master_type):
+    from api import services
+    doctype, display = _get_table(master_type)
+    if doctype in services.DOCUMENT_CLASSES:
+        from lambda_erp.validation import document_requirements
+        return document_requirements(services.DOCUMENT_CLASSES[doctype])
+    from lambda_erp.master_integrity import structure_requirements, STRUCTURAL_FIELDS
+    return {'required': [display], 'conditional': ['Unknown input fields are rejected; supplied links must exist.'] + structure_requirements(master_type), 'children': {},
+            'structural_fields': list(STRUCTURAL_FIELDS.get(master_type, ()))}
+
+
+def _structural_reference(master_type, doctype, name):
+    """Check declared links too; new document types inherit reference protection.
+
+    Unlike best-effort delete diagnostics, validation must not swallow SQL
+    failures and then approve a structural change.
+    """
+    from api import services
+    db = get_db()
+    links = set()
+    for cls in services.DOCUMENT_CLASSES.values():
+        links.update((cls.DOCTYPE, field) for field, target in cls.LINK_FIELDS.items() if target == doctype)
+        for key, fields in cls.CHILD_LINK_FIELDS.items():
+            links.update((cls.CHILD_TABLES[key][0], field) for field, target in fields.items() if target == doctype)
+    for kind, fields in MASTER_LINK_FIELDS.items():
+        table, _ = _get_table(kind)
+        links.update((table, field) for field, target in fields.items() if target == doctype)
+    for table, field in sorted(links):
+        # Some declarations validate transient/defaulted inputs. Only stored
+        # columns can carry a persistent reference (SQLite masks missing ones).
+        if field not in db._get_table_columns(table):
+            continue
+        if db.sql(f'SELECT name FROM "{table}" WHERE "{field}" = ? LIMIT 1', [name]):
+            return f'{table}.{field}'
+    for query, label in [*DELETE_REFERENCE_CHECKS.get(master_type, []), *MASTER_REFERENCE_CHECKS.get(master_type, [])]:
+        if db.sql(query, [name] * query.count('?')):
+            return label
+    return None
+
+
+def _validate_master_input(master_type, doctype, data, name=None):
+    db = get_db()
+    allowed = db._get_table_columns(doctype)
+    unknown = set(data) - allowed
+    if unknown:
+        raise ValidationError(f'{doctype}: Unknown field(s): {", ".join(sorted(unknown))}. Use get_master_fields.')
+    if name and data.get('name') not in (None, name):
+        raise ValidationError('Cannot change master identity; create a new record instead')
+    merged = dict(db.get_value(doctype, name, list(allowed)) or {}) if name else {}
+    merged.update(data)
+    for field in master_requirements(master_type)['required']:
+        if missing(merged.get(field)):
+            raise ValidationError(f'{doctype}: {field} is required')
+    for field, table in MASTER_LINK_FIELDS.get(master_type, {}).items():
+        if merged.get(field) and not db.exists(table, merged[field]):
+            raise ValidationError(f'{doctype}: {field} must reference an existing {table}')
+
+
 def create_master_record(master_type: str, data: dict) -> dict:
+    with get_db().atomic():
+        return _create_master_record(master_type, data)
+
+
+def _create_master_record(master_type: str, data: dict) -> dict:
     doctype, _ = _get_table(master_type)
     if not doctype:
         raise HTTPException(status_code=404, detail=f"Unknown master type: {master_type}")
@@ -245,6 +317,12 @@ def create_master_record(master_type: str, data: dict) -> dict:
     if db.exists(doctype, doc["name"]):
         raise HTTPException(status_code=409, detail=f"{doctype} {doc['name']} already exists")
 
+    from api import services
+    if doctype in services.DOCUMENT_CLASSES:
+        return _echo_identity_alias(master_type, services.create_document(services.DOCTYPE_TO_SLUG[doctype], doc))
+
+    _validate_master_input(master_type, doctype, doc)
+
     columns = db._get_table_columns(doctype)
     stamp = now()
     if "creation" in columns and not doc.get("creation"):
@@ -267,6 +345,13 @@ def create_master_record(master_type: str, data: dict) -> dict:
 
 
 def update_master_record(master_type: str, name: str, data: dict) -> dict:
+    from lambda_erp.master_integrity import STRUCTURAL_FIELDS
+    exclusive = bool(set(data) & set(STRUCTURAL_FIELDS.get(master_type, ())))
+    with get_db().atomic(exclusive_master_edit=exclusive):
+        return _update_master_record(master_type, name, data)
+
+
+def _update_master_record(master_type: str, name: str, data: dict) -> dict:
     doctype, _ = _get_table(master_type)
     if not doctype:
         raise HTTPException(status_code=404, detail=f"Unknown master type: {master_type}")
@@ -289,7 +374,23 @@ def update_master_record(master_type: str, name: str, data: dict) -> dict:
                 ),
             )
 
+    if normalized.get('name') not in (None, name):
+        raise ValidationError('Cannot change master identity; create a new record instead')
+    from api import services
+    if doctype in services.DOCUMENT_CLASSES:
+        return _echo_identity_alias(master_type, services.update_document(services.DOCTYPE_TO_SLUG[doctype], name, normalized))
+
     update_fields = {k: v for k, v in normalized.items() if k != "name"}
+    if not db.exists(doctype, name):
+        raise HTTPException(status_code=404, detail=f"{doctype} {name} not found")
+    _validate_master_input(master_type, doctype, normalized, name)
+    from lambda_erp.master_integrity import structural_changes
+    stored = db.get_value(doctype, name, list(db._get_table_columns(doctype)))
+    changed = structural_changes(master_type, stored, normalized)
+    if changed:
+        reference = _structural_reference(master_type, doctype, name)
+        if reference:
+            raise ValidationError(f'{doctype} {name}: cannot change structural fields {", ".join(changed)}; referenced by {reference}. Use a new master or a deliberate migration.')
     if "modified" in db._get_table_columns(doctype) and "modified" not in update_fields:
         update_fields["modified"] = now()
     if update_fields:
@@ -559,6 +660,14 @@ def adjacent_master(
     return {"prev": neighbor("prev"), "next": neighbor("next")}
 
 
+@router.get("/{master_type}/fields")
+def master_fields(master_type: str, _user: dict = _viewer):
+    if not _get_table(master_type)[0]:
+        raise HTTPException(status_code=404, detail=f"Unknown master type: {master_type}")
+    from api.chat import _handle_get_master_fields
+    return _handle_get_master_fields({'master_type': master_type})
+
+
 @router.get("/{master_type}/{name}")
 def get_master(master_type: str, name: str, _user: dict = _viewer):
     doctype, _ = _get_table(master_type)
@@ -598,6 +707,11 @@ def delete_master_record(master_type: str, name: str) -> dict:
     if not db.exists(doctype, name):
         raise HTTPException(status_code=404, detail=f"{doctype} {name} not found")
 
+    from api import services
+    if doctype in services.DOCUMENT_CLASSES and 'discarded' in db._get_table_columns(doctype):
+        services.discard_document(services.DOCTYPE_TO_SLUG[doctype], name)
+        return {'ok': True, 'status': 'discarded'}
+
     reference = _find_reference(master_type, name)
     if reference:
         columns = db._get_table_columns(doctype)

{lambda_erp-0.8.32 → lambda_erp-0.8.34}/api/services.py

@@ -458,16 +458,77 @@ def _default_tax_rows(cls, data: dict) -> list | None:
     ]
 
 
+def document_field_metadata(doctype_slug: str) -> dict:
+    from lambda_erp.validation import document_requirements
+    doctype, cls = get_document_class(doctype_slug)
+    if not cls:
+        raise ValueError(f"Unknown document type: {doctype_slug}")
+    db = get_db()
+    return {
+        "doctype": doctype_slug,
+        "fields": sorted(db._get_table_columns(doctype)),
+        "text_fields": sorted(db._get_text_columns(doctype)),
+        "default_search_fields": document_search_columns(db, doctype_slug),
+        "child_tables": sorted(cls.CHILD_TABLES),
+        "link_fields": dict(cls.LINK_FIELDS),
+        "dynamic_link_fields": dict(cls.DYNAMIC_LINK_FIELDS),
+        "input_fields": sorted(cls.INPUT_FIELDS),
+        "read_only_fields": sorted(cls.SERVER_MANAGED_FIELDS),
+        "child_input_fields": {key: sorted(value) for key, value in cls.CHILD_INPUT_FIELDS.items()},
+        "requirements": document_requirements(cls),
+    }
+
+
+def _validate_document_input(doctype, cls, data):
+    from lambda_erp.exceptions import ValidationError
+    if not isinstance(data, dict):
+        raise ValidationError("Document data must be an object")
+    # Response-only annotations can accompany a round trip through the form.
+    data = {key: value for key, value in data.items() if key != "_validation"}
+    db = get_db()
+    allowed = db._get_table_columns(doctype) | set(cls.CHILD_TABLES) | set(cls.INPUT_FIELDS)
+    unknown = set(data) - allowed
+    if unknown:
+        raise ValidationError(f"{doctype}: Unknown field(s): {', '.join(sorted(unknown))}. Use get_document_fields to inspect supported fields.")
+    for key, (table, _) in cls.CHILD_TABLES.items():
+        if key not in data:
+            continue
+        rows = data[key]
+        if not isinstance(rows, list):
+            raise ValidationError(f"{doctype}: {key} must be an array")
+        allowed_child = db._get_table_columns(table) | set(cls.CHILD_INPUT_FIELDS.get(key, ()))
+        for idx, row in enumerate(rows, 1):
+            if not isinstance(row, dict):
+                raise ValidationError(f"{doctype}: {key} row {idx} must be an object")
+            unknown = set(row) - allowed_child
+            if unknown:
+                raise ValidationError(f"{doctype}: {key} row {idx}: Unknown field(s): {', '.join(sorted(unknown))}")
+    return data
+
+
+def _document_validation(doc):
+    warnings = []
+    if doc.DOCTYPE == 'Proposal' and (not doc.get('customer') or not doc.get('company') or not doc.get('quotations')):
+        warnings.append({'code': 'proposal_incomplete', 'message': 'Draft saved; PDF output requires Customer, Company and at least one Quotation.'})
+    if doc.DOCTYPE == "Reservation" and not doc.get("asset") and doc.get("status") in {"Reserved", "Out"}:
+        warnings.append({
+            "code": "asset_unassigned", "field": "asset",
+            "message": "Pool capacity is reserved; no specific machine is assigned. This booking appears on a pool row in the fleet calendar. Assign an asset before dispatch.",
+        })
+    return {"warnings": warnings}
+
+
 def create_document(doctype_slug: str, data: dict) -> dict:
     doctype, cls = get_document_class(doctype_slug)
     if not cls:
         raise ValueError(f"Unknown document type: {doctype_slug}")
+    data = _validate_document_input(doctype, cls, data)
     default_taxes = _default_tax_rows(cls, data)
     if default_taxes is not None:
         data = {**data, "taxes": default_taxes}
     doc = cls(data)
     doc.save()
-    return doc.as_dict()
+    return load_document(doctype_slug, doc.name)
 
 
 def load_document(doctype_slug: str, name: str) -> dict:
@@ -475,13 +536,16 @@ def load_document(doctype_slug: str, name: str) -> dict:
     if not cls:
         raise ValueError(f"Unknown document type: {doctype_slug}")
     doc = cls.load(name)
-    return doc.as_dict()
+    result = doc.as_dict()
+    result["_validation"] = _document_validation(doc)
+    return result
 
 
 def update_document(doctype_slug: str, name: str, data: dict) -> dict:
     doctype, cls = get_document_class(doctype_slug)
     if not cls:
         raise ValueError(f"Unknown document type: {doctype_slug}")
+    data = _validate_document_input(doctype, cls, data)
     doc = cls.load(name)
     # Update parent fields
     for key, value in data.items():
@@ -494,7 +558,7 @@ def update_document(doctype_slug: str, name: str, data: dict) -> dict:
             for row in data[table_name]:
                 doc.append(table_name, _dict(row))
     doc.save()
-    return doc.as_dict()
+    return load_document(doctype_slug, doc.name)
 
 
 def batch_update_documents(doctype_slug: str, updates: list) -> dict:
@@ -528,12 +592,13 @@ def batch_update_documents(doctype_slug: str, updates: list) -> dict:
             results.append({"name": name, "ok": False, "error": "missing 'data' object"})
             continue
         try:
-            update_document(doctype_slug, name, data)
-            results.append({"name": name, "ok": True})
+            saved = update_document(doctype_slug, name, data)
+            results.append({"name": name, "ok": True, "warnings": saved.get('_validation', {}).get('warnings', [])})
             updated += 1
         except Exception as e:  # noqa: BLE001 — per-item best effort; report, don't abort
             results.append({"name": name, "ok": False, "error": str(e)})
-    return {"updated": updated, "failed": len(results) - updated, "results": results}
+    warnings = [{**warning, 'name': row['name']} for row in results for warning in row.get('warnings', [])]
+    return {"updated": updated, "failed": len(results) - updated, "results": results, '_validation': {'warnings': warnings}}
 
 
 def submit_document(doctype_slug: str, name: str) -> dict: