refactor(webapp): Update to use new geo queries - offersByHub, offerToHub

- Rename GetOffersToHub → GetOffersByHub
- Rename GetDeliveryToHub → GetOfferToHub
- Delete FindRoutes.graphql, FindProductRoutes.graphql
- Update catalog pages and CalcResultContent to use new query names
- Regenerate GraphQL types

app/components/CalcResultContent.vue

@@ -62,8 +62,7 @@
 </template>
 
 <script setup lang="ts">
-import { FindRoutesDocument } from '~/composables/graphql/public/geo-generated'
-import type { RoutePathType } from '~/composables/graphql/public/geo-generated'
+import { GetOffersByHubDocument } from '~/composables/graphql/public/geo-generated'
 import type { RouteStageItem } from '~/components/RouteStagesList.vue'
 import { GetOfferDocument } from '~/composables/graphql/public/exchange-generated'
 
@@ -87,10 +86,9 @@ const summaryMeta = computed(() => {
   return meta
 })
 
-// Determine context (new flow: product + destination; legacy: from param)
+// Determine context
 const productUuid = computed(() => (route.query.productUuid as string) || searchStore.searchForm.productUuid)
 const destinationUuid = computed(() => (route.query.locationUuid as string) || searchStore.searchForm.locationUuid)
-const legacyFromUuid = computed(() => route.params.id as string | undefined)
 
 type ProductRouteOption = {
   sourceUuid?: string | null
@@ -101,95 +99,39 @@ type ProductRouteOption = {
   routes?: RoutePathType[] | null
 }
 
-const fetchProductRoutes = async () => {
+const fetchOffersByHub = async () => {
   if (!productUuid.value || !destinationUuid.value) return null
   const { client } = useApolloClient('publicGeo')
-  const { default: gql } = await import('graphql-tag')
-
-  const query = gql`
-    query FindProductRoutes($productUuid: String!, $toUuid: String!, $limitSources: Int, $limitRoutes: Int) {
-      findProductRoutes(
-        productUuid: $productUuid
-        toUuid: $toUuid
-        limitSources: $limitSources
-        limitRoutes: $limitRoutes
-      ) {
-        sourceUuid
-        sourceName
-        sourceLat
-        sourceLon
-        distanceKm
-        routes {
-          totalDistanceKm
-          totalTimeSeconds
-          stages {
-            fromUuid
-            fromName
-            fromLat
-            fromLon
-            toUuid
-            toName
-            toLat
-            toLon
-            distanceKm
-            travelTimeSeconds
-            transportType
-          }
-        }
-      }
-    }
-  `
 
   const { data } = await client.query({
-    query,
+    query: GetOffersByHubDocument,
     variables: {
+      hubUuid: destinationUuid.value,
       productUuid: productUuid.value,
-      toUuid: destinationUuid.value,
-      limitSources: 5,
-      limitRoutes: 1
-    }
-  })
-  return data
-}
-
-const fetchLegacyRoutes = async () => {
-  if (!legacyFromUuid.value || !destinationUuid.value) return null
-  const { client } = useApolloClient('publicGeo')
-  const { data } = await client.query({
-    query: FindRoutesDocument,
-    variables: {
-      fromUuid: legacyFromUuid.value,
-      toUuid: destinationUuid.value,
-      limit: 3
+      limit: 5
     }
   })
   return data
 }
 
 const { data: productRoutesData, pending, error } = await useAsyncData(
-  () => `product-routes-${productUuid.value}-${destinationUuid.value}-${legacyFromUuid.value || 'none'}`,
+  () => `offers-by-hub-${productUuid.value}-${destinationUuid.value}`,
   async () => {
-    // Prefer product-based routes; fallback to legacy if no product
     if (productUuid.value && destinationUuid.value) {
-      return await fetchProductRoutes()
-    }
-    if (legacyFromUuid.value && destinationUuid.value) {
-      return await fetchLegacyRoutes()
+      return await fetchOffersByHub()
     }
     return null
   },
-  { watch: [productUuid, destinationUuid, legacyFromUuid] }
+  { watch: [productUuid, destinationUuid] }
 )
 
 const productRouteOptions = computed(() => {
-  const options = productRoutesData.value?.findProductRoutes as ProductRouteOption[] | undefined
+  const options = productRoutesData.value?.offersByHub as ProductRouteOption[] | undefined
   return options?.filter(Boolean) || []
 })
 
 const legacyRoutes = computed(() => {
-  const data = productRoutesData.value?.findRoutes
-  if (!data) return []
-  return (data as (RoutePathType | null)[]).filter((r): r is RoutePathType => r !== null)
+  return []  // Legacy routes removed
 })
 
 const mapRouteStages = (route: RoutePathType): RouteStageItem[] => {