diff --git a/changelog.d/1570-places-no-store-on-errors.md b/changelog.d/1570-places-no-store-on-errors.md new file mode 100644 index 0000000000..4753638588 --- /dev/null +++ b/changelog.d/1570-places-no-store-on-errors.md @@ -0,0 +1,2 @@ +- Stop the browser caching a refused Google Places or Geocoding answer, so a + fixed key works at once (Rudy Celekli, @rudycelekli, #1570). diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md index cbf83325fe..f3e9317952 100644 --- a/docs/CURRENT-STATE.md +++ b/docs/CURRENT-STATE.md @@ -8439,7 +8439,8 @@ Providers normalize coordinates, canonical name, label, place types and optional bounds. Camera framing, nearby landmark recovery and footprint selection remain in their consumers, including the Capitol identity/containment safeguards. Radio keeps localized country names in labels rather than station filters. -Nearby/text-search endpoints retain their existing behavior. +Nearby/text-search cache and error rules are listed under Proxy/Security +Baseline below. **Google geocoding is a server route, not a browser call** (#363). Forward and reverse lookups go to `/api/google/geocode` and `/api/google/reverse-geocode`, @@ -8759,6 +8760,7 @@ apply to `public/` assets or built-preview serving. - `AISSTREAM_API_KEY` is server-side only; the browser reads the same-origin `/api/vessels` cache. - `/api/google/nearby-places` keeps the Google key out of Places requests issued for voice scene context. - `/api/google/text-search` keeps the Google key server-side for view-biased Places recovery used by annotation resolution. +- The Places and geocode routes cache only an answer (`private, max-age=300`). For geocode, that means an HTTP success with `OK` or `ZERO_RESULTS`, because Google sends `REQUEST_DENIED` and `OVER_QUERY_LIMIT` as HTTP 200. Every other reply, including an unreadable Places 200 (now a 502), is `no-store`. - `/api/overpass` is bounded by body/response caps, per-client/global rate limits, concurrency limits, operator-configured upstreams, in-flight dedupe, cache bounds, and static validation that every selector is spatially bounded. - `/api/military-installations` uses an independent limiter with the same 90-per-client/300-global one-minute bounds, so viewport installation refreshes never consume `/api/overpass` annotation capacity. - `/api/route` proxies bounded OSRM route requests for annotation routes, with profile allowlisting, distance caps, response caps, caching, and sanitized "no route found" errors; routing outages return 502. diff --git a/server/providers/places/google.js b/server/providers/places/google.js index 2f6742d1c4..93a8ba3f8e 100644 --- a/server/providers/places/google.js +++ b/server/providers/places/google.js @@ -62,6 +62,8 @@ const GEOCODE_UPSTREAM_TIMEOUT_MS = 10_000; const GEOCODE_MAX_RESPONSE_BYTES = 256 * 1024; +const GEOCODE_ANSWER_STATUSES = new Set(['OK', 'ZERO_RESULTS']); + /** Validate a free-text geocoder query before consuming request quota. */ export function validateGeocodeAddress(searchParams) { const address = String(searchParams.get('address') || '').trim(); @@ -105,6 +107,10 @@ export function googlePlacesContextProxy({ // Gate first, like the OpenAI routes: a cross-site caller learns nothing // about this endpoint's method surface. if (admitSameSite(req, res)) return; + // Default to no-store. The browser caches only the 200 answer below. + // A cached refusal (bad key, API off, quota) would outlive the key fix + // by five minutes. + res.setHeader('Cache-Control', 'no-store'); if (req.method !== 'GET') { res.statusCode = 405; res.setHeader('Content-Type', 'application/json'); @@ -120,7 +126,6 @@ export function googlePlacesContextProxy({ if (keyless) { res.statusCode = keyless.statusCode; res.setHeader('Content-Type', 'application/json'); - res.setHeader('Cache-Control', 'no-store'); res.end(JSON.stringify(keyless.payload)); return; } @@ -185,18 +190,21 @@ export function googlePlacesContextProxy({ }), }, ); - const data = await response.json().catch(() => ({})); - const places = projectNearbyPlaces(data, latitude, longitude); + const data = await response.json().catch(() => null); + // A 200 we could not read is an upstream failure, not an empty answer. + if (response.ok && !data) + throw new Error('Google Places request failed'); + const places = projectNearbyPlaces(data || {}, latitude, longitude); res.statusCode = response.ok ? 200 : response.status; res.setHeader('Content-Type', 'application/json; charset=utf-8'); - res.setHeader('Cache-Control', 'private, max-age=300'); + if (response.ok) res.setHeader('Cache-Control', 'private, max-age=300'); res.end( JSON.stringify({ places, error: response.ok ? null - : data.error?.message || 'Google Places request failed', + : data?.error?.message || 'Google Places request failed', }), ); } catch (error) { @@ -213,11 +221,12 @@ export function googlePlacesContextProxy({ // Text Search: resolve a named landmark/POI to a real coordinate, biased to // the view. Geocoding scatters obscure monument/POI names across the city; - // a view-biased Text Search lands on the actual feature. Same key, field - // mask, throttle, and `places: []` error contract as nearby-places above. + // a view-biased Text Search lands on the actual feature. Same key, throttle, + // cache rule, and `places: []` error contract as nearby-places above. middlewares.use('/api/google/text-search', async (req, res) => { // Paid like nearby-places, so gated the same way, first. if (admitSameSite(req, res)) return; + res.setHeader('Cache-Control', 'no-store'); if (req.method !== 'GET') { res.statusCode = 405; res.setHeader('Content-Type', 'application/json'); @@ -233,7 +242,6 @@ export function googlePlacesContextProxy({ if (keyless) { res.statusCode = keyless.statusCode; res.setHeader('Content-Type', 'application/json'); - res.setHeader('Cache-Control', 'no-store'); res.end(JSON.stringify(keyless.payload)); return; } @@ -306,18 +314,20 @@ export function googlePlacesContextProxy({ }), }, ); - const data = await response.json().catch(() => ({})); - const places = projectTextSearchPlaces(data, latitude, longitude); + const data = await response.json().catch(() => null); + if (response.ok && !data) + throw new Error('Google Places request failed'); + const places = projectTextSearchPlaces(data || {}, latitude, longitude); res.statusCode = response.ok ? 200 : response.status; res.setHeader('Content-Type', 'application/json; charset=utf-8'); - res.setHeader('Cache-Control', 'private, max-age=300'); + if (response.ok) res.setHeader('Cache-Control', 'private, max-age=300'); res.end( JSON.stringify({ places, error: response.ok ? null - : data.error?.message || 'Google Places request failed', + : data?.error?.message || 'Google Places request failed', }), ); } catch (error) { @@ -357,6 +367,7 @@ export function googlePlacesContextProxy({ // Gate first, like the Places routes above: a cross-site caller learns // nothing about this endpoint's method surface. if (admitSameSite(req, res)) return; + res.setHeader('Cache-Control', 'no-store'); if (req.method !== 'GET') { refuse(405, 'Method not allowed'); return; @@ -370,7 +381,6 @@ export function googlePlacesContextProxy({ if (keyless) { res.statusCode = keyless.statusCode; res.setHeader('Content-Type', 'application/json'); - res.setHeader('Cache-Control', 'no-store'); res.end(JSON.stringify(keyless.payload)); return; } @@ -437,7 +447,10 @@ export function googlePlacesContextProxy({ res.statusCode = response.ok ? 200 : response.status; res.setHeader('Content-Type', 'application/json; charset=utf-8'); - res.setHeader('Cache-Control', 'private, max-age=300'); + // Geocoding reports a denied key or spent quota as HTTP 200 with a + // status of its own; only an answer is worth keeping. + if (response.ok && GEOCODE_ANSWER_STATUSES.has(data.status)) + res.setHeader('Cache-Control', 'private, max-age=300'); res.end(JSON.stringify(data)); } catch { // Fixed public text: a transport, URL or runtime message would diff --git a/src/costEndpointThrottle.test.mjs b/src/costEndpointThrottle.test.mjs index 8a4e5bc55c..9aa2ef45d8 100644 --- a/src/costEndpointThrottle.test.mjs +++ b/src/costEndpointThrottle.test.mjs @@ -335,6 +335,7 @@ test('the Google places route throttles by default and keeps its places[] contra const overLimit = await request(handler, { url, method: 'GET' }); assert.equal(overLimit.status, 429); assert.equal(overLimit.headers['retry-after'], '5'); + assert.equal(overLimit.headers['cache-control'], 'no-store'); // Every error response on this route carries places[]; the client reads it // unconditionally, so a throttled reply must not be the one shape that omits it. assert.deepEqual(JSON.parse(overLimit.body).places, []); diff --git a/src/googleGeocodeProxy.test.mjs b/src/googleGeocodeProxy.test.mjs index 98ffd876e3..4675999a79 100644 --- a/src/googleGeocodeProxy.test.mjs +++ b/src/googleGeocodeProxy.test.mjs @@ -134,6 +134,7 @@ test('a bad or keyless geocode request never reaches Google', async () => { ]) { const response = await invokeRoute(routes.get(path), { url }); assert.equal(response.statusCode, 400); + assert.equal(response.headers['cache-control'], 'no-store'); assert.deepEqual(response.body.results, []); assert.equal(response.body.status, 'REQUEST_DENIED'); } @@ -144,6 +145,7 @@ test('a bad or keyless geocode request never reaches Google', async () => { url: '/?address=Austin&lat=30&lon=-97', }); assert.equal(rejected.statusCode, 405); + assert.equal(rejected.headers['cache-control'], 'no-store'); } // Keyless is an empty capability, not an outage: a 200 the browser adapters @@ -167,6 +169,33 @@ test('a bad or keyless geocode request never reaches Google', async () => { assert.deepEqual(upstream, []); }); +test('only a Geocoding answer is kept by the browser', async () => { + // Google can report a denied key or exhausted quota with HTTP 200. + for (const [httpStatus, status, cacheControl] of [ + [200, 'OK', 'private, max-age=300'], + [200, 'ZERO_RESULTS', 'private, max-age=300'], + [200, 'REQUEST_DENIED', 'no-store'], + [200, 'OVER_QUERY_LIMIT', 'no-store'], + [200, 'OVER_DAILY_LIMIT', 'no-store'], + [200, 'UNKNOWN_ERROR', 'no-store'], + [503, 'ZERO_RESULTS', 'no-store'], + ]) { + const routes = installRoutes({ + fetchImpl: async () => + Response.json({ status, results: [] }, { status: httpStatus }), + }); + for (const path of ['/api/google/geocode', '/api/google/reverse-geocode']) { + const label = `${path} ${httpStatus} ${status}`; + const response = await invokeRoute(routes.get(path), { + url: '/?address=Austin&lat=30&lon=-97', + }); + assert.equal(response.statusCode, httpStatus, label); + assert.equal(response.body.status, status, label); + assert.equal(response.headers['cache-control'], cacheControl, label); + } + } +}); + test('an upstream failure reaches the browser as fixed public text', async () => { const routes = installRoutes({ fetchImpl: async () => { @@ -178,6 +207,7 @@ test('an upstream failure reaches the browser as fixed public text', async () => url: '/?address=Austin&lat=30&lon=-97', }); assert.equal(response.statusCode, 502); + assert.equal(response.headers['cache-control'], 'no-store'); assert.deepEqual(response.body, { status: 'UNKNOWN_ERROR', results: [], diff --git a/src/tooling/placeProviders.test.mjs b/src/tooling/placeProviders.test.mjs index f68532c795..600f4d05cd 100644 --- a/src/tooling/placeProviders.test.mjs +++ b/src/tooling/placeProviders.test.mjs @@ -52,6 +52,11 @@ function install(register) { }; } +const ROUTES = [ + ['/api/google/nearby-places', '?lat=30&lon=-97'], + ['/api/google/text-search', '?q=museum&lat=30&lon=-97'], +]; + test('nearby labels rank landmarks, deduplicate names/addresses and bound the projection', () => { const place = (name, types, longitude = 0) => ({ displayName: { text: name }, @@ -176,16 +181,70 @@ for (const preview of [false, true]) { JSON.parse(calls[1].options.body).locationBias.circle.radius, 50, ); - assert.equal((await request(search, '?lat=30&lon=-97')).statusCode, 400); - assert.equal((await request(nearby, '?lat=bad&lon=-97')).statusCode, 400); - assert.equal((await request(nearby, '', 'POST')).statusCode, 405); + for (const [route, query, method, statusCode] of [ + [search, '?lat=30&lon=-97', 'GET', 400], + [nearby, '?lat=bad&lon=-97', 'GET', 400], + [nearby, '', 'POST', 405], + ]) { + const refused = await request(route, query, method); + assert.equal(refused.statusCode, statusCode, `${method} ${route}`); + assert.equal( + refused.headers['cache-control'], + 'no-store', + `${method} ${route}`, + ); + } t.mock.method(globalThis, 'fetch', async () => Response.json({ error: { message: 'Denied' } }, { status: 403 }), ); - assert.deepEqual((await request(search, '?q=museum&lat=30&lon=-97')).body, { - places: [], - error: 'Denied', - }); + for (const [route, query] of ROUTES) { + const refused = await request(route, query); + assert.equal(refused.statusCode, 403, route); + assert.equal(refused.headers['cache-control'], 'no-store', route); + assert.deepEqual(refused.body, { places: [], error: 'Denied' }, route); + } + }); +} + +for (const [name, upstream, statusCode, cacheControl] of [ + [ + 'unreadable 200', + () => new Response('not json', { status: 200 }), + 502, + 'no-store', + ], + [ + 'unreadable 429', + () => new Response('Too Many Requests', { status: 429 }), + 429, + 'no-store', + ], + [ + 'transport failure', + () => { + throw new TypeError('fetch failed'); + }, + 502, + 'no-store', + ], + // Google returns {} for a successful search with no places. + ['empty answer ({})', () => Response.json({}), 200, 'private, max-age=300'], +]) { + test(`a Places ${name} is a ${statusCode} with Cache-Control ${cacheControl}`, async () => { + const request = install((middlewares) => + googlePlacesContextProxy({ + resolveApiKey: () => 'fixture-server-key', + fetchImpl: async () => upstream(), + }).configureServer({ middlewares }), + ); + for (const [route, query] of ROUTES) { + const res = await request(route, query); + assert.equal(res.statusCode, statusCode, route); + assert.equal(res.headers['cache-control'], cacheControl, route); + assert.deepEqual(res.body.places, [], route); + if (statusCode === 200) assert.equal(res.body.error, null, route); + else assert.ok(res.body.error, route); + } }); }