signalk-race-control 0.11.0 → 0.11.1

package/index.js

@@ -2172,6 +2172,66 @@ module.exports = function (app) {
       res.json({ currentRaceId: state.currentRaceId, races });
     });
 
+    // Proxies an Overpass API query (used by the course editor's OpenSeaMap
+    // nav-mark search/snap) through this server rather than the browser
+    // calling a public Overpass mirror directly. Two problems forced this:
+    // overpass-api.de — the one mirror actually verified to carry real,
+    // complete seamark data — sends no Access-Control-Allow-Origin header,
+    // so a browser fetch to it is blocked outright regardless of whether
+    // the request itself would succeed; and of the two mirrors that do
+    // support CORS, one has been unreachable and the other has been
+    // observed returning a confident HTTP 200 with zero elements for real,
+    // densely-tagged areas. A server-to-server request isn't subject to
+    // CORS at all, so this can freely use the mirror that actually works.
+    const OVERPASS_ENDPOINTS = [
+      'https://overpass-api.de/api/interpreter',
+      'https://overpass.kumi.systems/api/interpreter',
+      'https://overpass.osm.ch/api/interpreter'
+    ];
+    router.get('/overpass', async (req, res) => {
+      const query = req.query.data;
+      if (!query) return res.status(400).json({ error: 'Missing data query parameter' });
+      // overpass-api.de has the best data but is also the most rate-
+      // limited/overloaded public instance — it can 504 one moment and
+      // work fine a couple of seconds later. A valid-but-empty response
+      // from a worse mirror is accepted only as a last resort (remembered,
+      // not returned immediately), and the whole mirror list gets a second
+      // pass after a short pause before actually giving up — otherwise a
+      // single transient overload on the good mirror would get cached by
+      // the client as "nothing charted here" for the rest of the session.
+      let emptyResult = null;
+      for (let pass = 0; pass < 2; pass++) {
+        for (const base of OVERPASS_ENDPOINTS) {
+          try {
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), 12000);
+            let r;
+            try {
+              // overpass-api.de specifically 406s a generic/default
+              // User-Agent (confirmed: it rejects Node's own default one)
+              // — identify the app explicitly, as any well-behaved
+              // Overpass client should.
+              r = await fetch(`${base}?data=${encodeURIComponent(query)}`, {
+                signal: controller.signal,
+                headers: { 'User-Agent': 'signalk-race-control (+https://github.com/joabakk/signalk-race-control)' }
+              });
+            } finally {
+              clearTimeout(timer);
+            }
+            if (!r.ok) continue;
+            const data = await r.json();
+            if (!data || !Array.isArray(data.elements)) continue;
+            if (data.elements.length) return res.json(data);
+            emptyResult = data;
+          } catch (e) {
+            // try the next mirror
+          }
+        }
+        if (pass === 0) await new Promise((resolve) => setTimeout(resolve, 2000));
+      }
+      res.json(emptyResult || { elements: [] });
+    });
+
     router.post('/races', (req, res) => {
       const name = ((req.body && req.body.name) || '').trim();
       if (!name) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signalk-race-control",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "description": "SignalK plugin and webapp for tracking elapsed and handicap-corrected (Time-on-Time) race time, with a per-boat editable TCF and boat names pulled from AIS when available.",
   "main": "index.js",
   "author": "Joachim Bakke <github@heiamoss.com>",

package/public/app.js

@@ -1412,32 +1412,29 @@
   // autocomplete and the pick-on-map snap. Silently returns nothing on
   // any failure or timeout, same spirit as the reverse-geocode name
   // suggestion.
-  // Public Overpass mirrors are individually flaky (rate limits, regional-
-  // only data, outages) — every configured one is queried and their
-  // results merged, rather than stopping at the first success. A single
-  // mirror can return a confident, well-formed, but empty result for an
-  // area its own extract just doesn't cover, which would otherwise poison
-  // the cache for that whole area for the rest of the session; querying
-  // both is only paid once per newly-explored area (not per keystroke or
-  // click the way this used to run), so the extra latency is worth it.
-  const OVERPASS_ENDPOINTS = ['https://overpass.kumi.systems/api/interpreter', 'https://overpass.osm.ch/api/interpreter'];
+  // Goes through this plugin's own server (see the /overpass route)
+  // rather than calling a public Overpass mirror directly from here: the
+  // mirror with real, complete seamark data (overpass-api.de) sends no
+  // CORS headers, so a browser fetch to it is blocked outright — a
+  // server-to-server request isn't subject to CORS at all. The server
+  // also handles falling back across mirrors, so this stays a single
+  // same-origin call.
   async function queryOverpass(overpassQuery) {
-    const elements = [];
-    for (const base of OVERPASS_ENDPOINTS) {
+    try {
       const controller = new AbortController();
-      const timer = setTimeout(() => controller.abort(), 7000);
+      const timer = setTimeout(() => controller.abort(), 90000);
+      let res;
       try {
-        const res = await fetch(`${base}?data=${encodeURIComponent(overpassQuery)}`, { signal: controller.signal });
-        if (!res.ok) continue;
-        const data = await res.json();
-        if (data && Array.isArray(data.elements)) elements.push(...data.elements);
-      } catch (e) {
-        // try the next endpoint
+        res = await fetch(`${API}/overpass?data=${encodeURIComponent(overpassQuery)}`, { signal: controller.signal });
       } finally {
         clearTimeout(timer);
       }
+      if (!res.ok) return [];
+      const data = await res.json();
+      return data && Array.isArray(data.elements) ? data.elements : [];
+    } catch (e) {
+      return [];
     }
-    return elements;
   }
 
   function seamarkElementsToResults(elements) {
@@ -1465,8 +1462,24 @@
       if (seamarkCacheBounds && seamarkCacheBounds.contains(bounds)) return;
     }
     const padded = bounds.pad(0.5);
-    const bbox = `${padded.getSouth()},${padded.getWest()},${padded.getNorth()},${padded.getEast()}`;
-    const overpassQuery = `[out:json][timeout:15];node["seamark:type"](${bbox});out body 200;`;
+    // The actual Overpass query is clamped to a sane max span around the
+    // padded area's center — a chart zoomed out to show a whole region
+    // (easy to end up at after an auto-fit spanning far-apart boat tracks)
+    // would otherwise turn this into a practically unbounded query, whose
+    // out-body cap then gets consumed by whatever Overpass returns first
+    // rather than the marks actually near what's being searched/picked.
+    // seamarkCacheBounds still tracks the full (unclamped) padded area
+    // below so a wide view isn't re-queried on every subsequent call.
+    const MAX_SPAN_DEG = 1; // ~110km of latitude — generous for any single race course
+    const center = padded.getCenter();
+    const latSpan = Math.min(padded.getNorth() - padded.getSouth(), MAX_SPAN_DEG);
+    const lonSpan = Math.min(padded.getEast() - padded.getWest(), MAX_SPAN_DEG);
+    const queryBounds = L.latLngBounds(
+      [center.lat - latSpan / 2, center.lng - lonSpan / 2],
+      [center.lat + latSpan / 2, center.lng + lonSpan / 2]
+    );
+    const bbox = `${queryBounds.getSouth()},${queryBounds.getWest()},${queryBounds.getNorth()},${queryBounds.getEast()}`;
+    const overpassQuery = `[out:json][timeout:15];node["seamark:type"](${bbox});out body 1000;`;
     seamarkCacheFetch = queryOverpass(overpassQuery);
     let elements;
     try {