diff --git a/frontend/src/types/api.ts b/frontend/src/types/api.ts
index 5339336bb..7104adc68 100644
--- a/frontend/src/types/api.ts
+++ b/frontend/src/types/api.ts
@@ -520,7 +520,7 @@ export interface SupplierQualityMetric {
numerator: number | null;
denominator: number | null;
share: number | null;
- /** Set when status is unavailable. */
+ /** Set when status is unavailable. On epcis_failed it also says the count is tenant wide. */
reason: string | null;
}
diff --git a/services/admin/app/supplier_compliance_routes.py b/services/admin/app/supplier_compliance_routes.py
index 1559b9a34..23079cc9b 100644
--- a/services/admin/app/supplier_compliance_routes.py
+++ b/services/admin/app/supplier_compliance_routes.py
@@ -252,7 +252,9 @@ async def get_supplier_data_quality(
) -> SupplierDataQualityResponse:
"""Four separate data quality measures per facility over a rolling window.
- Scoped to the tenant and to facilities owned by the calling user.
+ Scoped to the tenant and to facilities owned by the calling user, except
+ epcis_failed: EPCIS receipts carry no facility, so that share is tenant
+ wide and repeated on every facility.
"""
tenant_id = TenantContext.get_tenant_context(db)
if not tenant_id:
diff --git a/services/admin/tests/test_supplier_data_quality_routes.py b/services/admin/tests/test_supplier_data_quality_routes.py
index 7eca1bd5b..3e3c67c8d 100644
--- a/services/admin/tests/test_supplier_data_quality_routes.py
+++ b/services/admin/tests/test_supplier_data_quality_routes.py
@@ -12,7 +12,14 @@
import pytest
from fastapi import FastAPI
from fastapi.testclient import TestClient
-from shared.supplier_data_quality import DEFAULT_WINDOW_DAYS, LATE_CTE_LABEL, MAX_WINDOW_DAYS, MIN_RECORDS
+from shared.supplier_data_quality import (
+ DEFAULT_WINDOW_DAYS,
+ EPCIS_TENANT_SCOPE_REASON,
+ EPCIS_UNAVAILABLE_REASON,
+ LATE_CTE_LABEL,
+ MAX_WINDOW_DAYS,
+ MIN_RECORDS,
+)
TENANT = uuid4()
OTHER_TENANT = uuid4()
@@ -48,6 +55,11 @@
]
+# Tenant wide EPCIS receipts: enough for a share, every other one rejected.
+RECEIPTS = [uuid4() for _ in range(MIN_RECORDS)]
+REJECTED_RECEIPTS = RECEIPTS[::2]
+
+
class FakeSession:
def __init__(self) -> None:
self.facilities = {
@@ -72,9 +84,13 @@ def calls():
return []
-def _client(monkeypatch, calls, tenant=TENANT):
+def _client(monkeypatch, calls, tenant=TENANT, receipt_counts=(len(REJECTED_RECEIPTS), len(RECEIPTS))):
import app.supplier_compliance_routes as routes
+ def fake_receipt_counts(_db, tenant_id, since):
+ calls.append(("receipts", tenant_id))
+ return receipt_counts
+
def fake_records(_db, tenant_id, user_id, facility_ids, since):
calls.append(("records", tenant_id, user_id, list(facility_ids)))
return [dict(row) for row in RECORD_ROWS]
@@ -87,6 +103,7 @@ def fake_lots(_db, tenant_id, user_id, facility_ids, since):
monkeypatch.setattr(routes, "fetch_lot_rows", fake_lots)
monkeypatch.setattr("shared.supplier_data_quality.fetch_record_rows", fake_records)
monkeypatch.setattr("shared.supplier_data_quality.fetch_lot_rows", fake_lots)
+ monkeypatch.setattr("shared.supplier_data_quality.fetch_receipt_counts", fake_receipt_counts)
monkeypatch.setattr(routes.TenantContext, "get_tenant_context", lambda _db: tenant)
app = FastAPI()
@@ -114,9 +131,39 @@ def test_summary_returns_four_separate_metrics_for_owned_facilities(monkeypatch,
len(RECORD_ROWS),
)
assert supplier["metrics"][2]["status"] == "unavailable"
- assert supplier["metrics"][3]["status"] == "unavailable"
- assert all(call[1:3] == (str(TENANT), str(USER)) for call in calls)
- assert all(call[3] == [str(OWN_FACILITY)] for call in calls)
+ epcis = supplier["metrics"][3]
+ assert (epcis["status"], epcis["numerator"], epcis["denominator"], epcis["share"], epcis["reason"]) == (
+ "ok",
+ len(REJECTED_RECEIPTS),
+ len(RECEIPTS),
+ len(REJECTED_RECEIPTS) / len(RECEIPTS),
+ EPCIS_TENANT_SCOPE_REASON,
+ )
+ scoped = [call for call in calls if call[0] != "receipts"]
+ assert all(call[1:3] == (str(TENANT), str(USER)) for call in scoped)
+ assert all(call[3] == [str(OWN_FACILITY)] for call in scoped)
+ # Receipts carry no facility: one tenant scoped count, no user or facility filter.
+ assert [call for call in calls if call[0] == "receipts"] == [("receipts", str(TENANT))]
+
+
+def test_epcis_under_min_records_is_not_enough_data(monkeypatch, calls):
+ receipts = RECEIPTS[: MIN_RECORDS - 1]
+ rejected = receipts[::2]
+ client = _client(monkeypatch, calls, receipt_counts=(len(rejected), len(receipts)))
+ [supplier] = client.get("/v1/supplier/data-quality").json()["suppliers"]
+ epcis = supplier["metrics"][3]
+ assert (epcis["status"], epcis["numerator"], epcis["denominator"], epcis["share"]) == (
+ "not_enough_data",
+ len(rejected),
+ len(receipts),
+ None,
+ )
+
+
+def test_epcis_unreadable_receipts_is_unavailable(monkeypatch, calls):
+ [supplier] = _client(monkeypatch, calls, receipt_counts=None).get("/v1/supplier/data-quality").json()["suppliers"]
+ epcis = supplier["metrics"][3]
+ assert (epcis["status"], epcis["reason"]) == ("unavailable", EPCIS_UNAVAILABLE_REASON)
@pytest.mark.parametrize("window", [0, MAX_WINDOW_DAYS + 1, -1])
diff --git a/services/ingestion/app/epcis/router.py b/services/ingestion/app/epcis/router.py
index 2978f9abc..8eb0c89cf 100644
--- a/services/ingestion/app/epcis/router.py
+++ b/services/ingestion/app/epcis/router.py
@@ -6,12 +6,20 @@
from __future__ import annotations
+import json
from datetime import datetime, timezone
from typing import Optional
from fastapi import APIRouter, Depends, Header, HTTPException, Query, Request
from fastapi.responses import JSONResponse
from pydantic import BaseModel, Field
+from shared.epcis_receipts import (
+ RECEIPT_ACCEPTED,
+ RECEIPT_REJECTED,
+ record_epcis_receipt,
+ summarize_error,
+ summarize_failed_events,
+)
from shared.tenant_context import TenantContext
from ..shared.tenant_resolution import resolve_tenant_id
@@ -81,6 +89,29 @@ def _resolve_authenticated_tenant(
return resolved_tenant
+def _receipt_for_error(tenant_id: Optional[str], raw_body: bytes, exc: BaseException) -> None:
+ """Rejected receipt for a document whose ingest raised. Never raises."""
+ if tenant_id:
+ record_epcis_receipt(tenant_id, raw_body, RECEIPT_REJECTED, summarize_error(exc))
+
+
+def _receipt_for_response(tenant_id: Optional[str], raw_body: bytes, response: JSONResponse) -> None:
+ """Receipt for a document that got a response: rejected from HTTP 400 up.
+
+ A partial batch (207) is accepted, with the failed event count as summary.
+ """
+ if not tenant_id:
+ return
+ try:
+ content = json.loads(response.body)
+ failed = content.get("failed") if isinstance(content, dict) else None
+ summary = summarize_failed_events(failed, content.get("total")) if failed else None
+ except (ValueError, TypeError):
+ summary = None
+ status = RECEIPT_REJECTED if response.status_code >= 400 else RECEIPT_ACCEPTED
+ record_epcis_receipt(tenant_id, raw_body, status, summary)
+
+
class BatchIngestRequest(BaseModel):
events: list[dict] = Field(default_factory=list)
@@ -135,9 +166,17 @@ async def ingest_epcis_event(
ctx: TenantContext = Depends(require_tenant_context),
):
resolved_tenant = ctx.tenant_id
+ # FastAPI already read and cached the body to parse ``event``.
+ raw_body = await request.body()
- payload, status_code = _ingest_single_event(resolved_tenant, event)
- return JSONResponse(content=payload, status_code=status_code)
+ try:
+ payload, status_code = _ingest_single_event(resolved_tenant, event)
+ response = JSONResponse(content=payload, status_code=status_code)
+ except Exception as exc:
+ _receipt_for_error(resolved_tenant, raw_body, exc)
+ raise
+ _receipt_for_response(resolved_tenant, raw_body, response)
+ return response
@router.post("/events/batch", summary="Batch ingest EPCIS events")
@@ -159,6 +198,28 @@ async def ingest_epcis_batch(
x_regengine_api_key: Optional[str] = Header(default=None, alias="X-RegEngine-API-Key"),
_: TenantContext | None = Depends(require_tenant_context),
):
+ # Without a dependency context (direct calls) the tenant is resolved
+ # inside _ingest_batch_document, so no tenant is known up front and no
+ # receipt is filed.
+ receipt_tenant = _.tenant_id if _ is not None else None
+ raw_body = await request.body() if receipt_tenant else b""
+ try:
+ response = _ingest_batch_document(request, body, mode, x_tenant_id, x_regengine_api_key, _)
+ except Exception as exc:
+ _receipt_for_error(receipt_tenant, raw_body, exc)
+ raise
+ _receipt_for_response(receipt_tenant, raw_body, response)
+ return response
+
+
+def _ingest_batch_document(
+ request: Request,
+ body: BatchIngestRequest,
+ mode: Optional[str],
+ x_tenant_id: Optional[str],
+ x_regengine_api_key: Optional[str],
+ _: TenantContext | None,
+) -> JSONResponse:
if not body.events:
raise HTTPException(status_code=400, detail="Batch ingest requires at least one event")
@@ -378,9 +439,17 @@ async def ingest_epcis_xml(
# Stream the body with a hard cap. RequestSizeLimitMiddleware only enforces
# the Content-Length header, so a chunked upload would otherwise buffer an
# unbounded XML document into memory here before parsing (DoS).
- raw_body = await read_request_body_with_limit(
- request, max_bytes=MAX_FILE_SIZE_BYTES, label="EPCIS XML"
- )
+ raw_body = await read_request_body_with_limit(request, max_bytes=MAX_FILE_SIZE_BYTES, label="EPCIS XML")
+ try:
+ response = _ingest_xml_document(resolved_tenant, raw_body, mode)
+ except Exception as exc:
+ _receipt_for_error(resolved_tenant, raw_body, exc)
+ raise
+ _receipt_for_response(resolved_tenant, raw_body, response)
+ return response
+
+
+def _ingest_xml_document(resolved_tenant: str, raw_body: bytes, mode: str) -> JSONResponse:
if not raw_body:
raise HTTPException(status_code=400, detail="Empty XML payload")
diff --git a/services/ingestion/tests/test_epcis_document_receipts.py b/services/ingestion/tests/test_epcis_document_receipts.py
new file mode 100644
index 000000000..a43d3ecff
--- /dev/null
+++ b/services/ingestion/tests/test_epcis_document_receipts.py
@@ -0,0 +1,276 @@
+"""EPCIS ingest routes write one document receipt per request body.
+
+Persistence is stubbed and ``record_epcis_receipt`` is captured, so the tests
+check what each route files (tenant, SHA-256 of the raw body, status, summary)
+and that a failing receipt write leaves the ingest response unchanged. Ids and
+payload values are generated per run.
+"""
+
+from __future__ import annotations
+
+import importlib
+import json
+import sys
+from pathlib import Path
+from uuid import uuid4
+
+import pytest
+from fastapi import FastAPI, HTTPException
+from fastapi.testclient import TestClient
+
+service_dir = Path(__file__).parent.parent
+sys.path.insert(0, str(service_dir))
+
+router_mod = importlib.import_module("app.epcis.router")
+from app.webhook_compat import _verify_api_key # noqa: E402
+from shared.epcis_receipts import ( # noqa: E402
+ MAX_ERROR_SUMMARY_LENGTH,
+ RECEIPT_ACCEPTED,
+ RECEIPT_REJECTED,
+ document_sha256,
+)
+
+from services.ingestion.tests.tenant_context_overrides import install_tenant_context_override # noqa: E402
+
+TENANT = str(uuid4())
+
+
+@pytest.fixture
+def receipts(monkeypatch: pytest.MonkeyPatch) -> list[dict]:
+ filed: list[dict] = []
+
+ def _capture(tenant_id, raw_body, status, error_summary=None, session_factory=None):
+ filed.append({"tenant_id": tenant_id, "raw_body": raw_body, "status": status, "error_summary": error_summary})
+ return True
+
+ monkeypatch.setattr(router_mod, "record_epcis_receipt", _capture)
+ return filed
+
+
+@pytest.fixture
+def client() -> TestClient:
+ app = FastAPI()
+ app.include_router(router_mod.router)
+ app.dependency_overrides[_verify_api_key] = lambda: None
+ install_tenant_context_override(app, default_tenant=TENANT, enforce_claims=True)
+ with TestClient(app) as c:
+ yield c
+
+
+def _json_body(payload: dict) -> bytes:
+ return json.dumps(payload).encode()
+
+
+def _post_json(client: TestClient, path: str, payload: dict):
+ raw = _json_body(payload)
+ return raw, client.post(path, content=raw, headers={"Content-Type": "application/json"})
+
+
+def _event() -> dict:
+ return {"id": str(uuid4()), "value": str(uuid4())}
+
+
+def _assert_receipt(receipt: dict, raw: bytes, status: str) -> None:
+ assert receipt["tenant_id"] == TENANT
+ assert receipt["raw_body"] == raw
+ assert document_sha256(receipt["raw_body"]) == document_sha256(raw)
+ assert receipt["status"] == status
+
+
+# ── single event ─────────────────────────────────────────────────────────────
+
+
+def test_accepted_event_files_accepted_receipt_with_raw_body(client, receipts, monkeypatch):
+ created_id = str(uuid4())
+ monkeypatch.setattr(router_mod, "_ingest_single_event", lambda t, e: ({"cte_id": created_id}, 201))
+ raw, resp = _post_json(client, "/api/v1/epcis/events", _event())
+
+ assert resp.status_code == 201
+ assert resp.json() == {"cte_id": created_id}
+ [receipt] = receipts
+ _assert_receipt(receipt, raw, RECEIPT_ACCEPTED)
+ assert receipt["error_summary"] is None
+
+
+def test_validation_failure_files_rejected_receipt_without_payload(client, receipts, monkeypatch):
+ event = _event()
+
+ def _reject(_tenant, payload):
+ # The message quotes the payload, as real validation messages can.
+ raise HTTPException(
+ status_code=422,
+ detail={"error": "fsma_validation_failed", "message": f"bad value {payload['value']}"},
+ )
+
+ monkeypatch.setattr(router_mod, "_ingest_single_event", _reject)
+ raw, resp = _post_json(client, "/api/v1/epcis/events", event)
+
+ assert resp.status_code == 422
+ [receipt] = receipts
+ _assert_receipt(receipt, raw, RECEIPT_REJECTED)
+ assert receipt["error_summary"] == "HTTPException 422 fsma_validation_failed"
+ assert event["value"] not in receipt["error_summary"]
+
+
+def test_unexpected_error_files_rejected_receipt_with_class_only(client, receipts, monkeypatch):
+ event = _event()
+
+ def _boom(_tenant, payload):
+ raise RuntimeError(payload["value"])
+
+ monkeypatch.setattr(router_mod, "_ingest_single_event", _boom)
+ raw = _json_body(event)
+ with pytest.raises(RuntimeError):
+ client.post("/api/v1/epcis/events", content=raw, headers={"Content-Type": "application/json"})
+
+ [receipt] = receipts
+ _assert_receipt(receipt, raw, RECEIPT_REJECTED)
+ assert receipt["error_summary"] == RuntimeError.__name__
+
+
+def test_receipt_write_failure_does_not_change_the_response(client, monkeypatch):
+ created_id = str(uuid4())
+ monkeypatch.setattr(router_mod, "_ingest_single_event", lambda t, e: ({"cte_id": created_id}, 201))
+
+ def _broken_session():
+ raise ConnectionError(str(uuid4()))
+
+ # The real writer runs; only the session factory fails.
+ monkeypatch.setattr("shared.database.get_db_safe", _broken_session)
+ _, resp = _post_json(client, "/api/v1/epcis/events", _event())
+
+ assert resp.status_code == 201
+ assert resp.json() == {"cte_id": created_id}
+
+
+def test_receipt_write_failure_keeps_the_rejection(client, monkeypatch):
+ def _reject(_tenant, _payload):
+ raise HTTPException(status_code=422, detail={"error": "fsma_validation_failed"})
+
+ monkeypatch.setattr(router_mod, "_ingest_single_event", _reject)
+ monkeypatch.setattr("shared.database.get_db_safe", lambda: None)
+ _, resp = _post_json(client, "/api/v1/epcis/events", _event())
+
+ assert resp.status_code == 422
+ assert resp.json()["detail"] == {"error": "fsma_validation_failed"}
+
+
+# ── batch ────────────────────────────────────────────────────────────────────
+
+
+def test_atomic_batch_files_one_accepted_receipt(client, receipts, monkeypatch):
+ events = [_event() for _ in range(3)]
+ monkeypatch.setattr(
+ router_mod, "_ingest_batch_events_db_atomic", lambda t, evs: [({"cte_id": str(uuid4())}, 201) for _ in evs]
+ )
+ raw, resp = _post_json(client, "/api/v1/epcis/events/batch?mode=atomic", {"events": events})
+
+ assert resp.status_code == 201
+ [receipt] = receipts
+ _assert_receipt(receipt, raw, RECEIPT_ACCEPTED)
+
+
+def test_atomic_batch_validation_failure_files_rejected_receipt(client, receipts, monkeypatch):
+ def _reject(_tenant, _events):
+ raise HTTPException(status_code=400, detail={"error": "batch_validation_failed", "errors": _events})
+
+ monkeypatch.setattr(router_mod, "_ingest_batch_events_db_atomic", _reject)
+ events = [_event() for _ in range(2)]
+ raw, resp = _post_json(client, "/api/v1/epcis/events/batch?mode=atomic", {"events": events})
+
+ assert resp.status_code == 400
+ [receipt] = receipts
+ _assert_receipt(receipt, raw, RECEIPT_REJECTED)
+ assert receipt["error_summary"] == "HTTPException 400 batch_validation_failed"
+ assert all(event["value"] not in receipt["error_summary"] for event in events)
+
+
+def test_partial_batch_with_some_failures_is_accepted_with_failed_count(client, receipts, monkeypatch):
+ events = [_event() for _ in range(4)]
+ failing = {events[0]["id"], events[2]["id"]}
+
+ def _single(_tenant, event):
+ if event["id"] in failing:
+ raise HTTPException(status_code=422, detail=event["value"])
+ return {"cte_id": str(uuid4())}, 201
+
+ monkeypatch.setattr(router_mod, "_ingest_single_event", _single)
+ raw, resp = _post_json(client, "/api/v1/epcis/events/batch?mode=partial", {"events": events})
+
+ assert resp.status_code == 207
+ [receipt] = receipts
+ _assert_receipt(receipt, raw, RECEIPT_ACCEPTED)
+ assert receipt["error_summary"] == f"{len(failing)} of {len(events)} events failed"
+
+
+def test_partial_batch_with_every_event_failing_is_rejected(client, receipts, monkeypatch):
+ events = [_event() for _ in range(2)]
+
+ def _single(_tenant, event):
+ raise HTTPException(status_code=422, detail=event["value"])
+
+ monkeypatch.setattr(router_mod, "_ingest_single_event", _single)
+ raw, resp = _post_json(client, "/api/v1/epcis/events/batch?mode=partial", {"events": events})
+
+ assert resp.status_code == 400
+ [receipt] = receipts
+ _assert_receipt(receipt, raw, RECEIPT_REJECTED)
+ assert receipt["error_summary"] == f"{len(events)} of {len(events)} events failed"
+
+
+def test_empty_batch_files_rejected_receipt(client, receipts):
+ raw, resp = _post_json(client, "/api/v1/epcis/events/batch", {"events": []})
+
+ assert resp.status_code == 400
+ [receipt] = receipts
+ _assert_receipt(receipt, raw, RECEIPT_REJECTED)
+ assert receipt["error_summary"] == "HTTPException 400"
+
+
+# ── XML ──────────────────────────────────────────────────────────────────────
+
+
+def _post_xml(client: TestClient, raw: bytes, mode: str = "atomic"):
+ return client.post(
+ f"/api/v1/epcis/events/xml?mode={mode}", content=raw, headers={"Content-Type": "application/xml"}
+ )
+
+
+def test_xml_document_files_accepted_receipt(client, receipts, monkeypatch):
+ raw = uuid4().hex.encode()
+ events = [_event() for _ in range(2)]
+ monkeypatch.setattr(router_mod, "_is_xml_content", lambda body: True)
+ monkeypatch.setattr(router_mod, "_parse_epcis_xml", lambda body: events)
+ monkeypatch.setattr(
+ router_mod, "_ingest_batch_events_db_atomic", lambda t, evs: [({"cte_id": str(uuid4())}, 201) for _ in evs]
+ )
+
+ assert _post_xml(client, raw).status_code == 201
+ [receipt] = receipts
+ _assert_receipt(receipt, raw, RECEIPT_ACCEPTED)
+
+
+def test_xml_without_events_files_rejected_receipt(client, receipts, monkeypatch):
+ raw = uuid4().hex.encode()
+ monkeypatch.setattr(router_mod, "_is_xml_content", lambda body: True)
+ monkeypatch.setattr(router_mod, "_parse_epcis_xml", lambda body: [])
+
+ assert _post_xml(client, raw).status_code == 422
+ [receipt] = receipts
+ _assert_receipt(receipt, raw, RECEIPT_REJECTED)
+ assert receipt["error_summary"] == "HTTPException 422"
+
+
+def test_non_xml_body_files_rejected_receipt(client, receipts, monkeypatch):
+ raw = uuid4().hex.encode()
+ monkeypatch.setattr(router_mod, "_is_xml_content", lambda body: False)
+
+ assert _post_xml(client, raw).status_code == 400
+ [receipt] = receipts
+ _assert_receipt(receipt, raw, RECEIPT_REJECTED)
+ assert len(receipt["error_summary"]) <= MAX_ERROR_SUMMARY_LENGTH
+
+
+def test_invalid_mode_is_rejected_before_the_body_is_read(client, receipts):
+ assert _post_xml(client, uuid4().hex.encode(), mode=uuid4().hex).status_code == 400
+ assert receipts == []
diff --git a/services/shared/epcis_receipts.py b/services/shared/epcis_receipts.py
new file mode 100644
index 000000000..fb5ffd8fa
--- /dev/null
+++ b/services/shared/epcis_receipts.py
@@ -0,0 +1,162 @@
+"""EPCIS document receipts: ``fsma.epcis_document_receipts``.
+
+One row per EPCIS document an ingest route receives, accepted or rejected,
+keyed by the SHA-256 of the raw request body. ``error_summary`` is built by
+:func:`summarize_error` and never carries payload content: only the exception
+class, the HTTP status, and the machine error code of a dict ``detail``. Free
+text details are dropped, because messages can interpolate payload values. A
+failed event count may be added by the caller.
+
+Receipts are tenant scoped. An EPCIS upload is not linked to a supplier
+facility, so the supplier data quality ``epcis_failed`` metric is a tenant
+wide share (see ``shared.supplier_data_quality``).
+
+Writing a receipt is fail open: :func:`record_epcis_receipt` never raises, so
+a receipt failure cannot change an ingest response.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import logging
+import re
+import uuid
+from datetime import datetime
+from typing import Any, Callable, Mapping, Optional
+
+from sqlalchemy import text
+
+logger = logging.getLogger(__name__)
+
+RECEIPT_ACCEPTED = "accepted"
+RECEIPT_REJECTED = "rejected"
+RECEIPT_STATUSES = (RECEIPT_ACCEPTED, RECEIPT_REJECTED)
+# Matches the error_summary length check in alembic v136.
+MAX_ERROR_SUMMARY_LENGTH = 200
+
+# A machine error code such as ``batch_validation_failed``. The EPCIS ingest
+# path sets ``detail["error"]`` from string literals only.
+_SAFE_CODE = re.compile(r"^[a-z][a-z0-9_]{0,63}$")
+
+_INSERT_SQL = text(
+ """
+ INSERT INTO fsma.epcis_document_receipts (tenant_id, document_sha256, status, error_summary)
+ VALUES (CAST(:tenant_id AS uuid), :document_sha256, :status, :error_summary)
+ """
+)
+
+_COUNTS_SQL = text(
+ """
+ SELECT count(*) FILTER (WHERE status = 'rejected') AS rejected,
+ count(*) AS total
+ FROM fsma.epcis_document_receipts
+ WHERE tenant_id = CAST(:tid AS uuid)
+ AND received_at >= :since
+ """
+)
+
+
+def document_sha256(raw_body: bytes) -> str:
+ return hashlib.sha256(raw_body).hexdigest()
+
+
+def _truncate(summary: str) -> str:
+ return summary[:MAX_ERROR_SUMMARY_LENGTH]
+
+
+def summarize_error(exc: BaseException) -> str:
+ """Exception class, HTTP status and the dict detail's error code.
+
+ ``str(exc)`` and string details are never used: either can quote the
+ payload.
+ """
+ parts = [type(exc).__name__]
+ status_code = getattr(exc, "status_code", None)
+ if isinstance(status_code, int):
+ parts.append(str(status_code))
+ detail = getattr(exc, "detail", None)
+ code = detail.get("error") if isinstance(detail, Mapping) else None
+ if isinstance(code, str) and _SAFE_CODE.match(code):
+ parts.append(code)
+ return _truncate(" ".join(parts))
+
+
+def summarize_failed_events(failed: int, total: int) -> str:
+ return _truncate(f"{failed} of {total} events failed")
+
+
+def record_epcis_receipt(
+ tenant_id: Any,
+ raw_body: bytes,
+ status: str,
+ error_summary: Optional[str] = None,
+ session_factory: Optional[Callable[[], Any]] = None,
+) -> bool:
+ """Insert one receipt in its own transaction. Never raises.
+
+ Returns True when the row was committed. A tenant id that is not a UUID
+ is skipped: the column is uuid and the RLS check casts the tenant GUC.
+ """
+ try:
+ tenant = str(uuid.UUID(str(tenant_id)))
+ except (ValueError, AttributeError, TypeError):
+ logger.warning("epcis_receipt_skipped reason=tenant_not_uuid")
+ return False
+ if status not in RECEIPT_STATUSES:
+ logger.warning("epcis_receipt_skipped reason=unknown_status")
+ return False
+
+ session = None
+ try:
+ if session_factory is None:
+ from shared.database import get_db_safe # noqa: PLC0415 (no engine setup at import)
+
+ session_factory = get_db_safe
+ session = session_factory()
+ if session is None:
+ logger.warning("epcis_receipt_write_failed tenant=%s error_class=NoSession", tenant)
+ return False
+ from shared.tenant_context import set_tenant_guc # noqa: PLC0415
+
+ set_tenant_guc(session, tenant)
+ session.execute(
+ _INSERT_SQL,
+ {
+ "tenant_id": tenant,
+ "document_sha256": document_sha256(raw_body),
+ "status": status,
+ "error_summary": _truncate(error_summary) if error_summary else None,
+ },
+ )
+ session.commit()
+ return True
+ except Exception as exc: # noqa: BLE001 -- receipts must never change the ingest response
+ logger.warning("epcis_receipt_write_failed tenant=%s error_class=%s", tenant, type(exc).__name__)
+ if session is not None:
+ try:
+ session.rollback()
+ except Exception: # noqa: BLE001
+ pass
+ return False
+ finally:
+ if session is not None:
+ try:
+ session.close()
+ except Exception: # noqa: BLE001
+ pass
+
+
+def fetch_receipt_counts(db_session: Any, tenant_id: str, since: datetime) -> Optional[tuple[int, int]]:
+ """(rejected, total) receipts for the tenant since ``since``.
+
+ Runs in a savepoint and returns None when the table cannot be read (for
+ example before alembic v136 is applied), so the caller's transaction and
+ the other metrics are unaffected.
+ """
+ try:
+ with db_session.begin_nested():
+ row = db_session.execute(_COUNTS_SQL, {"tid": tenant_id, "since": since}).mappings().one()
+ except Exception as exc: # noqa: BLE001 -- one unreadable metric must not fail the summary
+ logger.warning("epcis_receipt_counts_failed error_class=%s", type(exc).__name__)
+ return None
+ return int(row["rejected"]), int(row["total"])
diff --git a/services/shared/supplier_data_quality.py b/services/shared/supplier_data_quality.py
index 50e05930c..5346b3277 100644
--- a/services/shared/supplier_data_quality.py
+++ b/services/shared/supplier_data_quality.py
@@ -17,11 +17,17 @@
``shared.rules.seeds``), or when it starts at this facility (harvesting or
first land based receiving).
3. ``late_cte``: unavailable. No agreed sending time is stored per supplier.
-4. ``epcis_failed``: unavailable. EPCIS documents are not stored as files with
- a validation result, and nothing ties an EPCIS upload to a facility.
-
-Read only. Every query filters on tenant, on the calling supplier user and on
-that user's facility ids.
+4. ``epcis_failed``: share of EPCIS documents received in the window that were
+ rejected (``fsma.epcis_document_receipts``, written by the EPCIS ingest
+ routes). Receipts are tenant scoped: an EPCIS upload carries no supplier
+ facility, so this cannot be mapped per facility. The tenant wide share is
+ computed once and shown on every facility, with
+ ``EPCIS_TENANT_SCOPE_REASON`` saying so. It is unavailable only when the
+ receipts table cannot be read.
+
+Read only. The record and lot queries filter on tenant, on the calling
+supplier user and on that user's facility ids. The EPCIS receipt count
+filters on tenant only (see above).
"""
from __future__ import annotations
@@ -29,6 +35,7 @@
from datetime import datetime, timedelta
from typing import Any, Mapping, Optional, Sequence
+from shared.epcis_receipts import fetch_receipt_counts
from sqlalchemy import text
MIN_RECORDS = 20
@@ -45,10 +52,11 @@
LATE_CTE_UNAVAILABLE_REASON = (
"No agreed sending time is recorded for this supplier, so late records cannot be measured."
)
-EPCIS_UNAVAILABLE_REASON = (
- "EPCIS uploads are not stored as files with a validation result linked to a facility, "
- "so failing files cannot be counted."
+EPCIS_TENANT_SCOPE_REASON = (
+ "Counted for your whole account, not for this facility: an EPCIS upload is not linked "
+ "to a facility, so every facility shows the same count."
)
+EPCIS_UNAVAILABLE_REASON = "EPCIS document receipts could not be read."
# Copy of services/ingestion/app/webhook_models.py REQUIRED_KDES_BY_CTE, keyed
# by supplier CTE name. The admin service cannot import the ingestion package
@@ -239,6 +247,14 @@ def unavailable_metric(key: str, reason: str) -> dict[str, Any]:
}
+def epcis_failed_metric(counts: Optional[tuple[int, int]]) -> dict[str, Any]:
+ """Tenant wide rejected share from (rejected, total) receipt counts."""
+ if counts is None:
+ return unavailable_metric(METRIC_EPCIS_FAILED, EPCIS_UNAVAILABLE_REASON)
+ rejected, total = counts
+ return {**share_metric(METRIC_EPCIS_FAILED, rejected, total), "reason": EPCIS_TENANT_SCOPE_REASON}
+
+
def window_start(now: datetime, window_days: int) -> datetime:
return now - timedelta(days=window_days)
@@ -284,14 +300,18 @@ def unlinked_lots(rows: Sequence[Mapping[str, Any]]) -> list[dict[str, Any]]:
def summarize_facility(
record_rows: Sequence[Mapping[str, Any]],
lot_rows: Sequence[Mapping[str, Any]],
+ epcis_counts: Optional[tuple[int, int]],
) -> dict[str, dict[str, Any]]:
- """The four metrics for one facility, keyed by metric."""
+ """The four metrics for one facility, keyed by metric.
+
+ ``epcis_counts`` is the tenant wide (rejected, total), not per facility.
+ """
lot_count = len(group_lots(lot_rows))
return {
METRIC_MISSING_KDE: share_metric(METRIC_MISSING_KDE, len(flag_records(record_rows)), len(record_rows)),
METRIC_UNLINKED_LOT: share_metric(METRIC_UNLINKED_LOT, len(unlinked_lots(lot_rows)), lot_count),
METRIC_LATE_CTE: unavailable_metric(METRIC_LATE_CTE, LATE_CTE_UNAVAILABLE_REASON),
- METRIC_EPCIS_FAILED: unavailable_metric(METRIC_EPCIS_FAILED, EPCIS_UNAVAILABLE_REASON),
+ METRIC_EPCIS_FAILED: epcis_failed_metric(epcis_counts),
}
@@ -394,8 +414,11 @@ def fetch_supplier_quality(
since: datetime,
) -> dict[str, dict[str, dict[str, Any]]]:
"""Per facility metrics for ``facility_ids`` (every id is present)."""
+ if not facility_ids:
+ return {}
records = _by_facility(
fetch_record_rows(db_session, tenant_id, supplier_user_id, facility_ids, since), facility_ids
)
lots = _by_facility(fetch_lot_rows(db_session, tenant_id, supplier_user_id, facility_ids, since), facility_ids)
- return {key: summarize_facility(records[key], lots[key]) for key in facility_ids}
+ epcis_counts = fetch_receipt_counts(db_session, tenant_id, since)
+ return {key: summarize_facility(records[key], lots[key], epcis_counts) for key in facility_ids}
diff --git a/services/shared/tests/test_epcis_receipts.py b/services/shared/tests/test_epcis_receipts.py
new file mode 100644
index 000000000..6f8dfab36
--- /dev/null
+++ b/services/shared/tests/test_epcis_receipts.py
@@ -0,0 +1,202 @@
+"""EPCIS document receipts: hashing, sanitized summaries, fail open writes.
+
+No database. Fake sessions record what the writer and the count reader send.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import uuid
+from contextlib import nullcontext
+from datetime import datetime, timezone
+
+import pytest
+from fastapi import HTTPException
+from shared.epcis_receipts import (
+ MAX_ERROR_SUMMARY_LENGTH,
+ RECEIPT_ACCEPTED,
+ RECEIPT_REJECTED,
+ RECEIPT_STATUSES,
+ document_sha256,
+ fetch_receipt_counts,
+ record_epcis_receipt,
+ summarize_error,
+ summarize_failed_events,
+)
+
+
+class FakeSession:
+ def __init__(self, fail_on_insert: bool = False) -> None:
+ self.statements: list[tuple[str, dict]] = []
+ self.fail_on_insert = fail_on_insert
+ self.committed = False
+ self.rolled_back = False
+ self.closed = False
+
+ def execute(self, statement, params=None):
+ sql = str(statement)
+ if self.fail_on_insert and "INSERT" in sql:
+ raise RuntimeError(str(uuid.uuid4()))
+ self.statements.append((sql, dict(params or {})))
+
+ def commit(self):
+ self.committed = True
+
+ def rollback(self):
+ self.rolled_back = True
+
+ def close(self):
+ self.closed = True
+
+
+def _raw() -> bytes:
+ return uuid.uuid4().hex.encode()
+
+
+# --- hashing and summaries ---------------------------------------------------
+
+
+def test_document_sha256_is_hex_digest_of_raw_body():
+ raw = _raw()
+ assert document_sha256(raw) == hashlib.sha256(raw).hexdigest()
+
+
+def test_statuses_match_the_table_check_constraint():
+ assert RECEIPT_STATUSES == ("accepted", "rejected")
+
+
+def test_summary_keeps_class_status_and_error_code_only():
+ secret = str(uuid.uuid4())
+ exc = HTTPException(status_code=422, detail={"error": "fsma_validation_failed", "message": secret})
+ assert summarize_error(exc) == "HTTPException 422 fsma_validation_failed"
+
+
+@pytest.mark.parametrize(
+ "detail_template",
+ ["Unmapped bizStep: {}", "EPCIS event '{}' not found", "{}", "Unsupported event type {}"],
+)
+def test_summary_drops_string_details(detail_template):
+ # Plain words included: a string detail can interpolate a payload value
+ # with no punctuation around it.
+ value = uuid.uuid4().hex
+ summary = summarize_error(HTTPException(status_code=400, detail=detail_template.format(value)))
+ assert value not in summary
+ assert summary == "HTTPException 400"
+
+
+def test_summary_drops_an_error_code_that_is_not_a_code():
+ value = f"{uuid.uuid4()} {uuid.uuid4()}"
+ summary = summarize_error(HTTPException(status_code=400, detail={"error": value}))
+ assert summary == "HTTPException 400"
+
+
+def test_summary_of_plain_exception_is_class_name_only():
+ value = str(uuid.uuid4())
+ assert summarize_error(ValueError(value)) == ValueError.__name__
+
+
+def test_summary_is_truncated():
+ long_name = "E" * (MAX_ERROR_SUMMARY_LENGTH * 2)
+ exc = type(long_name, (Exception,), {})()
+ assert len(summarize_error(exc)) == MAX_ERROR_SUMMARY_LENGTH
+
+
+def test_failed_event_summary_counts_only():
+ failed, total = len(RECEIPT_STATUSES), MAX_ERROR_SUMMARY_LENGTH
+ assert summarize_failed_events(failed, total) == f"{failed} of {total} events failed"
+
+
+# --- writer ------------------------------------------------------------------
+
+
+def test_record_sets_tenant_guc_then_inserts_and_commits():
+ tenant = str(uuid.uuid4())
+ raw = _raw()
+ session = FakeSession()
+
+ assert record_epcis_receipt(tenant, raw, RECEIPT_ACCEPTED, session_factory=lambda: session) is True
+
+ (guc_sql, guc_params), (insert_sql, insert_params) = session.statements
+ assert "set_config('app.tenant_id'" in guc_sql
+ assert tenant in guc_params.values()
+ assert "fsma.epcis_document_receipts" in insert_sql
+ assert insert_params == {
+ "tenant_id": tenant,
+ "document_sha256": document_sha256(raw),
+ "status": RECEIPT_ACCEPTED,
+ "error_summary": None,
+ }
+ assert session.committed and session.closed
+
+
+def test_record_truncates_error_summary():
+ session = FakeSession()
+ summary = "x" * (MAX_ERROR_SUMMARY_LENGTH * 2)
+ record_epcis_receipt(str(uuid.uuid4()), _raw(), RECEIPT_REJECTED, summary, session_factory=lambda: session)
+ assert len(session.statements[-1][1]["error_summary"]) == MAX_ERROR_SUMMARY_LENGTH
+
+
+def test_record_never_raises_on_insert_failure():
+ session = FakeSession(fail_on_insert=True)
+ assert record_epcis_receipt(str(uuid.uuid4()), _raw(), RECEIPT_REJECTED, session_factory=lambda: session) is False
+ assert session.rolled_back and session.closed and not session.committed
+
+
+def test_record_never_raises_when_session_factory_fails():
+ def _broken():
+ raise ConnectionError(str(uuid.uuid4()))
+
+ assert record_epcis_receipt(str(uuid.uuid4()), _raw(), RECEIPT_ACCEPTED, session_factory=_broken) is False
+
+
+def test_record_without_session_is_skipped():
+ assert record_epcis_receipt(str(uuid.uuid4()), _raw(), RECEIPT_ACCEPTED, session_factory=lambda: None) is False
+
+
+def test_record_skips_non_uuid_tenant_without_opening_a_session():
+ def _must_not_open(): # pragma: no cover (must not run)
+ raise AssertionError("no session expected")
+
+ assert record_epcis_receipt(uuid.uuid4().hex[:8], _raw(), RECEIPT_ACCEPTED, session_factory=_must_not_open) is False
+
+
+def test_record_rejects_unknown_status():
+ session = FakeSession()
+ status = uuid.uuid4().hex
+ assert record_epcis_receipt(str(uuid.uuid4()), _raw(), status, session_factory=lambda: session) is False
+ assert session.statements == []
+
+
+# --- count reader ------------------------------------------------------------
+
+
+class CountSession:
+ def __init__(self, row: dict | None = None, error: Exception | None = None) -> None:
+ self.row = row
+ self.error = error
+ self.params: dict | None = None
+
+ def begin_nested(self):
+ return nullcontext()
+
+ def execute(self, statement, params):
+ if self.error:
+ raise self.error
+ self.params = params
+ row = self.row
+ return type("Result", (), {"mappings": lambda _self: type("M", (), {"one": lambda _m: row})()})()
+
+
+def test_counts_are_tenant_and_window_scoped():
+ tenant = str(uuid.uuid4())
+ since = datetime.now(timezone.utc)
+ rejected, total = len(RECEIPT_STATUSES), MAX_ERROR_SUMMARY_LENGTH
+ session = CountSession(row={"rejected": rejected, "total": total})
+
+ assert fetch_receipt_counts(session, tenant, since) == (rejected, total)
+ assert session.params == {"tid": tenant, "since": since}
+
+
+def test_unreadable_receipts_table_returns_none():
+ session = CountSession(error=RuntimeError(str(uuid.uuid4())))
+ assert fetch_receipt_counts(session, str(uuid.uuid4()), datetime.now(timezone.utc)) is None
diff --git a/services/shared/tests/test_supplier_data_quality.py b/services/shared/tests/test_supplier_data_quality.py
index 4d5c2e5d3..599d3d3b2 100644
--- a/services/shared/tests/test_supplier_data_quality.py
+++ b/services/shared/tests/test_supplier_data_quality.py
@@ -14,12 +14,15 @@
from shared.supplier_data_quality import (
COLUMN_BACKED_KDES,
DEFAULT_WINDOW_DAYS,
+ EPCIS_TENANT_SCOPE_REASON,
+ EPCIS_UNAVAILABLE_REASON,
METRIC_EPCIS_FAILED,
METRIC_LATE_CTE,
METRIC_MISSING_KDE,
METRIC_UNLINKED_LOT,
MIN_RECORDS,
WEBHOOK_REQUIRED_KDES,
+ epcis_failed_metric,
fetch_supplier_quality,
flag_records,
group_lots,
@@ -242,7 +245,9 @@ def test_summarize_facility_keeps_four_separate_metrics():
incomplete = [_record("shipping", {}) for _ in range(MIN_RECORDS - len(complete))]
records = complete + incomplete
lots = [_lot_row(str(uuid.uuid4()), "shipping", {}) for _ in range(MIN_RECORDS // 2)]
- summary = summarize_facility(records, lots)
+ receipts = [uuid.uuid4() for _ in range(MIN_RECORDS)]
+ rejected = receipts[::2]
+ summary = summarize_facility(records, lots, (len(rejected), len(receipts)))
assert set(summary) == {METRIC_MISSING_KDE, METRIC_UNLINKED_LOT, METRIC_LATE_CTE, METRIC_EPCIS_FAILED}
assert summary[METRIC_MISSING_KDE]["share"] == len(incomplete) / len(records)
@@ -252,7 +257,70 @@ def test_summarize_facility_keeps_four_separate_metrics():
len(lots),
)
assert summary[METRIC_LATE_CTE]["status"] == "unavailable"
- assert summary[METRIC_EPCIS_FAILED]["status"] == "unavailable"
+ assert summary[METRIC_EPCIS_FAILED]["share"] == len(rejected) / len(receipts)
+
+
+# --- EPCIS failed (tenant wide) ----------------------------------------------
+
+
+def test_epcis_failed_share_from_receipts_says_it_is_tenant_wide():
+ receipts = [uuid.uuid4() for _ in range(MIN_RECORDS)]
+ rejected = receipts[::2]
+ metric = epcis_failed_metric((len(rejected), len(receipts)))
+ assert metric == {
+ "key": METRIC_EPCIS_FAILED,
+ "status": "ok",
+ "numerator": len(rejected),
+ "denominator": len(receipts),
+ "share": len(rejected) / len(receipts),
+ "reason": EPCIS_TENANT_SCOPE_REASON,
+ }
+
+
+def test_epcis_failed_under_min_records_is_not_enough_data():
+ receipts = [uuid.uuid4() for _ in range(MIN_RECORDS - 1)]
+ rejected = receipts[::2]
+ metric = epcis_failed_metric((len(rejected), len(receipts)))
+ assert metric["status"] == "not_enough_data"
+ assert metric["share"] is None
+ assert (metric["numerator"], metric["denominator"]) == (len(rejected), len(receipts))
+ assert metric["reason"] == EPCIS_TENANT_SCOPE_REASON
+
+
+def test_epcis_failed_without_receipts_is_not_enough_data():
+ assert epcis_failed_metric((0, 0))["status"] == "not_enough_data"
+
+
+def test_epcis_failed_is_unavailable_when_receipts_cannot_be_read():
+ assert epcis_failed_metric(None) == unavailable_metric(METRIC_EPCIS_FAILED, EPCIS_UNAVAILABLE_REASON)
+
+
+def test_epcis_reasons_use_no_dashes():
+ for reason in (EPCIS_TENANT_SCOPE_REASON, EPCIS_UNAVAILABLE_REASON):
+ assert not any(dash in reason for dash in ("\u2013", "\u2014", " - "))
+
+
+def test_fetch_supplier_quality_repeats_tenant_epcis_counts_on_every_facility(monkeypatch):
+ import shared.supplier_data_quality as quality
+
+ tenant = str(uuid.uuid4())
+ facilities = [str(uuid.uuid4()) for _ in range(MIN_RECORDS // 10)]
+ receipts = [uuid.uuid4() for _ in range(MIN_RECORDS)]
+ rejected = receipts[::2]
+ calls = []
+
+ def fake_counts(_db, tenant_id, since):
+ calls.append(tenant_id)
+ return len(rejected), len(receipts)
+
+ monkeypatch.setattr(quality, "fetch_record_rows", lambda *args: [])
+ monkeypatch.setattr(quality, "fetch_lot_rows", lambda *args: [])
+ monkeypatch.setattr(quality, "fetch_receipt_counts", fake_counts)
+ result = fetch_supplier_quality(object(), tenant, str(uuid.uuid4()), facilities, datetime.now(timezone.utc))
+
+ assert calls == [tenant]
+ assert set(result) == set(facilities)
+ assert {result[key][METRIC_EPCIS_FAILED]["share"] for key in facilities} == {len(rejected) / len(receipts)}
def test_fetch_supplier_quality_without_facilities_runs_no_query():
diff --git a/supabase/migrations/20261024070000_epcis_document_receipts.sql b/supabase/migrations/20261024070000_epcis_document_receipts.sql
new file mode 100644
index 000000000..2ca99c03c
--- /dev/null
+++ b/supabase/migrations/20261024070000_epcis_document_receipts.sql
@@ -0,0 +1,81 @@
+-- EPCIS document receipts.
+--
+-- One row per EPCIS document the ingest routes receive (POST
+-- /api/v1/epcis/events, /events/batch and /events/xml), accepted or rejected.
+-- document_sha256 is the SHA-256 of the raw request body. error_summary is a
+-- short sanitized summary (exception class, HTTP status, error code or failed
+-- event count); it never holds payload content or secrets.
+--
+-- Receipts are tenant scoped. An EPCIS upload is not linked to a supplier
+-- facility, so the supplier data quality metric epcis_failed is a tenant wide
+-- share shown on every facility.
+--
+-- Idempotent: safe to re-run. Downgrade block at the end of this file.
+
+CREATE TABLE IF NOT EXISTS fsma.epcis_document_receipts (
+ id uuid primary key default gen_random_uuid(),
+ tenant_id uuid not null,
+ document_sha256 text not null,
+ received_at timestamptz not null default now(),
+ status text not null,
+ error_summary text,
+ constraint epcis_document_receipts_status_check
+ check (status in ('accepted', 'rejected')),
+ constraint epcis_document_receipts_sha256_check
+ check (document_sha256 ~ '^[0-9a-f]{64}$'),
+ constraint epcis_document_receipts_error_summary_length_check
+ check (error_summary is null or char_length(error_summary) <= 200)
+);
+
+-- Read path: rejected share per tenant over a rolling window.
+create index if not exists idx_epcis_document_receipts_tenant_received
+ on fsma.epcis_document_receipts (tenant_id, received_at);
+
+ALTER TABLE fsma.epcis_document_receipts ENABLE ROW LEVEL SECURITY;
+ALTER TABLE fsma.epcis_document_receipts FORCE ROW LEVEL SECURITY;
+
+-- CASE form, not OR: public.get_tenant_context() raises when app.tenant_id is
+-- unset and Postgres does not order OR operands, so the sysadmin arm is tested
+-- first (same predicate shape as alembic v096, v134 and v135).
+drop policy if exists tenant_isolation_epcis_document_receipts on fsma.epcis_document_receipts;
+create policy tenant_isolation_epcis_document_receipts on fsma.epcis_document_receipts
+ for all
+ using (
+ case
+ when (select current_setting('regengine.is_sysadmin', true)) = 'true'
+ and current_user = 'regengine_sysadmin' then true
+ else tenant_id = (select public.get_tenant_context())
+ end
+ )
+ with check (
+ case
+ when (select current_setting('regengine.is_sysadmin', true)) = 'true'
+ and current_user = 'regengine_sysadmin' then true
+ else tenant_id = (select public.get_tenant_context())
+ end
+ );
+
+-- Runtime role allowlist (alembic v111): new tables are inaccessible to the
+-- app role until a migration names them. Insert and select only: a receipt is
+-- evidence and is never updated or deleted by the app.
+do $$
+begin
+ if exists (select 1 from pg_roles where rolname = 'anon') then
+ revoke all on fsma.epcis_document_receipts from anon;
+ end if;
+ if exists (select 1 from pg_roles where rolname = 'authenticated') then
+ revoke all on fsma.epcis_document_receipts from authenticated;
+ end if;
+ if exists (select 1 from pg_roles where rolname = 'regengine') then
+ grant select, insert on fsma.epcis_document_receipts to regengine;
+ end if;
+ if exists (select 1 from pg_roles where rolname = 'regengine_sysadmin') then
+ grant select on fsma.epcis_document_receipts to regengine_sysadmin;
+ end if;
+end $$;
+
+-- Downgrade (run by hand only; drops every receipt):
+--
+-- DROP POLICY IF EXISTS tenant_isolation_epcis_document_receipts ON fsma.epcis_document_receipts;
+-- DROP INDEX IF EXISTS fsma.idx_epcis_document_receipts_tenant_received;
+-- DROP TABLE IF EXISTS fsma.epcis_document_receipts;
From b6908a0ddbaed8688cf67976956fdfc5584bd230 Mon Sep 17 00:00:00 2001
From: Christopher <131207452+PetrefiedThunder@users.noreply.github.com>
Date: Sat, 24 Oct 2026 01:17:21 -0700
Subject: [PATCH 3/9] test(epcis): size receipt batches from MIN_RECORDS and
check partial counts are ints
Signed-off-by: Christopher <131207452+PetrefiedThunder@users.noreply.github.com>
---
services/ingestion/app/epcis/router.py | 4 ++-
.../tests/test_epcis_document_receipts.py | 29 +++++++++++++++----
2 files changed, 26 insertions(+), 7 deletions(-)
diff --git a/services/ingestion/app/epcis/router.py b/services/ingestion/app/epcis/router.py
index 8eb0c89cf..91c4c5819 100644
--- a/services/ingestion/app/epcis/router.py
+++ b/services/ingestion/app/epcis/router.py
@@ -105,7 +105,9 @@ def _receipt_for_response(tenant_id: Optional[str], raw_body: bytes, response: J
try:
content = json.loads(response.body)
failed = content.get("failed") if isinstance(content, dict) else None
- summary = summarize_failed_events(failed, content.get("total")) if failed else None
+ total = content.get("total") if isinstance(content, dict) else None
+ counts_are_ints = isinstance(failed, int) and isinstance(total, int)
+ summary = summarize_failed_events(failed, total) if counts_are_ints and failed else None
except (ValueError, TypeError):
summary = None
status = RECEIPT_REJECTED if response.status_code >= 400 else RECEIPT_ACCEPTED
diff --git a/services/ingestion/tests/test_epcis_document_receipts.py b/services/ingestion/tests/test_epcis_document_receipts.py
index a43d3ecff..d3d390747 100644
--- a/services/ingestion/tests/test_epcis_document_receipts.py
+++ b/services/ingestion/tests/test_epcis_document_receipts.py
@@ -29,10 +29,13 @@
RECEIPT_REJECTED,
document_sha256,
)
+from shared.supplier_data_quality import MIN_RECORDS # noqa: E402
from services.ingestion.tests.tenant_context_overrides import install_tenant_context_override # noqa: E402
TENANT = str(uuid4())
+# Batch size comes from the spec constant, not a picked number.
+BATCH_SIZE = MIN_RECORDS
@pytest.fixture
@@ -159,7 +162,7 @@ def _reject(_tenant, _payload):
def test_atomic_batch_files_one_accepted_receipt(client, receipts, monkeypatch):
- events = [_event() for _ in range(3)]
+ events = [_event() for _ in range(BATCH_SIZE)]
monkeypatch.setattr(
router_mod, "_ingest_batch_events_db_atomic", lambda t, evs: [({"cte_id": str(uuid4())}, 201) for _ in evs]
)
@@ -175,7 +178,7 @@ def _reject(_tenant, _events):
raise HTTPException(status_code=400, detail={"error": "batch_validation_failed", "errors": _events})
monkeypatch.setattr(router_mod, "_ingest_batch_events_db_atomic", _reject)
- events = [_event() for _ in range(2)]
+ events = [_event() for _ in range(BATCH_SIZE)]
raw, resp = _post_json(client, "/api/v1/epcis/events/batch?mode=atomic", {"events": events})
assert resp.status_code == 400
@@ -186,8 +189,8 @@ def _reject(_tenant, _events):
def test_partial_batch_with_some_failures_is_accepted_with_failed_count(client, receipts, monkeypatch):
- events = [_event() for _ in range(4)]
- failing = {events[0]["id"], events[2]["id"]}
+ events = [_event() for _ in range(BATCH_SIZE)]
+ failing = {event["id"] for event in events[::2]}
def _single(_tenant, event):
if event["id"] in failing:
@@ -204,7 +207,7 @@ def _single(_tenant, event):
def test_partial_batch_with_every_event_failing_is_rejected(client, receipts, monkeypatch):
- events = [_event() for _ in range(2)]
+ events = [_event() for _ in range(BATCH_SIZE)]
def _single(_tenant, event):
raise HTTPException(status_code=422, detail=event["value"])
@@ -238,7 +241,7 @@ def _post_xml(client: TestClient, raw: bytes, mode: str = "atomic"):
def test_xml_document_files_accepted_receipt(client, receipts, monkeypatch):
raw = uuid4().hex.encode()
- events = [_event() for _ in range(2)]
+ events = [_event() for _ in range(BATCH_SIZE)]
monkeypatch.setattr(router_mod, "_is_xml_content", lambda body: True)
monkeypatch.setattr(router_mod, "_parse_epcis_xml", lambda body: events)
monkeypatch.setattr(
@@ -274,3 +277,17 @@ def test_non_xml_body_files_rejected_receipt(client, receipts, monkeypatch):
def test_invalid_mode_is_rejected_before_the_body_is_read(client, receipts):
assert _post_xml(client, uuid4().hex.encode(), mode=uuid4().hex).status_code == 400
assert receipts == []
+
+
+@pytest.mark.parametrize(
+ "counts", [{"failed": str(BATCH_SIZE), "total": BATCH_SIZE}, {"failed": BATCH_SIZE, "total": None}]
+)
+def test_partial_response_with_non_int_counts_files_no_summary(receipts, counts):
+ from fastapi.responses import JSONResponse
+
+ raw = uuid4().hex.encode()
+ router_mod._receipt_for_response(TENANT, raw, JSONResponse(counts, status_code=207))
+
+ [receipt] = receipts
+ _assert_receipt(receipt, raw, RECEIPT_ACCEPTED)
+ assert receipt["error_summary"] is None
From 8cc9a3bea156406418db696d2b64ba1f7d52b6a8 Mon Sep 17 00:00:00 2001
From: Christopher <131207452+PetrefiedThunder@users.noreply.github.com>
Date: Sat, 24 Oct 2026 01:18:26 -0700
Subject: [PATCH 4/9] test(security): count the agreed sending hours PUT as a
dual session CSRF mutation
Signed-off-by: Christopher <131207452+PetrefiedThunder@users.noreply.github.com>
---
tests/security/test_route_security_manifest.py | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/tests/security/test_route_security_manifest.py b/tests/security/test_route_security_manifest.py
index 69ab87850..d7622fe8d 100644
--- a/tests/security/test_route_security_manifest.py
+++ b/tests/security/test_route_security_manifest.py
@@ -192,8 +192,8 @@ def test_dual_session_routes_record_cookie_tenancy_and_csrf_adapter(manifest):
dual = [item for item in manifest["enabled_operations"] if item["test_adapter"] == "tenant_dual_session_csrf"]
mutations = [item for item in dual if item["method"] in {"POST", "PUT", "PATCH", "DELETE"}]
- assert len(dual) == 54
- assert len(mutations) == 23
+ assert len(dual) == 55
+ assert len(mutations) == 24
assert all(item["authentication"] == "bearer-token-or-opaque-session-cookie" for item in dual)
assert all(item["storage_boundary"] == "admin-postgres:jwt-tenant-or-session-membership-tenant" for item in dual)
From 627cd9d954d30320cfc6496649eec15ddaf70306 Mon Sep 17 00:00:00 2001
From: Christopher <131207452+PetrefiedThunder@users.noreply.github.com>
Date: Sat, 24 Oct 2026 19:59:15 -0700
Subject: [PATCH 5/9] fix(copy): real-data follow-up to #3471 (v3) (#3544)
* fix(dashboard): drop fabricated demo data from recall report page
Remove the hardcoded demo investigation stats and affected-lot rows
(invented suppliers, lot codes, consumer counts). Demo mode now renders
the same No data yet empty state with a link to import records.
* feat(copy): label every EPCIS intake and export mention as (Preview)
EPCIS is preview on both paths, so feature-name mentions across app and
marketing copy now carry the (Preview) marker. The integrations eyebrow
now reads CSV upload, JSON events API, EPCIS (Preview). The FDA sortable
export stays unlabeled. Stored keys and option values are unchanged.
* fix(copy): keep typed EPCIS format value unlabeled in customer-readiness
The format field is a string union used for logic; the (Preview) marker
stays on the display name only.
* feat(pricing): show honest unavailable state when billing is unreachable
Drop the hardcoded tier prices and the silent fallback. Prices now come
only from the billing service; when it cannot be reached the page renders
a Pricing is temporarily unavailable state with signup and contact links
instead of invented figures. Hardcoded dollar amounts in the pricing copy
and metadata are removed as well. EPCIS 2.0 export carries the (Preview)
label; the FDA sortable export stays unlabeled.
* fix(app): remove sample and sandbox banners and the simulated ingest walkthrough
Dashboard shell and DemoBanner now say No data yet with a link to connect
real data on the Ingest page. The ingest page no longer fakes a job for
the first example URL; it submits for real. The Sample: Daily FDA package
archive entry is removed from the archive jobs list. Test assertions
updated for the EPCIS (Preview) status labels.
* fix(data-import): remove synthetic sample dataset simulation
Delete SAMPLE_EVENTS, the handleLoadSample flow with its state and types,
and the Load Sample Dataset / Run Simulation card. A regression test
asserts the control is not rendered. Real CSV upload and the API guide
are unchanged.
* test(copy): assert csv-sftp display text never renders SFTP
Display labels were already clean (CSV Import); this locks the invariant
for the csv-sftp registry entry name, customer copy, and the
csv_sftp_import delivery-mode label. Stored keys and ids are unchanged.
* fix(receiving): use a comma in generated Receiving Dock location names
New receiving submissions name the location 'Receiving Dock,
'
instead of using a dash. No existing records are touched.
* fix(inflow-lab): hide Inflow Lab links from dashboard, docs, ingest, integrations and product
* fix(tools): remove Inflow Lab simulator, walkthrough sample payloads and recall drill demo data
Drops tools/inflow-lab components, lib/api-samples ingest walkthrough JSON, synthetic tools/ask and tools/export copy, and invented proof/recall-drill numbers. Recall report shows the #3536 no_data empty state.
* ci: trigger required gates
Signed-off-by: Christopher <131207452+PetrefiedThunder@users.noreply.github.com>
---------
Signed-off-by: Christopher <131207452+PetrefiedThunder@users.noreply.github.com>
Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
---
.../public/samples/sample_recall_drill.csv | 11 -
.../__tests__/components/demo-banner.test.tsx | 8 +-
.../components/evidence-chain.test.tsx | 167 -
.../src/__tests__/lib/inflow-error.test.ts | 14 -
.../lib/inflow-lab-exception-grouping.test.ts | 152 -
.../pages/dashboard-navigation.test.tsx | 10 +-
.../src/__tests__/pages/data-import.test.tsx | 6 +
.../__tests__/pages/docs-contract.test.tsx | 42 +-
.../pages/experimental-gating.test.tsx | 24 +-
.../src/__tests__/pages/inflow-lab.test.tsx | 761 -----
.../src/__tests__/pages/ingest-epcis.test.tsx | 4 +-
.../__tests__/pages/pre-revenue-copy.test.ts | 9 +-
.../pages/proof-recall-drill.test.tsx | 49 -
.../__tests__/pages/recall-report.test.tsx | 84 +-
frontend/src/app/buyer-programs/page.tsx | 2 +-
frontend/src/app/compliance/page.tsx | 2 +-
.../src/app/dashboard/compliance/page.tsx | 30 +-
.../src/app/dashboard/export-jobs/page.tsx | 12 +-
.../src/app/dashboard/inflow-lab/page.tsx | 22 +-
.../src/app/dashboard/integrations/page.tsx | 134 +-
frontend/src/app/dashboard/layout.tsx | 6 +-
frontend/src/app/dashboard/page.tsx | 20 +-
.../src/app/dashboard/recall-drills/page.tsx | 2 +-
.../src/app/dashboard/recall-report/page.tsx | 198 +-
frontend/src/app/dashboard/receiving/page.tsx | 2 +-
frontend/src/app/developers/page.tsx | 4 +-
.../src/app/docs/api/ApiReferenceClient.tsx | 28 +-
frontend/src/app/docs/changelog/page.tsx | 2 +-
.../connectors/inflow-lab/opengraph-image.tsx | 10 -
.../app/docs/connectors/inflow-lab/page.tsx | 175 +-
frontend/src/app/docs/fsma-204/page.tsx | 4 +-
frontend/src/app/docs/page.tsx | 3 +-
frontend/src/app/docs/quickstart/page.tsx | 12 +-
frontend/src/app/docs/walkthrough/page.tsx | 47 +-
frontend/src/app/fsma/integration/page.tsx | 2 +-
frontend/src/app/ingest/page.tsx | 43 +-
frontend/src/app/ingest/sandbox-handoff.ts | 4 +-
frontend/src/app/integrations/page.tsx | 90 +-
frontend/src/app/pricing/page.tsx | 99 +-
frontend/src/app/product/page.tsx | 10 -
frontend/src/app/proof/page.tsx | 10 +-
frontend/src/app/proof/recall-drill/page.tsx | 515 ---
frontend/src/app/sitemap.ts | 6 +-
frontend/src/app/tools/ask/page.tsx | 204 +-
.../components/DataImportClient.tsx | 151 -
frontend/src/app/tools/export/page.tsx | 122 +-
.../inflow-lab-dashboard-preview/page.tsx | 23 +-
.../components/DashboardInflowLab.tsx | 2311 --------------
.../inflow-lab/components/EvidenceChain.tsx | 322 --
.../inflow-lab/components/InflowLabClient.tsx | 2774 -----------------
.../components/InflowLabTutorial.tsx | 224 --
.../inflow-lab/lib/exception-grouping.ts | 121 -
.../app/tools/inflow-lab/opengraph-image.tsx | 10 -
frontend/src/app/tools/inflow-lab/page.tsx | 28 +-
frontend/src/app/trust/architecture/page.tsx | 4 +-
frontend/src/app/trust/page.tsx | 6 +-
frontend/src/app/trust/retention/page.tsx | 4 +-
frontend/src/app/walkthrough/page.tsx | 2 +-
frontend/src/app/why-regengine/page.tsx | 12 +-
.../components/control-plane/demo-banner.tsx | 8 +-
.../src/components/dashboard/breadcrumb.tsx | 1 -
.../dashboard/metrics-overview-widget.tsx | 4 +-
.../components/layout/marketing-footer.tsx | 6 +-
.../components/pricing/PricingPageClient.tsx | 6 +-
frontend/src/components/ui/tutorial.tsx | 4 +-
.../lib/api-samples/ingest-inflow-lab.json | 22 -
.../src/lib/api-samples/ingest-receiving.json | 21 -
.../src/lib/api-samples/ingest-samples.ts | 73 +-
.../ingest-walkthrough-receiving.json | 22 -
.../ingest-walkthrough-shipping.json | 22 -
.../ingest-walkthrough-transformation.json | 28 -
frontend/src/lib/customer-readiness.test.ts | 8 +
frontend/src/lib/customer-readiness.ts | 18 +-
frontend/src/lib/doc-pages.ts | 1 -
frontend/src/lib/inflow-error.ts | 6 -
.../src/lib/marketing-analytics-routes.ts | 3 +-
frontend/tests/visual/routes.json | 2 +-
77 files changed, 404 insertions(+), 9004 deletions(-)
delete mode 100644 frontend/public/samples/sample_recall_drill.csv
delete mode 100644 frontend/src/__tests__/components/evidence-chain.test.tsx
delete mode 100644 frontend/src/__tests__/lib/inflow-error.test.ts
delete mode 100644 frontend/src/__tests__/lib/inflow-lab-exception-grouping.test.ts
delete mode 100644 frontend/src/__tests__/pages/inflow-lab.test.tsx
delete mode 100644 frontend/src/__tests__/pages/proof-recall-drill.test.tsx
delete mode 100644 frontend/src/app/docs/connectors/inflow-lab/opengraph-image.tsx
delete mode 100644 frontend/src/app/proof/recall-drill/page.tsx
delete mode 100644 frontend/src/app/tools/inflow-lab/components/DashboardInflowLab.tsx
delete mode 100644 frontend/src/app/tools/inflow-lab/components/EvidenceChain.tsx
delete mode 100644 frontend/src/app/tools/inflow-lab/components/InflowLabClient.tsx
delete mode 100644 frontend/src/app/tools/inflow-lab/components/InflowLabTutorial.tsx
delete mode 100644 frontend/src/app/tools/inflow-lab/lib/exception-grouping.ts
delete mode 100644 frontend/src/app/tools/inflow-lab/opengraph-image.tsx
delete mode 100644 frontend/src/lib/api-samples/ingest-inflow-lab.json
delete mode 100644 frontend/src/lib/api-samples/ingest-receiving.json
delete mode 100644 frontend/src/lib/api-samples/ingest-walkthrough-receiving.json
delete mode 100644 frontend/src/lib/api-samples/ingest-walkthrough-shipping.json
delete mode 100644 frontend/src/lib/api-samples/ingest-walkthrough-transformation.json
delete mode 100644 frontend/src/lib/inflow-error.ts
diff --git a/frontend/public/samples/sample_recall_drill.csv b/frontend/public/samples/sample_recall_drill.csv
deleted file mode 100644
index daa15cd42..000000000
--- a/frontend/public/samples/sample_recall_drill.csv
+++ /dev/null
@@ -1,11 +0,0 @@
-Traceability Lot Code (TLC),Product Description,Quantity,Unit of Measure,Event Type,Event Date,Event Time,Facility Name,Facility GLN,Facility Address,Confidence Score
-SV-20240115-001,Romaine Lettuce,500,cases,SHIPPING,2024-01-15,14:00:00,Sunny Valley Farms,1234567890128,"123 Farm Road, Salinas CA",0.98
-SV-20240115-001,Romaine Lettuce,500,cases,RECEIVING,2024-01-16,08:00:00,Fresh Cut Co,2345678901234,"456 Processing Lane, Fresno CA",0.97
-FC-20240116-A,Chopped Romaine,250,cases,TRANSFORMATION,2024-01-16,10:00:00,Fresh Cut Co,2345678901234,"456 Processing Lane, Fresno CA",0.95
-FC-20240116-B,Romaine Hearts,250,cases,TRANSFORMATION,2024-01-16,11:00:00,Fresh Cut Co,2345678901234,"456 Processing Lane, Fresno CA",0.95
-FC-20240116-A,Chopped Romaine,100,cases,SHIPPING,2024-01-17,06:00:00,Fresh Cut Co,2345678901234,"456 Processing Lane, Fresno CA",0.96
-FC-20240116-A,Chopped Romaine,100,cases,RECEIVING,2024-01-17,10:00:00,Metro Foods,3456789012340,"789 Distribution Dr, Oakland CA",0.94
-FC-20240116-B,Romaine Hearts,150,cases,SHIPPING,2024-01-17,07:00:00,Fresh Cut Co,2345678901234,"456 Processing Lane, Fresno CA",0.96
-FC-20240116-B,Romaine Hearts,150,cases,RECEIVING,2024-01-17,11:00:00,Valley Wholesale,4567890123456,"321 Wholesale Ave, Stockton CA",0.93
-FC-20240116-A,Chopped Romaine,50,cases,SHIPPING,2024-01-18,05:00:00,Metro Foods,3456789012340,"789 Distribution Dr, Oakland CA",0.95
-FC-20240116-A,Chopped Romaine,50,cases,RECEIVING,2024-01-18,08:00:00,SuperMart #42,5678901234562,"100 Retail St, San Jose CA",0.92
diff --git a/frontend/src/__tests__/components/demo-banner.test.tsx b/frontend/src/__tests__/components/demo-banner.test.tsx
index 91ca22ed7..410c79984 100644
--- a/frontend/src/__tests__/components/demo-banner.test.tsx
+++ b/frontend/src/__tests__/components/demo-banner.test.tsx
@@ -9,13 +9,13 @@ import { DemoBanner } from '@/components/control-plane/demo-banner';
describe('DemoBanner Component', () => {
it('renders when visible=true', () => {
render( = {}) {
- const props: EvidenceChainProps = {
- nodes: lineage(3),
- hasData: true,
- isBlocked: true,
- isBusy: false,
- lot: { code: 'lot-code', product: 'product-name', supplier: 'supplier-name', cases: 1 },
- missingEvidence: 'Shipping, DC receiving',
- patternLabel: 'Missing handoff evidence',
- fixPath: 'Map the missing handoff fields once, then re-run the lot group.',
- lotsAffected: 2,
- rowsRead: 11,
- lotCount: 3,
- runKey: 1,
- onRun: vi.fn(),
- onOpenEditor: vi.fn(),
- onFocusDefect: null,
- ...overrides,
- };
- return { props, ...render( = {}): LotForGrouping {
- return {
- lotCode: id,
- product: opts.product ?? "Romaine",
- missingCtes,
- readiness: opts.readiness ?? {
- state: "warning",
- deliveryLabel: "posted",
- exportReady: false,
- },
- events: opts.events ?? 4,
- cases: opts.cases ?? 4,
- supplier: opts.supplier,
- };
-}
-
-function buildHandoffLots(count: number): LotForGrouping[] {
- return Array.from({ length: count }, (_, i) => {
- const missing = i % 3 === 0 ? ["Shipping"] : i % 3 === 1 ? ["Initial packing"] : ["DC receiving"];
- return lot(`TLC-HANDOFF-${i.toString().padStart(3, "0")}`, missing, { product: "Romaine" });
- });
-}
-
-function buildSourceLots(count: number, supplierSplit: { harvestSupplier: string; coolingSupplier: string }) {
- return Array.from({ length: count }, (_, i) => {
- const role = i % 5;
- if (role === 0 || role === 1 || role === 2) {
- return lot(`TLC-SOURCE-H-${i}`, ["Harvesting"], { supplier: supplierSplit.harvestSupplier });
- }
- if (role === 3) {
- return lot(`TLC-SOURCE-C-${i}`, ["Cooling"], { supplier: supplierSplit.coolingSupplier });
- }
- return lot(`TLC-SOURCE-B-${i}`, ["Harvesting", "Cooling"], { supplier: supplierSplit.harvestSupplier });
- });
-}
-
-function buildMixedLots(count: number) {
- return Array.from({ length: count }, (_, i) => {
- const combos = [
- ["Harvesting", "Shipping"],
- ["Cooling", "DC receiving"],
- ["Initial packing", "Harvesting"],
- ["Shipping", "Cooling"],
- ];
- return lot(`TLC-MIXED-${i}`, combos[i % combos.length]);
- });
-}
-
-describe("classifyExceptionLot", () => {
- it("classifies a lot with only handoff CTEs missing as handoff", () => {
- expect(classifyExceptionLot(lot("a", ["Shipping"]))).toBe("handoff");
- expect(classifyExceptionLot(lot("a", ["Initial packing", "DC receiving"]))).toBe("handoff");
- });
-
- it("classifies a lot with only source CTEs missing as source", () => {
- expect(classifyExceptionLot(lot("a", ["Harvesting"]))).toBe("source");
- expect(classifyExceptionLot(lot("a", ["Harvesting", "Cooling"]))).toBe("source");
- });
-
- it("classifies a lot with both handoff and source CTEs missing as mixed", () => {
- expect(classifyExceptionLot(lot("a", ["Harvesting", "Shipping"]))).toBe("mixed");
- expect(classifyExceptionLot(lot("a", ["Cooling", "DC receiving"]))).toBe("mixed");
- });
-
- it("classifies a lot with no missing CTEs but otherwise blocked as mixed", () => {
- expect(classifyExceptionLot(lot("a", []))).toBe("mixed");
- });
-});
-
-describe("groupExceptionsByPattern", () => {
- it("returns three groups in canonical order: handoff, source, mixed", () => {
- const groups = groupExceptionsByPattern([]);
- expect(groups.map((g) => g.id)).toEqual(["handoff", "source", "mixed"]);
- });
-
- it("partitions a 35-lot fixture into the right counts (18 / 10 / 7)", () => {
- const fixture: LotForGrouping[] = [
- ...buildHandoffLots(18),
- ...buildSourceLots(10, { harvestSupplier: "Supplier B", coolingSupplier: "Supplier C" }),
- ...buildMixedLots(7),
- ];
- expect(fixture).toHaveLength(35);
-
- const groups = groupExceptionsByPattern(fixture);
-
- const byId = Object.fromEntries(groups.map((g) => [g.id, g]));
- expect(byId.handoff.lots).toHaveLength(18);
- expect(byId.source.lots).toHaveLength(10);
- expect(byId.mixed.lots).toHaveLength(7);
- });
-
- it("flags handoff and source groups as bulk-actionable but mixed as not", () => {
- const fixture: LotForGrouping[] = [
- ...buildHandoffLots(2),
- ...buildSourceLots(2, { harvestSupplier: "Supplier B", coolingSupplier: "Supplier C" }),
- ...buildMixedLots(2),
- ];
-
- const groups = groupExceptionsByPattern(fixture);
- const byId = Object.fromEntries(groups.map((g) => [g.id, g]));
-
- expect(byId.handoff.bulkActionable).toBe(true);
- expect(byId.source.bulkActionable).toBe(true);
- expect(byId.mixed.bulkActionable).toBe(false);
- });
-
- it("preserves lot identity within each group (no reordering across groups)", () => {
- const handoffLot = lot("HO-1", ["Shipping"]);
- const sourceLot = lot("SR-1", ["Harvesting"]);
- const mixedLot = lot("MX-1", ["Harvesting", "Shipping"]);
-
- const groups = groupExceptionsByPattern([mixedLot, sourceLot, handoffLot]);
- const byId = Object.fromEntries(groups.map((g) => [g.id, g]));
-
- expect(byId.handoff.lots[0].lotCode).toBe("HO-1");
- expect(byId.source.lots[0].lotCode).toBe("SR-1");
- expect(byId.mixed.lots[0].lotCode).toBe("MX-1");
- });
-});
-
-describe("summarizeSourceSuppliers", () => {
- it("breaks source lots down by supplier and missing-KDE field with overlap", () => {
- const sourceLots: LotForGrouping[] = [
- ...Array.from({ length: 4 }, (_, i) =>
- lot(`B-${i}`, ["Harvesting"], { supplier: "Supplier B" })
- ),
- ...Array.from({ length: 2 }, (_, i) =>
- lot(`C-${i}`, ["Cooling"], { supplier: "Supplier C" })
- ),
- ...Array.from({ length: 4 }, (_, i) =>
- lot(`BC-${i}`, ["Harvesting", "Cooling"], { supplier: "Supplier B" })
- ),
- ];
-
- const summary = summarizeSourceSuppliers(sourceLots);
- const harvestB = summary.harvestSuppliers.find((s) => s.supplier === "Supplier B");
- const coolingC = summary.coolingSuppliers.find((s) => s.supplier === "Supplier C");
-
- expect(harvestB?.lotCount).toBe(8);
- expect(coolingC?.lotCount).toBe(2);
- expect(summary.overlapCount).toBe(4);
- });
-});
diff --git a/frontend/src/__tests__/pages/dashboard-navigation.test.tsx b/frontend/src/__tests__/pages/dashboard-navigation.test.tsx
index d7a450d9f..f31990594 100644
--- a/frontend/src/__tests__/pages/dashboard-navigation.test.tsx
+++ b/frontend/src/__tests__/pages/dashboard-navigation.test.tsx
@@ -67,20 +67,14 @@ describe('Dashboard navigation discoverability', () => {
expect(screen.queryByText('All Systems Operational')).not.toBeInTheDocument();
});
- it('exposes Inflow Lab as a top-level active dashboard link', async () => {
+ it('does not surface Inflow Lab in the dashboard navigation', async () => {
render(
Inflow content
,
);
- const inflowLink = screen
- .getAllByText('Inflow Lab')
- .map((node) => node.closest('a'))
- .find((link) => link?.getAttribute('aria-current') === 'page');
- expect(inflowLink).not.toBeNull();
- expect(inflowLink).toHaveAttribute('href', '/dashboard/inflow-lab');
- expect(inflowLink).toHaveAttribute('aria-current', 'page');
+ expect(screen.queryByText('Inflow Lab')).not.toBeInTheDocument();
expect(screen.getByRole('button', { name: /Intake/i })).toBeInTheDocument();
expect(screen.getAllByText('Document Ingestion')[0].closest('a')).toHaveAttribute('href', '/ingest');
});
diff --git a/frontend/src/__tests__/pages/data-import.test.tsx b/frontend/src/__tests__/pages/data-import.test.tsx
index 282f46f90..29cfa6759 100644
--- a/frontend/src/__tests__/pages/data-import.test.tsx
+++ b/frontend/src/__tests__/pages/data-import.test.tsx
@@ -50,6 +50,12 @@ function csvResult(accepted: number, rejected: number) {
describe('Data Import Hub CSV results', () => {
beforeEach(() => vi.clearAllMocks());
+ it('does not render the sample dataset simulation control', () => {
+ render(
,
-}));
-
vi.mock('@/components/mobile/FieldCaptureClient', () => ({
FieldCaptureClient: () =>
,
}));
@@ -65,12 +64,6 @@ describe('experimental feature gating (flag off)', () => {
expect(screen.getByText(/Audit review is not enabled/i)).toBeInTheDocument();
});
- it('renders a feature-not-enabled state instead of the dashboard Inflow Lab', () => {
- render(content
,
);
- expect(screen.getAllByText('Inflow Lab').length).toBeGreaterThan(0);
+ expect(screen.queryByText('Inflow Lab')).not.toBeInTheDocument();
expect(screen.getAllByText('FSMA 204 Dashboard').length).toBeGreaterThan(0);
expect(screen.getAllByText('Field Capture').length).toBeGreaterThan(0);
});
- it('renders the real dashboard Inflow Lab page', () => {
- render(();
- return {
- ...actual,
- useAuth: vi.fn().mockReturnValue({
- isAuthenticated: false,
- isHydrated: true,
- tenantId: null,
- }),
- };
-});
-
-vi.mock('@/lib/tenant-context', async (importOriginal) => {
- const actual = await importOriginal();
- return {
- ...actual,
- useTenant: vi.fn().mockReturnValue({ tenantId: null }),
- };
-});
-
-vi.mock('@/lib/fetch-with-csrf', () => ({
- fetchWithCsrf: vi.fn((input: RequestInfo | URL, init?: RequestInit) =>
- (globalThis as unknown as { fetch: typeof fetch }).fetch(input, init),
- ),
-}));
-
-import DashboardInflowLabPage from '@/app/dashboard/inflow-lab/page';
-import { AuthProvider } from '@/lib/auth-context';
-import { TenantProvider } from '@/lib/tenant-context';
-import { useAuth } from '@/lib/auth-context';
-import { useTenant } from '@/lib/tenant-context';
-
-const completeLot = '00614141000012-20260426-000001';
-const partialLot = '00614141000012-20260426-000003';
-
-function inflowRecord(sequence_no: number, lotCode: string, cteType: string) {
- return {
- sequence_no,
- destination_mode: 'mock',
- delivery_status: 'posted',
- delivery_attempts: 1,
- event: {
- cte_type: cteType,
- traceability_lot_code: lotCode,
- product_description: lotCode === partialLot ? 'Green Leaf Lettuce' : 'Spring Mix',
- location_name: `${cteType} station`,
- timestamp: '2026-04-26T18:12:00.000Z',
- },
- };
-}
-
-const completeLotRecords = [
- inflowRecord(5, completeLot, 'harvesting'),
- inflowRecord(4, completeLot, 'cooling'),
- inflowRecord(3, completeLot, 'initial_packing'),
- inflowRecord(2, completeLot, 'shipping'),
- inflowRecord(1, completeLot, 'receiving'),
-];
-
-const serviceRecords = [
- ...completeLotRecords,
- inflowRecord(7, partialLot, 'harvesting'),
- inflowRecord(6, partialLot, 'cooling'),
-];
-
-const sandboxEvaluation = {
- total_events: 1,
- compliant_events: 1,
- non_compliant_events: 0,
- total_kde_errors: 0,
- total_rule_failures: 0,
- submission_blocked: false,
- blocking_reasons: [],
- events: [
- {
- event_index: 0,
- cte_type: 'shipping',
- traceability_lot_code: 'TLC-FEED-001',
- product_description: 'Romaine Lettuce',
- kde_errors: [],
- rules_failed: 0,
- rules_warned: 0,
- compliant: true,
- all_results: [],
- },
- ],
-};
-
-const savedWorkbenchRun = {
- run_id: 'run-123456789abc',
- tenant_id: 'tenant-123',
- source: 'inflow-lab-data-feeder',
- csv: 'cte_type,traceability_lot_code\nshipping,TLC-FEED-001',
- result: sandboxEvaluation,
- readiness: {
- score: 94,
- label: 'export ready after authenticated commit',
- components: [],
- },
- fix_queue: [],
- commit_gate: {
- mode: 'staging',
- allowed: true,
- export_eligible: false,
- reasons: ['Ready to request authenticated production commit.'],
- next_state: 'production_evidence',
- },
- saved_at: '2026-05-06T18:00:00.000Z',
- input_hash: 'abc123',
- result_hash: 'def456',
- commit_decision_id: 'run-123456789abc:staging',
-};
-
-const savedWorkbenchSummary = {
- tenant_id: 'tenant-123',
- score: 94,
- label: 'export ready after authenticated commit',
- run_id: savedWorkbenchRun.run_id,
- saved_at: savedWorkbenchRun.saved_at,
- unresolved_fix_count: 0,
- export_eligible: false,
- source: savedWorkbenchRun.source,
-};
-
-function jsonResponse(payload: unknown, init?: ResponseInit) {
- return Promise.resolve(
- new Response(JSON.stringify(payload), {
- status: 200,
- headers: { 'content-type': 'application/json' },
- ...init,
- }),
- );
-}
-
-// Stands in for rows the user pastes: header plus one opaque row, no record values.
-const USER_CSV = 'cte_type,traceability_lot_code\nreceiving,user-lot';
-
-async function enterUserCsv(user: ReturnType) {
- await user.click(await screen.findByRole('button', { name: 'Open data editor' }));
- const textarea = await screen.findByRole('textbox', { name: 'Inbound CSV data' });
- fireEvent.change(textarea, { target: { value: USER_CSV } });
-}
-
-function renderDashboardInflowLabPage() {
- return render(
-
-
-
- ,
- );
-}
-
-describe('Dashboard Inflow Lab', () => {
- const mockFetch = vi.fn();
-
- beforeEach(() => {
- vi.clearAllMocks();
- window.HTMLElement.prototype.scrollIntoView = vi.fn();
- vi.mocked(useAuth).mockReturnValue({
- isAuthenticated: false,
- isHydrated: true,
- tenantId: null,
- } as ReturnType);
- vi.mocked(useTenant).mockReturnValue({
- tenantId: null,
- setTenantId: vi.fn(),
- isSystemTenant: false,
- } as unknown as ReturnType);
- const localStore: Record = {};
- const sessionStore: Record = {};
- vi.stubGlobal('localStorage', {
- getItem: vi.fn((key: string) => localStore[key] ?? null),
- setItem: vi.fn((key: string, value: string) => {
- localStore[key] = value;
- }),
- removeItem: vi.fn((key: string) => {
- delete localStore[key];
- }),
- clear: vi.fn(() => {
- Object.keys(localStore).forEach((key) => delete localStore[key]);
- }),
- length: 0,
- key: vi.fn(() => null),
- });
- vi.stubGlobal('sessionStorage', {
- getItem: vi.fn((key: string) => sessionStore[key] ?? null),
- setItem: vi.fn((key: string, value: string) => {
- sessionStore[key] = value;
- }),
- removeItem: vi.fn((key: string) => {
- delete sessionStore[key];
- }),
- clear: vi.fn(() => {
- Object.keys(sessionStore).forEach((key) => delete sessionStore[key]);
- }),
- length: 0,
- key: vi.fn(() => null),
- });
- mockFetch.mockImplementation((input: RequestInfo | URL) => {
- const url = String(input);
- if (url.includes('/api/ingestion/api/v1/inflow-workbench/readiness/summary')) {
- return jsonResponse({
- tenant_id: 'tenant-123',
- unresolved_fix_count: 0,
- export_eligible: false,
- source: 'none',
- });
- }
- if (url.includes(`/api/ingestion/api/v1/inflow-workbench/runs/${savedWorkbenchRun.run_id}`)) {
- return jsonResponse(savedWorkbenchRun);
- }
- if (url.endsWith('/api/ingestion/api/v1/sandbox/evaluate')) {
- return jsonResponse(sandboxEvaluation);
- }
- if (url.endsWith('/api/ingestion/api/v1/inflow-workbench/readiness/preview')) {
- return jsonResponse({
- score: 94,
- label: 'export ready after authenticated commit',
- components: [],
- });
- }
- if (url.endsWith('/api/ingestion/api/v1/inflow-workbench/runs')) {
- return jsonResponse(savedWorkbenchRun);
- }
- if (url.endsWith('/api/healthz')) {
- return jsonResponse({ ok: true, build: { version: 'test-build' } });
- }
- if (url.endsWith('/api/simulate/status')) {
- return jsonResponse({
- running: false,
- stats: {
- total_records: serviceRecords.length,
- unique_lots: 2,
- delivery: { posted: serviceRecords.length, failed: 0, generated: 0, attempts: serviceRecords.length },
- },
- });
- }
- if (url.includes('/api/events')) {
- return jsonResponse({ events: serviceRecords });
- }
- if (url.includes(`/api/lineage/${encodeURIComponent(completeLot)}`)) {
- return jsonResponse({ records: completeLotRecords });
- }
- if (url.includes(`/api/lineage/${encodeURIComponent(partialLot)}`)) {
- return jsonResponse({
- records: serviceRecords.filter(
- (record) => record.event.traceability_lot_code === partialLot,
- ),
- });
- }
- return jsonResponse({});
- });
- vi.stubGlobal('fetch', mockFetch);
- });
-
- it('explains an empty release-disabled simulator 404', async () => {
- mockFetch.mockResolvedValue(new Response(null, { status: 404 }));
- renderDashboardInflowLabPage();
- expect(await screen.findByText(/Inflow Lab service connection:.*unavailable/)).toHaveTextContent('Core backend health does not include the simulator');
- });
-
- it('renders the Inflow Lab header with one Sandbox chip and a single boundary banner', async () => {
- renderDashboardInflowLabPage();
-
- expect(screen.getByRole('heading', { name: 'Inflow Lab' })).toBeInTheDocument();
-
- const sandboxChips = screen.getAllByText('Sandbox');
- expect(sandboxChips).toHaveLength(1);
-
- const banner = screen.getByRole('status');
- expect(banner).toHaveTextContent('Sandbox preview only.');
- expect(banner).toHaveTextContent(
- /Production FDA-oriented exports stay sealed and review-ready\. Nothing here writes to them\./,
- );
-
- expect(screen.queryByText('Mock environment')).not.toBeInTheDocument();
- expect(screen.queryByText('Boundary active')).not.toBeInTheDocument();
- expect(screen.queryByText('Sandbox diagnosis')).not.toBeInTheDocument();
- });
-
- it('shows the business activity as a traced chain without exposing internal scoring details', async () => {
- renderDashboardInflowLabPage();
-
- const chain = await screen.findByTestId('inflow-evidence-chain');
- // The handoff is shown as evidence rather than described in prose: every
- // CTE from harvest to receive, ending in the consequence.
- // Matched loosely because each label carries an sr-only state suffix,
- // and the mock's location names ("cooling station") repeat the CTE word.
- for (const cte of ['Harvesting', 'Cooling', 'Initial packing', 'Shipping', 'DC receiving']) {
- expect(within(chain).getAllByText(cte, { exact: false }).length).toBeGreaterThan(0);
- }
- expect(within(chain).getByText('Export gate')).toBeInTheDocument();
-
- // The scoring recipe stays internal — the chain reports what is missing
- // and what to do about it, never how readiness is computed.
- expect(
- within(chain).queryByText(/weighting|coefficient|scoring model|formula/i),
- ).not.toBeInTheDocument();
- });
-
- it('reports one lead defect and one fix path', async () => {
- renderDashboardInflowLabPage();
-
- const chain = await screen.findByTestId('inflow-evidence-chain');
- expect(await within(chain).findByText(/records? never arrived\./)).toBeInTheDocument();
- expect(within(chain).getByText('Missing')).toBeInTheDocument();
- expect(within(chain).getByText('Pattern')).toBeInTheDocument();
- expect(within(chain).getByText('Lots affected')).toBeInTheDocument();
- expect(screen.getByRole('button', { name: 'Focus this defect' })).toBeInTheDocument();
- });
-
- it('uses the proof-lead action to select the blocked lot and open its story in the rail', async () => {
- const user = userEvent.setup();
- renderDashboardInflowLabPage();
-
- await user.click(await screen.findByRole('button', { name: 'Focus this defect' }));
-
- expect(await screen.findByText(/This proof lead is blocked on/i)).toBeInTheDocument();
- expect(screen.getByRole('button', { name: 'Show matching queue group' })).toBeInTheDocument();
- expect(document.querySelector('[data-exception-group="handoff"]')).toHaveClass('bg-rose-100/70');
- expect(document.querySelector('[data-selected-lot-panel]')).toHaveAttribute('data-proof-lead-highlight', 'true');
- });
-
- it('renders the 5-step funnel with a single Run sandbox test CTA in the active step', async () => {
- renderDashboardInflowLabPage();
-
- const funnel = await screen.findByTestId('inflow-funnel');
- expect(within(funnel).getByText('Loaded')).toBeInTheDocument();
- expect(within(funnel).getByText('Validated')).toBeInTheDocument();
- expect(within(funnel).getByText('Passing')).toBeInTheDocument();
- expect(within(funnel).getByText('Preview-ready')).toBeInTheDocument();
- expect(within(funnel).getByText('Production import')).toBeInTheDocument();
-
- const sandboxButtons = screen.getAllByRole('button', { name: /Run sandbox test/i });
- expect(sandboxButtons).toHaveLength(1);
-
- const activeStep = funnel.querySelector('[data-funnel-step="passing"]');
- expect(activeStep).not.toBeNull();
- expect(activeStep!).toContainElement(sandboxButtons[0]);
- });
-
- it('renders the readiness panel with five stacked-bar factors', async () => {
- renderDashboardInflowLabPage();
-
- await waitFor(() => {
- expect(screen.getByText('KDE completeness')).toBeInTheDocument();
- });
- expect(screen.getByText('CTE lifecycle')).toBeInTheDocument();
- expect(screen.getByText('Delivery quality')).toBeInTheDocument();
- expect(screen.getByText('Sandbox pass rate')).toBeInTheDocument();
- expect(screen.getByText('Connection health')).toBeInTheDocument();
- expect(screen.getByText('not run')).toBeInTheDocument();
- });
-
- it('renders exceptions as failure-pattern groups, hiding empty groups on the all filter', async () => {
- renderDashboardInflowLabPage();
-
- // The fixture has one handoff-style partial lot; the handoff group must
- // render. Anchor on the rendered group node directly instead of a
- // parent , because the card structure around the Exceptions
- // heading is layout-driven and has changed over time.
- const handoffNode = await waitFor(() => {
- const node = document.querySelector('[data-exception-group="handoff"]');
- if (!node) throw new Error('handoff group not rendered');
- return node as HTMLElement;
- });
- expect(within(handoffNode as HTMLElement).getByText('Missing handoff evidence')).toBeInTheDocument();
- expect(screen.queryByText('Missing source evidence')).not.toBeInTheDocument();
- expect(screen.queryByText('Mixed / multi-cause')).not.toBeInTheDocument();
- });
-
- it('shows an empty-filter state when the active filter selects a group with 0 lots', async () => {
- const user = userEvent.setup();
- renderDashboardInflowLabPage();
-
- await waitFor(() => {
- expect(screen.getByText('Exceptions')).toBeInTheDocument();
- });
- // Click the 'mixed' filter chip; the fixture has no mixed lots so the
- // section must surface a clear empty-filter state with a Clear filter
- // affordance.
- await user.click(screen.getByRole('button', { name: 'mixed' }));
- const empty = await waitFor(() => {
- const node = document.querySelector('[data-empty-filter-state]');
- if (!node) throw new Error('empty-filter state not rendered');
- return node as HTMLElement;
- });
- expect(empty).toHaveTextContent(/No lots match the/);
- expect(within(empty).getByRole('button', { name: 'Clear filter' })).toBeInTheDocument();
- });
-
- it('handoff group has a Fix all bulk CTA, mixed group never does', async () => {
- renderDashboardInflowLabPage();
- const handoff = await waitFor(() => {
- const node = document.querySelector('[data-exception-group="handoff"]');
- if (!node) throw new Error('handoff group not rendered');
- return node as HTMLElement;
- });
- // "Fix all" is a navigation into the fix queue, so it renders as a
- // link (role=link) rather than an inert button.
- const fixAll = within(handoff).getByRole('link', { name: /^Fix all /i });
- expect(fixAll).toHaveAttribute('href', '/exceptions');
-
- // The mixed group, even when populated, must never carry a Fix all
- // bulk CTA per the audit (per-lot triage only). Filter to mixed and
- // confirm the empty-filter card shows up rather than a Fix all.
- // (When the fixture produces mixed lots in a future test, the
- // assertion is the same: data-exception-group="mixed" never contains
- // a "Fix all" button.)
- const mixed = document.querySelector('[data-exception-group="mixed"]');
- if (mixed) {
- expect(within(mixed as HTMLElement).queryByText(/^Fix all /)).not.toBeInTheDocument();
- }
- });
-
- it('keeps the selected lot detail in a sticky right rail with Lifecycle and KDE tiles', async () => {
- renderDashboardInflowLabPage();
-
- // ``Selected lot`` is the section heading that renders even when no
- // lot is loaded yet. Wait for ``Lifecycle`` instead — it only appears
- // once selectedLotData is non-null (i.e. a lot has been picked from
- // the fetched events). Use findByText for built-in timeout.
- expect(await screen.findByText('Lifecycle')).toBeInTheDocument();
- expect(screen.getByText('Selected lot')).toBeInTheDocument();
- expect(screen.getByText('Lot KDE summary')).toBeInTheDocument();
- expect(screen.getByRole('button', { name: 'Fix this lot' })).toBeInTheDocument();
- expect(screen.getByText(/Proof lead lot .* is dragging down/i)).toBeInTheDocument();
- });
-
- it('triggers a sandbox evaluation when Run sandbox test is pressed in the funnel', async () => {
- const user = userEvent.setup();
- renderDashboardInflowLabPage();
-
- await user.click(screen.getByRole('button', { name: /Run sandbox test/i }));
- expect(screen.getByText(/Paste CSV text or upload a CSV file before evaluating\./i)).toBeInTheDocument();
- });
-
- it('offers no sample data loader, only Upload CSV for the user\'s own rows', () => {
- renderDashboardInflowLabPage();
-
- expect(screen.queryByRole('button', { name: /sample/i })).not.toBeInTheDocument();
- expect(screen.queryByRole('button', { name: /example/i })).not.toBeInTheDocument();
- expect(screen.getByRole('button', { name: 'Upload CSV' })).toBeInTheDocument();
- });
-
- it('does not evaluate anything when Run trace is pressed before the user adds rows', async () => {
- const user = userEvent.setup();
- renderDashboardInflowLabPage();
-
- await user.click(await screen.findByRole('button', { name: /Run trace/ }));
-
- expect(screen.getByText(/Paste CSV text or upload a CSV file before evaluating\./i)).toBeInTheDocument();
- const textarea = await screen.findByRole('textbox', { name: 'Inbound CSV data' });
- expect((textarea as HTMLTextAreaElement).value).toBe('');
- expect(
- mockFetch.mock.calls.some(([url]) => String(url) === '/api/ingestion/api/v1/sandbox/evaluate'),
- ).toBe(false);
- });
-
- it('runs the trace on the user\'s own rows without saving until requested', async () => {
- const user = userEvent.setup();
- vi.mocked(useAuth).mockReturnValue({
- isAuthenticated: true,
- isHydrated: true,
- tenantId: 'tenant-123',
- user: {
- id: 'writer-1',
- email: 'writer@example.com',
- is_sysadmin: false,
- status: 'active',
- role_name: 'member',
- permissions: ['inflow.write'],
- },
- } as ReturnType);
- vi.mocked(useTenant).mockReturnValue({ tenantId: 'tenant-123' } as ReturnType);
-
- renderDashboardInflowLabPage();
-
- await enterUserCsv(user);
- await user.click(screen.getByRole('button', { name: /Run trace/ }));
-
- await waitFor(() => {
- expect(mockFetch).toHaveBeenCalledWith(
- '/api/ingestion/api/v1/sandbox/evaluate',
- expect.objectContaining({
- method: 'POST',
- body: JSON.stringify({ csv: USER_CSV }),
- }),
- );
- });
- expect(await screen.findByText(/Sandbox evaluator processed 1 event/i)).toBeInTheDocument();
- expect(
- mockFetch.mock.calls.filter(
- ([url]) => String(url) === '/api/ingestion/api/v1/inflow-workbench/runs',
- ),
- ).toHaveLength(0);
-
- await user.click(screen.getByRole('button', { name: 'Save test run' }));
-
- await waitFor(() => {
- expect(mockFetch).toHaveBeenCalledWith(
- '/api/ingestion/api/v1/inflow-workbench/runs',
- expect.objectContaining({ method: 'POST' }),
- );
- });
- });
-
- it('keeps public guided proof runs local without calling authenticated readiness preview', async () => {
- const user = userEvent.setup();
- renderDashboardInflowLabPage();
-
- await enterUserCsv(user);
- await user.click(screen.getByRole('button', { name: /Run trace/ }));
-
- await waitFor(() => {
- expect(mockFetch).toHaveBeenCalledWith(
- '/api/ingestion/api/v1/sandbox/evaluate',
- expect.objectContaining({ method: 'POST' }),
- );
- });
- expect(
- mockFetch.mock.calls.some(
- ([url]) => String(url) === '/api/ingestion/api/v1/inflow-workbench/readiness/preview',
- ),
- ).toBe(false);
- expect(
- mockFetch.mock.calls.some(
- ([url]) => String(url) === '/api/ingestion/api/v1/inflow-workbench/runs',
- ),
- ).toBe(false);
- });
-
- it('loads the latest saved workbench run when the dashboard opens with an authenticated tenant session', async () => {
- vi.mocked(useAuth).mockReturnValue({
- isAuthenticated: true,
- isHydrated: true,
- tenantId: 'tenant-123',
- user: {
- id: 'reader-1',
- email: 'reader@example.com',
- is_sysadmin: false,
- status: 'active',
- role_name: 'member',
- permissions: ['inflow.read'],
- },
- } as ReturnType);
- vi.mocked(useTenant).mockReturnValue({ tenantId: 'tenant-123' } as ReturnType);
- mockFetch.mockImplementation((input: RequestInfo | URL) => {
- const url = String(input);
- if (url.includes('/api/ingestion/api/v1/inflow-workbench/readiness/summary')) {
- return jsonResponse(savedWorkbenchSummary);
- }
- if (url.includes(`/api/ingestion/api/v1/inflow-workbench/runs/${savedWorkbenchRun.run_id}`)) {
- return jsonResponse(savedWorkbenchRun);
- }
- if (url.endsWith('/api/healthz')) {
- return jsonResponse({ ok: true, build: { version: 'test-build' } });
- }
- if (url.endsWith('/api/simulate/status')) {
- return jsonResponse({
- running: false,
- stats: {
- total_records: serviceRecords.length,
- unique_lots: 2,
- delivery: { posted: serviceRecords.length, failed: 0, generated: 0, attempts: serviceRecords.length },
- },
- });
- }
- if (url.includes('/api/events')) {
- return jsonResponse({ events: serviceRecords });
- }
- if (url.includes(`/api/lineage/${encodeURIComponent(completeLot)}`)) {
- return jsonResponse({ records: completeLotRecords });
- }
- if (url.includes(`/api/lineage/${encodeURIComponent(partialLot)}`)) {
- return jsonResponse({
- records: serviceRecords.filter(
- (record) => record.event.traceability_lot_code === partialLot,
- ),
- });
- }
- return jsonResponse({});
- });
-
- renderDashboardInflowLabPage();
-
- await waitFor(() => {
- expect(mockFetch).toHaveBeenCalledWith(
- '/api/ingestion/api/v1/inflow-workbench/readiness/summary?tenant_id=tenant-123',
- expect.objectContaining({ method: 'GET' }),
- );
- });
- expect(
- await screen.findByText(/Latest saved workbench run/i),
- ).toBeInTheDocument();
- expect(screen.getByText('run-123456789abc')).toBeInTheDocument();
- expect(screen.getByText(/0 open fixes remain in workbench\./i)).toBeInTheDocument();
- expect(screen.queryByText(/Last test run · never/i)).not.toBeInTheDocument();
- });
-
- it('keeps sandbox evaluation non-persistent until Save test run is pressed', async () => {
- const user = userEvent.setup();
- vi.mocked(useAuth).mockReturnValue({
- isAuthenticated: true,
- isHydrated: true,
- tenantId: 'tenant-123',
- user: {
- id: 'writer-1',
- email: 'writer@example.com',
- is_sysadmin: false,
- status: 'active',
- role_name: 'member',
- permissions: ['inflow.write'],
- },
- } as ReturnType);
- vi.mocked(useTenant).mockReturnValue({ tenantId: 'tenant-123' } as ReturnType);
-
- renderDashboardInflowLabPage();
-
- await user.click(screen.getByRole('button', { name: /Run sandbox test/i }));
- const textarea = await screen.findByRole('textbox', { name: 'Inbound CSV data' });
- await user.type(textarea, 'cte_type,traceability_lot_code\nshipping,TLC-FEED-001');
- await user.click(screen.getByRole('button', { name: /Run sandbox test/i }));
-
- await waitFor(() => {
- expect(screen.getByText(/Sandbox evaluator processed 1 event/i)).toBeInTheDocument();
- });
- expect(
- mockFetch.mock.calls.filter(
- ([url]) => String(url) === '/api/ingestion/api/v1/inflow-workbench/runs',
- ),
- ).toHaveLength(0);
- expect(screen.getByRole('button', { name: 'Save test run' })).toBeInTheDocument();
- expect(
- screen.getByText(/Sandbox evaluation is stateless until you explicitly save a test run\./i),
- ).toBeInTheDocument();
-
- await user.click(screen.getByRole('button', { name: 'Save test run' }));
-
- await waitFor(() => {
- expect(mockFetch).toHaveBeenCalledWith(
- '/api/ingestion/api/v1/inflow-workbench/runs',
- expect.objectContaining({ method: 'POST' }),
- );
- });
- expect(await screen.findByText(/Saved to Inflow Workbench as/i)).toBeInTheDocument();
- expect(screen.getByText('run-123456789abc')).toBeInTheDocument();
- expect(screen.getByText(/0 open fixes remain for this saved test run\./i)).toBeInTheDocument();
- expect(screen.queryByText(/Last test run · never/i)).not.toBeInTheDocument();
- });
-
- it('disables saving when the session lacks inflow.write even if the role name looks privileged', async () => {
- const user = userEvent.setup();
- vi.mocked(useAuth).mockReturnValue({
- isAuthenticated: true,
- isHydrated: true,
- tenantId: 'tenant-123',
- user: {
- id: 'owner-readonly-1',
- email: 'readonly-owner@example.com',
- is_sysadmin: false,
- status: 'active',
- role_name: 'owner',
- permissions: ['inflow.read'],
- },
- } as ReturnType);
- vi.mocked(useTenant).mockReturnValue({ tenantId: 'tenant-123' } as ReturnType);
-
- renderDashboardInflowLabPage();
-
- await user.click(screen.getByRole('button', { name: /Run sandbox test/i }));
- const textarea = await screen.findByRole('textbox', { name: 'Inbound CSV data' });
- await user.type(textarea, 'cte_type,traceability_lot_code\nshipping,TLC-FEED-001');
- await user.click(screen.getByRole('button', { name: /Run sandbox test/i }));
-
- const saveButton = await screen.findByRole('button', { name: 'Save unavailable' });
- expect(saveButton).toBeDisabled();
-
- expect(
- await screen.findByText(
- /You can evaluate sandbox data here, but only users with write access can save an Inflow Workbench test run\./i,
- ),
- ).toBeInTheDocument();
- expect(
- mockFetch.mock.calls.filter(
- ([url]) => String(url) === '/api/ingestion/api/v1/inflow-workbench/runs',
- ),
- ).toHaveLength(0);
- expect(screen.queryByText(/Saved to Inflow Workbench as/i)).not.toBeInTheDocument();
- });
-
- it('opens fix queue navigation from the section-level button', async () => {
- renderDashboardInflowLabPage();
- const link = await screen.findByRole('link', { name: 'Open fix queue' });
- // Canonical exceptions route is top-level /exceptions (mirrors the
- // dashboard sidebar entry); /dashboard/exceptions does not exist.
- expect(link).toHaveAttribute('href', '/exceptions');
- });
-
- it('shows a clickable tutorial banner that opens the step-by-step walkthrough', async () => {
- const user = userEvent.setup();
- renderDashboardInflowLabPage();
-
- const banner = await screen.findByTestId('inflow-tutorial-banner');
- expect(banner).toHaveTextContent('New to Inflow Lab? Learn to operate it step by step');
-
- await user.click(
- within(banner).getByRole('button', { name: /Learn to operate it step by step/i }),
- );
-
- expect(await screen.findByText('Step 1 of 7')).toBeInTheDocument();
- expect(screen.getByText('What Inflow Lab is')).toBeInTheDocument();
- });
-
- it('walks forward through the tutorial steps', async () => {
- const user = userEvent.setup();
- renderDashboardInflowLabPage();
-
- const banner = await screen.findByTestId('inflow-tutorial-banner');
- await user.click(
- within(banner).getByRole('button', { name: /Learn to operate it step by step/i }),
- );
- await screen.findByText('Step 1 of 7');
-
- await user.click(screen.getByRole('button', { name: /Next/i }));
- expect(await screen.findByText('Step 2 of 7')).toBeInTheDocument();
- expect(screen.getByText('Bring supplier data in')).toBeInTheDocument();
- });
-
- it('dismisses the tutorial banner without disabling the How to use entry point', async () => {
- const user = userEvent.setup();
- renderDashboardInflowLabPage();
-
- const banner = await screen.findByTestId('inflow-tutorial-banner');
- await user.click(within(banner).getByRole('button', { name: 'Dismiss tutorial banner' }));
-
- await waitFor(() => {
- expect(screen.queryByTestId('inflow-tutorial-banner')).not.toBeInTheDocument();
- });
-
- // The walkthrough must stay reachable from the header after dismissal.
- await user.click(screen.getByRole('button', { name: /How to use/i }));
- expect(await screen.findByText('Step 1 of 7')).toBeInTheDocument();
- });
-
- it('exposes filter chips for all/handoff/source/mixed', async () => {
- renderDashboardInflowLabPage();
- await waitFor(() => {
- expect(screen.getByText('Filter')).toBeInTheDocument();
- });
- expect(screen.getByRole('button', { name: 'all' })).toBeInTheDocument();
- expect(screen.getByRole('button', { name: 'handoff' })).toBeInTheDocument();
- expect(screen.getByRole('button', { name: 'source' })).toBeInTheDocument();
- expect(screen.getByRole('button', { name: 'mixed' })).toBeInTheDocument();
- });
-});
diff --git a/frontend/src/__tests__/pages/ingest-epcis.test.tsx b/frontend/src/__tests__/pages/ingest-epcis.test.tsx
index 04750adbb..9b8136c4c 100644
--- a/frontend/src/__tests__/pages/ingest-epcis.test.tsx
+++ b/frontend/src/__tests__/pages/ingest-epcis.test.tsx
@@ -284,7 +284,7 @@ describe('EPCIS 2.0 import on /ingest', () => {
expect(mocks.ingestEpcisXml).not.toHaveBeenCalled();
expect(mocks.validateEpcis).not.toHaveBeenCalled();
expect(mocks.ingestFile).not.toHaveBeenCalled();
- expect(screen.queryByText('EPCIS processed')).not.toBeInTheDocument();
+ expect(screen.queryByText('EPCIS (Preview) processed')).not.toBeInTheDocument();
});
it('shows backend failures with the same error pattern as the CSV tab', async () => {
@@ -296,7 +296,7 @@ describe('EPCIS 2.0 import on /ingest', () => {
expect(await screen.findByText('Ingestion Failed')).toBeInTheDocument();
expect(screen.getByText('Batch ingest failed')).toBeInTheDocument();
- expect(screen.queryByText('EPCIS processed')).not.toBeInTheDocument();
+ expect(screen.queryByText('EPCIS (Preview) processed')).not.toBeInTheDocument();
expect(mocks.refresh).not.toHaveBeenCalled();
});
diff --git a/frontend/src/__tests__/pages/pre-revenue-copy.test.ts b/frontend/src/__tests__/pages/pre-revenue-copy.test.ts
index 8d6a5b488..52a2ae3a7 100644
--- a/frontend/src/__tests__/pages/pre-revenue-copy.test.ts
+++ b/frontend/src/__tests__/pages/pre-revenue-copy.test.ts
@@ -48,14 +48,15 @@ describe('pre-revenue public copy', () => {
}
});
- it('keeps the published $425/mo price on pricing surfaces with the Founding rate wording', () => {
+ it('shows no hardcoded prices on pricing surfaces', () => {
const client = read('src/components/pricing/PricingPageClient.tsx');
- expect(client).toContain('RegEngine's Founding rate starts at $425/mo (billed annually).');
- expect(client).toContain('The Founding rate starts at $425/mo, billed annually.');
+ expect(client).not.toContain('$425');
expect(client).toContain('Founding rate\n');
const page = read('src/app/pricing/page.tsx');
- expect(page).toContain('FSMA 204 traceability readiness from $425/mo.');
+ expect(page).not.toContain('$425');
+ expect(page).not.toMatch(/gaMonthly: \d/);
+ expect(page).toContain('Pricing is temporarily unavailable');
expect(page).toContain('What does the Founding rate include?');
});
diff --git a/frontend/src/__tests__/pages/proof-recall-drill.test.tsx b/frontend/src/__tests__/pages/proof-recall-drill.test.tsx
deleted file mode 100644
index 2b0f65497..000000000
--- a/frontend/src/__tests__/pages/proof-recall-drill.test.tsx
+++ /dev/null
@@ -1,49 +0,0 @@
-import { render, screen } from '@testing-library/react';
-import userEvent from '@testing-library/user-event';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import RecallDrillPage from '@/app/proof/recall-drill/page';
-
-describe('public proof recall drill page', () => {
- beforeEach(() => {
- vi.stubGlobal(
- 'fetch',
- vi.fn().mockResolvedValue({
- ok: true,
- json: async () => ({
- steps: [
- {
- name: 'Identifying from API',
- duration_ms: 100,
- status: 'ok',
- detail: 'Endpoint loaded the frozen public dataset.',
- },
- ],
- time_to_trace_seconds: 0.1,
- output_csv_url: '/samples/sample_recall_drill.csv',
- lot_code: 'SV-20240115-001',
- fda_24h_mandate_seconds: 86400,
- timestamp: '2026-05-19T00:00:00Z',
- }),
- }),
- );
- });
-
- afterEach(() => {
- vi.unstubAllGlobals();
- });
-
- it('starts the public backend drill endpoint and renders returned steps', async () => {
- const user = userEvent.setup();
- render(• Advisory coverage/completeness checklist
• Append-only commit
• FDA-oriented sortable spreadsheet
- • CSV upload, JSON events API (EPCIS export)
+ • CSV upload, JSON events API, EPCIS export (Preview)
• Hash manifest re-checkable at /verify
diff --git a/frontend/src/app/compliance/page.tsx b/frontend/src/app/compliance/page.tsx
index 7dc5b5266..38177035e 100644
--- a/frontend/src/app/compliance/page.tsx
+++ b/frontend/src/app/compliance/page.tsx
@@ -257,7 +257,7 @@ export default function CompliancePage() {
FSMA 204
-
EPCIS 2.0 export
+
EPCIS 2.0 export (Preview)
GS1
FDA CTEs
KDEs
diff --git a/frontend/src/app/dashboard/compliance/page.tsx b/frontend/src/app/dashboard/compliance/page.tsx
index be965d0f8..0ee189b69 100644
--- a/frontend/src/app/dashboard/compliance/page.tsx
+++ b/frontend/src/app/dashboard/compliance/page.tsx
@@ -33,7 +33,7 @@ import { useAuth } from '@/lib/auth-context';
import { useTenant } from '@/lib/tenant-context';
import { fetchComplianceScore, fetchWorkbenchReadinessSummary } from '@/lib/api-hooks';
import { ErrorState } from '@/components/ui/error-state';
-import { experimentalFeaturesEnabled, filterExperimentalLinks } from '@/lib/experimental-features';
+import { filterExperimentalLinks } from '@/lib/experimental-features';
import { NO_DATA_YET } from '@/lib/empty-values';
/* ── Types matching ComplianceScoreResponse from backend ── */
@@ -127,9 +127,9 @@ const STATUS_CONFIG = {
const COMPLIANCE_SETUP_STEPS = [
{
title: 'Load traceability records',
- detail: 'Import a CSV, scan labels, or run Inflow Lab so the score has CTE and KDE evidence to evaluate.',
- href: '/dashboard/inflow-lab',
- action: 'Open Inflow Lab',
+ detail: 'Import a CSV or scan labels so the score has CTE and KDE evidence to evaluate.',
+ href: '/ingest',
+ action: 'Import records',
icon: Upload,
},
{
@@ -141,7 +141,7 @@ const COMPLIANCE_SETUP_STEPS = [
},
{
title: 'Preview export readiness',
- detail: 'Once records exist, configure FDA and EPCIS export jobs for audit-response workflows.',
+ detail: 'Once records exist, configure FDA and EPCIS (Preview) export jobs for audit-response workflows.',
href: '/dashboard/export-jobs',
action: 'Set up exports',
icon: Download,
@@ -439,13 +439,6 @@ export default function ComplianceDashboardPage() {
If this workspace is new, there may not be enough records yet. You can keep this page open, or jump directly to the setup paths below.
- {experimentalFeaturesEnabled() && (
-
-
- Open Inflow Lab
-
-
- )}
Start receiving
@@ -515,7 +508,7 @@ export default function ComplianceDashboardPage() {
- Inflow Workbench
+ Import readiness
@@ -552,13 +545,6 @@ export default function ComplianceDashboardPage() {
- {experimentalFeaturesEnabled() && (
-
-
- Open Workbench
-
- )}
@@ -596,7 +582,7 @@ export default function ComplianceDashboardPage() {
Recall Drill
- 24-hr simulation
+ 24-hr response
@@ -616,7 +602,7 @@ export default function ComplianceDashboardPage() {
EPCIS Export
+ EPCIS Export (Preview)
GS1 2.0 format
diff --git a/frontend/src/app/dashboard/export-jobs/page.tsx b/frontend/src/app/dashboard/export-jobs/page.tsx
index d4a54ad8a..8ede51ad7 100644
--- a/frontend/src/app/dashboard/export-jobs/page.tsx
+++ b/frontend/src/app/dashboard/export-jobs/page.tsx
@@ -69,9 +69,9 @@ export default function ExportJobsPage() {
const exportPrereqs = filterExperimentalLinks([
{
title: 'Connect source data',
- detail: 'Use Inflow Lab or import tools to build the record set export jobs will package once scheduling ships.',
- href: '/dashboard/inflow-lab',
- action: 'Open Inflow Lab',
+ detail: 'Use the import tools to build the record set export jobs will package once scheduling ships.',
+ href: '/ingest',
+ action: 'Import records',
icon: Database,
},
{
@@ -182,7 +182,7 @@ export default function ExportJobsPage() {
className={`${fieldControlClasses} h-11`}
>
FDA Package
-
GS1 EPCIS 2.0
+
GS1 EPCIS 2.0 (Preview)
Audit Bundle
@@ -250,7 +250,7 @@ export default function ExportJobsPage() {
{exportPrereqs.map((step) => (
@@ -279,7 +279,7 @@ export default function ExportJobsPage() {
{[
['Cadence', 'Weekly / Daily / Monthly'],
- ['Bundle', 'FDA or EPCIS'],
+ ['Bundle', 'FDA or EPCIS (Preview)'],
['Integrity', 'Manifest hash'],
].map(([term, detail]) => (
diff --git a/frontend/src/app/dashboard/inflow-lab/page.tsx b/frontend/src/app/dashboard/inflow-lab/page.tsx
index 7d381be63..1e29a5146 100644
--- a/frontend/src/app/dashboard/inflow-lab/page.tsx
+++ b/frontend/src/app/dashboard/inflow-lab/page.tsx
@@ -1,23 +1,5 @@
-import { Metadata } from "next";
-import { DashboardInflowLab } from "@/app/tools/inflow-lab/components/DashboardInflowLab";
-import { FeatureNotEnabled } from "@/components/experimental/FeatureNotEnabled";
-import { isExperimentalPageEnabled } from "@/lib/experimental-features";
-
-export const metadata: Metadata = {
- title: "Inflow Lab | RegEngine Dashboard",
- description:
- "Test supplier traceability data before it flows into production exports: sandbox-only diagnostics, grouped exceptions, and a sticky lot lifecycle.",
-};
+import { notFound } from "next/navigation";
export default function DashboardInflowLabPage() {
- if (!isExperimentalPageEnabled("/dashboard/inflow-lab")) {
- return (
-
- );
- }
- return
;
+ notFound();
}
diff --git a/frontend/src/app/dashboard/integrations/page.tsx b/frontend/src/app/dashboard/integrations/page.tsx
index 337081ddd..3a3449785 100644
--- a/frontend/src/app/dashboard/integrations/page.tsx
+++ b/frontend/src/app/dashboard/integrations/page.tsx
@@ -7,16 +7,12 @@ import {
ArrowRight,
Archive,
Braces,
- CheckCircle2,
ClipboardCheck,
FileSpreadsheet,
- FlaskConical,
- GitBranch,
Play,
RefreshCcw,
Save,
ShieldCheck,
- Terminal,
} from 'lucide-react';
import {
CAPABILITY_REGISTRY,
@@ -44,7 +40,7 @@ import { cn } from '@/lib/utils';
import { apiClient } from '@/lib/api-client';
import { useAuth } from '@/lib/auth-context';
import { useTenant } from '@/lib/tenant-context';
-import { experimentalFeaturesEnabled, filterExperimentalLinks } from '@/lib/experimental-features';
+import { filterExperimentalLinks } from '@/lib/experimental-features';
import type {
CreateIntegrationProfileRequest,
IntegrationProfile,
@@ -72,19 +68,6 @@ const STATUS_TONES: Record
= {
contract_only: 'neutral',
};
-const INFLOW_CONNECTOR = CAPABILITY_REGISTRY.find((item) => item.id === 'inflow-lab');
-
-const INFLOW_FACTS = [
- ['Public slug', 'inflow-lab'],
-];
-
-const INFLOW_PATH = [
- ['Simulator', 'FSMA 204 event batch'],
- ['JSON events API', '/api/v1/webhooks/ingest'],
- ['Alias resolution', 'inflow-lab -> inflow_lab'],
- ['Dashboard source', 'Tagged as Inflow Lab'],
-];
-
const ROUTE_GUIDANCE = [
{
title: 'Import Data',
@@ -98,12 +81,6 @@ const ROUTE_GUIDANCE = [
href: '/ingest/curation',
icon: ClipboardCheck,
},
- {
- title: 'Inflow Lab',
- description: 'Run FSMA event simulations and event replay without mixing test traffic into normal imports.',
- href: '/dashboard/inflow-lab',
- icon: FlaskConical,
- },
{
title: 'FDA Export',
description: 'Generate export jobs after records are curated and ready for regulator response.',
@@ -144,20 +121,6 @@ const DEFAULT_PROFILE_MAPPING = {
reference_document: 'bol_number',
};
-const DEFAULT_PREVIEW_EVENT = JSON.stringify([
- {
- event_type: 'shipping',
- lot_code: 'TLC-ROMAINE-0426',
- item_description: 'Romaine hearts',
- case_count: 24,
- uom: 'cases',
- ship_date: '2026-04-30T15:00:00Z',
- origin_facility: 'FreshPack Central',
- destination_facility: 'DC-17',
- bol_number: 'BOL-88921',
- },
-], null, 2);
-
export default function DashboardIntegrationsPage() {
const { isAuthenticated } = useAuth();
const { tenantId } = useTenant();
@@ -167,15 +130,15 @@ export default function DashboardIntegrationsPage() {
const [profiles, setProfiles] = useState([]);
const [profilesStatus, setProfilesStatus] = useState<'idle' | 'loading' | 'error'>('loading');
const [profileError, setProfileError] = useState(null);
- const [profileName, setProfileName] = useState('FreshPack shipping CSV');
- const [supplierName, setSupplierName] = useState('FreshPack Central');
+ const [profileName, setProfileName] = useState('');
+ const [supplierName, setSupplierName] = useState('');
const [sourceType, setSourceType] = useState('csv');
const [defaultCteType, setDefaultCteType] = useState('shipping');
- const [profileNotes, setProfileNotes] = useState('Supplier uses BOL number for FSMA reference document.');
+ const [profileNotes, setProfileNotes] = useState('');
const [fieldMapping, setFieldMapping] = useState>({ ...DEFAULT_PROFILE_MAPPING });
const [savingProfile, setSavingProfile] = useState(false);
const [previewProfileId, setPreviewProfileId] = useState('');
- const [previewEventText, setPreviewEventText] = useState(DEFAULT_PREVIEW_EVENT);
+ const [previewEventText, setPreviewEventText] = useState('');
const [previewResult, setPreviewResult] = useState(null);
const [previewError, setPreviewError] = useState(null);
const [previewing, setPreviewing] = useState(false);
@@ -345,7 +308,7 @@ export default function DashboardIntegrationsPage() {
window.location.reload()}>
Data inflow entry points
- Pick the route by intent so simulated connector traffic stays separate from customer imports and FDA export work.
+ Pick the route by intent: import customer files, review mappings, then generate FDA exports when records are ready.
@@ -612,7 +575,7 @@ export default function DashboardIntegrationsPage() {
Validate-only preview
- Sample events JSON
+ Events JSON