Errors & Validation

TradingView's Charting Library parses every /history and /symbols body as JSON and checks body.s. If it sees "error", it extracts body.errmsg and logs it; if it sees anything else it doesn't recognize (HTML, plain text, envelope), it throws an opaque browser-console error. All TV endpoints must therefore respond with valid UDF-shaped JSON, even in failure paths.

UDF error shape

{
  "s": "error",
  "errmsg": "<short, stable code or phrase>"
}

• s is always the literal string "error".
• errmsg is a short stable tag where possible (unknown_symbol, invalid resolution, timeout, internal_error) so clients can switch on it. Where a human phrase is more informative during development, we use one ("from must be <= to").
• No envelope wrapping. No data/message keys. No HTML.

Implementation: internal/modules/nepse/tradingview/write.go

func writeUDFError(w http.ResponseWriter, status int, errmsg string) {
    writeJSON(w, status, map[string]string{"s": "error", "errmsg": errmsg})
}

Handler-level validation

Validation constants

const nepseEpoch int64 = 946684800 // 2000-01-01 UTC

var validResolutions = map[string]struct{}{
    "1":  {}, "5":  {}, "15": {}, "30": {}, "60": {},
    "1D": {}, "1W": {}, "1M": {},
}

Timeout mapping

Each data-fetching handler wraps the request context with a 5-second budget:

ctx, cancel := tvContext(r) // 5s WithTimeout
defer cancel()
resp, err := h.svc.GetHistory(ctx, ...)
if err != nil {
    if errors.Is(err, context.DeadlineExceeded) {
        writeUDFError(w, http.StatusGatewayTimeout, "timeout")
        return
    }
    ...
}

Panic recovery

chi's default middleware.Recoverer returns plain text on panic, which the TradingView JSON parser rejects. The TV group is wrapped with a second recoverer that emits UDF-shaped JSON:

// internal/modules/nepse/tradingview/recovery.go
func Recoverer() func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            defer func() {
                if rec := recover(); rec != nil {
                    slog.Error("tradingview: panic recovered",
                        "panic", rec,
                        "path", r.URL.Path,
                        "stack", string(debug.Stack()),
                    )
                    writeUDFError(w, http.StatusInternalServerError, "internal_error")
                }
            }()
            next.ServeHTTP(w, r)
        })
    }
}

Wired in router.go:

r.Group(func(r chi.Router) {
    r.Use(rl60.Middleware)
    r.Use(tradingview.Recoverer())   // ← JSON on panic
    r.Use(chimw.Compress(5))
    // ... TV routes
})

A panic produces:

• HTTP status: 500
• Content-Type: application/json
• Body: {"s":"error","errmsg":"internal_error"}

Status-code summary

Developer-side validation checklist

Before shipping an endpoint change, confirm:

• Every error path goes through writeUDFError (not response.Error).
• No handler ever writes HTML or plain text except /time.
• context.DeadlineExceeded is explicitly handled before the generic 500 branch.
• pgx.ErrNoRows is mapped to a UDF-appropriate response (usually no_data or 404 unknown_symbol).
• New endpoints are added to the TV router group so they inherit the Recoverer + rate limit + gzip.

References

• Write helpers: internal/modules/nepse/tradingview/write.go
• Recoverer: internal/modules/nepse/tradingview/recovery.go
• Handler validation: internal/modules/nepse/tradingview/handler.go