Merged in feat/SW-1453-city-listing-on-country-page (pull request #1222)

feat(SW-1453): added city listing component

* feat(SW-1453): added city listing component


Approved-by: Christian Andolf
Approved-by: Fredrik Thorsson

server/routers/contentstack/destinationCountryPage/query.ts

@@ -1,13 +1,16 @@
+import { env } from "@/env/server"
 import {
   GetDestinationCountryPage,
   GetDestinationCountryPageRefs,
 } from "@/lib/graphql/Query/DestinationCountryPage/DestinationCountryPage.graphql"
 import { request } from "@/lib/graphql/request"
 import { notFound } from "@/server/errors/trpc"
-import { contentstackExtendedProcedureUID, router } from "@/server/trpc"
+import { contentStackUidWithServiceProcedure, router } from "@/server/trpc"
+import { toApiLang } from "@/server/utils"
 
 import { generateTag } from "@/utils/generateTag"
 
+import { getCitiesByCountry } from "../../hotels/utils"
 import {
   destinationCountryPageRefsSchema,
   destinationCountryPageSchema,
@@ -20,16 +23,19 @@ import {
   getDestinationCountryPageRefsSuccessCounter,
   getDestinationCountryPageSuccessCounter,
 } from "./telemetry"
-import { generatePageTags } from "./utils"
+import { generatePageTags, getCityListDataByCityIdentifier } from "./utils"
 
+import { ApiCountry } from "@/types/enums/country"
+import type { RequestOptionsWithOutBody } from "@/types/fetch"
 import type {
   GetDestinationCountryPageData,
   GetDestinationCountryPageRefsSchema,
 } from "@/types/trpc/routers/contentstack/destinationCountryPage"
 
 export const destinationCountryPageQueryRouter = router({
-  get: contentstackExtendedProcedureUID.query(async ({ ctx }) => {
-    const { lang, uid } = ctx
+  get: contentStackUidWithServiceProcedure.query(async ({ ctx }) => {
+    const { lang, uid, serviceToken } = ctx
+    const apiLang = toApiLang(lang)
 
     getDestinationCountryPageRefsCounter.add(1, { lang, uid })
     console.info(
@@ -128,27 +134,64 @@ export const destinationCountryPageQueryRouter = router({
       throw notFoundError
     }
 
-    const destinationCountryPage = destinationCountryPageSchema.safeParse(
+    const validatedResponse = destinationCountryPageSchema.safeParse(
       response.data
     )
 
-    if (!destinationCountryPage.success) {
+    if (!validatedResponse.success) {
       getDestinationCountryPageFailCounter.add(1, {
         lang,
         uid: `${uid}`,
         error_type: "validation_error",
-        error: JSON.stringify(destinationCountryPage.error),
+        error: JSON.stringify(validatedResponse.error),
       })
       console.error(
         "contentstack.destinationCountryPage validation error",
         JSON.stringify({
           query: { lang, uid },
-          error: destinationCountryPage.error,
+          error: validatedResponse.error,
         })
       )
       return null
     }
 
+    const params = new URLSearchParams({
+      language: apiLang,
+    })
+    const options: RequestOptionsWithOutBody = {
+      // needs to clear default option as only
+      // cache or next.revalidate is permitted
+      cache: undefined,
+      headers: {
+        Authorization: `Bearer ${serviceToken}`,
+      },
+      next: {
+        revalidate: env.CACHE_TIME_HOTELS,
+      },
+    }
+    const selectedCountry =
+      validatedResponse.data.destinationCountryPage.destination_settings.country
+    const apiCountry = ApiCountry[lang][selectedCountry]
+    const cities = await getCitiesByCountry([apiCountry], options, params, lang)
+
+    const publishedCities = cities[apiCountry].filter(
+      (city) => city.isPublished
+    )
+
+    const cityPages = await Promise.all(
+      publishedCities.map(async (city) => {
+        if (!city.cityIdentifier) {
+          return null
+        }
+
+        const data = await getCityListDataByCityIdentifier(
+          lang,
+          city.cityIdentifier
+        )
+        return data ? { ...data, cityName: city.name } : null
+      })
+    )
+
     getDestinationCountryPageSuccessCounter.add(1, { lang, uid: `${uid}` })
     console.info(
       "contentstack.destinationCountryPage success",
@@ -157,6 +200,11 @@ export const destinationCountryPageQueryRouter = router({
       })
     )
 
-    return destinationCountryPage.data
+    return {
+      ...validatedResponse.data,
+      cities: cityPages
+        .flat()
+        .filter((city): city is NonNullable<typeof city> => !!city),
+    }
   }),
 })