fix(SW-1446): use existing functions for url data

apps/scandic-web/lib/graphql/Query/Locations/Locations.graphql

@@ -1,21 +0,0 @@
-query GetLocationsUrls($locale: String!) {
-  hotels: all_hotel_page(locale: $locale) {
-    items {
-      url
-      id: hotel_page_id
-    }
-  }
-  cities: all_destination_city_page {
-    items {
-      url
-      id: destination_settings {
-        sv: city_sweden
-        pl: city_poland
-        no: city_norway
-        de: city_germany
-        fi: city_finland
-        da: city_denmark
-      }
-    }
-  }
-}

apps/scandic-web/lib/trpc/memoizedRequests/index.ts

@@ -301,13 +301,13 @@ export const getJumpToData = cache(async function getMemoizedJumpToData() {
         if (isCity) {
           url = urls.cities.find(
             (c) =>
-              c.id &&
+              c.city &&
               location.cityIdentifier &&
-              c.id === location.cityIdentifier
+              c.city === location.cityIdentifier
           )?.url
         } else if (isHotel) {
           url = urls.hotels.find(
-            (h) => h.id && location.id && h.id === location.id
+            (h) => h.hotelId && location.id && h.hotelId === location.id
           )?.url
         }
 

apps/scandic-web/server/routers/contentstack/destinationCityPage/output.ts

@@ -1,6 +1,7 @@
 import { z } from "zod"
 
 import { discriminatedUnionArray } from "@/lib/discriminatedUnion"
+import { isDefined } from "@/server/utils"
 
 import { removeMultipleSlashes } from "@/utils/url"
 
@@ -41,16 +42,16 @@ const destinationCityPageDestinationSettingsSchema = z
       city_sweden,
       location,
     }) => {
-      const cities = [
+      return {
-        city_denmark,
+        city:
-        city_finland,
+          city_denmark ||
-        city_germany,
+          city_finland ||
-        city_poland,
+          city_germany ||
-        city_norway,
+          city_poland ||
-        city_sweden,
+          city_norway ||
-      ].filter((city): city is string => Boolean(city))
+          city_sweden,
-
+        location,
-      return { city: cities[0], location }
+      }
     }
   )
 
@@ -182,20 +183,31 @@ export const cityPageCountSchema = z
 export const cityPageUrlsSchema = z
   .object({
     all_destination_city_page: z.object({
-      items: z.array(
+      items: z
-        z
+        .array(
-          .object({
+          z
-            url: z.string(),
+            .object({
-            destination_settings: destinationCityPageDestinationSettingsSchema,
+              url: z.string().nullish(),
-            system: systemSchema,
+              destination_settings:
-          })
+                destinationCityPageDestinationSettingsSchema,
-          .transform((data) => {
+              system: systemSchema,
-            return {
+            })
-              city: data.destination_settings.city,
+            .transform((data) => {
-              url: removeMultipleSlashes(`/${data.system.locale}/${data.url}`),
+              if (!data.destination_settings.city || !data.url) {
-            }
+                return null
-          })
+              }
-      ),
+
+              return {
+                city: data.destination_settings.city,
+                url: removeMultipleSlashes(
+                  `/${data.system.locale}/${data.url}`
+                ),
+              }
+            })
+        )
+        .transform((data) => {
+          return data.filter(isDefined)
+        }),
     }),
   })
   .transform(({ all_destination_city_page }) => all_destination_city_page.items)

apps/scandic-web/server/routers/contentstack/destinationCityPage/query.ts

@@ -149,6 +149,10 @@ export const destinationCityPageQueryRouter = router({
     }
     const destinationCityPage = validatedResponse.data.destination_city_page
     const cityIdentifier = destinationCityPage.destination_settings.city
+    if (!cityIdentifier) {
+      return null
+    }
+
     const city = await getCityByCityIdentifier({
       cityIdentifier,
       lang,

apps/scandic-web/server/routers/hotels/query.ts

@@ -3,9 +3,8 @@ import { Lang } from "@/constants/languages"
 import { env } from "@/env/server"
 import * as api from "@/lib/api"
 import { dt } from "@/lib/dt"
-import { GetLocationsUrls } from "@/lib/graphql/Query/Locations/Locations.graphql"
-import { request } from "@/lib/graphql/request"
 import { badRequestError, unauthorizedError } from "@/server/errors/trpc"
+import { getCityPageUrls } from "@/server/routers/contentstack/destinationCityPage/utils"
 import {
   contentStackBaseWithServiceProcedure,
   publicProcedure,
@@ -18,15 +17,10 @@ import { toApiLang } from "@/server/utils"
 import { generateChildrenString } from "@/components/HotelReservation/utils"
 import { getCacheClient } from "@/services/dataCache"
 import { cache } from "@/utils/cache"
-import { removeMultipleSlashes } from "@/utils/url"
 
 import { getHotelPageUrls } from "../contentstack/hotelPage/utils"
 import { getVerifiedUser } from "../user/query"
 import { additionalDataSchema } from "./schemas/hotel/include/additionalData"
-import {
-  type GetLocationsUrlsData,
-  locationsUrlsSchema,
-} from "./schemas/location/urls"
 import { meetingRoomsSchema } from "./schemas/meetingRoom"
 import {
   ancillaryPackageInputSchema,
@@ -1532,43 +1526,32 @@ export const hotelQueryRouter = router({
           JSON.stringify({ query: { lang } })
         )
 
-        const response = await request<GetLocationsUrlsData>(
+        const [hotelPageUrlsResult, cityPageUrlsResult] =
-          GetLocationsUrls,
+          await Promise.allSettled([
-          { locale: lang },
+            getHotelPageUrls(lang),
-          {
+            getCityPageUrls(lang),
-            key: `${lang}:${procedureName}`,
+          ])
-            ttl: "max",
+
-          }
+        if (
-        )
+          hotelPageUrlsResult.status === "rejected" ||
-        if (!response.data) {
+          cityPageUrlsResult.status === "rejected"
+        ) {
           locationsUrlsFailCounter.add(1, {
             lang,
-            error_type: "no data",
+            error_type: "no_data",
-            response: JSON.stringify(response),
+            response: JSON.stringify({
+              hotelPageUrlsResult,
+              cityPageUrlsResult,
+            }),
           })
 
           console.error(`${procedureName}: no data`, {
             variables: { lang },
-            error_type: "no data",
+            error_type: "no_data",
-            response,
+            response: {
-          })
+              hotelPageUrlsResult,
-
+              cityPageUrlsResult,
-          return null
+            },
-        }
-
-        const locationsUrls = locationsUrlsSchema.safeParse(response.data)
-
-        if (!locationsUrls.success) {
-          locationsUrlsFailCounter.add(1, {
-            lang,
-            error_type: "validation_error",
-            error: JSON.stringify(locationsUrls.error),
-          })
-
-          console.error(`${procedureName}: validation error`, {
-            variables: { lang },
-            error_type: "validation_error",
-            error: locationsUrls.error,
           })
 
           return null
@@ -1580,16 +1563,10 @@ export const hotelQueryRouter = router({
           variables: { lang },
         })
 
-        const { data } = locationsUrls
+        return {
-        data.hotels = data.hotels.map((hotel) => {
+          hotels: hotelPageUrlsResult.value,
-          hotel.url = removeMultipleSlashes(`/${lang}/${hotel.url}`)
+          cities: cityPageUrlsResult.value,
-          return hotel
+        }
-        })
-        data.cities = data.cities.map((city) => {
-          city.url = removeMultipleSlashes(`/${lang}/${city.url}`)
-          return city
-        })
-        return locationsUrls.data
       }),
   }),
   map: router({

apps/scandic-web/stores/destination-data/helper.ts

@@ -69,8 +69,10 @@ export function getFilteredCities(
     (hotel) => hotel.hotel.cityIdentifier
   )
 
-  return cities.filter((city) =>
+  return cities.filter(
-    filteredCityIdentifiers.includes(city.destination_settings.city)
+    (city) =>
+      city.destination_settings.city &&
+      filteredCityIdentifiers.includes(city.destination_settings.city)
   )
 }