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

import { env } from "@/env/server"
import {
  GetDestinationOverviewPage,
  GetDestinationOverviewPageRefs,
} from "@/lib/graphql/Query/DestinationOverviewPage/DestinationOverviewPage.graphql"
import { request } from "@/lib/graphql/request"
import { notFound } from "@/server/errors/trpc"
import {
  contentstackExtendedProcedureUID,
  router,
  serviceProcedure,
} from "@/server/trpc"
import { toApiLang } from "@/server/utils"

import { generateTag } from "@/utils/generateTag"

import {
  getCitiesByCountry,
  getCountries,
  getHotelIdsByCityId,
} from "../../hotels/utils"
import { getCityPageUrls } from "../destinationCityPage/utils"
import { getCountryPageUrls } from "../destinationCountryPage/utils"
import {
  destinationOverviewPageRefsSchema,
  destinationOverviewPageSchema,
} from "./output"
import {
  getDestinationOverviewPageCounter,
  getDestinationOverviewPageFailCounter,
  getDestinationOverviewPageRefsCounter,
  getDestinationOverviewPageRefsFailCounter,
  getDestinationOverviewPageRefsSuccessCounter,
  getDestinationOverviewPageSuccessCounter,
} from "./telemetry"

import type {
  Cities,
  DestinationsData,
} from "@/types/components/destinationOverviewPage/destinationsList/destinationsData"
import {
  TrackingChannelEnum,
  type TrackingSDKPageData,
} from "@/types/components/tracking"
import type { RequestOptionsWithOutBody } from "@/types/fetch"
import type {
  GetDestinationOverviewPageData,
  GetDestinationOverviewPageRefsSchema,
} from "@/types/trpc/routers/contentstack/destinationOverviewPage"

export const destinationOverviewPageQueryRouter = router({
  get: contentstackExtendedProcedureUID.query(async ({ ctx }) => {
    const { lang, uid } = ctx

    getDestinationOverviewPageRefsCounter.add(1, { lang, uid: `${uid}` })
    console.info(
      "contentstack.destinationOverviewPage.refs start",
      JSON.stringify({
        query: { lang, uid },
      })
    )
    const refsResponse = await request<GetDestinationOverviewPageRefsSchema>(
      GetDestinationOverviewPageRefs,
      {
        locale: lang,
        uid,
      },
      {
        cache: "force-cache",
        next: {
          tags: [generateTag(lang, uid)],
        },
      }
    )
    if (!refsResponse.data) {
      const notFoundError = notFound(refsResponse)
      getDestinationOverviewPageRefsFailCounter.add(1, {
        lang,
        uid,
        error_type: "not_found",
        error: JSON.stringify({ code: notFoundError.code }),
      })
      console.error(
        "contentstack.destinationOverviewPage.refs not found error",
        JSON.stringify({
          query: { lang, uid },
          error: { code: notFoundError.code },
        })
      )
      throw notFoundError
    }

    const validatedRefsData = destinationOverviewPageRefsSchema.safeParse(
      refsResponse.data
    )

    if (!validatedRefsData.success) {
      getDestinationOverviewPageRefsFailCounter.add(1, {
        lang,
        uid,
        error_type: "validation_error",
        error: JSON.stringify(validatedRefsData.error),
      })
      console.error(
        "contentstack.destinationOverviewPage.refs validation error",
        JSON.stringify({
          query: { lang, uid },
          error: validatedRefsData.error,
        })
      )
      return null
    }

    getDestinationOverviewPageRefsSuccessCounter.add(1, { lang, uid: `${uid}` })
    console.info(
      "contentstack.destinationOverviewPage.refs success",
      JSON.stringify({
        query: { lang, uid },
      })
    )

    getDestinationOverviewPageCounter.add(1, { lang, uid: `${uid}` })
    console.info(
      "contentstack.destinationOverviewPage start",
      JSON.stringify({
        query: { lang, uid },
      })
    )
    const response = await request<GetDestinationOverviewPageData>(
      GetDestinationOverviewPage,
      {
        locale: lang,
        uid,
      },
      {
        cache: "force-cache",
        next: {
          tags: [generateTag(lang, uid)],
        },
      }
    )
    if (!response.data) {
      const notFoundError = notFound(response)
      getDestinationOverviewPageFailCounter.add(1, {
        lang,
        uid: `${uid}`,
        error_type: "not_found",
        error: JSON.stringify({ code: notFoundError.code }),
      })
      console.error(
        "contentstack.destinationOverviewPage not found error",
        JSON.stringify({
          query: { lang, uid },
          error: { code: notFoundError.code },
        })
      )
      throw notFoundError
    }

    const destinationOverviewPage = destinationOverviewPageSchema.safeParse(
      response.data
    )

    if (!destinationOverviewPage.success) {
      getDestinationOverviewPageFailCounter.add(1, {
        lang,
        uid: `${uid}`,
        error_type: "validation_error",
        error: JSON.stringify(destinationOverviewPage.error),
      })
      console.error(
        "contentstack.destinationOverviewPage validation error",
        JSON.stringify({
          query: { lang, uid },
          error: destinationOverviewPage.error,
        })
      )
      return null
    }

    getDestinationOverviewPageSuccessCounter.add(1, { lang, uid: `${uid}` })
    console.info(
      "contentstack.destinationOverviewPage success",
      JSON.stringify({
        query: { lang, uid },
      })
    )

    const system = destinationOverviewPage.data.destination_overview_page.system
    const tracking: TrackingSDKPageData = {
      pageId: system.uid,
      domainLanguage: lang,
      publishDate: system.updated_at,
      createDate: system.created_at,
      channel: TrackingChannelEnum.hotels,
      pageType: "destinationoverviewpage",
      pageName: "destination|overview",
      siteSections: "destination|overview",
      siteVersion: "new-web",
    }

    return {
      destinationOverviewPage:
        destinationOverviewPage.data.destination_overview_page,
      tracking,
    }
  }),
  destinations: router({
    get: serviceProcedure.query(async function ({ ctx }) {
      const apiLang = toApiLang(ctx.lang)
      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 ${ctx.serviceToken}`,
        },
        next: {
          revalidate: env.CACHE_TIME_HOTELS,
        },
      }
      const countries = await getCountries(options, params, ctx.lang)
      const countryPages = await getCountryPageUrls(ctx.lang)

      if (!countries) {
        return null
      }

      const countryNames = countries.data.map((country) => country.name)

      const citiesByCountry = await getCitiesByCountry(
        countryNames,
        options,
        params,
        ctx.lang,
        true
      )

      const cityPages = await getCityPageUrls(ctx.lang)

      const destinations: DestinationsData = await Promise.all(
        Object.entries(citiesByCountry).map(async ([country, cities]) => {
          const citiesWithHotelCount = await Promise.all(
            cities.map(async (city) => {
              const hotelIdsParams = new URLSearchParams({
                language: apiLang,
                city: city.id,
              })

              const hotels = await getHotelIdsByCityId(
                city.id,
                options,
                hotelIdsParams
              )

              const cityPage = cityPages.find(
                (cityPage) => cityPage.city === city.cityIdentifier
              )

              if (!cityPage) {
                return null
              }

              return {
                id: city.id,
                name: city.name,
                hotelIds: hotels,
                hotelCount: hotels?.length ?? 0,
                url: cityPage.url,
              }
            })
          )

          const activeCitiesWithHotelCount: Cities =
            citiesWithHotelCount.filter(
              (city): city is Cities[number] => !!city
            )

          const countryPage = countryPages.find(
            (countryPage) => countryPage.country === country
          )

          return {
            country,
            countryUrl: countryPage?.url,
            numberOfHotels: activeCitiesWithHotelCount.reduce(
              (acc, city) => acc + city.hotelCount,
              0
            ),
            cities: activeCitiesWithHotelCount,
          }
        })
      )

      return destinations.sort((a, b) => a.country.localeCompare(b.country))
    }),
  }),
})