2 commits

Author	SHA1	Message	Date
Emi Griffith	2f0bda1e28	frontend: fetch City() concurrently with the page's primary API call ... MonthPage and RecordsPage each made two backend calls sequentially (CityMonth/CityRecords, then City) where the second never depended on the first's result -- both are independent single-slug lookups. Waiting for one full round trip before even starting the other was pure latency with nothing to show for it. fetchWithCity launches both concurrently via goroutines and a WaitGroup. Verified live against a stub with an injected 400ms delay on both endpoints: city page (1 call) and month/records pages (2 calls each) all cost ~0.404s now, not ~0.404s vs ~0.8s -- the two-call pages no longer pay double. Error priority is preserved exactly: if the primary call fails, its error wins even when City also fails or hasn't finished, matching the old sequential code (which never called City() once primary had already failed). The one real trade-off, called out in the comment: City() is now always launched even on a request that's about to 404 from primary, so an invalid slug costs one extra (wasted, cheap) backend lookup it previously skipped -- worth it since a bad slug is the rare path and a good one is the common path this speeds up. Tests: happy path; primary-error-wins and city-error-surfaces (both single and combined failure); and a deterministic concurrency proof via rendezvous channels rather than timing (the old sequential code would deadlock this test, not just run it slower). Full suite green under `-race -count=2`. Docker build (which runs `go test` inside the image) passes.	2026-07-23 23:04:17 -07:00
emi	92e74c585a	frontend: rewrite the SSR content service in Go (#28) ... Ports frontend/ (Jinja2/FastAPI, ~1180 LOC) to Go with html/template. No climate math, no DB, no auth -- every route fetches from the backend's /content/* API. Verified with a golden-HTML diff, not just unit tests: both the Python original and the Go rewrite were run against the same committed fixtures and every route compared byte-for-byte, confirmed programmatically. That process caught defects unit tests alone missed, since map[string]any has no compile-time field check: - Render-context keys were snake_case throughout while the templates read PascalCase fields. A missing map key doesn't error, it silently renders empty -- title, meta description, canonical URL, OpenGraph tags, and the homepage's entire ranked list were blank on every page despite every route returning 200. Fixed by renaming every key to match each template's own documented field contract, and passing API structs straight through wherever their fields already matched (removes a whole layer of future drift risk). - Three pages 500'd: ToolHref needed a composed href, not a bare "lat,lon" fragment; the records table needed the raw API struct. - JSON-LD was double-encoded: <script type="application/ld+json"> is JAVASCRIPT context to html/template's escaper regardless of the script's type attribute, so template.HTML gets re-escaped as a quoted JS string. Needed template.JS. The glossary term page's JSON-LD was never built at all -- added. - html/template silently strips literal HTML and JS comments from parsed output (verified in isolation) -- both need a FuncMap function returning template.HTML/template.JS to survive. Packaging: 187MB -> 22.6MB. Two defects caught before reaching a host: the Swarm stack's entrypoint override with no explicit command drops the image's CMD entirely (every deploy would have exited 127), and COPY --chown by name fails under the classic Docker builder on Alpine. Both fixed. go build/vet/test -race clean; docker build passes its embedded test step under both BuildKit and the classic builder; shellcheck 0 findings.	2026-07-24 00:53:48 +00:00