fix: db vendo per-leg geometries & polylines

Author: Medformatik

apps/web/src/components/map/layers/TransitItineraryLayer.tsx

@@ -1,7 +1,8 @@
 "use client";
 
-import { MODE_COLORS, useDirectionsStore } from "@openmapx/core";
-import { useEffect } from "react";
+import type { GeoJSONLineString } from "@integrations/transit/types";
+import { API_ENDPOINTS, apiClient, MODE_COLORS, useDirectionsStore } from "@openmapx/core";
+import { useEffect, useRef, useState } from "react";
 import { useMap } from "@/lib/MapContext";
 import { PRIMARY_BLUE_HEX } from "@/lib/theme";
 
@@ -15,6 +16,52 @@ export function TransitItineraryLayer() {
   const { mapRef, mapReady, styleVersion, fitBounds } = useMap();
   const { mode, transitItineraries, activeItineraryIndex } = useDirectionsStore();
 
+  // Refined per-leg geometries fetched lazily from /leg-geometry after the
+  // itinerary is selected. Keyed by tripId; replaces stopovers geometry when available.
+  const [legGeometries, setLegGeometries] = useState<Record<string, GeoJSONLineString>>({});
+  // Track the fetch generation so stale responses from a previous itinerary are discarded.
+  const fetchGenRef = useRef(0);
+  // Track which (itinerary list, index) pair has already had bounds fitted.
+  // Keying on the list reference catches new searches that reset the index back
+  // to 0, which a bare index comparison would miss.
+  const fittedRef = useRef<{ list: typeof transitItineraries; index: number } | null>(null);
+
+  useEffect(() => {
+    if (mode !== "transit") {
+      setLegGeometries({});
+      return;
+    }
+    const itinerary = transitItineraries[activeItineraryIndex];
+    if (!itinerary) return;
+
+    const gen = ++fetchGenRef.current;
+    setLegGeometries({});
+
+    const transitLegs = itinerary.legs.filter((leg) => leg.tripId && leg.mode !== "walking");
+    if (transitLegs.length === 0) return;
+
+    void Promise.allSettled(
+      transitLegs.map(async (leg) => {
+        if (!leg.tripId) return;
+        const { tripId } = leg;
+        try {
+          const params: Record<string, string> = { trip_id: tripId };
+          if (leg.from.stopId) params.from_stop_id = leg.from.stopId;
+          if (leg.to.stopId) params.to_stop_id = leg.to.stopId;
+          const geo = await apiClient.get<GeoJSONLineString>(
+            API_ENDPOINTS.transitLegGeometry,
+            params,
+          );
+          if (fetchGenRef.current === gen && geo?.coordinates?.length >= 2) {
+            setLegGeometries((prev) => ({ ...prev, [tripId]: geo }));
+          }
+        } catch {
+          // geometry not available for this leg — stopovers geometry is used
+        }
+      }),
+    );
+  }, [mode, transitItineraries, activeItineraryIndex]);
+
   useEffect(() => {
     void styleVersion;
     const map = mapRef.current;
@@ -38,19 +85,20 @@ export function TransitItineraryLayer() {
 
     cleanup();
 
-    // Build line features for each leg
+    // Build line features for each leg; use refined trip geometry when available
     const lineFeatures = itinerary.legs.map((leg, i) => {
       const isWalk = leg.mode === "walking";
       const color = isWalk
         ? "#757575"
         : leg.route?.color
           ? `#${leg.route.color.replace("#", "")}`
           : (MODE_COLORS[leg.mode] ?? PRIMARY_BLUE_HEX);
+      const geometry = (leg.tripId ? legGeometries[leg.tripId] : undefined) ?? leg.geometry;
 
       return {
         type: "Feature" as const,
         properties: { isWalk, color, index: i },
-        geometry: leg.geometry,
+        geometry,
       };
     });
 
@@ -126,27 +174,44 @@ export function TransitItineraryLayer() {
       },
     });
 
-    // Fit bounds to itinerary
-    const allCoords: [number, number][] = [];
-    for (const leg of itinerary.legs) {
-      for (const coord of leg.geometry.coordinates) {
-        allCoords.push(coord);
+    // Fit bounds only when the itinerary set or selected index changes, not on
+    // every legGeometries update. Comparing the list reference catches new
+    // searches that reset the index to 0 (a bare index check would miss them).
+    const alreadyFitted =
+      fittedRef.current?.list === transitItineraries &&
+      fittedRef.current?.index === activeItineraryIndex;
+    if (!alreadyFitted) {
+      fittedRef.current = { list: transitItineraries, index: activeItineraryIndex };
+      const allCoords: [number, number][] = [];
+      for (const leg of itinerary.legs) {
+        for (const coord of leg.geometry.coordinates) {
+          allCoords.push(coord);
+        }
+      }
+      if (allCoords.length >= 2) {
+        const lngs = allCoords.map((c) => c[0]);
+        const lats = allCoords.map((c) => c[1]);
+        fitBounds(
+          [
+            [Math.min(...lngs), Math.min(...lats)],
+            [Math.max(...lngs), Math.max(...lats)],
+          ],
+          80,
+        );
       }
-    }
-    if (allCoords.length >= 2) {
-      const lngs = allCoords.map((c) => c[0]);
-      const lats = allCoords.map((c) => c[1]);
-      fitBounds(
-        [
-          [Math.min(...lngs), Math.min(...lats)],
-          [Math.max(...lngs), Math.max(...lats)],
-        ],
-        80,
-      );
     }
 
     return cleanup;
-  }, [mapRef, mapReady, styleVersion, mode, transitItineraries, activeItineraryIndex, fitBounds]);
+  }, [
+    mapRef,
+    mapReady,
+    styleVersion,
+    mode,
+    transitItineraries,
+    activeItineraryIndex,
+    fitBounds,
+    legGeometries,
+  ]);
 
   return null;
 }

integrations/transit-db-vendo/index.ts

@@ -34,5 +34,7 @@ export function setup(ctx: IntegrationContext): void {
     async getVehicleJourney(tripId: string) {
       return dbVendo.getTrip(tripId);
     },
+    getLegGeometry: (tripId: string, fromStopId?: string, toStopId?: string) =>
+      dbVendo.getLegGeometry(tripId, fromStopId, toStopId),
   });
 }

integrations/transit-db-vendo/provider.ts

@@ -18,15 +18,43 @@ import {
   USER_AGENT_TRANSIT,
 } from "@openmapx/core";
 import { createClient } from "db-vendo-client";
-import { profile as dbProfile } from "db-vendo-client/p/db/index.js";
+// dbnav uses app.services-bahn.de — documented as more stable than the db
+// profile (app.vendo.noncd.db.de, "possibly shut off soon" per readme).
+// @ts-expect-error — no type declarations for the dbnav profile sub-path
+import { profile as dbnavProfile } from "db-vendo-client/p/dbnav/index.js";
+// @ts-expect-error — no type declarations for the dbweb profile sub-path
+import { profile as dbwebProfile } from "db-vendo-client/p/dbweb/index.js";
+// @ts-expect-error — no type declarations for throttle/retry sub-paths
+import { withRetrying } from "db-vendo-client/retry.js";
+// @ts-expect-error — no type declarations for throttle/retry sub-paths
+import { withThrottling } from "db-vendo-client/throttle.js";
 
 const PREFIX = "db:";
+const UA = process.env.DB_USER_AGENT ?? USER_AGENT_TRANSIT;
 
+// Primary client for journey planning, departures, stops, etc.
+// dbnav quota: 60 req/min → throttle to 1/s. Retry up to 3× on transient
+// failures (network timeouts, 5xx); HafasErrors are never retried.
 // biome-ignore lint/suspicious/noExplicitAny: external untyped package
-const client: any = createClient(dbProfile, process.env.DB_USER_AGENT ?? USER_AGENT_TRANSIT, {
+const client: any = createClient(withRetrying(withThrottling(dbnavProfile, 1, 1000)), UA, {
   enrichStations: true,
 });
 
+// Secondary client for polyline geometry via /reiseloesung/fahrt?poly=true.
+// dbweb is "aggressively blocked" per docs, so we:
+//   • throttle to 1 req/2 s (very conservative)
+//   • retry up to 2× with a short backoff (3 s, 6 s) so the UI doesn't stall
+//   • randomize the User-Agent to reduce fingerprinting-based blocking
+// biome-ignore lint/suspicious/noExplicitAny: external untyped package
+const dbwebClient: any = createClient(
+  withRetrying(withThrottling({ ...dbwebProfile, randomizeUserAgent: true }, 1, 2000), {
+    retries: 2,
+    minTimeout: 3_000,
+    factor: 2,
+  }),
+  UA,
+);
+
 // biome-ignore lint/suspicious/noExplicitAny: external API response
 function normalizeStop(s: any): TransitStop {
   return {
@@ -175,9 +203,23 @@ function legToTripLeg(leg: any): TripLeg {
       [toLng, toLat],
     ],
   };
-  const polyFeature = leg.polyline?.features?.[0]?.geometry;
-  if (polyFeature?.type === "LineString" && Array.isArray(polyFeature.coordinates)) {
-    geometry = polyFeature as GeoJSONLineString;
+  if (Array.isArray(leg.stopovers) && leg.stopovers.length >= 2) {
+    // db-vendo-client does not support polylines in journeys(); use stopover
+    // coordinates as a multi-point fallback so the route passes through real
+    // intermediate stations instead of drawing a single straight line.
+    const coords: [number, number][] = [];
+    for (const s of leg.stopovers) {
+      // biome-ignore lint/suspicious/noExplicitAny: external API response
+      const sv = s as any;
+      const lat = sv.stop?.location?.latitude ?? sv.location?.latitude;
+      const lng = sv.stop?.location?.longitude ?? sv.location?.longitude;
+      if (typeof lat === "number" && typeof lng === "number") {
+        coords.push([lng, lat]);
+      }
+    }
+    if (coords.length >= 2) {
+      geometry = { type: "LineString", coordinates: coords };
+    }
   }
 
   // stopovers includes origin + destination; subtract 2 for intermediate count
@@ -237,8 +279,11 @@ export async function planJourney(
         results: numItineraries ?? 3,
         stopovers: true,
         remarks: true,
-        // Note: polylines are NOT supported in journeys() for db-vendo-client;
-        // only in refreshJourney() and trip(). Geometry falls back to straight lines.
+        // polylines are not supported in journeys() for db-vendo-client; only
+        // refreshJourney() accepts the option, but the DB vendo API no longer
+        // returns polylineGroup data there either. We use stopover coordinates
+        // as a multi-point fallback (see legToTripLeg), and refine per-leg via
+        // getLegGeometry() when the user selects an itinerary.
       },
     );
     if (!data.journeys?.length) return null;
@@ -295,6 +340,120 @@ export async function planJourney(
   }
 }
 
+// Leg Geometry
+
+/** Return the index in `coords` closest to `[lng, lat]` (squared equirectangular distance). */
+function closestIndex(coords: [number, number][], lng: number, lat: number): number {
+  let best = 0;
+  let bestDist = Infinity;
+  for (let i = 0; i < coords.length; i++) {
+    const d = (coords[i][0] - lng) ** 2 + (coords[i][1] - lat) ** 2;
+    if (d < bestDist) {
+      bestDist = d;
+      best = i;
+    }
+  }
+  return best;
+}
+
+/**
+ * Fetch the exact track shape for a single transit leg.
+ *
+ * Uses the bahn.de web client whose /reiseloesung/fahrt endpoint supports
+ * poly=true and returns the full polyline as a FeatureCollection of Points.
+ * The result is clipped to the user's boarding/alighting stops. Falls back to
+ * stopover coordinates if the polyline is not available.
+ */
+export async function getLegGeometry(
+  tripId: string,
+  fromStopId?: string,
+  toStopId?: string,
+): Promise<GeoJSONLineString | null> {
+  const rawId = stripPrefix(tripId);
+  const rawFrom = fromStopId ? stripPrefix(fromStopId) : undefined;
+  const rawTo = toStopId ? stripPrefix(toStopId) : undefined;
+  try {
+    // Use the bahn.de web client: its /reiseloesung/fahrt endpoint accepts
+    // poly=true and returns the full track polyline as a FeatureCollection of
+    // Point features. The HAFAS trip IDs from the db profile are compatible.
+    // biome-ignore lint/suspicious/noExplicitAny: external API response
+    const data: any = await dbwebClient.trip(rawId, { stopovers: true, polyline: true });
+    const trip = data.trip ?? data;
+
+    // The polyline comes back as a GeoJSON FeatureCollection of Point features.
+    // Convert to a LineString and clip to the boarding / alighting stops.
+    // biome-ignore lint/suspicious/noExplicitAny: external API response
+    const stopovers: any[] = trip.stopovers ?? [];
+    const polyCollection = trip.polyline;
+
+    if (
+      polyCollection?.type === "FeatureCollection" &&
+      Array.isArray(polyCollection.features) &&
+      polyCollection.features.length >= 2
+    ) {
+      const allCoords: [number, number][] = [];
+      // biome-ignore lint/suspicious/noExplicitAny: external API response
+      for (const f of polyCollection.features as any[]) {
+        if (f.geometry?.type === "Point" && Array.isArray(f.geometry.coordinates)) {
+          allCoords.push(f.geometry.coordinates as [number, number]);
+        }
+      }
+
+      if (allCoords.length >= 2) {
+        // Clip to the user's leg using the boarding/alighting stop coordinates
+        // as anchor points (find the nearest polyline point to each station).
+        const fromStop = rawFrom ? stopovers.find((s) => s.stop?.id === rawFrom) : null;
+        const toStop = rawTo ? stopovers.find((s) => s.stop?.id === rawTo) : null;
+
+        let startIdx = 0;
+        let endIdx = allCoords.length - 1;
+
+        if (fromStop?.stop?.location) {
+          startIdx = closestIndex(
+            allCoords,
+            fromStop.stop.location.longitude,
+            fromStop.stop.location.latitude,
+          );
+        }
+        if (toStop?.stop?.location) {
+          endIdx = closestIndex(
+            allCoords,
+            toStop.stop.location.longitude,
+            toStop.stop.location.latitude,
+          );
+        }
+
+        // Ensure correct order (trains always run origin→destination in the polyline)
+        if (startIdx > endIdx) [startIdx, endIdx] = [endIdx, startIdx];
+
+        const clipped = allCoords.slice(startIdx, endIdx + 1);
+        if (clipped.length >= 2) {
+          return { type: "LineString", coordinates: clipped };
+        }
+      }
+    }
+
+    // Fallback: use stopover coordinates clipped to the leg's stop range.
+    let fromIdx = rawFrom ? stopovers.findIndex((s) => s.stop?.id === rawFrom) : -1;
+    let toIdx = rawTo ? stopovers.findIndex((s) => s.stop?.id === rawTo) : -1;
+    if (fromIdx === -1) fromIdx = 0;
+    if (toIdx === -1) toIdx = stopovers.length - 1;
+
+    const slice = stopovers.slice(fromIdx, toIdx + 1);
+    const coords: [number, number][] = [];
+    for (const s of slice) {
+      const lat = s.stop?.location?.latitude;
+      const lng = s.stop?.location?.longitude;
+      if (typeof lat === "number" && typeof lng === "number") {
+        coords.push([lng, lat]);
+      }
+    }
+    return coords.length >= 2 ? { type: "LineString", coordinates: coords } : null;
+  } catch {
+    return null;
+  }
+}
+
 // Trip Detail
 
 export async function getTrip(tripId: string): Promise<VehicleJourney | null> {